sipmessage.cxx

一个著名的SIP协议栈

      strm << header(h_CallID).value();

      if (header(h_RequestLine).getMethod() == ACK || 
          header(h_RequestLine).getMethod() == CANCEL)
      {
         strm << INVITE;
         strm << header(h_CSeq).sequence();
      }
      else
      {
         strm << header(h_CSeq).method();
         strm << header(h_CSeq).sequence();
      }
           
      mRFC2543TransactionId = strm.getHex();
   }
   else
   {
      InfoLog (<< "Trying to compute a transaction id on a 2543 response. Drop the response");
      DebugLog (<< *this);
      throw Exception("Drop invalid 2543 response", __FILE__, __LINE__);
   }
}

const Data&
SipMessage::getRFC2543TransactionId() const
{
   if(!( exists(h_Vias) && header(h_Vias).front().exists(p_branch) &&
         header(h_Vias).front().param(p_branch).hasMagicCookie() ) )
   {
      if (mRFC2543TransactionId.empty())
      {
         compute2543TransactionHash();
      }
   }
   return mRFC2543TransactionId;
}


Data
SipMessage::getCanonicalIdentityString() const
{
   Data result;
   DataStream strm(result);
   
   // digest-string = addr-spec ":" addr-spec ":" callid ":" 1*DIGIT SP method ":"
   //             SIP-Date ":" [ addr-spec ] ":" message-body
  
   strm << header(h_From).uri();
   strm << Symbols::BAR;
   
   strm << header(h_To).uri();
   strm << Symbols::BAR;
   
   strm << header(h_CallId).value();
   strm << Symbols::BAR;
   
   header(h_CSeq).sequence(); // force parsed
   header(h_CSeq).encodeParsed( strm );
   strm << Symbols::BAR;
   
   // if there is no date, it will throw 
   if ( !exists(h_Date) )
   {
      WarningLog( << "Computing Identity on message with no Date header" );
      // TODO FIX - should it have a throw here ???? Help ???
   }
   header(h_Date).dayOfMonth(); // force it to be parsed 
   header(h_Date).encodeParsed( strm );
   strm << Symbols::BAR;
   
   if ( exists(h_Contacts) )
   { 
      if ( header(h_Contacts).front().isAllContacts() )
      {
         strm << Symbols::STAR;
      }
      else
      {
         strm << header(h_Contacts).front().uri();
      }
   }
   strm << Symbols::BAR;
   
   // bodies 
   if (mContents != 0)
   {
      mContents->encode(strm);
   }
   else if (mContentsHfv != 0)
   {
      mContentsHfv->encode(strm);
   }

   strm.flush();

   DebugLog( << "Indentity Canonical String is: " << result );
   
   return result;
}


void
SipMessage::setRFC2543TransactionId(const Data& tid)
{
   mRFC2543TransactionId = tid;
}

bool
SipMessage::isRequest() const
{
   return mRequest;
}

bool
SipMessage::isResponse() const
{
   return mResponse;
}

resip::MethodTypes
SipMessage::method() const
{
   resip::MethodTypes res=UNKNOWN;
   try
   {
      if(isRequest())
      {
         res=header(h_RequestLine).getMethod();
      }
      else if(isResponse())
      {
         res=header(h_CSeq).method();
      }
      else
      {
         assert(0);
      }
   }
   catch(resip::ParseBuffer::Exception&)
   {
   }
   
   return res;
}

std::ostream&
SipMessage::encodeBrief(std::ostream& str) const
{
   static const Data  request("SipReq:  ");
   static const Data response("SipResp: ");
   static const Data tid(" tid=");
   static const Data contact(" contact=");
   static const Data cseq(" cseq=");
   static const Data slash(" / ");
   static const Data wire(" from(wire)");
   static const Data ftu(" from(tu)");
   static const Data tlsd(" tlsd=");

   if (isRequest()) 
   {
      str << request;
      MethodTypes meth = header(h_RequestLine).getMethod();
      if (meth != UNKNOWN)
      {
         str << getMethodName(meth);
      }
      else
      {
         str << header(h_RequestLine).unknownMethodName();
      }
      
      str << Symbols::SPACE;
      str << header(h_RequestLine).uri().getAor();
   }
   else if (isResponse())
   {
      str << response;
      str << header(h_StatusLine).responseCode();
   }
   if (exists(h_Vias) && !this->header(h_Vias).empty())
   {
      str << tid;
      str << getTransactionId();
   }
   else
   {
      str << " NO-VIAS ";
   }

   str << cseq;
   if (header(h_CSeq).method() != UNKNOWN)
   {
      str << getMethodName(header(h_CSeq).method());
   }
   else
   {
      str << header(h_CSeq).unknownMethodName();
   }

   try
   {
      if (exists(h_Contacts) && !header(h_Contacts).empty())
      {
         str << contact;
         str << header(h_Contacts).front().uri().getAor();
      }
   }
   catch(resip::ParseBuffer::Exception&)
   {
      str << " MALFORMED CONTACT ";
   }
   
   str << slash;
   str << header(h_CSeq).sequence();
   str << (mIsExternal ? wire : ftu);
   if (!mTlsDomain.empty())
   {
      str << tlsd << mTlsDomain;
   }
   
   return str;
}

