weHTTP.h

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/>.
*/
#ifndef __WEHTTP_H__
#define __WEHTTP_H__

#include "weStrings.h"
#include "weBlob.h"
#include "weUrl.h"
#include "weiTransport.h"
#include <curl/curl.h>
#include <boost/algorithm/string/predicate.hpp>

using namespace boost::algorithm;

class WeHTTP;
class WeHttpRequest;

class WeProxy
{
public:
    WeURL   proxyAddr;
    curl_proxytype type;
};

class WeHttpResponse : public iweResponse
{
public:
    WeHttpResponse();
    ~WeHttpResponse();

    WeStringLinks& Headers(void)     { return (headers); };

    WeStringLinks& Cookies(void)     { return (cookies); };




    int HttpCode(void)      { return httpCode;  };
    void HttpCode(int code) { httpCode = code;  };



    CURL* CURLHandle(void)  { return curlHandle; };

    void CurlSetOpts(WeHttpRequest* req = NULL);

    const CURLcode &GetLastError(void) const   { return(lastError);    };

    const char* GetErrorMessage(void) const   { return(errorBuff);    };

    bool CurlInit(void);

    void Process(iweTransport* proc);

protected:
    static size_t Receiver(void *ptr, size_t size, size_t nmemb, void *ourpointer);
    static size_t HeadersRecv(void *ptr, size_t size, size_t nmemb, void *ourpointer);

#ifndef __DOXYGEN__
protected:
    WeStringLinks headers;
    WeStringLinks cookies;
    int httpCode;
    WeBlob headData;
    CURL* curlHandle;
    CURLcode lastError;
    char errorBuff[CURL_ERROR_SIZE];

// private:
//     WeHttpResponse(WeHttpResponse&) {};             ///< Avoid object coping
//     WeHttpResponse& operator=(WeHttpResponse&) {};  ///< Avoid object coping
#endif //__DOXYGEN__
};

class WeHttpRequest : public iweRequest
{
public:
    /* types and constants */
    enum weHttpMethod {wemGet, wemPost, wemPut, wemHead, wemTrace};
    enum {composeOverwrite, composeAdd};
public:
    WeHttpRequest();
    WeHttpRequest(string url, weHttpMethod meth = wemGet, WeHttpResponse* resp = NULL);

    virtual WeURL  &RequestUrl(void)  { return(reqUrl);   };
    virtual void RequestUrl(const string &ReqUrl, iweOperation* resp = NULL);
    virtual void RequestUrl(const WeURL &ReqUrl, iweOperation* resp = NULL);

    void ComposePost(int method = composeOverwrite);

    WeBlob& Data()  { return data;  };

    WeStringLinks& PostData()    { return postData;  };




    const weHttpMethod &Method(void) const  { return(method);   };
    void Method(const weHttpMethod &meth)   { method = meth;    };

    // Access the Proxy
    WeProxy *Proxy(void) const  { return(proxy);    };
    void Proxy(WeProxy *prx)    { proxy = prx;      };

#ifndef __DOXYGEN__
protected:
    weHttpMethod    method;
    WeURL           reqUrl;
    WeBlob          data;
    WeStringLinks    postData;
    WeProxy         *proxy;
#endif //__DOXYGEN__
};

class WeHTTP : public iweTransport
{
public:
    WeHTTP();
    ~WeHTTP();

    virtual iweResponse* Request(iweRequest* req, iweResponse* resp = NULL);
    virtual iweResponse* Request(string url, iweResponse* resp = NULL);
    virtual iweResponse* Request(WeURL& url, iweResponse* resp = NULL);

    const CURLMcode &GetLastError(void) const   { return(lastError);    };

    const CURLMcode ProcessRequests(void);

    virtual string& GetName()                   { return protoName; };
    virtual bool IsOwnProtocol(string& proto)   {return iequals(proto, protoName); };

#ifndef __DOXYGEN__
protected:
    CURLM*          transferHandle;
    CURLMcode       lastError;

private:
    static string   protoName;
    WeHTTP(WeHTTP&) {};             
    WeHTTP& operator=(WeHTTP&) { return *this; };  
#endif //__DOXYGEN__
};

#endif //__WEHTTP_H__

---

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