http.h

Go to the documentation of this file.

/*  http.h - simple HTTP request library
    Copyright (C) 2001-2004 Mark Weaver
    Written by Mark Weaver <mark@npsl.co.uk>

    Part of the Open-Win32 library.
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    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; if not, write to the
    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA  02111-1307, USA.
*/

#ifndef OW32_http_h
#define OW32_http_h

#include <OW32/OW32Libs.h>
#include <OW32/AsyncSecureSocketClient.h>
#include <OW32/auto_buf.h>
#include <OW32/RefCounted.h>
#include <OW32/URIComponents.h>
#include <OW32/SyncObjects.h>

#include <memory> // for std::auto_ptr

namespace OW32
{

enum HTTP_ERRORS
{
    HTTP_NO_ERROR = 0,

    HTTP_NO_HTTP_PREFIX,
    HTTP_INVALID_VERSION,
    HTTP_INVALID_SERVER_RESPONSE,
    HTTP_INVALID_STATUS_CODE,
    HTTP_INVALID_CONTENT_LENGTH,
    HTTP_INVALID_TRANSFER_ENCODING,
    HTTP_SERVER_CLOSED_CONNECTION,
    HTTP_INVALID_CHUNK_HEADER,
    HTTP_REDIRECT_WITHOUT_LOCATION,

    HTTP_MAXIMUM_REDIRECTS_EXCEEDED,
    HTTP_MAXIMUM_SIZE_EXCEEDED,

    HTTP_READ_TIMEOUT,
    HTTP_SEND_TIMEOUT,
    HTTP_CONNECT_TIMEOUT,
    HTTP_SOCKET_FAILED,
    HTTP_IOCP_FAILED,
    HTTP_BIND_FAILED,
    HTTP_CONNECT_FAILED,
    HTTP_SHUTDOWN_FAILED,
    HTTP_READ_FAILED,
    HTTP_SEND_FAILED,
    HTTP_IO_PENDING,
    HTTP_NAME_RESOLUTION_FAILED
};

class OW32_LIB_EXPORT CHTTP;

class OW32_LIB_EXPORT CHTTPListener
{
public:
    virtual void OnConnection(CHTTP* /*http*/) {}

    virtual void OnConnectionClosed(CHTTP* /*http*/) {}

    virtual void OnError(CHTTP* /*http*/) {}

    virtual void OnPageReceived(CHTTP* /*http*/) {}

    virtual void OnChunkReceived(CHTTP* /*http*/, int /*currentLength*/) {}

    virtual bool OnRedirect(CHTTP* /*http*/) { return false; }

