SipLayer.h

Go to the documentation of this file.

#ifndef PACKETPP_SIP_LAYER
#define PACKETPP_SIP_LAYER

#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();

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

        // Overridden methods

        OsiModelLayer getOsiModelLayer() { return OsiModelSesionLayer; }

        void parseNextLayer();

        void computeCalculateFields();

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

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



    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, std::string requestUri, std::string version = "SIP/2.0");

        ~SipRequestLayer();

        SipRequestLayer(const SipRequestLayer& other);

        SipRequestLayer& operator=(const SipRequestLayer& other);

        inline SipRequestFirstLine* getFirstLine() { return m_FirstLine; }

        // implement Layer's abstract methods

        std::string toString();

    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,
            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,
            Sip580PreconditionFailure,
            Sip600BusyEverywhere,
            Sip603Decline,
            Sip604DoesNotExistAnywhere,
            Sip606NotAcceptable,
            Sip607Unwanted,
            SipStatusCodeUnknown
        };

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

        SipResponseLayer(SipResponseLayer::SipResponseStatusCode statusCode, std::string statusCodeString = "", std::string sipVersion = "SIP/2.0");

        virtual ~SipResponseLayer();

        SipResponseLayer(const SipResponseLayer& other);

        SipResponseLayer& operator=(const SipResponseLayer& other);

        inline SipResponseFirstLine* getFirstLine() { return m_FirstLine; }

        // implement Layer's abstract methods

        std::string toString();

    private:
        SipResponseFirstLine* m_FirstLine;
    };



    class SipRequestFirstLine
    {
        friend class SipRequestLayer;
    public:

        inline SipRequestLayer::SipMethod getMethod() { return m_Method; }

        bool setMethod(SipRequestLayer::SipMethod newMethod);

        std::string getUri();

        bool setUri(std::string newUri);

        inline std::string getVersion() { return m_Version; }

        static SipRequestLayer::SipMethod parseMethod(char* data, size_t dataLen);

        inline int getSize() { return m_FirstLineEndOffset; }

        inline bool isComplete() { return m_IsComplete; }

        class SipRequestFirstLineException : public std::exception
        {
        public:
            ~SipRequestFirstLineException() 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:
        SipRequestFirstLine(SipRequestLayer* sipRequest);
        SipRequestFirstLine(SipRequestLayer* sipRequest, SipRequestLayer::SipMethod method, std::string version, std::string uri);
            //throw(SipRequestFirstLineException); // Deprecated in C++17

        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:
        inline SipResponseLayer::SipResponseStatusCode getStatusCode() { return m_StatusCode; }

        int getStatusCodeAsInt();

        std::string getStatusCodeString();

        bool setStatusCode(SipResponseLayer::SipResponseStatusCode newStatusCode, std::string statusCodeString = "");

        inline std::string getVersion() { return m_Version; }

        void setVersion(std::string newVersion);

        static SipResponseLayer::SipResponseStatusCode parseStatusCode(char* data, size_t dataLen);

        inline int getSize() { return m_FirstLineEndOffset; }

        inline bool isComplete() { return m_IsComplete; }

        class SipResponseFirstLineException : public std::exception
        {
        public:
            ~SipResponseFirstLineException() 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:
        SipResponseFirstLine(SipResponseLayer* sipResponse);
        SipResponseFirstLine(SipResponseLayer* sipResponse,  std::string version, SipResponseLayer::SipResponseStatusCode statusCode, std::string statusCodeString = "");

        static std::string parseVersion(char* data, size_t dataLen);
        static SipResponseLayer::SipResponseStatusCode validateStatusCode(char* data, size_t dataLen, SipResponseLayer::SipResponseStatusCode potentialCode);


        SipResponseLayer* m_SipResponse;
        std::string m_Version;
        SipResponseLayer::SipResponseStatusCode m_StatusCode;
        int m_FirstLineEndOffset;
        bool m_IsComplete;
        SipResponseFirstLineException m_Exception;
    };

}

#endif // PACKETPP_SIP_LAYER