Home    News    Components    Get ViTooKi    Documentation    Community    Developers    @sf.net  

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

MovieListRequest.cpp

/***********************************************************************
*                                                                      *
* ViTooKi                                                              *
*                                                                      *
* title: MovieListRequest.cpp                                          *
*                                                                      *
*                                                                      *
*                                                                      *
* ITEC institute of the University of Klagenfurt (Austria)             *
* http://www.itec.uni-klu.ac.at                                        *
*                                                                      *
*                                                                      *
* For more information visit the ViTooKi homepage:                     *
* http://ViTooKi.sourceforge.net                                       *
* vitooki-user@lists.sourceforge.net                                   *
* vitooki-devel@lists.sourceforge.net                                  *
*                                                                      *
* This file is part of ViTooKi, a free video toolkit.                  *
* ViTooKi is free software; you can redistribute it and/or             *
* modify it under the terms of the GNU General Public License          *
* as published by the Free Software Foundation; either version 2       *
* of the License, or (at your option) any later version.               *
*                                                                      *
* This program is distributed in the hope that it will be useful,      *
* but WITHOUT ANY WARRANTY; without even the implied warranty of       *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the         *
* GNU General Public License for more details.                         *
*                                                                      *
* You should have received a copy of the GNU General Public License    *
* along with this program; if not, write to the Free Software          *
* Foundation, Inc., 59 Temple Place - Suite 330, Boston,               *
* MA  02111-1307, USA.                                                 *
*                                                                      *
***********************************************************************/

/***********************************************************************
*                                                                      *
*  REVISION HISTORY:                                                   *
*                                                                      *
*                                                                      *
*                                                                      *
***********************************************************************/

/***********************************************************************
* Video Session Migration System, 2004                                 *
* Author: Klaus Schoeffmann                                            *
************************************************************************/


#include "MovieListRequest.hpp"

/***********************************************************************/
MovieListRequest::MovieListRequest()
{}

/***********************************************************************/
MovieListRequest::~MovieListRequest()
{}

/***********************************************************************/
int MovieListRequest::createSocket(const char *host, int port)
{
  struct hostent *hp;
  struct sockaddr_in sin;
  int sock;

  if (!(hp = gethostbyname(host)))
  {
    cerr << "\nMovieListRequest::createSocket: Cannot resolve host '" << host << "'";
    return 0;
  }

  sin.sin_family = AF_INET;
  bcopy (hp->h_addr, (char*) &sin.sin_addr, hp->h_length);
  sin.sin_port = htons(port);

  if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0)
  {
    cerr << "\nMovieListRequest::createSocket: Error on socket create (" << host << "/" << port << ")";
    return 0;
  }

  if (connect(sock, (struct sockaddr*) &sin, sizeof(sin)) < 0)
  {
    cerr << "\nMovieListRequest::createSocket: Error on socket connect (" << host << "/" << port << ")";
    close(sock);
    return 0;
  }

  return sock;
}


/***********************************************************************/
char* MovieListRequest::makeHttpRequest(const char *hostname, int port, string msg, char *recbuffer,  uint &contentLength)
{
  int sock = createSocket(hostname, port);

  if (sock > 0)
  {
    //send request to the server
    send(sock, (char *) msg.c_str(), sizeof(char) * msg.length(), 0);

    //wait for response
    memset(recbuffer, 0, MAX_RECBUFFER_SIZE);

    //read until no more bytes (because of MTU)
    uint bytesRead = 0, bytesReadCum = 0;
    do
    {
      bytesRead = recv(sock, recbuffer + bytesReadCum, sizeof(char) * MAX_RECBUFFER_SIZE, 0);
      bytesReadCum += bytesRead;
    }
    while (bytesRead != 0);

    if (strstr(recbuffer, "HTTP") != NULL && strstr(recbuffer, "200 OK") != NULL)
    {

      //look for start of real content
      char *content = strstr(recbuffer, "Content-Length: ");
      if (content != NULL)
      {
        contentLength = atoi(content+16);
        content = strstr(content, "\r\n\r\n");
        if (content != NULL)
        {
          return content+4;
        }
      }
    }
  }

  return NULL;
}

