Http.hpp

Go to the documentation of this file.

/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
#ifndef HTTP_HPP_
#define HTTP_HPP_

#include <curl/curl.h>
#include <string>
#include <vector>

namespace OpenAB
{

class HttpMessage;

class HttpSession
{
  public:
    HttpSession();

    virtual ~HttpSession();

    bool init();

    void cleanup();

    bool execute (HttpMessage* msg);

    void enableTrace(bool enabled);

  private:
    HttpSession(HttpSession const &other);

    HttpSession& operator=(HttpSession const &other);

    void reset();

    CURL* curl;
    curl_slist * internalHeader;

    std::string lastErrorStr;
    std::string responseBuffer;
    std::string responseHeaders;
    const char* writeBuffer;
    unsigned int currentWriteOffset;
    bool traceEnabled;

    static size_t readResponse (void* ptr, size_t size, size_t nmemb, HttpSession* curl);
    static size_t readResponseHeaders (void* ptr, size_t size, size_t nmemb, HttpSession* curl);
    static size_t writeData (void* ptr, size_t size, size_t nmemb, HttpSession* curl);
    static int writeSeek(HttpSession *curl, curl_off_t offset, int origin);

    static int printTrace (CURL* curl, curl_infotype type, char* data, size_t size, void* userp);
};


class HttpMessage
{
  public:
    HttpMessage();

    ~HttpMessage();

    enum RequestType
    {
      POST = 0, //< POST request
      GET,      //< GET request
      PUT,      //< PUT request
      CUSTOM    //< Custom request
    };

    enum ResponseCode
    {
      OK = 200,
      CREATED = 201,
      ACCEPTED = 202,
      NO_CONTENT = 204,
      MULTISTATUS = 207,
      MOVED_PERMAMENTLY = 301,
      BAD_REQUEST = 400,
      UNAUTHORIZED = 401,
      FORBIDDEN = 403,
      NOT_FOUND = 404,
      PRECONDITION_FAILED = 412
    };

    static std::string responseCodeDescription(long code);


    void setRequestType(RequestType type);

    void setRequestType(const std::string& custom);

    RequestType getRequestType() const;

    std::string getCustomRequestType() const;

    typedef std::vector<std::pair<std::string, std::string> > Headers;

    void appendHeader(const std::string& key, const std::string& value);

    const Headers& getHeaders() const;

    void setData (const std::string& data);

    std::string getData() const;

    void setFollowRedirection (bool follow);

    bool followRedirection() const;

    void setURL (const std::string& url);

    std::string getURL() const;

    void setResponse(const std::string& response);

    std::string getResponse() const;

    void setResponseHeaders(const std::string& headers);

    Headers getResponseHeaders() const;

    void setResponseCode(long code);

    long getResponseCode() const;

    void setErrorString(const std::string& errorStr);

    std::string getErrorString() const;

    void setCredentials(const std::string& login, const std::string& password);

    void getCredentials(std::string& login, std::string& password);

    void enableBasicHttpAuthentication(bool enable);

    bool basicHttpAuthenticationEnabled();

    void enableDigestHttpAuthentication(bool enable);

    bool digestHttpAuthenticationEnabled();

  private:
    HttpMessage(HttpMessage const &other);

    HttpMessage& operator=(HttpMessage const &other);

    RequestType requestType;
    std::string customRequestType;
    Headers headers;
    std::string data;
    std::string url;
    bool redirectionEnabled;
    long responseCode;
    std::string response;
    Headers responseHeaders;
    std::string errorString;
    bool basicAuthenticationEnabled;
    bool digestAuthenticationEnabled;
    std::string login;
    std::string password;
};

class HttpAuthorizer
{
  public:
    virtual ~HttpAuthorizer() {};

    virtual bool authorizeMessage(HttpMessage* msg) = 0;
};

} //namespace OpenAB
#endif // HTTP_HPP_