HttpLayer.h

Go to the documentation of this file.

#ifndef PACKETPP_HTTP_LAYER
#define PACKETPP_HTTP_LAYER
 
#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"
 
 
 
    // -------- Class HttpMessage -----------------
 
 
    class HttpMessage : public TextBasedProtocolMessage
    {
    public:
 
        virtual ~HttpMessage() {}
 
        static bool isHttpPort(uint16_t port) { return port == 80 || port == 8080; }
 
        // 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() 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 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);
 
        HttpRequestFirstLine* getFirstLine() const { return m_FirstLine; }
 
        std::string getUrl() const;
 
        // implement Layer's abstract methods
        std::string toString() const;
 
    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);
 
        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(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(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:
        HttpResponseLayer::HttpResponseStatusCode getStatusCode() const { return m_StatusCode; }
 
        int getStatusCodeAsInt() const;
 
        std::string getStatusCodeString() const;
 
        bool setStatusCode(HttpResponseLayer::HttpResponseStatusCode newStatusCode, std::string statusCodeString = "");
 
        HttpVersion getVersion() const { return m_Version; }
 
        void setVersion(HttpVersion newVersion);
 
        static HttpResponseLayer::HttpResponseStatusCode parseStatusCode(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(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 */