HttpLayer.h

Go to the documentation of this file.

#ifndef PACKETPP_HTTP_LAYER
#define PACKETPP_HTTP_LAYER

#include "TextBasedProtocol.h"
#include <string>
#include <exception>
#include <map>


namespace pcpp
{

    enum HttpVersion
    {
        ZeroDotNine,
        OneDotZero,
        OneDotOne,
        HttpVersionUnknown
    };

    // some popular HTTP fields

#define PCPP_HTTP_HOST_FIELD                "Host"

#define PCPP_HTTP_CONNECTION_FIELD          "Connection"

#define PCPP_HTTP_USER_AGENT_FIELD          "User-Agent"

#define PCPP_HTTP_REFERER_FIELD             "Referer"

#define PCPP_HTTP_ACCEPT_FIELD              "Accept"

#define PCPP_HTTP_ACCEPT_ENCODING_FIELD     "Accept-Encoding"

#define PCPP_HTTP_ACCEPT_LANGUAGE_FIELD     "Accept-Language"

#define PCPP_HTTP_COOKIE_FIELD              "Cookie"

#define PCPP_HTTP_CONTENT_LENGTH_FIELD      "Content-Length"

#define PCPP_HTTP_CONTENT_ENCODING_FIELD    "Content-Encoding"

#define PCPP_HTTP_CONTENT_TYPE_FIELD        "Content-Type"

#define PCPP_HTTP_TRANSFER_ENCODING_FIELD   "Transfer-Encoding"

#define PCPP_HTTP_SERVER_FIELD              "Server"



    // -------- Class HttpMessage -----------------


    class HttpMessage : public TextBasedProtocolMessage
    {
    public:

        virtual ~HttpMessage() {}

        static const std::map<uint16_t, bool>* getHTTPPortMap();

        // overriden methods

        virtual HeaderField* addField(const std::string& fieldName, const std::string& fieldValue);
        virtual HeaderField* addField(const HeaderField& newField);
        virtual HeaderField* insertField(HeaderField* prevField, const std::string& fieldName, const std::string& fieldValue);
        virtual HeaderField* insertField(HeaderField* prevField, const HeaderField& newField);

        OsiModelLayer getOsiModelLayer() { return OsiModelApplicationLayer; }

    protected:
        HttpMessage(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet) : TextBasedProtocolMessage(data, dataLen, prevLayer, packet) {}
        HttpMessage() : TextBasedProtocolMessage() {}
        HttpMessage(const HttpMessage& other) : TextBasedProtocolMessage(other) {}
        HttpMessage& operator=(const HttpMessage& other) { TextBasedProtocolMessage::operator=(other); return *this; }

        // implementation of abstract methods
        char getHeaderFieldNameValueSeparator() { return ':'; }
        bool spacesAllowedBetweenHeaderFieldNameAndValue() { return true; }
    };




    class HttpRequestFirstLine;




    // -------- Class HttpRequestLayer -----------------

    class HttpRequestLayer : public HttpMessage
    {
        friend class HttpRequestFirstLine;
    public:
        enum HttpMethod
        {
            HttpGET,
            HttpHEAD,
            HttpPOST,
            HttpPUT,
            HttpDELETE,
            HttpTRACE,
            HttpOPTIONS,
            HttpCONNECT,
            HttpPATCH,
            HttpMethodUnknown
        };

        HttpRequestLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);

        HttpRequestLayer(HttpMethod method, std::string uri, HttpVersion version);

        virtual ~HttpRequestLayer();

        HttpRequestLayer(const HttpRequestLayer& other);

        HttpRequestLayer& operator=(const HttpRequestLayer& other);

        inline HttpRequestFirstLine* getFirstLine() { return m_FirstLine; }

        std::string getUrl();

        // implement Layer's abstract methods
        std::string toString();

