SipLayer.h

Go to the documentation of this file.

#pragma once
 
#include "TextBasedProtocol.h"
 
 
namespace pcpp
{
// some popular SIP header fields
 
#define PCPP_SIP_FROM_FIELD "From"
#define PCPP_SIP_TO_FIELD "To"
#define PCPP_SIP_VIA_FIELD "Via"
#define PCPP_SIP_CALL_ID_FIELD "Call-ID"
#define PCPP_SIP_CONTENT_TYPE_FIELD "Content-Type"
#define PCPP_SIP_CONTENT_LENGTH_FIELD "Content-Length"
#define PCPP_SIP_CONTENT_DISPOSITION_FIELD "Content-Disposition"
#define PCPP_SIP_CONTENT_ENCODING_FIELD "Content-Encoding"
#define PCPP_SIP_CONTENT_LANGUAGE_FIELD "Content-Language"
#define PCPP_SIP_CSEQ_FIELD "CSeq"
#define PCPP_SIP_CONTACT_FIELD "Contact"
#define PCPP_SIP_MAX_FORWARDS_FIELD "Max-Forwards"
#define PCPP_SIP_USER_AGENT_FIELD "User-Agent"
#define PCPP_SIP_ACCEPT_FIELD "Accept"
#define PCPP_SIP_ACCEPT_ENCODING_FIELD "Accept-Encoding"
#define PCPP_SIP_ACCEPT_LANGUAGE_FIELD "Accept-Language"
#define PCPP_SIP_ALLOW_FIELD "Allow"
#define PCPP_SIP_AUTHORIZATION_FIELD "Authorization"
#define PCPP_SIP_DATE_FIELD "Date"
#define PCPP_SIP_MIME_VERSION_FIELD "MIME-Version"
#define PCPP_SIP_REASON_FIELD "Reason"
#define PCPP_SIP_SUPPORTED_FIELD "Supported"
#define PCPP_SIP_SERVER_FIELD "Server"
#define PCPP_SIP_WWW_AUTHENTICATE_FIELD "WWW-Authenticate"
#define PCPP_SIP_RETRY_AFTER_FIELD "Retry-After"
#define PCPP_SIP_RECORD_ROUTE_FIELD "Record-Route"
 
    class SipLayer : public TextBasedProtocolMessage
    {
    public:
        int getContentLength() const;
 
        HeaderField* setContentLength(int contentLength, const std::string& prevFieldName = "");
 
        // Overridden methods
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelSesionLayer;
        }
 
        void parseNextLayer() override;
 
        void computeCalculateFields() override;
 
        static bool isSipPort(uint16_t port)
        {
            return port == 5060 || port == 5061;
        }
 
