httprequest.h

/* $Id: httprequest.h 131 2012-04-13 10:33:27Z felfert $
 *
 * EHS is a library for embedding HTTP(S) support into a C++ application
 *
 * Copyright (C) 2004 Zachary J. Hansen
 *
 * Code cleanup, new features and bugfixes: Copyright (C) 2010 Fritz Elfert
 *
 *    This library is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License version 2.1 as published by the Free Software Foundation;
 *
 *    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
 *    Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser 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
 *
 *    This can be found in the 'COPYING' file.
 *
 */

#ifndef HTTPREQUEST_H
#define HTTPREQUEST_H

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

enum RequestMethod {
    REQUESTMETHOD_OPTIONS, /* not implemented */
    REQUESTMETHOD_GET,
    REQUESTMETHOD_HEAD,
    REQUESTMETHOD_POST,
    REQUESTMETHOD_PUT, 
    REQUESTMETHOD_DELETE, 
    REQUESTMETHOD_TRACE, 
    REQUESTMETHOD_CONNECT, 
    REQUESTMETHOD_UNKNOWN 
};

class HttpRequest {

    private:

        HttpRequest (int inRequestId, EHSConnection *ipoSourceEHSConnection);

    public:

        virtual ~HttpRequest ( );

        std::string RemoteAddress();

        int RemotePort();

        std::string LocalAddress();

        int LocalPort();

        DEPRECATED("Use RemoteAddress()")
            std::string Address() { return RemoteAddress(); }

        DEPRECATED("Use RemotePort()")
            int Port() { return RemotePort(); }

        int Id() const { return m_nRequestId; }

        EHSConnection *Connection() const { return m_poSourceEHSConnection; }

        RequestMethod Method() const { return m_nRequestMethod; }

        bool Secure() const { return m_bSecure; }

        bool ClientDisconnected();

        const std::string &Uri() const { return m_sUri; }

        const std::string &HttpVersion() const { return m_sHttpVersionNumber; }

        const std::string &Body() const { return m_sBody; }

        StringCaseMap &Headers() { return m_oRequestHeaders; }

        FormValueMap &FormValues() { return m_oFormValueMap; }

        CookieMap &Cookies() { return m_oCookieMap; }

        FormValue &FormValues(const std::string & name)
        {
            return m_oFormValueMap[name];
        }

        std::string Headers(const std::string & name)
        {
            if (m_oRequestHeaders.find(name) != m_oRequestHeaders.end()) {
                return m_oRequestHeaders[name];
            }
            return std::string();
        }

        void SetHeader(const std::string & name, const std::string & value)
        {
            m_oRequestHeaders[name] = value;
        }

        std::string Cookies(const std::string & name)
        {
            if (m_oCookieMap.find(name) != m_oCookieMap.end()) {
                return m_oCookieMap[name];
            }
            return std::string();
        }

    private:

        HttpRequest(const HttpRequest &);

        HttpRequest & operator=(const HttpRequest &);

        void GetFormDataFromString(const std::string &irsString);

        enum HttpParseStates {
            HTTPPARSESTATE_INVALID = 0,
            HTTPPARSESTATE_REQUEST,
            HTTPPARSESTATE_HEADERS,
            HTTPPARSESTATE_BODY,
            HTTPPARSESTATE_BODYCHUNK,
            HTTPPARSESTATE_BODYTRAILER,
            HTTPPARSESTATE_BODYTRAILER2,
            HTTPPARSESTATE_COMPLETEREQUEST,
            HTTPPARSESTATE_INVALIDREQUEST
        };

        enum ParseMultipartFormDataResult { 
            PARSEMULTIPARTFORMDATA_INVALID = 0,
            PARSEMULTIPARTFORMDATA_SUCCESS,
            PARSEMULTIPARTFORMDATA_FAILED 
        };

        enum ParseSubbodyResult {
            PARSESUBBODY_INVALID = 0,
            PARSESUBBODY_SUCCESS,
            PARSESUBBODY_INVALIDSUBBODY, // no blank line?
            PARSESUBBODY_FAILED // other reason
        };

        ParseMultipartFormDataResult ParseMultipartFormData();

        ParseSubbodyResult ParseSubbody(std::string sSubBody);

        HttpParseStates ParseData(std::string & irsData);

        int ParseCookieData (std::string & irsData);

        HttpParseStates m_nCurrentHttpParseState;

        RequestMethod m_nRequestMethod;

        std::string m_sUri;

        std::string m_sOriginalUri;

        std::string m_sHttpVersionNumber;

        std::string m_sBody; 

        std::string m_sLastHeaderName;

        bool m_bSecure;

        StringCaseMap m_oRequestHeaders;

        FormValueMap m_oFormValueMap;

        CookieMap m_oCookieMap;

        int m_nRequestId;

        EHSConnection * m_poSourceEHSConnection;

        bool m_bChunked;

        size_t m_nChunkLen;

        friend class EHSConnection;
        friend class EHS;
};


// GLOBAL HELPER FUNCTIONS

std::string GetNextLine(std::string & buffer);

RequestMethod GetRequestMethodFromString(const std::string & method);

bool IsMultivalHeader(const std::string &header);

bool MultivalHeaderContains(const std::string &header, const std::string &value);

#endif // HTTPREQUEST_H