SipMessage.hxx

Go to the documentation of this file.

#if !defined(RESIP_SIPMESSAGE_HXX)
#define RESIP_SIPMESSAGE_HXX 
 
#include <sys/types.h>
 
#include <cstddef>
#include <list>
#include <vector>
#include <limits>
#include <memory>
#include <utility>
#include <iterator>
#include <type_traits>
 
#include "resip/stack/Contents.hxx"
#include "resip/stack/Headers.hxx"
#include "resip/stack/TransactionMessage.hxx"
#include "resip/stack/ParserContainer.hxx"
#include "resip/stack/ParserCategories.hxx"
#include "resip/stack/SecurityAttributes.hxx"
#include "resip/stack/Tuple.hxx"
#include "resip/stack/Uri.hxx"
#include "resip/stack/MessageDecorator.hxx"
#include "resip/stack/Cookie.hxx"
#include "resip/stack/ConnectionInfo.hxx"
#include "resip/stack/WsCookieContext.hxx"
#include "rutil/compat.hxx"
#include "rutil/ResipAssert.h"
#include "rutil/BaseException.hxx"
#include "rutil/Data.hxx"
#include "rutil/DinkyPool.hxx"
#include "rutil/StlPoolAllocator.hxx"
#include "rutil/Timer.hxx"
#include "rutil/HeapInstanceCounter.hxx"
 
#if defined(_MSC_VER) && !defined(__clang__)
#include <intrin.h>
#pragma intrinsic(_BitScanForward)
#if defined(_M_X64) || defined(_M_ARM64)
#pragma intrinsic(_BitScanForward64)
#endif
#if defined(_M_IX86) || defined(_M_X64)
#pragma intrinsic(_tzcnt_u32)
#endif
#if defined(_M_X64)
#pragma intrinsic(_tzcnt_u64)
#endif
#endif
 
namespace resip
{
 
class Contents;
class ExtensionHeader;
class SecurityAttributes;
 
class SipMessage : public TransactionMessage
{
   public:
      RESIP_HeapCount(SipMessage);
#ifndef __SUNPRO_CC
      typedef std::list< std::pair<Data, HeaderFieldValueList*>, StlPoolAllocator<std::pair<Data, HeaderFieldValueList*>, PoolBase > > UnknownHeaders;
#else
      typedef std::list< std::pair<Data, HeaderFieldValueList*> > UnknownHeaders;
#endif
 
      class KnownHeaders
      {
         private:
            using HeaderIndex = unsigned char;
            static constexpr HeaderIndex InvalidHeaderIndex = static_cast<HeaderIndex>(-1);
            static_assert(Headers::MAX_HEADERS <= InvalidHeaderIndex, "HeaderIndex type is too small to cover all SIP header types");
 
            using UsedBitMaskWord = std::size_t;
            static constexpr unsigned int UsedBitMaskWordBits = static_cast<unsigned int>(std::numeric_limits<UsedBitMaskWord>::digits);
            static constexpr unsigned int UsedBitMaskWordCount = (static_cast<unsigned int>(Headers::MAX_HEADERS) + UsedBitMaskWordBits - 1u) / UsedBitMaskWordBits;
 
         public:
            class HeaderInfo
            {
                  friend class KnownHeaders;
 
               private:
                  HeaderFieldValueList* mValues;
                  Headers::Type mType;
 
               public:
                  constexpr HeaderInfo() noexcept : mValues(nullptr), mType(Headers::UNKNOWN) {}
                  explicit constexpr HeaderInfo(Headers::Type type, HeaderFieldValueList* values = nullptr) noexcept : mValues(values), mType(type) {}
 
                  Headers::Type getType() const noexcept { return mType; }
 
                  HeaderFieldValueList* getValues() const noexcept { return mValues; }
                  void setValues(HeaderFieldValueList* values) noexcept { mValues = values; }
 
               private:
                  void setType(Headers::Type type) noexcept { mType = type; }
            };
 
         private:
            using TypedHeaders = std::vector<HeaderInfo, StlPoolAllocator<HeaderInfo, PoolBase> >;
 
            template<typename AdoptedIterator>
            class UsedIterator
            {
                  friend class KnownHeaders;
 
               public:
                  using iterator_category = std::forward_iterator_tag;
                  using difference_type = typename std::iterator_traits<AdoptedIterator>::difference_type;
                  using value_type = typename std::iterator_traits<AdoptedIterator>::value_type;
                  using reference = typename std::iterator_traits<AdoptedIterator>::reference;
                  using pointer = typename std::iterator_traits<AdoptedIterator>::pointer;
 
               private:
                  AdoptedIterator mIterator;
                  AdoptedIterator mEnd;
 
               public:
                  constexpr UsedIterator() noexcept : mIterator(), mEnd(mIterator) {}
                  UsedIterator(UsedIterator const&) = default;
 
