weHTTP.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"

#ifndef __DOXYGEN__
string WeHTTP::protoName = "http";
#endif // __DOXYGEN__

WeHttpRequest::WeHttpRequest()
{
    proxy = NULL;
}

WeHttpRequest::WeHttpRequest( string url, WeHttpRequest::weHttpMethod meth /*= wemGet*/, WeHttpResponse* resp /*= NULL*/ )
{
    method = meth;
    RequestUrl(url, resp);
    throw runtime_error("Not implemented");
}

void WeHttpRequest::RequestUrl( const string &ReqUrl, iweOperation* resp /*= NULL*/ )
{
    WeURL   weurl;

    weurl = ReqUrl;
    return RequestUrl(weurl, resp);
}

void WeHttpRequest::RequestUrl( const WeURL &ReqUrl, iweOperation* resp /*= NULL*/ )
{
    reqUrl = ReqUrl;
    if (resp != NULL) {
    }
}

void WeHttpRequest::ComposePost( int method /*= composeOverwrite*/ )
{
    if (method == wemPost || method == wemPut) {
    }
}
WeHTTP::WeHTTP()
{
    transferHandle = curl_multi_init();
    if (transferHandle == NULL) {
        throw WeError("curl_multi_init failed!");
    }
    responces.clear();
    WeLibInit();
}

WeHTTP::~WeHTTP()
{
    WeResponseList::iterator hnd;
    WeHttpResponse* point;

    if (transferHandle != NULL) {
        for (hnd = responces.begin(); hnd != responces.end(); hnd++) {
            try {
                point = dynamic_cast<WeHttpResponse*>(*hnd);
                curl_multi_remove_handle(transferHandle, point->CURLHandle());
                delete point;
            }
            catch (...) {}; // just skip
        }
        curl_multi_cleanup(transferHandle);
    }
}

iweResponse* WeHTTP::Request( iweRequest* req, iweResponse* resp /*= NULL*/ )
{
    WeHttpResponse* retval;

    if (!req->RequestUrl().IsValid()) {
        if (resp != NULL) {
            string url = req->RequestUrl().ToString();
            req->RequestUrl().Restore(url, &(resp->RealUrl()));
        }
    }

    if (!req->RequestUrl().IsValid()) {
        // bad luck! still not valid request... :(
    }

    if (resp == NULL) {
        retval = new WeHttpResponse();
        retval->BaseUrl(req->RequestUrl());
        retval->RelocCount(0);
    }
    else {
        retval = dynamic_cast<WeHttpResponse*>(resp);
        if (!retval->BaseUrl().IsValid()) {
            retval->BaseUrl(req->RequestUrl());
        }
        if (!retval->CurlInit()) {
            return NULL;
        }
    }

    try {
        WeHttpRequest* r = dynamic_cast<WeHttpRequest*>(req);
        retval->CurlSetOpts(r);
    }
    catch (...) {}; // just skip
    retval->Processed(false);

    responces.push_back(retval);

    if (transferHandle != NULL) {
        curl_multi_add_handle(transferHandle, retval->CURLHandle());
        ProcessRequests();
    }
    return (iweResponse*)retval;
}

iweResponse* WeHTTP::Request( string url, iweResponse* resp /*= NULL*/ )
{
    WeHttpRequest* req = new WeHttpRequest;

    if (req == NULL) {
        throw WeError(string("Can't create WeHttpRequest! ") + __FILE__ + boost::lexical_cast<std::string>(__LINE__));
        return NULL;
    }
    req->RequestUrl(url, resp);
    if (!req->RequestUrl().IsValid()) {
        if (resp != NULL) {
            req->RequestUrl().Restore(url, &(resp->RealUrl()));
        }
    }
    req->Method(WeHttpRequest::wemGet);
    return Request(req, resp);
}

iweResponse* WeHTTP::Request( WeURL& url, iweResponse* resp /*= NULL*/ )
{
    WeHttpRequest* req = new WeHttpRequest;

    if (req == NULL) {
        throw WeError(string("Can't create WeHttpRequest! ") + __FILE__ + boost::lexical_cast<std::string>(__LINE__));
        return NULL;
    }
    req->RequestUrl(url, resp);
    req->Method(WeHttpRequest::wemGet);
    return Request(req, resp);
}

const CURLMcode WeHTTP::ProcessRequests( void )
{
    int running_handles;
    int msgs_in_queue;
    CURLMsg *cmsg;
    WeResponseList::iterator hnd;
    WeHttpResponse* resp;

    if (transferHandle != NULL) {
        lastError = curl_multi_perform(transferHandle, &running_handles);

        while (lastError == CURLM_CALL_MULTI_PERFORM) {
            lastError = curl_multi_perform(transferHandle, &running_handles);
        }

        cmsg = curl_multi_info_read(transferHandle, &msgs_in_queue);
        while (cmsg != NULL)
        {
            if (cmsg->msg == CURLMSG_DONE) {
                // find the response
                for (hnd = responces.begin(); hnd != responces.end();) {
                    try {
                        resp = dynamic_cast<WeHttpResponse*>(*hnd);
                        if ( resp->CURLHandle() == cmsg->easy_handle) {
                            responces.erase(hnd);
                            hnd = responces.begin();
                            curl_multi_remove_handle(transferHandle, resp->CURLHandle());
                            resp->Process(this);
                            break;
                        }
                    }
                    catch (...) {}; // just skip
                    hnd++;
                }
            }
            // delete cmsg;
            cmsg = curl_multi_info_read(transferHandle, &msgs_in_queue);
        }
    }
    else {
        lastError = CURLM_BAD_HANDLE;
    }
    return lastError;
}

---

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