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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

HttpRequest.cpp

/***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title: HttpRequest.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:                                                   *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 ***********************************************************************/

#include "HttpRequest.hpp"


/***********************************************************************/
HttpRequest::HttpRequest(const char *url)
{
        uri = new Url(url);
        if (uri->getPort() == 0)
                uri->setPort(80); //default http port


        contentLength = 0;
        contentType = mime_unknown;
        headerbuf = NULL;
        contentStart = NULL;
}


/***********************************************************************/
HttpRequest::~HttpRequest() {
        closeSock();
}



/***********************************************************************/
int HttpRequest::continueReceive(char *recbuffer, int size) {
        int num;
        int realsize;
        if (headerbuf && contentStart) {
                num = bufend - (contentStart - headerbuf);
                realsize = MIN(num,size);
                memcpy(recbuffer, contentStart, realsize);
                contentStart+=realsize;

                if (contentStart == headerbuf+bufend) {
                        //all initial payload bytes are forwarded
                        delete [] headerbuf;
                        contentStart = NULL;
                        bufend = 0;
                }
                return realsize;
        }
        else {
                num = recv(sock, recbuffer, size, 0);
                if (num == 0) //regular end of connection
                        return -1;
                else
                        return num; //may also be -1 on error!
        }
}


/***********************************************************************/
bool HttpRequest::makeHttpRequest()
{

  headerbuf = new char[MAX_HEADERS_SIZE];
        int len;

  if (createSocket(uri->getServerName(), uri->getPort())) {
    //send request to the server

                char *msg = new char[MAX_HEADERS_SIZE];
                strcpy(msg, "GET ");
                strcat(msg, uri->getPath());
                strcat(msg, " HTTP/1.0\r\n\r\n");
                //dprintf_full("makeHttpRequest #%s#\n",msg);
    send(sock, msg, strlen(msg), 0);
                delete [] msg;

    //wait for response
    memset(headerbuf, 0, MAX_HEADERS_SIZE);

                
                len = 0; bufend = 0;
                do {
                        len = recv(sock, headerbuf+bufend, MAX_HEADERS_SIZE-bufend-1, 0);
                        //                      dprintf_full("makeHttpRequest read #%s# RET %i\n",headerbuf,len);
                        /*
                                for (int i=0; i < len; i++)
                                printf("%c",*((char*)(headerbuf+bufend+i)));
                                printf("%c\n");
                        */

                        bufend += len;
                        contentStart = strstr(headerbuf, "\r\n\r\n");
                        if (contentStart)
                                contentStart+=4;
                } while ((len > 0) && !contentStart);
                
                
                if (len != -1)  {
                        //search for HTTP 200 OK
                        if (strstr(headerbuf, "HTTP") != NULL && strstr(headerbuf, "200 OK") != NULL) {
                                
                                char *posFound = NULL;

                                //search for content-length
                                if ((posFound = strstr(headerbuf, "Content-Length: ")) != NULL) {
                                        contentLength = atoi(posFound + strlen("Content-Length: "));
                                } else {
                                        dprintf_err("HttpRequest::makeHttpRequest(): content-length in #%s# not found. setting to -1\n",headerbuf);
                                        contentLength = -1;
                                }

                                //search for content-type
                                if ((posFound = strstr(headerbuf, "Content-Type: ")) != NULL) {
                                        char *mime = posFound + strlen("Content-Type: ");
                                        for (int i=0; i < NUM_KNOWN_HTTP_MIMETYPES; i++) {
                                                if (strstr(mime,HttpMimeTypeStrings[i]) != NULL) {
                                                        contentType = (HttpMimeType)i;
                                                        break;
                                                }
                                        }
                                } else {
                                        dprintf_err("HttpRequest::makeHttpRequest(): content-type in #%s# not found. setting to application/octetstream\n",headerbuf);
                                        contentType = mime_unknown;
                                }

                                return true;
                        }
                }

                dprintf_err_fatal("HttpRequest::makeHttpRequest: file not found on server!\n");
                return false;
        } else
                return false;
}


/***********************************************************************/
bool HttpRequest::isIPNumber(const char *host) {
        assert(host);
        for (unsigned int i = 0; i < strlen(host); i++) {
                if (!((host[i] >= '0' && host[i] <= '9') || host[i] == '.')) return false;
        }
        return true;
}



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

#ifndef WINCE   
        /*
  if (isIPNumber(host)) {
        unsigned int addr = inet_addr(host);
        hp = gethostbyaddr((char*)&addr, 4, AF_INET);
  } else
        */
 {
        hp = gethostbyname(host);
  }

  if (!hp)
  {
        int myerr = 0;
        dprintf_err_fatal("HttpRequest::createSocket: Cannot resolve host '%s' (err=%d)\n", host, myerr);
        return false;
  }
#endif


  if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) 
  {
    dprintf_err_fatal("HttpRequest::createSocket: Error on socket create (%s:%d)\n", host, port);
    return false;
  }

  sin.sin_family = AF_INET;
  sin.sin_port = htons(port);
#ifndef WINCE
  memcpy(&sin.sin_addr, hp->h_addr, hp->h_length);
#else
  unsigned long addr = inet_addr(host);
  sin.sin_addr.S_un.S_addr = addr;
#endif



  if (connect(sock, (struct sockaddr*) &sin, sizeof(struct sockaddr)) != 0)
  {
    dprintf_err_fatal("HttpRequest::createSocket: Error on socket connect (%s:%d)\n", host, port);
        closeSock();
    return false;
  }

  return true;
}



/***********************************************************************/
void HttpRequest::closeSock()
{
        if (sock != 0) {
#ifdef WIN32
                closesocket(sock);
#else
                close(sock);
#endif
  }
}

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