                  template<
                     typename OtherAdoptedIterator1,
                     typename OtherAdoptedIterator2,
                     typename = typename std::enable_if<
                        std::is_constructible<AdoptedIterator, OtherAdoptedIterator1&&>::value && std::is_constructible<AdoptedIterator, OtherAdoptedIterator2&&>::value
                     >::type
                  >
                  explicit constexpr UsedIterator(OtherAdoptedIterator1&& iter, OtherAdoptedIterator2&& end)
                     noexcept(std::is_nothrow_constructible<AdoptedIterator, OtherAdoptedIterator1&&>::value &&
                        std::is_nothrow_constructible<AdoptedIterator, OtherAdoptedIterator2&&>::value) :
                     mIterator(std::forward<OtherAdoptedIterator1>(iter)),
                     mEnd(std::forward<OtherAdoptedIterator2>(end))
                  {
                  }
 
                  template<
                     typename OtherAdoptedIterator,
                     typename = typename std::enable_if<
                        !std::is_same<OtherAdoptedIterator, AdoptedIterator>::value && std::is_constructible<AdoptedIterator, OtherAdoptedIterator const&>::value
                     >::type
                  >
                  constexpr UsedIterator(UsedIterator<OtherAdoptedIterator> const& that)
                     noexcept(std::is_nothrow_constructible<AdoptedIterator, OtherAdoptedIterator const&>::value) :
                     mIterator(that.mIterator),
                     mEnd(that.mEnd)
                  {
                  }
 
                  reference operator*() const noexcept { return *mIterator; }
                  pointer operator->() const noexcept { return mIterator.operator->(); }
                  UsedIterator& operator++() { increment(); return *this; }
                  UsedIterator operator++(int) { UsedIterator copy(*this); increment(); return copy; }
 
                  friend bool operator==(UsedIterator const& left, UsedIterator const& right) noexcept { return left.mIterator == right.mIterator; }
                  friend bool operator!=(UsedIterator const& left, UsedIterator const& right) noexcept { return !(left == right); }
 
               private:
                  void increment() noexcept
                  {
                     ++mIterator;
                     advanceToNextUsedEntry();
                  }
 
                  void advanceToNextUsedEntry() noexcept
                  {
                     while (mIterator != mEnd && mIterator->getType() == Headers::UNKNOWN)
                        ++mIterator;
                  }
            };
 
         public:
            using iterator = UsedIterator<TypedHeaders::iterator>;
            using const_iterator = UsedIterator<TypedHeaders::const_iterator>;
            using value_type = TypedHeaders::value_type;
            using reference = TypedHeaders::reference;
            using const_reference = TypedHeaders::const_reference;
            using pointer = TypedHeaders::pointer;
            using const_pointer = TypedHeaders::const_pointer;
            using size_type = TypedHeaders::size_type;
            using difference_type = TypedHeaders::difference_type;
            using allocator_type = TypedHeaders::allocator_type;
 
            class OrderedView
            {
                  friend class KnownHeaders;
 
               public:
                  using value_type = KnownHeaders::value_type;
                  using reference = KnownHeaders::reference;
                  using const_reference = KnownHeaders::const_reference;
                  using pointer = KnownHeaders::pointer;
                  using const_pointer = KnownHeaders::const_pointer;
                  using size_type = KnownHeaders::size_type;
                  using difference_type = KnownHeaders::difference_type;
 
               private:
                  class Iterator
                  {
                        friend class OrderedView;
 
                     public:
                        using iterator_category = std::forward_iterator_tag;
                        using difference_type = std::ptrdiff_t;
                        using value_type = KnownHeaders::value_type;
                        using reference = value_type const&;
                        using pointer = const value_type*;
 
                     private:
                        using size_type = OrderedView::size_type;
 
                     private:
                        const KnownHeaders* mKnownHeaders;
                        size_type mPos;
 
                     public:
                        constexpr Iterator() noexcept : mKnownHeaders(nullptr), mPos(0u) {}
                        Iterator(Iterator const&) = default;
 
                        explicit constexpr Iterator(const KnownHeaders* knownHeaders, size_type pos) noexcept :
                           mKnownHeaders(knownHeaders),
                           mPos(pos)
                        {
                        }
 
                        reference operator*() const noexcept { return dereference(); }
                        pointer operator->() const noexcept { return &dereference(); }
                        Iterator& operator++() { increment(); return *this; }
                        Iterator operator++(int) { Iterator copy(*this); increment(); return copy; }
 
                        friend bool operator==(Iterator const& left, Iterator const& right) noexcept
                        {
                           resip_assert(left.mKnownHeaders == right.mKnownHeaders);
                           return left.mPos == right.mPos;
                        }
                        friend bool operator!=(Iterator const& left, Iterator const& right) noexcept
                        {
                           resip_assert(left.mKnownHeaders == right.mKnownHeaders);
                           return left.mPos != right.mPos;
                        }
 
                     private:
                        reference dereference() const noexcept
                        {
                           resip_assert(mKnownHeaders != nullptr);
                           return mKnownHeaders->mHeaders[mKnownHeaders->mHeaderIndices[mPos]];
                        }
 