bool
SipMessage::isClientTransaction() const
{
   assert(mRequest || mResponse);
   return ((mIsExternal && mResponse) || (!mIsExternal && mRequest));
}

std::ostream& 
SipMessage::encode(std::ostream& str) const
{
   return encode(str, false);
}

std::ostream& 
SipMessage::encodeSipFrag(std::ostream& str) const
{
   return encode(str, true);
}

// dynamic_cast &str to DataStream* to avoid CountStream?

std::ostream& 
SipMessage::encode(std::ostream& str, bool isSipFrag) const
{
   if (mStartLine != 0)
   {
      mStartLine->encode(Data::Empty, str);
   }

   for (int i = 0; i < Headers::MAX_HEADERS; i++)
   {
      if (i != Headers::ContentLength) // !dlb! hack...
      {
         if (mHeaders[i] != 0)
         {
            mHeaders[i]->encode(i, str);
         }
      }
      else
      {
         if (mContents != 0)
         {
            size_t size;
            {
               CountStream cs(size);
               mContents->encode(cs);
            }
            str << "Content-Length: " << size << "\r\n";
         }
         else if (mContentsHfv != 0)
         {
            str << "Content-Length: " << mContentsHfv->mFieldLength << "\r\n";
         }
         else if (!isSipFrag)
         {
            str << "Content-Length: 0\r\n";
         }
      }
   }

   for (UnknownHeaders::const_iterator i = mUnknownHeaders.begin(); 
        i != mUnknownHeaders.end(); i++)
   {
      i->second->encode(i->first, str);
   }

   str << Symbols::CRLF;
   
   if (mContents != 0)
   {
      mContents->encode(str);
   }
   else if (mContentsHfv != 0)
   {
      mContentsHfv->encode(str);
   }
   
   return str;
}

std::ostream& 
SipMessage::encodeEmbedded(std::ostream& str) const
{
   bool first = true;
   for (int i = 0; i < Headers::MAX_HEADERS; i++)
   {
      if (i != Headers::ContentLength)
      {
         if (mHeaders[i] != 0)
         {
            if (first)
            {
               str << Symbols::QUESTION;
               first = false;
            }
            else
            {
               str << Symbols::AMPERSAND;
            }
            mHeaders[i]->encodeEmbedded(Headers::getHeaderName(i), str);
         }
      }
   }

   for (UnknownHeaders::const_iterator i = mUnknownHeaders.begin(); 
        i != mUnknownHeaders.end(); i++)
   {
      if (first)
      {
         str << Symbols::QUESTION;
         first = false;
      }
      else
      {
         str << Symbols::AMPERSAND;
      }
      i->second->encodeEmbedded(i->first, str);
   }

   if (mContents != 0)
   {
      if (first)
      {
         str << Symbols::QUESTION;
      }
      else
      {
         str << Symbols::AMPERSAND;
      }
      str << "body=";
      // !dlb! encode escaped for characters
      Data contents;
      {
         DataStream s(contents);
         mContents->encode(s);
      }
      str << Embedded::encode(contents);
   }
   else if (mContentsHfv != 0)
   {
      if (first)
      {
         str << Symbols::QUESTION;
      }
      else
      {
         str << Symbols::AMPERSAND;
      }
      str << "body=";
      // !dlb! encode escaped for characters
      Data contents;
      {
         DataStream s(contents);
         mContentsHfv->encode(str);
      }
      str << Embedded::encode(contents);
   }
   
   return str;
}

void
SipMessage::addBuffer(char* buf)
{
   mBufferList.push_back(buf);
}

void 
SipMessage::setStartLine(const char* st, int len)
{
   mStartLine = new HeaderFieldValueList;
   mStartLine-> push_back(new HeaderFieldValue(st, len));
   ParseBuffer pb(st, len);
   const char* start;
   start = pb.skipWhitespace();
   pb.skipNonWhitespace();
   MethodTypes method = getMethodType(start, pb.position() - start);
   if (method == UNKNOWN) //probably a status line
   {
      start = pb.skipChar(Symbols::SPACE[0]);
      pb.skipNonWhitespace();