HttpLayer.h

Go to the documentation of this file.

#ifndef PACKETPP_HTTP_LAYER
#define PACKETPP_HTTP_LAYER

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

#ifndef PCPP_DEPRECATED
#if defined(__GNUC__) || defined(__clang__)
#define PCPP_DEPRECATED __attribute__((deprecated))
#elif defined(_MSC_VER)
#define PCPP_DEPRECATED __declspec(deprecated)
#else
#pragma message("WARNING: DEPRECATED feature is not implemented for this compiler")
#define PCPP_DEPRECATED
#endif
#endif


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"


    // -------- classes to be defined later -----------------


    class HttpRequestFirstLine;
    class HttpResponseFirstLine;


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


    class HttpMessage : public TextBasedProtocolMessage
    {
    public:

        virtual ~HttpMessage() {}

        static bool isHttpPort(uint16_t port) { return port == 80 || port == 8080; }

        // overridden 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() const { 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() const { return ':'; }
        bool spacesAllowedBetweenHeaderFieldNameAndValue() const { return true; }
    };


    // -------- 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, const std::string& uri, HttpVersion version);

        virtual ~HttpRequestLayer();

        HttpRequestLayer(const HttpRequestLayer& other);

        HttpRequestLayer& operator=(const HttpRequestLayer& other);

        HttpRequestFirstLine* getFirstLine() const { return m_FirstLine; }

        std::string getUrl() const;

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

    private:
        HttpRequestFirstLine* m_FirstLine;
    };

    // -------- Class HttpResponseStatusCode -----------------

    class HttpResponseStatusCode
    {
    public:
        enum Value: int
        {
            Http100Continue = 100,
            Http101SwitchingProtocols = 101,
            Http102Processing = 102,
            Http103EarlyHints = 103,
            Http200OK= 200,
            Http201Created = 201,
            Http202Accepted = 202,
            Http203NonAuthoritativeInformation = 203,
            Http204NoContent = 204,
            Http205ResetContent = 205,
            Http206PartialContent = 206,
            Http207MultiStatus = 207,
            Http208AlreadyReported = 208,
            Http226IMUsed = 226,
            Http300MultipleChoices = 300,
            Http301MovedPermanently = 301,
            Http302 = 302,
            Http303SeeOther = 303,
            Http304NotModified = 304,
            Http305UseProxy = 305,
            Http306SwitchProxy = 306,
            Http307TemporaryRedirect = 307,
            Http308PermanentRedirect = 308,
            Http400BadRequest = 400,
            Http401Unauthorized = 401,
            Http402PaymentRequired = 402,
            Http403Forbidden = 403,
            Http404NotFound = 404,
            Http405MethodNotAllowed = 405,
            Http406NotAcceptable = 406,
            Http407ProxyAuthenticationRequired = 407,
            Http408RequestTimeout = 408,
            Http409Conflict = 409,
            Http410Gone = 410,
            Http411LengthRequired = 411,
            Http412PreconditionFailed = 412,
            Http413RequestEntityTooLarge = 413,
            Http414RequestURITooLong = 414,
            Http415UnsupportedMediaType = 415,
            Http416RequestedRangeNotSatisfiable = 416,
            Http417ExpectationFailed = 417,
            Http418ImATeapot = 418,
            Http419AuthenticationTimeout = 419,
            Http420 = 420,
            Http421MisdirectedRequest = 421,
            Http422UnprocessableEntity = 422,
            Http423Locked = 423,
            Http424FailedDependency = 424,
            Http425TooEarly = 425,
            Http426UpgradeRequired = 426,
            Http428PreconditionRequired = 428,
            Http429TooManyRequests = 429,
            Http431RequestHeaderFieldsTooLarge = 431,
            Http440LoginTimeout = 440,
            Http444NoResponse = 444,
            Http449RetryWith = 449,
            Http450BlockedByWindowsParentalControls = 450,
            Http451 = 451,
            Http494RequestHeaderTooLarge = 494,
            Http495CertError = 495,
            Http496NoCert = 496,
            Http497HTTPtoHTTPS = 497,
            Http498TokenExpiredInvalid = 498,
            Http499 = 499,

            Http500InternalServerError = 500,
            Http501NotImplemented = 501,
            Http502BadGateway = 502,
            Http503ServiceUnavailable = 503,
            Http504GatewayTimeout = 504,
            Http505HTTPVersionNotSupported = 505,
            Http506VariantAlsoNegotiates = 506,
            Http507InsufficientStorage = 507,
            Http508LoopDetected = 508,
            Http509BandwidthLimitExceeded = 509,
            Http510NotExtended = 510,
            Http511NetworkAuthenticationRequired = 511,
            Http520OriginError = 520,
            Http521WebServerIsDown = 521,
            Http522ConnectionTimedOut = 522,
            Http523ProxyDeclinedRequest = 523,
            Http524aTimeoutOccurred = 524,
            Http598NetworkReadTimeoutError = 598,
            Http599NetworkConnectTimeoutError = 599,

            HttpStatus1xxCodeUnknown = 900001, // 1xx: Informational - Request received, continuing process
            HttpStatus2xxCodeUnknown = 900002, // 2xx: Success - The action was successfully received, understood, and accepted
            HttpStatus3xxCodeUnknown = 900003, // 3xx: Redirection - Further action must be taken in order to complete the request
            HttpStatus4xxCodeUnknown = 900004, // 4xx: Client Error - The request contains bad syntax or cannot be fulfilled
            HttpStatus5xxCodeUnknown = 900005, // 5xx: Server Error - The server failed to fulfill an apparently valid request
            HttpStatusCodeUnknown = 999999, // other arbitrary number
        };

        HttpResponseStatusCode() = default;

        // cppcheck-suppress noExplicitConstructor
        HttpResponseStatusCode(Value statusCode) : m_Value(statusCode) { }

        explicit HttpResponseStatusCode(const int &statusCodeNumber, const std::string& statusMessage = "");

        explicit HttpResponseStatusCode(const Value& statusCode, const std::string& statusMessage);

        // Allow switch and comparisons.
        operator Value() const { return m_Value; }
        // Prevent usage: if(httpResponseStatusCode)
        explicit operator bool() const = delete;

        std::string toString() const
        {
            return std::to_string(m_Value);
        }

        int toInt() const
        {
            return static_cast<int>(m_Value);
        }

        std::string getMessage() const;
        bool isUnsupportedCode() const
        {
            return m_Value > 599;
        }

    private:
        Value m_Value = HttpStatusCodeUnknown;
        std::string m_CustomizedMessage;
    };

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

    class HttpResponseLayer : public HttpMessage
    {
        friend class HttpResponseFirstLine;
    public:
        // backward compatibility
        using HttpResponseStatusCode = pcpp::HttpResponseStatusCode;

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

        PCPP_DEPRECATED explicit HttpResponseLayer(HttpVersion version, const HttpResponseStatusCode& statusCode, const std::string& statusCodeString);

        explicit HttpResponseLayer(HttpVersion version, const HttpResponseStatusCode& statusCode);

        virtual ~HttpResponseLayer();

        HttpResponseLayer(const HttpResponseLayer& other);

        HttpResponseLayer& operator=(const HttpResponseLayer& other);

        HttpResponseFirstLine* getFirstLine() const { return m_FirstLine; }

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

        int getContentLength() const;

        // implement Layer's abstract methods

        std::string toString() const;

    private:
        HttpResponseFirstLine* m_FirstLine;

    };





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

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

        bool setMethod(HttpRequestLayer::HttpMethod newMethod);

        std::string getUri() const;

        bool setUri(std::string newUri);

        HttpVersion getVersion() const { return m_Version; }

        void setVersion(HttpVersion newVersion);

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

        int getSize() const { return m_FirstLineEndOffset; }

        bool isComplete() const { return m_IsComplete; }

        class HttpRequestFirstLineException : public std::exception
        {
        public:
            ~HttpRequestFirstLineException() throw() {}
            void setMessage(const 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, const std::string& uri = "/");

        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:
        HttpResponseStatusCode getStatusCode() const { return m_StatusCode; }

        int getStatusCodeAsInt() const;

        std::string getStatusCodeString() const;

        PCPP_DEPRECATED bool setStatusCode(const HttpResponseStatusCode& newStatusCode, const std::string& statusCodeString);

        bool setStatusCode(const HttpResponseStatusCode& newStatusCode);

        HttpVersion getVersion() const { return m_Version; }

        void setVersion(HttpVersion newVersion);

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

        static HttpVersion parseVersion(const char* data, size_t dataLen);

        int getSize() const { return m_FirstLineEndOffset; }

        bool isComplete() const { return m_IsComplete; }

        class HttpResponseFirstLineException : public std::exception
        {
        public:
            ~HttpResponseFirstLineException() throw() {}
            void setMessage(const 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, const HttpResponseStatusCode& statusCode);

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

} // namespace pcpp

#endif /* PACKETPP_HTTP_LAYER */