                        void increment() noexcept
                        {
                           resip_assert(mPos < Headers::MAX_HEADERS);
                           ++mPos;
                           advanceToNextUsedEntry();
                        }
 
#if defined(_MSC_VER) && !defined(__clang__)
#pragma warning(push)
// unary minus operator applied to unsigned type, result still unsigned
#pragma warning(disable: 4146)
#endif
 
                        void advanceToNextUsedEntry() noexcept
                        {
                           resip_assert(mKnownHeaders != nullptr);
 
                           size_type mask_pos = mPos / UsedBitMaskWordBits;
                           size_type bit_pos = mPos % UsedBitMaskWordBits;
                           for (; mask_pos < UsedBitMaskWordCount; ++mask_pos)
                           {
                              const UsedBitMaskWord mask =
                                 mKnownHeaders->mUsedBitMask[mask_pos] & static_cast<UsedBitMaskWord>(-(static_cast<UsedBitMaskWord>(1u) << bit_pos));
                              if (mask != 0u)
                              {
                                 bit_pos = countrZeroNz(mask);
                                 break;
                              }
                              bit_pos = 0u;
                           }
 
                           mPos = mask_pos * UsedBitMaskWordBits + bit_pos;
 
                           resip_assert(mPos < Headers::MAX_HEADERS || mPos == (static_cast<size_type>(UsedBitMaskWordCount) * UsedBitMaskWordBits));
                        }
 
#if defined(_MSC_VER) && !defined(__clang__)
#pragma warning(pop)
#endif
 
#if defined(__GNUC__) || defined(__clang__)
                        static unsigned int countrZeroNz(unsigned int bitmask) noexcept { return __builtin_ctz(bitmask); }
                        static unsigned int countrZeroNz(unsigned long bitmask) noexcept { return __builtin_ctzl(bitmask); }
                        static unsigned int countrZeroNz(unsigned long long bitmask) noexcept { return __builtin_ctzll(bitmask); }
#elif defined(_MSC_VER)
                        static unsigned int countrZeroNz(uint32_t bitmask) noexcept
                        {
                           // On modern CPUs, tzcnt is slightly faster than bsf. CPUs without BMI1 will execute tzcnt
                           // and produce the same result as bsf for non-zero input.
#if defined(_M_IX86) || defined(_M_X64)
                           return static_cast<unsigned int>(_tzcnt_u32(bitmask));
#else
                           unsigned long res;
                           _BitScanForward(&res, bitmask);
                           return static_cast<unsigned int>(res);
#endif
                        }
 
                        static unsigned int countrZeroNz(uint64_t bitmask) noexcept
                        {
#if defined(_M_X64)
                           return static_cast<unsigned int>(_tzcnt_u64(bitmask));
#elif defined(_M_ARM64)
                           unsigned long res;
                           _BitScanForward64(&res, bitmask);
                           return static_cast<unsigned int>(res);
#else
                           unsigned int base_count = 0u;
                           uint32_t bitmask32 = static_cast<uint32_t>(bitmask);
                           if (bitmask32 == 0u)
                           {
                              base_count = 32u;
                              bitmask32 = static_cast<uint32_t>(bitmask >> 32u);
                           }
                           return base_count + countrZeroNz(bitmask32);
#endif
                        }
#else
                        static unsigned int countrZeroNz(UsedBitMaskWord bitmask) noexcept
                        {
                           unsigned int res = 0u;
                           for (unsigned int bits = UsedBitMaskWordBits >> 1u; bits > 0u && (bitmask & 1u) == 0u; bits >>= 1u)
                           {
                              if ((bitmask & ((static_cast<UsedBitMaskWord>(1u) << bits) - 1u)) == 0u)
                              {
                                 bitmask >>= bits;
                                 res += bits;
                              }
                           }
                           return res;
                        }
#endif
                  };
 
               public:
                  using iterator = Iterator;
                  using const_iterator = Iterator;
 
               private:
                  const KnownHeaders* mKnownHeaders;
 
               private:
                  explicit OrderedView(KnownHeaders const& knownHeaders) noexcept : mKnownHeaders(&knownHeaders)
                  {
                  }
 
               public:
                  bool empty() const noexcept { return mKnownHeaders->empty(); }
                  size_type size() const noexcept { return mKnownHeaders->size(); }
 
                  const_iterator cbegin() const noexcept { return begin(); }
                  const_iterator cend() const noexcept { return end(); }
 
                  const_iterator begin() const noexcept { const_iterator it(mKnownHeaders, 0u); it.advanceToNextUsedEntry(); return it; }
                  const_iterator end() const noexcept { return const_iterator(mKnownHeaders, static_cast<size_type>(UsedBitMaskWordCount) * UsedBitMaskWordBits); }
            };
 
            friend class OrderedView::Iterator;
 
         private:
            TypedHeaders mHeaders;
            HeaderIndex mSize;
            HeaderIndex mHeaderIndices[Headers::MAX_HEADERS];
            UsedBitMaskWord mUsedBitMask[UsedBitMaskWordCount];
 
