HttpLayer.h

Go to the documentation of this file.

#pragma once
 
#include "DeprecationUtils.h"
#include "TextBasedProtocol.h"
#include <string>
#include <exception>
 
 
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:
        ~HttpMessage() override = default;
 
        static bool isHttpPort(uint16_t port)
        {
            return port == 80 || port == 8080;
        }
 
        // overridden methods
 
        HeaderField* addField(const std::string& fieldName, const std::string& fieldValue) override;
        HeaderField* addField(const HeaderField& newField) override;
        HeaderField* insertField(HeaderField* prevField, const std::string& fieldName,
                                 const std::string& fieldValue) override;
        HeaderField* insertField(HeaderField* prevField, const HeaderField& newField) override;
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelApplicationLayer;
        }
 
    protected:
        HttpMessage(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet, ProtocolType protocol)
            : TextBasedProtocolMessage(data, dataLen, prevLayer, packet, protocol)
        {}
        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 override
        {
            return ':';
        }
        bool spacesAllowedBetweenHeaderFieldNameAndValue() const override
        {
            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);
 
        ~HttpRequestLayer() override;
 
        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 override;
 
    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,
 
            // clang-format off
            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
            // clang-format on
        };
 
        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("Use other constructors instead")
        explicit HttpResponseLayer(HttpVersion version, const HttpResponseStatusCode& statusCode,
                                   const std::string& statusCodeString);
 
        explicit HttpResponseLayer(HttpVersion version, const HttpResponseStatusCode& statusCode);
 
        ~HttpResponseLayer() override;
 
        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 override;
 
    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() noexcept
            {}
            void setMessage(const std::string& message)
            {
                m_Message = message;
            }
            virtual const char* what() const noexcept
            {
                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("Use the other overload instead")
        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() noexcept
            {}
            void setMessage(const std::string& message)
            {
                m_Message = message;
            }
            virtual const char* what() const noexcept
            {
                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