weHttpResp.cpp

Go to the documentation of this file.

/*
webEngine is the HTML processing library
Copyright (C) 2009 Andrew Abramov aabramov@ptsecurity.ru

This file is part of webEngine

webEngineis 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 3 of the License, or
(at your option) any later version.

webEngineis 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 webEngine.  If not, see <http://www.gnu.org/licenses/>.
*/
#include <boost/lexical_cast.hpp>
#include <algorithm>
#include "weHelper.h"
#include "weHTTP.h"
#include "weOptions.h"

WeHttpResponse::WeHttpResponse() :
headers(": ", "[\\n\\r]+"), cookies("=", "; ")
{
    curlHandle = NULL;
    baseUrl = "";
    realUrl = "";
    relocCount = 0;
    processed = false;
    httpCode = 0;
    data.clear();
    headData.clear();
    if (!CurlInit()) {
        throw WeError("curl_easy_init failed!");
    }
}

WeHttpResponse::~WeHttpResponse()
{
    if (curlHandle != NULL) {
        curl_easy_cleanup(curlHandle);
    }
    headers.Clear();
    cookies.Clear();
}

bool WeHttpResponse::CurlInit( void )
{
    if (curlHandle != NULL) {
        curl_easy_cleanup(curlHandle);
    }

    curlHandle = curl_easy_init();
    memset(errorBuff, 0, CURL_ERROR_SIZE);
    if (curlHandle == NULL) {
        return false;
    }
    curl_easy_reset(curlHandle);
    curl_easy_setopt(curlHandle, CURLOPT_ERRORBUFFER, errorBuff);
    curl_easy_setopt(curlHandle, CURLOPT_HTTP_TRANSFER_DECODING, 1);
    curl_easy_setopt(curlHandle, CURLOPT_PROXY, "");
    curl_easy_setopt(curlHandle, CURLOPT_WRITEFUNCTION, &WeHttpResponse::Receiver);
    curl_easy_setopt(curlHandle, CURLOPT_WRITEDATA, this);
    curl_easy_setopt(curlHandle, CURLOPT_HEADERFUNCTION, &WeHttpResponse::HeadersRecv);
    curl_easy_setopt(curlHandle, CURLOPT_WRITEHEADER, this);
    return true;
}

void WeHttpResponse::CurlSetOpts(WeHttpRequest* req /*= NULL*/)
{
    if (req != NULL) {
        curl_easy_setopt(curlHandle, CURLOPT_URL, req->RequestUrl().ToString().c_str());
        if (req->Method() == WeHttpRequest::wemGet) {
            curl_easy_setopt(curlHandle, CURLOPT_HTTPGET, 1);
        }
        if (req->Method() == WeHttpRequest::wemPost) {
            curl_easy_setopt(curlHandle, CURLOPT_POST, 1);
            curl_easy_setopt(curlHandle, CURLOPT_POSTFIELDS, &(req->Data()[0]));
            curl_easy_setopt(curlHandle, CURLOPT_POSTFIELDSIZE, req->Data().size());
        }
        if (req->Method() == WeHttpRequest::wemPut) {
            curl_easy_setopt(curlHandle, CURLOPT_UPLOAD, 1);
            curl_easy_setopt(curlHandle, CURLOPT_READDATA, &(req->Data()[0]));
            curl_easy_setopt(curlHandle, CURLOPT_INFILESIZE, req->Data().size());
        }
        WeProxy* prx = req->Proxy();
        if (prx && prx->proxyAddr.IsValid()) {
            curl_easy_setopt(curlHandle, CURLOPT_PROXYTYPE, prx->type);
            curl_easy_setopt(curlHandle, CURLOPT_PROXY, prx->proxyAddr.ToString().c_str());
        }
    }
}

void WeHttpResponse::Process(iweTransport* proc)
{
    char *st;

    if (curlHandle) {
        lastError = curl_easy_getinfo(curlHandle, CURLINFO_RESPONSE_CODE, &httpCode);
        lastError = curl_easy_getinfo(curlHandle, CURLINFO_EFFECTIVE_URL, &st);
        if (lastError == CURLE_OK) {
            realUrl = st;
            //delete str;
        }
        processed = true;
    }
    data.push_back(0);
    headData.push_back(0);
    headers.Parse((char*)&headData[0]);
    if (proc != NULL) {
        if (httpCode >= 300 && httpCode < 400 && proc->IsSet(weoFollowLinks) && relocCount < proc->RelocationCount()) {
            // redirections
            relocCount++;
            string url = headers.FindFirst("Location");
            if (!url.empty()) {
                headData.clear();
                data.clear();
                proc->Request(url, this);
            }
        }
    }
}

size_t WeHttpResponse::Receiver( void *ptr, size_t size, size_t nmemb, void *ourpointer )
{
    if (ourpointer == NULL)
        return 0;

    WeHttpResponse* object = (WeHttpResponse*)ourpointer;
    size_t last = object->data.size();
    object->data.insert(object->data.end(), (unsigned char*)ptr, (unsigned char*)ptr + (size * nmemb));
    return (object->data.size() - last);
}

size_t WeHttpResponse::HeadersRecv( void *ptr, size_t size, size_t nmemb, void *ourpointer )
{
    if (ourpointer == NULL)
        return 0;

    WeHttpResponse* object = (WeHttpResponse*)ourpointer;
    size_t last = object->headData.size();
    object->headData.resize(last + (size * nmemb));
    memcpy(&(object->headData[last]), (unsigned char*)ptr, (size * nmemb));
    return (object->headData.size() - last);
}

---

	©2009 Positive Technologies	Generated on Tue Jul 14 18:27:30 2009 for WebEngine by		1.5.7