         public:
            KnownHeaders() noexcept : mSize(0u) { resetIndices(); }
            explicit KnownHeaders(const allocator_type& alloc)
               noexcept(std::is_nothrow_constructible<TypedHeaders, const allocator_type&>::value) :
               mHeaders(alloc),
               mSize(0u)
            {
               resetIndices();
            }
 
            // Not copyable or moveable since the container elements may be associated with a memory pool
            KnownHeaders(const KnownHeaders&) = delete;
            KnownHeaders& operator=(const KnownHeaders&) = delete;
 
            bool empty() const noexcept { return mSize == 0u; }
            size_type size() const noexcept { return static_cast<size_type>(mSize); }
            void clear() noexcept;
            template<typename Disposer>
            void clearAndDispose(Disposer&& disposer) noexcept;
 
            const_iterator cbegin() const noexcept { return begin(); }
            const_iterator cend() const noexcept { return end(); }
 
            const_iterator begin() const noexcept { const_iterator it(mHeaders.begin(), mHeaders.end()); it.advanceToNextUsedEntry(); return it; }
            const_iterator end() const noexcept { return const_iterator(mHeaders.end(), mHeaders.end()); }
 
            iterator begin() noexcept { iterator it(mHeaders.begin(), mHeaders.end()); it.advanceToNextUsedEntry(); return it; }
            iterator end() noexcept { return iterator(mHeaders.end(), mHeaders.end()); }
 
            void reserve(size_type capacity) { mHeaders.reserve(capacity); }
            size_type capacity() const noexcept { return mHeaders.capacity(); }
 
            iterator find(Headers::Type type) noexcept;
            const_iterator find(Headers::Type type) const noexcept { return const_cast<KnownHeaders*>(this)->find(type); }
 
            void erase(iterator it) noexcept;
 
            template<typename ValuesFactory>
            iterator insert(Headers::Type type, ValuesFactory&& valuesFactory);
 
            OrderedView ordered() const noexcept { return OrderedView(*this); }
 
         private:
            void resetIndices() noexcept;
      };
 
      explicit SipMessage(const Tuple *receivedTransport = 0);
      SipMessage(const SipMessage& message);
 
      virtual Message* clone() const;
 
      SipMessage& operator=(const SipMessage& rhs);
      
      virtual const Data& getTransactionId() const;
 
      const Data& getRFC2543TransactionId() const;
      void setRFC2543TransactionId(const Data& tid);
      
      virtual ~SipMessage();
 
      static SipMessage* make(const Data& buffer, bool isExternal = false);
      void parseAllHeaders();
      
      static bool checkContentLength;
 
      class Exception final : public BaseException
      {
         public:
            Exception(const Data& msg, const Data& file, const int line)
               : BaseException(msg, file, line) {}
            const char* name() const noexcept override { return "SipMessage::Exception"; }
      };
 
      inline void setFromTU() { mIsExternal = false; }
 
      inline void setFromExternal() { mIsExternal = true; }
      
      inline bool isExternal() const { return mIsExternal; }
 
      inline bool isFromWire() const { return mReceivedTransportTuple.getType() != UNKNOWN_TRANSPORT; }
      
      virtual bool isClientTransaction() const;
      
      virtual EncodeStream& encode(EncodeStream& str) const;
      //sipfrags will not output Content Length if there is no body--introduce
      //friendship to hide this?
      virtual EncodeStream& encodeSipFrag(EncodeStream& str) const;
      EncodeStream& encodeEmbedded(EncodeStream& str) const;
      
      virtual EncodeStream& encodeBrief(EncodeStream& str) const;
      EncodeStream& encodeSingleHeader(Headers::Type type, EncodeStream& str) const;
 
      inline bool isRequest() const {return mRequest;}
      inline bool isResponse() const {return mResponse;}
      inline bool isInvalid() const {return mInvalid;}
      
      resip::MethodTypes method() const;
      const Data& methodStr() const;
      
      const resip::Data* getReason() const { return mReason; }
      
      const RequestLine& header(const RequestLineType& l) const;
 
      RequestLine& header(const RequestLineType& l);
 
      inline const RequestLine& const_header(const RequestLineType& l) const { return header(l); }
 
      const StatusLine& header(const StatusLineType& l) const;
 
      StatusLine& header(const StatusLineType& l);
 
      inline const StatusLine& const_header(const StatusLineType& l) const { return header(l); }
 
      bool exists(const HeaderBase& headerType) const;
      bool empty(const HeaderBase& headerType) const;
      inline void remove(const HeaderBase& headerType) { remove(headerType.getTypeNum()); }
 
      void remove(Headers::Type type);
 
#define defineHeader(_header, _name, _type, _rfc)                       \
      const H_##_header::Type& header(const H_##_header& headerType) const; \
            H_##_header::Type& header(const H_##_header& headerType); \
      inline const H_##_header::Type& const_header(const H_##_header& headerType) const \
      {\
         return header(headerType);\
      }
 
      
#define defineMultiHeader(_header, _name, _type, _rfc)                  \
      const H_##_header##s::Type& header(const H_##_header##s& headerType) const; \
            H_##_header##s::Type& header(const H_##_header##s& headerType); \
      inline const H_##_header##s::Type& const_header(const H_##_header##s& headerType) const \
      {\
         return header(headerType);\
      }
      