        static SipLayer* parseSipLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet,
                                       uint16_t srcPort, uint16_t dstPort);
 
        static SipLayer* parseSipLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
    protected:
        SipLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet, ProtocolType protocol)
            : TextBasedProtocolMessage(data, dataLen, prevLayer, packet, protocol)
        {}
        SipLayer() : TextBasedProtocolMessage()
        {}
        SipLayer(const SipLayer& other) : TextBasedProtocolMessage(other)
        {}
        SipLayer& operator=(const SipLayer& other)
        {
            TextBasedProtocolMessage::operator=(other);
            return *this;
        }
 
        // implementation of abstract methods
        char getHeaderFieldNameValueSeparator() const override
        {
            return ':';
        }
        bool spacesAllowedBetweenHeaderFieldNameAndValue() const override
        {
            return true;
        }
 
    private:
        enum class SipParseResult
        {
            Unknown = 0,
            Request = 1,
            Response = 2,
        };
 
        static SipParseResult detectSipMessageType(const uint8_t* data, size_t dataLen);
    };
 
    class SipRequestFirstLine;
 
    class SipRequestLayer : public SipLayer
    {
        friend class SipRequestFirstLine;
 
    public:
        enum SipMethod
        {
            SipINVITE,
            SipACK,
            SipBYE,
            SipCANCEL,
            SipREGISTER,
            SipPRACK,
            SipOPTIONS,
            SipSUBSCRIBE,
            SipNOTIFY,
            SipPUBLISH,
            SipINFO,
            SipREFER,
            SipMESSAGE,
            SipUPDATE,
            SipMethodUnknown
        };
 
        SipRequestLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        SipRequestLayer(SipMethod method, const std::string& requestUri, const std::string& version = "SIP/2.0");
 
        ~SipRequestLayer() override;
 
        SipRequestLayer(const SipRequestLayer& other);
 
        SipRequestLayer& operator=(const SipRequestLayer& other);
 
        SipRequestFirstLine* getFirstLine() const
        {
            return m_FirstLine;
        }
 
        // implement Layer's abstract methods
 
        std::string toString() const override;
 
    private:
        SipRequestFirstLine* m_FirstLine;
    };
 
    class SipResponseFirstLine;
 
    class SipResponseLayer : public SipLayer
    {
        friend class SipResponseFirstLine;
 
    public:
        enum SipResponseStatusCode
        {
            Sip100Trying,
            Sip180Ringing,
            Sip181CallisBeingForwarded,
            Sip182Queued,
            Sip183SessioninProgress,
            Sip199EarlyDialogTerminated,
            Sip200OK,
            Sip202Accepted,
            Sip204NoNotification,
            Sip300MultipleChoices,
            Sip301MovedPermanently,
            Sip302MovedTemporarily,
            Sip305UseProxy,
            Sip380AlternativeService,
            Sip400BadRequest,
            Sip401Unauthorized,
            Sip402PaymentRequired,
            Sip403Forbidden,
            Sip404NotFound,
            Sip405MethodNotAllowed,
            Sip406NotAcceptable,
            Sip407ProxyAuthenticationRequired,
            Sip408RequestTimeout,
            Sip409Conflict,
            Sip410Gone,
            Sip411LengthRequired,
            Sip412ConditionalRequestFailed,
            Sip413RequestEntityTooLarge,
            Sip414RequestURITooLong,
            Sip415UnsupportedMediaType,
            Sip416UnsupportedURIScheme,
            Sip417UnknownResourcePriority,
            Sip420BadExtension,
            Sip421ExtensionRequired,
            Sip422SessionIntervalTooSmall,
            Sip423IntervalTooBrief,
            Sip424BadLocationInformation,
            Sip425BadAlertMessage,
            Sip428UseIdentityHeader,
            Sip429ProvideReferrerIdentity,
            Sip430FlowFailed,
            Sip433AnonymityDisallowed,
            Sip436BadIdentityInfo,
            Sip437UnsupportedCertificate,
            Sip438InvalidIdentityHeader,
            Sip439FirstHopLacksOutboundSupport,
            Sip440MaxBreadthExceeded,
            Sip469BadInfoPackage,
            Sip470ConsentNeeded,
            Sip480TemporarilyUnavailable,
            Sip481Call_TransactionDoesNotExist,
            Sip482LoopDetected,
            Sip483TooManyHops,
            Sip484AddressIncomplete,
            Sip485Ambiguous,
            Sip486BusyHere,
            Sip487RequestTerminated,
            Sip488NotAcceptableHere,
            Sip489BadEvent,
            Sip491RequestPending,
            Sip493Undecipherable,
            Sip494SecurityAgreementRequired,
            Sip500ServerInternalError,
            Sip501NotImplemented,
            Sip502BadGateway,
            Sip503ServiceUnavailable,
            Sip504ServerTimeout,
            Sip505VersionNotSupported,
            Sip513MessageTooLarge,
            Sip555PushNotificationServiceNotSupported,
            Sip580PreconditionFailure,
            Sip600BusyEverywhere,
            Sip603Decline,
            Sip604DoesNotExistAnywhere,
            Sip606NotAcceptable,
            Sip607Unwanted,
            Sip608Rejected,
            SipStatusCodeUnknown
        };
 
        SipResponseLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        explicit SipResponseLayer(SipResponseLayer::SipResponseStatusCode statusCode, std::string statusCodeString = "",
                                  const std::string& sipVersion = "SIP/2.0");
 
        ~SipResponseLayer() override;
 
        SipResponseLayer(const SipResponseLayer& other);
 
        SipResponseLayer& operator=(const SipResponseLayer& other);
 
        SipResponseFirstLine* getFirstLine() const
        {
            return m_FirstLine;
        }
 
        // implement Layer's abstract methods
 
        std::string toString() const override;
 
    private:
        SipResponseFirstLine* m_FirstLine;
    };
 
    class SipRequestFirstLine
    {
        friend class SipRequestLayer;
 
    public:
        struct SipFirstLineData
        {
            std::string method;   
            std::string uri;      
            std::string version;  
        };
 
        SipRequestLayer::SipMethod getMethod() const
        {
            return m_Method;
        }
 
        bool setMethod(SipRequestLayer::SipMethod newMethod);
 
        std::string getUri() const;
 
        bool setUri(const std::string& newUri);
 
        std::string getVersion() const
        {
            return m_Version;
        }
 
        static SipRequestLayer::SipMethod parseMethod(const char* data, size_t dataLen);
 
        static std::pair<bool, SipFirstLineData> parseFirstLine(const char* data, size_t dataLen);
 
        int getSize() const
        {
            return m_FirstLineEndOffset;
        }
 
        bool isComplete() const
        {
            return m_IsComplete;
        }
 
        class SipRequestFirstLineException : public std::exception
        {
        public:
            ~SipRequestFirstLineException() 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:
        SipRequestFirstLine(SipRequestLayer* sipRequest);
        SipRequestFirstLine(SipRequestLayer* sipRequest, SipRequestLayer::SipMethod method, const std::string& version,
                            const std::string& uri);
 
        void parseVersion();
 
        SipRequestLayer* m_SipRequest;
        SipRequestLayer::SipMethod m_Method;
        std::string m_Version;
        int m_VersionOffset;
        int m_UriOffset;
        int m_FirstLineEndOffset;
        bool m_IsComplete;
        SipRequestFirstLineException m_Exception;
    };
 
    class SipResponseFirstLine
    {
        friend class SipResponseLayer;
 
    public:
        struct FirstLineData
        {
            std::string version;
            SipResponseLayer::SipResponseStatusCode statusCode;
        };
 
        SipResponseLayer::SipResponseStatusCode getStatusCode() const
        {
            return m_StatusCode;
        }
 
        int getStatusCodeAsInt() const;
 
        std::string getStatusCodeString() const;
 
        bool setStatusCode(SipResponseLayer::SipResponseStatusCode newStatusCode, std::string statusCodeString = "");
 
        std::string getVersion() const
        {
            return m_Version;
        }
 
        void setVersion(const std::string& newVersion);
 
        static SipResponseLayer::SipResponseStatusCode parseStatusCode(const char* data, size_t dataLen);
 
        static std::string parseVersion(const char* data, size_t dataLen);
 
        static std::pair<bool, FirstLineData> parseFirstLine(const char* data, size_t dataLen);
 
        int getSize() const
        {
            return m_FirstLineEndOffset;
        }
 
        bool isComplete() const
        {
            return m_IsComplete;
        }
 
        class SipResponseFirstLineException : public std::exception
        {
        public:
            ~SipResponseFirstLineException() 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:
        SipResponseFirstLine(SipResponseLayer* sipResponse);
        SipResponseFirstLine(SipResponseLayer* sipResponse, const std::string& version,
                             SipResponseLayer::SipResponseStatusCode statusCode, std::string statusCodeString = "");
 
        SipResponseLayer* m_SipResponse;
        std::string m_Version;
        SipResponseLayer::SipResponseStatusCode m_StatusCode;
        int m_FirstLineEndOffset;
        bool m_IsComplete;
        SipResponseFirstLineException m_Exception;
    };
 
}  // namespace pcpp