httprequest.cpp

/***************************************************************************
                           httprequest.cpp
                           -------------------
    class                : GetRequest
    begin                : 2004-05-15 - 2005-01-11
    copyright            : (C) 2004-2005 by Dominik Haumann
    email                : dhdev (at) gmx (dot) de

    dependency           : POSIX socket implementation and C++ (STL)
 ***************************************************************************/

/***************************************************************************
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License version 2 as published by the Free Software Foundation.
 *
 * This library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 ***************************************************************************/

//BEGIN includes
#include <sstream>

#include <stdio.h>
#include <errno.h>
#include <string.h>

#include <stdlib.h>

#ifndef WIN32
// unix/linux header files
//#include <tcpd.h> // sockaddr_in
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#define closesocket(s) close(s)
#endif

#include "httprequest.h"

// debug
#include <iostream>
//END includes

namespace HTTP {

//BEGIN GetRequest
GetRequest::GetRequest()
{
    m_useragent = "";
}

GetRequest::~GetRequest() { }

void GetRequest::setUserAgent(const std::string& ua)
{
    m_useragent = ua;
}

std::string GetRequest::getUserAgent() const
{
    return m_useragent;
}

void GetRequest::addHeader(const std::string& key, const std::string& value)
{
    m_additionalHeader[key] = value;
}

void GetRequest::addHeader(const std::string& key, int value)
{
    // int to string
    std::string str;
    std::stringstream ss;
    ss << value;
    ss >> str;

    addHeader(key, str);
}

void GetRequest::clearHeaders()
{
    m_additionalHeader.clear();
}

void GetRequest::reset()
{
    m_useragent = "";
    clearHeaders();
}

bool GetRequest::connect(const std::string& host, int port)
{
    m_success = true;
    m_host = host;
    unsigned long addr;
    struct hostent *host_info;

#ifdef WIN32
    // initialize TCP for Windows ("winsock")
    short wVersionRequested;
    WSADATA wsaData;
    wVersionRequested = MAKEWORD (1, 1);
    if (WSAStartup (wVersionRequested, &wsaData) != 0) {
        setError("HTTP request error: failed to init windows sockets\n");
        m_success = false;
        return false;
    }
#endif

    // create socket
    sock = socket( PF_INET, SOCK_STREAM, 0);
    if (sock < 0) {
        setError("HTTP request error: failed to create socket.");
        m_success = false;
        return false;
    }

    // create socked address of the server
    // it is: type, IP-Address and port number
    memset(&server, 0, sizeof (server));
    if ((addr = inet_addr(host.c_str())) != INADDR_NONE) {
        // host is a numeric IP address
        memcpy((char *)&server.sin_addr, &addr, sizeof(addr));
    } else {
        // convert servername to IP address
        host_info = gethostbyname(host.c_str());
        if (host_info == 0L) {
            setError("HTTP request error: unknown server: " + host + "\n");
            m_success = false;
            return false;
        }
        memcpy((char *)&server.sin_addr, host_info->h_addr, host_info->h_length);
    }

    server.sin_family = AF_INET;
    server.sin_port = htons(port);

    return true;
}

bool GetRequest::request(const std::string& page)
{
    m_success = true;
    m_header = "";
    m_data = "";
    m_rawdata = "";
    m_rawdata.reserve( 1048576 ); // reserve 1 MB

    setError("HTTP request: no error occured.");

    char buffer[8192];
    // connect to server
    if ( ::connect(sock, (struct sockaddr*)&server, sizeof(server)) < 0 ) {
        setError("HTTP request error: cannot connect to server");
        m_success = false;
        return false;
    }

    // create and send HTTP GET request
    std::string cmd = "GET /" + page + " HTTP/1.1\r\n"
                      "Host: " + m_host;

    if ( m_useragent.size() > 0 ) {
        cmd += "\r\nUser-Agent: " + m_useragent;
    }

    std::map <std::string, std::string>::iterator it = m_additionalHeader.begin();
    while ( it != m_additionalHeader.end() ) {
        cmd += "\r\n" + it->first + ": " + it->second;
        it++;
    }

    // add empty line
    cmd += "\n\n";

    sprintf(buffer, cmd.c_str());

    send(sock, buffer, strlen(buffer), 0);

    return true;
}

bool GetRequest::process( )
{
    int count;
    char buffer[8192];

    // get server answer
    count = recv(sock, buffer, sizeof(buffer), 0);

    // NOTE: use append, because this way we support binary data!
    m_rawdata.append(buffer, count);

    // check if we have reached the end of the http-stream
    if (count == 0 || isTransferFinished())
    {
        // close connection and socket
        closesocket(sock);

        // split data from response
        m_success = splitData();

        return false;
    }

    return true;
}

bool GetRequest::success() const
{
    return m_success;
}

//BEGIN getter
std::string GetRequest::getHeader() const
{
    return m_header;
}

std::string GetRequest::getHeaderAsString(const std::string& key) const
{
    if (m_header.size() > 0) {
        unsigned int pos = m_header.find("\r\n" + key + ": ", 0);
        if (pos == std::string::npos) return "";

        pos += 4 + key.size();

        unsigned int end = m_rawdata.find("\r\n", pos);
        if (end == std::string::npos) return "";

        return m_header.substr(pos, end - pos);
    }

    return "";
}

int GetRequest::getHeaderAsInt(const std::string& key) const
{
    std::string str = getHeaderAsString(key);

    if (str.size() == 0) {
        return 0;
    } else {
        int value;
        std::stringstream ss;
        ss << str;
        ss >> value;
        return value;
    }
}

std::string GetRequest::getData() const
{
    return m_data;
}

std::string GetRequest::getFooter() const
{
    return m_footer;
}

std::string GetRequest::getRaw() const
{
    return m_rawdata;
}

unsigned int GetRequest::getHeaderSize() const
{
    return m_header.size();
}

unsigned int GetRequest::getDataSize() const
{
    return m_data.size();
}

unsigned int GetRequest::getFooterSize() const
{
    return m_footer.size();
}

unsigned int GetRequest::getRawSize() const
{
    return m_rawdata.size();
}

std::string GetRequest::getError() const
{
    return m_errorMessage;
}
//END getter

void GetRequest::setError(std::string message)
{
    m_errorMessage = message;
}

bool GetRequest::isChunkedTransfer() const
{
    return ( m_rawdata.find("\r\nContent-Length: ", 0) == std::string::npos );
}

bool GetRequest::isTransferFinished() const
{
    if ( !isChunkedTransfer() ) return false;

    // now find the first empty line, as this marks is the end of the header \r\n\r\n
    unsigned int pos = m_rawdata.find("\r\n\r\n", 0);
    if (pos == std::string::npos) return false;
    pos += 4;

    unsigned int size;

    // now enter the loop and step through all the chunks, until
    // the last chunk is marked with 0. If we find that, all data
    // was transferred and we return true.
    while ( (size = findSize(pos, m_rawdata)) != std::string::npos ) {
        if ( size == 0 ) return true;

        // move pos over the chunked-info-line
        pos = m_rawdata.find("\r\n", pos);
        if (pos == std::string::npos) return false;
        pos += 2;
        pos += size + 2;
    }

    return false;
}

unsigned int GetRequest::getContentLength() const
{
    unsigned int pos = m_rawdata.find("\r\nContent-Length: ", 0) + 18; // 18 == strlen("\r\nContent-Length: ");
    unsigned int end = m_rawdata.find("\r\n", pos);

    std::string tmp = m_rawdata.substr(pos, end - pos);

    return atoi( tmp.c_str() );
}

bool GetRequest::postProcessData()
{
    // in detail, the chunked BNF
    //     Chunked-Body   = *chunk
    //                       last-chunk
    //                       trailer
    //                       CRLF

    // chunk          = chunk-size [ chunk-extension ] CRLF
    //                  chunk-data CRLF
    // chunk-size     = 1*HEX
    // last-chunk     = 1*("0") [ chunk-extension ] CRLF

    // chunk-extension= *( ";" chunk-ext-name [ "=" chunk-ext-val ] )
    // chunk-ext-name = token
    // chunk-ext-val  = token | quoted-string
    // chunk-data     = chunk-size(OCTET)
    // trailer        = *(entity-header CRLF)

    unsigned int size, pos, prev;

    size = findSize(0, m_data);
    if (size == std::string::npos) {
        m_success = false;
        return false;
    }

    // remove the first line
    pos = m_data.find("\r\n", 0);
    if (pos == std::string::npos) {
        m_success = false;
        return false;
    }

    pos += 2;

    m_data = m_data.erase(0, pos);
    prev = pos = size;

    // delete crlf from first chunk
    m_data = m_data.erase(pos, 2);

    while (true) {
        size = findSize(pos, m_data);

        if (size == std::string::npos) {
            m_success = false;
            return false;
        } else if (size == 0) {
            // last chunk
            m_data = m_data.erase(pos, std::string::npos);
            m_success = true;
            return true;
        }

        // remove the line
        pos = m_data.find("\r\n", pos);
        if (pos == std::string::npos) {
            m_success = false;
            return false;
        }

        pos += 2;
        m_data = m_data.erase(prev, pos - prev);
        pos = prev + size;
        prev = pos;

        // delete crlf from this chunk
        m_data = m_data.erase(pos, 2);
    }

    // never happens
    return true;
}

unsigned int GetRequest::findSize(unsigned int n, const std::string& source) const
{
    unsigned int end, crlf, semicolon, size;

    crlf = source.find("\r\n", n);
    if (crlf == std::string::npos)
        return std::string::npos;

    semicolon = source.find(";", n);
    if (semicolon == std::string::npos)
        semicolon = crlf;

    if (semicolon < crlf)
        end = semicolon;
    else
        end = crlf;

    std::stringstream ss;
    ss << source.substr(n, end - n);
    ss.setf(std::ios_base::hex, std::ios_base::basefield); // hex is the format
    ss >> size;

//    std::cout << "findSize(" << n << ") == " << size << " (" << source.substr(n, end - n) << ")" << std::endl;

    return size;
}

bool GetRequest::splitData()
{
    // info: http://www.jmarshall.com/easy/http/
    //
    // if we know the size, we can copy the amount of data.
    // otherwise we use the chuked transfer.
    //
    // chunked transfer:
    // Part A
    //   HTTP/1.1 200 OK
    //   Date: Fri, 31 Dec 1999 23:59:59 GMT
    //   Content-Type: text/plain
    //   Transfer-Encoding: chunked
    //
    // Part B
    //   1a; ignore-stuff-here
    // part C
    //   abcdefghijklmnopqrstuvwxyz
    //   10
    //   1234567890abcdef
    // Part D
    //   \r\n0\r\n
    //   some-footer: some-value
    //   another-footer: another-value
    //   [blank line here]


    if ( !isChunkedTransfer() ) {

        // get the exact length of data
        unsigned int size = getContentLength();

        unsigned int pos = m_rawdata.find("\r\n\r\n", 0);
        if (pos == std::string::npos) {
            setError("HTTP request error: no header information available");
            m_success = false;
            return false;
        }

        pos += 4;
        // split header
        m_header = m_rawdata.substr(0, pos);
        // remove header from m_data
        m_data = m_rawdata.substr(pos, size);
        m_footer = ""; // :)

    } else {

        // face part A: extract the header
        // find empty line
        unsigned int pos = m_rawdata.find("\r\n\r\n", 0);
        if (pos == std::string::npos) {
            setError("HTTP request error: no valid header found (chunked)");
            m_success = false;
            return false;
        } else {
            m_header = m_rawdata.substr(0, pos + 2);
        }
        pos += 4;

        // face part D: extract footer
        unsigned int end = m_rawdata.rfind("\r\n0", std::string::npos);
        if (end == std::string::npos) {
                setError("HTTP request error: no valid footer found (chunked)");
                m_success = false;
                return false;
            } else {
                // ha! we got footer
                end += 2;
                end = m_rawdata.find("\r\n", end);
                if (end == std::string::npos) {
                    setError("HTTP request error: no valid footer found (chunked*)");
                    m_success = false;
                    return false;
                }
                end += 2;
                m_footer = m_rawdata.substr(end, std::string::npos);
            }

        // copy data part to m_data
        m_data = m_rawdata.substr(pos, end - pos);

        // face part B and C
        // chunked means that we have many chunks with size/body.
        // what we do now, is to remove all sizes, eg. \r\nsize\r\n
        if (!postProcessData()) {
            setError("HTTP request error: the data part seems to be corrupted (chunked)");
            m_success = false;
            return false;
        }
    }

    return true;
}
//END GetRequest

}

// kate: space-indent on; indent-width 4; replace-tabs off;

---