      defineHeader(ContentDisposition, "Content-Disposition", Token, "RFC 3261");
      defineHeader(ContentEncoding, "Content-Encoding", Token, "RFC 3261");
      defineHeader(MIMEVersion, "Mime-Version", Token, "RFC 3261");
      defineHeader(Priority, "Priority", Token, "RFC 3261");
      defineHeader(Event, "Event", Token, "RFC 3265");
      defineHeader(SubscriptionState, "Subscription-State", Token, "RFC 3265");
      defineHeader(SIPETag, "SIP-ETag", Token, "RFC 3903");
      defineHeader(SIPIfMatch, "SIP-If-Match", Token, "RFC 3903");
      defineHeader(ContentId, "Content-ID", Token, "RFC 2045");
      defineMultiHeader(AllowEvents, "Allow-Events", Token, "RFC 3265");
      defineMultiHeader(Identity, "Identity", IdentityCategory, "RFC 8224");   // Originally defined in RFC 4474 as a single header, but later modified by RFC8224 to be a multiheader
      defineMultiHeader(AcceptEncoding, "Accept-Encoding", Token, "RFC 3261");
      defineMultiHeader(AcceptLanguage, "Accept-Language", Token, "RFC 3261");
      defineMultiHeader(Allow, "Allow", Token, "RFC 3261");
      defineMultiHeader(ContentLanguage, "Content-Language", Token, "RFC 3261");
      defineMultiHeader(ProxyRequire, "Proxy-Require", Token, "RFC 3261");
      defineMultiHeader(Require, "Require", Token, "RFC 3261");
      defineMultiHeader(Supported, "Supported", Token, "RFC 3261");
      defineMultiHeader(Unsupported, "Unsupported", Token, "RFC 3261");
      defineMultiHeader(SecurityClient, "Security-Client", Token, "RFC 3329");
      defineMultiHeader(SecurityServer, "Security-Server", Token, "RFC 3329");
      defineMultiHeader(SecurityVerify, "Security-Verify", Token, "RFC 3329");
      defineMultiHeader(RequestDisposition, "Request-Disposition", Token, "RFC 3841");
      defineMultiHeader(Reason, "Reason", Token, "RFC 3326");
      defineMultiHeader(Privacy, "Privacy", PrivacyCategory, "RFC 3323");
      defineMultiHeader(PMediaAuthorization, "P-Media-Authorization", Token, "RFC 3313");
      defineHeader(ReferSub, "Refer-Sub", Token, "RFC 4488");
      defineHeader(AnswerMode, "Answer-Mode", Token, "draft-ietf-answermode-04");
      defineHeader(PrivAnswerMode, "Priv-Answer-Mode", Token, "draft-ietf-answermode-04");
 
      defineMultiHeader(Accept, "Accept", Mime, "RFC 3261");
      defineHeader(ContentType, "Content-Type", Mime, "RFC 3261");
 
      defineMultiHeader(CallInfo, "Call-Info", GenericUri, "RFC 3261");
      defineMultiHeader(AlertInfo, "Alert-Info", GenericUri, "RFC 3261");
      defineMultiHeader(ErrorInfo, "Error-Info", GenericUri, "RFC 3261");
      defineHeader(IdentityInfo, "Identity-Info", GenericUri, "RFC 4474");
 
      defineMultiHeader(RecordRoute, "Record-Route", NameAddr, "RFC 3261");
      defineMultiHeader(Route, "Route", NameAddr, "RFC 3261");
      defineMultiHeader(Contact, "Contact", NameAddr, "RFC 3261");
      defineHeader(From, "From", NameAddr, "RFC 3261");
      defineHeader(To, "To", NameAddr, "RFC 3261");
      defineHeader(ReplyTo, "Reply-To", NameAddr, "RFC 3261");
      defineHeader(ReferTo, "Refer-To", NameAddr, "RFC 3515");
      defineHeader(ReferredBy, "Referred-By", NameAddr, "RFC 3892");
      defineMultiHeader(Path, "Path", NameAddr, "RFC 3327");
      defineMultiHeader(AcceptContact, "Accept-Contact", NameAddr, "RFC 3841");
      defineMultiHeader(RejectContact, "Reject-Contact", NameAddr, "RFC 3841");
      defineMultiHeader(PAssertedIdentity, "P-Asserted-Identity", NameAddr, "RFC 3325");
      defineMultiHeader(PPreferredIdentity, "P-Preferred-Identity", NameAddr, "RFC 3325");
      defineHeader(PCalledPartyId, "P-Called-Party-ID", NameAddr, "RFC 3455");
      defineMultiHeader(PAssociatedUri, "P-Associated-URI", NameAddr, "RFC 3455");
      defineMultiHeader(ServiceRoute, "Service-Route", NameAddr, "RFC 3608");
      defineMultiHeader(RemotePartyId, "Remote-Party-ID", NameAddr, "draft-ietf-sip-privacy-04"); // ?bwc? Not in 3323, should we keep?
      defineMultiHeader(HistoryInfo, "History-Info", NameAddr, "RFC 4244");
      defineMultiHeader(Diversion, "Diversion", NameAddr, "RFC 5806");
 