    virtual void OnRequestCompleted(CHTTP* /*http*/) {}
};

#ifdef _MSC_VER
#pragma warning(disable: 4251)
#endif

class OW32_LIB_EXPORT CConnectionThread;

class OW32_LIB_EXPORT CHTTP : 
    public CAsyncSocketCallback,
    public CRefCounted
{
public:

    static int initialise();

    static void terminate();

    static CHTTP* createObject() { return new CHTTP; }

    void Reset();

    void setListener(CHTTPListener* listener) { 
        m_pListener = listener; 
    }

    CHTTPListener* getListener() { return m_pListener; }

    void close() {
        if (m_pSocket.get()) m_pSocket->shutdown(SD_SEND);
    }

    void abort() {
        if (m_pSocket.get()) m_pSocket->close();
    }

    std::string lastErrorMessage();

    int lastError() const { return m_lastError; }

    DWORD lastAPIError() const { return m_lastAPIError; }

    // const int initialisers in class declaration
    // are unsupported by VC++ so we use an enum instead
    enum HTTP_OPTIONS { 
        OPT_FOLLOW_REDIRECT=1,
        OPT_KEEP_ALIVE=2,
    };

    bool isOptionSet(int opt) const { return !!(m_options & opt); }

    bool getOption(int opt) const { return (m_options & opt) != 0; }

    int setOption(int opt) { int old=m_options; m_options |= opt; return old & opt; }

    void clearOption(int opt) { m_options &= ~opt; }

    int setOptions(int opt) { int old=m_options; m_options=opt; return old; }

    int getOptions() const { return m_options; }

    int setMaximumResponseSize(int maxResponseSize) {
        int oldMaxResponseSize = m_maxResponseSize;
        m_maxResponseSize = maxResponseSize;
        return oldMaxResponseSize;
    }

    int getMaximumResponseSize() const {
        return m_maxResponseSize;
    }

    int setTimeout(int timeout) {
        int oldTimeout = m_timeout;
        m_timeout = timeout;
        return oldTimeout;
    }

    int getTimeout() const {
        return m_timeout;
    }

    int setMaximumRedirects(int maxRedirects) {
        int oldRedirects = m_maxRedirects;
        m_maxRedirects = maxRedirects;
        return oldRedirects;
    }

    int getMaximumRedirects() const {
        return m_maxRedirects;
    }

    CURIComponents &getURI() { return m_URI; }

    void setURI(const CURIComponents &URI) {
        m_URI = URI;
    }

    void setProxyServer(const char* proxyServer) { m_proxyServer = proxyServer; }

    const std::string& getProxyServer() const { return m_proxyServer; }

    void setProxyPort(int proxyPort) { m_proxyPort = proxyPort; }

    int getProxyPort() const { return m_proxyPort; }

    void parseURI(const char *URIString, std::string::size_type URILength) 
    {
        m_URI.parse(URIString, URILength);
    }

    void parseURI(const std::string &URIString)
    {
        m_URI.parse(URIString);
    }

    std::string getCanonicalURI() const
    {
        return m_URI.make();
    }

    auto_byte_buf& getRequest() { return m_request; }

    int getStatusCode() const { return m_statusCode; }

    bool isResponseValid() const { return m_lastError == HTTP_NO_ERROR && m_statusCode != -1; }

    const unsigned char *getResponse() const { return m_response.str(); } 

    unsigned char *detachResponse() { return m_response.detach(); }

    size_t getResponseLength() const { return m_response.length(); }

    size_t getHeaderLength() const { return m_bodyOffset; }

    const unsigned char *getBody() const { return m_bodyOffset ? m_response.str() + m_bodyOffset : NULL; }

    size_t getBodyOffset() const { return m_bodyOffset; }

    size_t getBodyLength() const {
        return m_trailerOffset ? m_trailerOffset - m_bodyOffset : m_response.length() ? m_response.length() - m_bodyOffset : 0; 
    }

    size_t getTrailerOffset() const { return m_trailerOffset; }

    size_t getTrailerLength() const { return m_response.length() ? m_response.length() - m_trailerOffset : 0; }

    int connect(AsyncIoType tAsyncIo, HANDLE hCompletionPort = NULL);

    int makeRequest(bool fInitial = true);

    void addHeader(const char *header);

    int formatGETRequest();

    bool isConnected() const { return m_connected; }

    static void urlEncode(auto_byte_buf& out, const unsigned char* data, int len);

    static unsigned char *findLineEnd(const unsigned char *start, const unsigned char *end);

    unsigned char *getHeader(const char *header);
    
    std::string getHeaderValue(const char *header);

private:
    CHTTP();

    ~CHTTP();

    virtual void onConnectCompletion(BOOL bRet);
    virtual void onReadCompletion(BOOL bRet, DWORD cbReceived);
    virtual void onSendCompletion(BOOL bRet, DWORD cbSent);
    virtual void onCloseCompletion(BOOL bRet);
    virtual void onTimeout();
    virtual void onAllNotificationsProcessed();

    typedef void (CHTTP::*HTTPIoCompletionFn)(BOOL bRet, DWORD BytesReceived, BOOL bChain);

    void OnRecvHeaders(BOOL bRet, DWORD BytesReceived, BOOL bChain);
    void OnRecvContentLength(BOOL bRet, DWORD BytesReceived, BOOL bChain);
    void OnRecvCompleteStream(BOOL bRet, DWORD BytesReceived, BOOL bChain);
    void OnRecvChunked(BOOL bRet, DWORD BytesReceived, BOOL bChain);
    void OnRecvFooter(BOOL bRet, DWORD BytesReceived, BOOL bChain);
    void OnSend(BOOL bRet, DWORD BytesSent, BOOL bChain);
    
    void OnConnect(int ErrorCode);

    friend class CConnectionThread;

    // Helper functions

    BOOL BeginRead(HTTPIoCompletionFn CompletionFn, DWORD dwLength);
    
    BOOL BeginSend(HTTPIoCompletionFn CompletionFn, DWORD dwLength);

    BOOL ReadLine(HTTPIoCompletionFn CompletionFn);

    BOOL ReadLineChunked();

    void PageReceived();

    void ChunkReceived();

    int error(bool fNotifyListnener, int errnum, DWORD lastAPIError = ERROR_SUCCESS);

    void clearError();

    CHTTPListener* m_pListener;

    CHTTP* m_nextFree;

    std::auto_ptr<CAsyncSocketBase> m_pSocket;

    int m_statusCode;

    int m_bodyOffset;

    int m_trailerOffset;

    CURIComponents m_URI;

    std::string m_proxyServer;
    int m_proxyPort;

    int m_options;


    CCriticalSection m_errorLock;

    int m_lastError;

    DWORD m_lastAPIError;

    OW32::auto_byte_buf m_request;

    OW32::auto_byte_buf m_headers;

    OW32::auto_byte_buf m_response;

    enum HTTP_State
    {
        Initial,
        Header,
        Content,
        Chunks,
        Entity_Header,
        CompleteStream,
        Complete
    };

    HTTP_State m_RecvState;

    HTTPIoCompletionFn m_SendCompletionFn;

    HTTPIoCompletionFn m_ReadCompletionFn;

    int m_ContentLength;
    
    bool m_bChunked;

    int m_maxResponseSize;

    int m_maxRedirects;

    int m_timeout;

    int m_redirects;

    int m_totalData;
    
    int m_pos;

    int m_lineStart;

    int m_eof;

    enum LineState {
        LS_SEEK,
        LS_MAYBE_CRLF,
        LS_MAYBE_CONTINUATION
    };
    LineState m_lineState;

    bool m_bFirstChunk;

    int m_totalSent;

    bool m_connected;

    bool m_autoRedirect;

    AsyncIoType m_AsyncIoType;

    HANDLE m_hCompletionPort;
};

#ifdef _MSC_VER
#pragma warning(default: 4251)
#endif

typedef CAutoRefCountedPtr<CHTTP> CHTTPPtr;

} // namespace OW32

#endif // OW32_http_h

---