    private:
        HttpRequestFirstLine* m_FirstLine;
    };





    // -------- Class HttpResponseLayer -----------------

    class HttpResponseFirstLine;


    class HttpResponseLayer : public HttpMessage
    {
        friend class HttpResponseFirstLine;
    public:
        enum HttpResponseStatusCode
        {
            Http100Continue,
            Http101SwitchingProtocols,
            Http102Processing,
            Http200OK,
            Http201Created,
            Http202Accepted,
            Http203NonAuthoritativeInformation,
            Http204NoContent,
            http205ResetContent,
            Http206PartialContent,
            Http207MultiStatus,
            Http208AlreadyReported,
            Http226IMUsed,
            Http300MultipleChoices,
            Http301MovedPermanently,
            Http302,
            Http303SeeOther,
            Http304NotModified,
            Http305UseProxy,
            Http306SwitchProxy,
            Http307TemporaryRedirect,
            Http308PermanentRedirect,
            Http400BadRequest,
            Http401Unauthorized,
            Http402PaymentRequired,
            Http403Forbidden,
            Http404NotFound,
            Http405MethodNotAllowed,
            Http406NotAcceptable,
            Http407ProxyAuthenticationRequired,
            Http408RequestTimeout,
            Http409Conflict,
            Http410Gone,
            Http411LengthRequired,
            Http412PreconditionFailed,
            Http413RequestEntityTooLarge,
            Http414RequestURITooLong,
            Http415UnsupportedMediaType,
            Http416RequestedRangeNotSatisfiable,
            Http417ExpectationFailed,
            Http418Imateapot,
            Http419AuthenticationTimeout,
            Http420,
            Http422UnprocessableEntity,
            Http423Locked,
            Http424FailedDependency,
            Http426UpgradeRequired,
            Http428PreconditionRequired,
            Http429TooManyRequests,
            Http431RequestHeaderFieldsTooLarge,
            Http440LoginTimeout,
            Http444NoResponse,
            Http449RetryWith,
            Http450BlockedByWindowsParentalControls,
            Http451,
            Http494RequestHeaderTooLarge,
            Http495CertError,
            Http496NoCert,
            Http497HTTPtoHTTPS,
            Http498TokenExpiredInvalid,
            Http499,
            Http500InternalServerError,
            Http501NotImplemented,
            Http502BadGateway,
            Http503ServiceUnavailable,
            Http504GatewayTimeout,
            Http505HTTPVersionNotSupported,
            Http506VariantAlsoNegotiates,
            Http507InsufficientStorage,
            Http508LoopDetected,
            Http509BandwidthLimitExceeded,
            Http510NotExtended,
            Http511NetworkAuthenticationRequired,
            Http520OriginError,
            Http521WebServerIsDown,
            Http522ConnectionTimedOut,
            Http523ProxyDeclinedRequest,
            Http524aTimeoutOccurred,
            Http598NetworkReadTimeoutError,
            Http599NetworkConnectTimeoutError,
            HttpStatusCodeUnknown
        };


        HttpResponseLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);

        HttpResponseLayer(HttpVersion version, HttpResponseLayer::HttpResponseStatusCode statusCode, std::string statusCodeString = "");

        virtual ~HttpResponseLayer();

        HttpResponseLayer(const HttpResponseLayer& other);

        HttpResponseLayer& operator=(const HttpResponseLayer& other);

        inline HttpResponseFirstLine* getFirstLine() { return m_FirstLine; }

        HeaderField* setContentLength(int contentLength, const std::string prevFieldName = "");

        int getContentLength();

        // implement Layer's abstract methods

        std::string toString();

    private:
        HttpResponseFirstLine* m_FirstLine;

    };





    // -------- Class HttpRequestFirstLine -----------------

    class HttpRequestFirstLine
    {
        friend class HttpRequestLayer;
    public:
        inline HttpRequestLayer::HttpMethod getMethod() { return m_Method; }

        bool setMethod(HttpRequestLayer::HttpMethod newMethod);

        std::string getUri();

        bool setUri(std::string newUri);

        inline HttpVersion getVersion() { return m_Version; }

        void setVersion(HttpVersion newVersion);

        static HttpRequestLayer::HttpMethod parseMethod(char* data, size_t dataLen);

        inline int getSize() { return m_FirstLineEndOffset; }

        inline bool isComplete() { return m_IsComplete; }

        class HttpRequestFirstLineException : public std::exception
        {
        public:
            ~HttpRequestFirstLineException() throw() {}
            void setMessage(std::string message) { m_Message = message; }
            virtual const char* what() const throw()
            {
                return m_Message.c_str();
            }
        private:
            std::string m_Message;
        };
    private:
        HttpRequestFirstLine(HttpRequestLayer* httpRequest);
        HttpRequestFirstLine(HttpRequestLayer* httpRequest, HttpRequestLayer::HttpMethod method, HttpVersion version, std::string uri = "/");
            //throw(HttpRequestFirstLineException); // Deprecated in C++17

        void parseVersion();

        HttpRequestLayer* m_HttpRequest;
        HttpRequestLayer::HttpMethod m_Method;
        HttpVersion m_Version;
        int m_VersionOffset;
        int m_UriOffset;
        int m_FirstLineEndOffset;
        bool m_IsComplete;
        HttpRequestFirstLineException m_Exception;
    };





    // -------- Class HttpResponseFirstLine -----------------

    class HttpResponseFirstLine
    {
        friend class HttpResponseLayer;
    public:
        inline HttpResponseLayer::HttpResponseStatusCode getStatusCode() { return m_StatusCode; }

        int getStatusCodeAsInt();

        std::string getStatusCodeString();

        bool setStatusCode(HttpResponseLayer::HttpResponseStatusCode newStatusCode, std::string statusCodeString = "");

        inline HttpVersion getVersion() { return m_Version; }

        void setVersion(HttpVersion newVersion);

        static HttpResponseLayer::HttpResponseStatusCode parseStatusCode(char* data, size_t dataLen);

        inline int getSize() { return m_FirstLineEndOffset; }

        inline bool isComplete() { return m_IsComplete; }

        class HttpResponseFirstLineException : public std::exception
        {
        public:
            ~HttpResponseFirstLineException() throw() {}
            void setMessage(std::string message) { m_Message = message; }
            virtual const char* what() const throw()
            {
                return m_Message.c_str();
            }
        private:
            std::string m_Message;
        };

    private:
        HttpResponseFirstLine(HttpResponseLayer* httpResponse);
        HttpResponseFirstLine(HttpResponseLayer* httpResponse,  HttpVersion version, HttpResponseLayer::HttpResponseStatusCode statusCode, std::string statusCodeString = "");

        static HttpVersion parseVersion(char* data, size_t dataLen);
        static HttpResponseLayer::HttpResponseStatusCode validateStatusCode(char* data, size_t dataLen, HttpResponseLayer::HttpResponseStatusCode potentialCode);


        HttpResponseLayer* m_HttpResponse;
        HttpVersion m_Version;
        HttpResponseLayer::HttpResponseStatusCode m_StatusCode;
        int m_FirstLineEndOffset;
        bool m_IsComplete;
        HttpResponseFirstLineException m_Exception;
    };

} // namespace pcpp

#endif /* PACKETPP_HTTP_LAYER */