      defineHeader(ContentTransferEncoding, "Content-Transfer-Encoding", StringCategory, "RFC 1521");
      defineHeader(Organization, "Organization", StringCategory, "RFC 3261");
      defineHeader(SecWebSocketKey, "Sec-WebSocket-Key", StringCategory, "RFC 6455");
      defineHeader(SecWebSocketKey1, "Sec-WebSocket-Key1", StringCategory, "draft-hixie- thewebsocketprotocol-76");
      defineHeader(SecWebSocketKey2, "Sec-WebSocket-Key2", StringCategory, "draft-hixie- thewebsocketprotocol-76");
      defineHeader(Origin, "Origin", StringCategory, "draft-hixie- thewebsocketprotocol-76");
      defineHeader(Host, "Host", StringCategory, "draft-hixie- thewebsocketprotocol-76");
      defineHeader(SecWebSocketAccept, "Sec-WebSocket-Accept", StringCategory, "RFC 6455");
      defineMultiHeader(Cookie, "Cookie", StringCategory, "RFC 6265");
      defineHeader(Server, "Server", StringCategory, "RFC 3261");
      defineHeader(Subject, "Subject", StringCategory, "RFC 3261");
      defineHeader(UserAgent, "User-Agent", StringCategory, "RFC 3261");
      defineHeader(Timestamp, "Timestamp", StringCategory, "RFC 3261");
 
      defineHeader(ContentLength, "Content-Length", UInt32Category, "RFC 3261");
      defineHeader(MaxForwards, "Max-Forwards", UInt32Category, "RFC 3261");
      defineHeader(MinExpires, "Min-Expires", UInt32Category, "RFC 3261");
      defineHeader(RSeq, "RSeq", UInt32Category, "RFC 3261");
 
      defineHeader(RetryAfter, "Retry-After", UInt32Category, "RFC 3261");
      defineHeader(FlowTimer, "Flow-Timer", UInt32Category, "RFC 5626");
 
      defineHeader(Expires, "Expires", ExpiresCategory, "RFC 3261");
      defineHeader(SessionExpires, "Session-Expires", ExpiresCategory, "RFC 4028");
      defineHeader(MinSE, "Min-SE", ExpiresCategory, "RFC 4028");
 
      defineHeader(CallID, "Call-ID", CallID, "RFC 3261");
      defineHeader(Replaces, "Replaces", CallID, "RFC 3891");
      defineHeader(InReplyTo, "In-Reply-To", CallID, "RFC 3261");
      defineHeader(Join, "Join", CallId, "RFC 3911");
      defineHeader(TargetDialog, "Target-Dialog", CallId, "RFC 4538");
 
      defineHeader(AuthenticationInfo, "Authentication-Info", Auth, "RFC 3261");
      defineMultiHeader(Authorization, "Authorization", Auth, "RFC 3261");
      defineMultiHeader(ProxyAuthenticate, "Proxy-Authenticate", Auth, "RFC 3261");
      defineMultiHeader(ProxyAuthorization, "Proxy-Authorization", Auth, "RFC 3261");
      defineMultiHeader(WWWAuthenticate, "Www-Authenticate", Auth, "RFC 3261");
 
      defineHeader(CSeq, "CSeq", CSeqCategory, "RFC 3261");
      defineHeader(Date, "Date", DateCategory, "RFC 3261");
      defineMultiHeader(Warning, "Warning", WarningCategory, "RFC 3261");
      defineMultiHeader(Via, "Via", Via, "RFC 3261");
      defineHeader(RAck, "RAck", RAckCategory, "RFC 3262");
 
      defineMultiHeader(PAccessNetworkInfo, "P-Access-Network-Info", Token, "RFC 7315"); // section 5.4.
      defineHeader(PChargingVector, "P-Charging-Vector", Token, "RFC 3455");
      defineHeader(PChargingFunctionAddresses, "P-Charging-Function-Addresses", Token, "RFC 3455");
      defineMultiHeader(PVisitedNetworkID, "P-Visited-Network-ID", TokenOrQuotedStringCategory, "RFC 3455");
 
      defineMultiHeader(UserToUser, "User-to-User", TokenOrQuotedStringCategory, "draft-ietf-cuss-sip-uui-17");
 
 
      const StringCategories& header(const ExtensionHeader& symbol) const;
 
      StringCategories& header(const ExtensionHeader& symbol);
      bool exists(const ExtensionHeader& symbol) const;
      void remove(const ExtensionHeader& symbol);
 
