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() const;
 
        HeaderField* setContentLength(int contentLength, const std::string prevFieldName = "");
 
        // Overridden methods
 
        OsiModelLayer getOsiModelLayer() const { 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() const { return ':'; }
        bool spacesAllowedBetweenHeaderFieldNameAndValue() const { 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);
 
        SipRequestFirstLine* getFirstLine() const { return m_FirstLine; }
 
        // implement Layer's abstract methods
 
        std::string toString() const;
 
    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);
 
        SipResponseFirstLine* getFirstLine() const { return m_FirstLine; }
 
        // implement Layer's abstract methods
 
        std::string toString() const;
 
    private:
        SipResponseFirstLine* m_FirstLine;
    };
 
 
 
    class SipRequestFirstLine
    {
        friend class SipRequestLayer;
    public:
 
        SipRequestLayer::SipMethod getMethod() const { return m_Method; }
 
        bool setMethod(SipRequestLayer::SipMethod newMethod);
 
        std::string getUri() const;
 
        bool setUri(std::string newUri);
 
        std::string getVersion() const { return m_Version; }
 
        static SipRequestLayer::SipMethod parseMethod(char* data, size_t dataLen);
 
        int getSize() const { return m_FirstLineEndOffset; }
 
        bool isComplete() const { 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:
        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(std::string newVersion);
 
        static SipResponseLayer::SipResponseStatusCode parseStatusCode(char* data, size_t dataLen);
 
        int getSize() const { return m_FirstLineEndOffset; }
 
        bool isComplete() const { 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