/***********************************************************************/
void MovieListRequest::addIfNotExists(list<char*> &imgList, char *str)
{
  list<char*>::iterator iter = imgList.begin();
  while (iter != imgList.end())
  {
    if (strcmp(str, *iter) == 0) return;
    iter++;
  }

  imgList.push_back(str);
}

/***********************************************************************/
void MovieListRequest::writeToFile(const char *filename, char *buffer, uint len)
{
  //create outputfilestream and write bytes to
  Globals::sdebug << "MovieListRequest::writeToFile(): trying '" << filename << "'";
  ofstream fileout(filename, ios::out);
  uint i = 0;
  while (i < len) fileout.put(*(buffer + (i++)));
  fileout.close();
  Globals::sdebug << "MovieListRequest::writeToFile(): '" << filename << "' successfully created!";
}


/***********************************************************************/
bool MovieListRequest::requestMovieList(const char *hostname, int port)
{

  //find out IP-Address of specified host
//  hostent *host = gethostbyname(hostname);
//  char *address = inet_ntoa(*(reinterpret_cast<in_addr*>(host->h_addr)));

  //buffer used for receiving
  char *buffer = new char[MAX_RECBUFFER_SIZE];
  char *bufferStart = buffer;
  uint contentLength;

  //send HTTP GET message for movielist
  ostringstream httpMsg;
  //httpMsg << "GET http://" << address << "/MovieList.xml HTTP/1.1\r\n\r\n"; httpMsg.flush();
  httpMsg << "GET /MovieList.xml HTTP/1.1\r\n\r\n"; httpMsg.flush();
  if ((buffer = makeHttpRequest(hostname, port, httpMsg.str(), buffer, contentLength)))
  {

    //write this content to a file, where the semiserver has access to
    writeToFile(Globals::getMoviesFileName(), buffer, contentLength);

    //search for images
    list<char*> imgList;
    char *imgStart, *imgEnd; //37
    while ((imgStart = strstr(buffer, "<Resource mimeType=\"image/jpeg\" ref=\"")) != NULL)
    {
      imgEnd = strstr(imgStart+strlen("<Resource mimeType=\"image/jpeg\" ref=\""), "\"");
      if (imgEnd != NULL)
      {
        char *foundImg = semifunc::newStrCpy(
                           imgStart+strlen("<Resource mimeType=\"image/jpeg\" ref=\""),
                           imgEnd-(imgStart+strlen("<Resource mimeType=\"image/jpeg\" ref=\"")));
        Globals::sdebug << "\nFound Image: " << foundImg;
        //add this image to the list, if not already there
        addIfNotExists(imgList, foundImg);
      }
      buffer = imgEnd;
    }

    //now request all images
    list<char*>::iterator iter = imgList.begin();
    while (iter != imgList.end())
    {
      char *img = *iter;
      ostringstream httpMsgImg;
      //httpMsgImg << "GET http://" << address << "/" << img << " HTTP/1.1\r\n\r\n";
      httpMsgImg << "GET /" << img << " HTTP/1.1\r\n\r\n";
      Globals::sdebug << "\n" << httpMsgImg.str().c_str();
      if ((buffer = makeHttpRequest(hostname, port, httpMsgImg.str(), bufferStart, contentLength)))
      {
        ostringstream filename;
        filename << Globals::getAbsoluteImagesFilePath() << img;
        writeToFile(filename.str().c_str(), buffer, contentLength);
      }

      iter++;
    }
    imgList.clear(); //clear list

    delete bufferStart;
    bufferStart = NULL;
    return true;

  }


  return false;
}

© ViTooKi 2003 :: [Lite version] Created with Doxygen