      const HeaderFieldValueList* getRawHeader(Headers::Type headerType) const;
      void setRawHeader(const HeaderFieldValueList* hfvs, Headers::Type headerType);
      const KnownHeaders& getRawHeaders() const noexcept { return mKnownHeaders; }
      const UnknownHeaders& getRawUnknownHeaders() const noexcept { return mUnknownHeaders; }
 
      const HeaderFieldValue& getRawBody() const noexcept { return mContentsHfv; }
 
      void setRawBody(const HeaderFieldValue& body);
 
      Contents* getContents() const;
 
      std::unique_ptr<Contents> releaseContents();
 
      void setContents(const Contents* contents);
      void setContents(std::unique_ptr<Contents> contents);
 
      void setStartLine(const char* start, uint32_t len);
 
      void setBody(const char* start, uint32_t len); 
      
      void addHeader(Headers::Type header,
                     const char* headerName, uint32_t headerNameLen,
                     const char* value, uint32_t valuelen);
 
      // Returns the source tuple for the transport that the message was received from
      // only makes sense for messages received from the wire.  Differs from Source
      // since it contains the transport bind address instead of the actual source 
      // address.
      const Tuple& getReceivedTransportTuple() const { return mReceivedTransportTuple; }
 
      void setReceivedTransportTuple(const Tuple& transportTuple) { mReceivedTransportTuple = transportTuple;}
 
      // Returns the source tuple that the message was received from
      // only makes sense for messages received from the wire
      void setSource(const Tuple& tuple) { mSource = tuple; }
      const Tuple& getSource() const { return mSource; }
      
      void setDestination(const Tuple& tuple) { mDestination = tuple; }
      Tuple& getDestination() { return mDestination; }
 
      void addBuffer(char* buf);
 
      uint64_t getCreatedTimeMicroSec() const { return mCreatedTime; }
 
      void setForceTarget(const Uri& uri);
      void clearForceTarget();
      const Uri& getForceTarget() const;
      bool hasForceTarget() const;
 
      const Data& getTlsDomain() const { return mTlsDomain; }
      void setTlsDomain(const Data& domain) { mTlsDomain = domain; }
 
      const std::shared_ptr<const ConnectionInfo>& getConnectionInfo() const noexcept { return mConnectionInfo; }
      void setConnectionInfo(std::shared_ptr<const ConnectionInfo> connectionInfo) noexcept { mConnectionInfo = std::move(connectionInfo); }
 
      // Shortcuts to the fields of getConnectionInfo(); empty if there is none.
      const std::list<Data>& getTlsPeerNames() const;
      const Data& getTlsSni() const;
      const CookieList& getWsCookies() const;
      std::shared_ptr<WsCookieContext> getWsCookieContext() const noexcept;
 
      // Each of these gives this message its own copy of the ConnectionInfo with
      // the one field changed, so other messages from the same connection keep
      // theirs.
      void setTlsPeerNames(const std::list<Data>& tlsPeerNames);
      void setWsCookies(const CookieList& wsCookies);
      void setWsCookieContext(std::shared_ptr<WsCookieContext> wsCookieContext);
 
      Data getCanonicalIdentityString() const;
 
      SipMessage& mergeUri(const Uri& source);
 
      void setSecurityAttributes(std::unique_ptr<SecurityAttributes>) noexcept;
      const SecurityAttributes* getSecurityAttributes() const noexcept { return mSecurityAttributes.get(); }
 
      void addOutboundDecorator(std::unique_ptr<MessageDecorator> md){mOutboundDecorators.push_back(md.release());}
      void clearOutboundDecorators();
      void callOutboundDecorators(const Tuple &src, 
                                    const Tuple &dest,
                                    const Data& sigcompId);
      void rollbackOutboundDecorators();
      void copyOutboundDecoratorsToStackCancel(SipMessage& cancel);
      void copyOutboundDecoratorsToStackFailureAck(SipMessage& ack);
      bool mIsDecorated;
 
      bool mIsBadAck200;
 
   protected:
      // !bwc! Removes or zeros all pointers to heap-allocated memory this
      // class owns.
      void clear(bool leaveResponseStuff=false);
      // !bwc! Frees all heap-allocated memory owned.
      void freeMem(bool leaveResponseStuff=false);
      // Clears mHeaders and cleans up memory
      void clearHeaders();
      
      // !bwc! Initializes members. Will not free heap-allocated memory.
      // Will begin by calling clear().
      void init(const SipMessage& rhs);
   
   private:
      void compute2543TransactionHash() const;
 
      EncodeStream& 
      encode(EncodeStream& str, bool isSipFrag) const;
 
      void copyFrom(const SipMessage& message);
 
      HeaderFieldValueList* ensureHeaders(Headers::Type type);
      HeaderFieldValueList* ensureHeaders(Headers::Type type) const; // throws if not present
 
      HeaderFieldValueList* ensureHeader(Headers::Type type);
      HeaderFieldValueList* ensureHeader(Headers::Type type) const; // throws if not present
 
      void throwHeaderMissing(Headers::Type type) const;
 
      inline HeaderFieldValueList* getEmptyHfvl()
      {
         void* ptr(mPool.allocate(sizeof(HeaderFieldValueList)));
         return new (ptr) HeaderFieldValueList(mPool);
      }
 
      inline HeaderFieldValueList* getCopyHfvl(const HeaderFieldValueList& hfvl)
      {
         void* ptr(mPool.allocate(sizeof(HeaderFieldValueList)));
         return new (ptr) HeaderFieldValueList(hfvl, mPool);
      }
 
      inline void freeHfvl(HeaderFieldValueList* hfvl)
      {
         if(hfvl)
         {
            hfvl->~HeaderFieldValueList();
            mPool.deallocate(hfvl);
         }
      }
 
      template<class T>
      ParserContainer<T>* makeParserContainer()
      {
         void* ptr(mPool.allocate(sizeof(ParserContainer<T>)));
         return new (ptr) ParserContainer<T>(mPool);
      }
 
      template<class T>
      ParserContainer<T>* makeParserContainer(HeaderFieldValueList* hfvs,
                                             Headers::Type type = Headers::UNKNOWN)
      {
         void* ptr(mPool.allocate(sizeof(ParserContainer<T>)));
         return new (ptr) ParserContainer<T>(hfvs, type, mPool);
      }
 
      // indicates this message came from the wire or we want it to look like it 
      // came from the wire (ie. internally generated responses to an internally 
      // generated request), set by the Transport and setFromTu and setFromExternal APIs
      bool mIsExternal;
 
      // Sizing so that average SipMessages don't need to allocate heap memory
      // To profile current sizing, enable DINKYPOOL_PROFILING in SipMessage.cxx 
      // and look for DebugLog message in SipMessage destructor to know when heap
      // allocations are occuring and how much of the pool is used.
      DinkyPool<3732> mPool;
 
      // raw text corresponding to each typed header (not yet parsed)
      KnownHeaders mKnownHeaders;
      
      // raw text corresponding to each unknown header
      UnknownHeaders mUnknownHeaders;
 
      // For messages received from the wire, this indicates information about 
      // the transport the message was received on
      Tuple mReceivedTransportTuple;
 
      // For messages received from the wire, this indicates where it came
      // from. Can be used to get to the Transport and/or reliable Connection
      Tuple mSource;
 
      // Used by the TU to specify where a message is to go
      Tuple mDestination;
      
      // Raw buffers coming from the Transport. message manages the memory
      std::vector<char*> mBufferList;
 
      // special case for the first line of message
      StartLine* mStartLine;
      char mStartLineMem[sizeof(RequestLine) > sizeof(StatusLine) ? sizeof(RequestLine) : sizeof(StatusLine)];
 
      // raw text for the contents (all of them)
      HeaderFieldValue mContentsHfv;
 
      // lazy parser for the contents
      mutable Contents* mContents;
 
      // cached value of a hash of the transaction id for a message received
      // from a 2543 sip element. as per rfc3261 see 17.2.3
      mutable Data mRFC2543TransactionId;
 
      // is a request or response
      bool mRequest;
      bool mResponse;
 
      bool mInvalid;
      resip::Data* mReason;
      
      uint64_t mCreatedTime;
 
      // used when next element is a strict router OR 
      // client forces next hop OOB
      Uri* mForceTarget;
 
      // domain associated with this message for tls cert
      Data mTlsDomain;
 
      // TLS peer names, SNI and WebSocket cookies of the connection the message
      // was received on, shared with every other message from that connection
      std::shared_ptr<const ConnectionInfo> mConnectionInfo;
 
      std::unique_ptr<SecurityAttributes> mSecurityAttributes;
 
      std::vector<MessageDecorator*> mOutboundDecorators;
 
      friend class TransportSelector;
};
 
}
 
#undef ensureHeaderTypeUseable
#undef ensureSingleHeader
#undef ensureMultiHeader
#undef defineHeader
#undef defineMultiHeader
 
#endif
 
/* ====================================================================
 * The Vovida Software License, Version 1.0 
 * 
 * Copyright (c) 2026 SIP Spectrum, Inc. https://www.sipspectrum.com
 * Copyright (c) 2000 Vovida Networks, Inc.  All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 
 * 3. The names "VOCAL", "Vovida Open Communication Application Library",
 *    and "Vovida Open Communication Application Library (VOCAL)" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact vocal@vovida.org.
 *
 * 4. Products derived from this software may not be called "VOCAL", nor
 *    may "VOCAL" appear in their name, without prior written
 *    permission of Vovida Networks, Inc.
 * 
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
 * NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL VOVIDA
 * NETWORKS, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT DAMAGES
 * IN EXCESS OF $1,000, NOR FOR ANY INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 * 
 * ====================================================================
 * 
 * This software consists of voluntary contributions made by Vovida
 * Networks, Inc. and many individuals on behalf of Vovida Networks,
 * Inc.  For more information on Vovida Networks, Inc., please see
 * <http://www.vovida.org/>.
 *
 * vi: set shiftwidth=3 expandtab:
 */