deprecateddialog.cxx

一个著名的SIP协议栈

{
   SipMessage* msg = Helper::makePublish( target, from, mContact );
   assert( msg );

   mRequestUri = msg->header(h_RequestLine).uri();
   mLocalEmpty = false;
   mLocalSequence = msg->header(h_CSeq).sequence();
   mCallId = msg->header(h_CallId);
   assert(msg->header(h_From).exists(p_tag));
   mLocalTag = msg->header(h_From).param(p_tag);  
   mRemoteUri = msg->header(h_To);
   mLocalUri = msg->header(h_From);
   
   return msg;
}


SipMessage* 
DeprecatedDialog::makeInitialMessage(const NameAddr& target, const NameAddr& from)
{
   SipMessage* msg = Helper::makeMessage( target, from, mContact );
   assert( msg );

   mRequestUri = msg->header(h_RequestLine).uri();
   mLocalEmpty = false;
   mLocalSequence = msg->header(h_CSeq).sequence();
   mCallId = msg->header(h_CallId);
   assert(msg->header(h_From).exists(p_tag));
   mLocalTag = msg->header(h_From).param(p_tag);  
   mRemoteUri = msg->header(h_To);
   mLocalUri = msg->header(h_From);
   
   return msg;
}


SipMessage* 
DeprecatedDialog::makeInitialInvite(const NameAddr& target, const NameAddr& from)
{
   SipMessage* msg = Helper::makeInvite( target, from, mContact );
   assert( msg );

   mRequestUri = msg->header(h_RequestLine).uri();
   mLocalEmpty = false;
   mLocalSequence = msg->header(h_CSeq).sequence();
   mCallId = msg->header(h_CallId);
   assert(msg->header(h_From).exists(p_tag));
   mLocalTag = msg->header(h_From).param(p_tag);  
   mRemoteUri = msg->header(h_To);
   mLocalUri = msg->header(h_From);
   
   return msg;
}


SipMessage*
DeprecatedDialog::makeInvite()
{
   SipMessage* request = makeRequestInternal(INVITE);
   incrementCSeq(*request);
   DebugLog(<< "DeprecatedDialog::makeInvite: " << *request);
   return request;
}


SipMessage*
DeprecatedDialog::makeRegister()
{
   SipMessage* request = makeRequestInternal(REGISTER);
   incrementCSeq(*request);
   DebugLog(<< "DeprecatedDialog::makeRegister: " << *request);
   return request;
}


SipMessage*
DeprecatedDialog::makeSubscribe()
{
   SipMessage* request = makeRequestInternal(SUBSCRIBE);
   incrementCSeq(*request);
   DebugLog(<< "DeprecatedDialog::makeSubscribe: " << *request);
   return request;
}

SipMessage*
DeprecatedDialog::makeBye()
{
   SipMessage* request = makeRequestInternal(BYE);
   incrementCSeq(*request);

   return request;
}


SipMessage*
DeprecatedDialog::makeRefer(const NameAddr& referTo)
{
   SipMessage* request = makeRequestInternal(REFER);
   request->header(h_ReferTo) = referTo;
   request->header(h_ReferredBy) = mLocalUri;
   incrementCSeq(*request);
   return request;
}

SipMessage*
DeprecatedDialog::makeNotify()
{
   SipMessage* request = makeRequestInternal(NOTIFY);
   incrementCSeq(*request);
   return request;
}


SipMessage*
DeprecatedDialog::makeOptions()
{
   SipMessage* request = makeRequestInternal(OPTIONS);
   incrementCSeq(*request);
   return request;
}

SipMessage*
DeprecatedDialog::makePublish()
{
   SipMessage* request = makeRequestInternal(PUBLISH);
   incrementCSeq(*request);
   return request;
}

SipMessage*
DeprecatedDialog::makeRequest(resip::MethodTypes method)
{
   assert(method != ACK);
   assert(method != CANCEL);
   
   SipMessage* request = makeRequestInternal(method);
   incrementCSeq(*request);
   return request;
}

SipMessage*
DeprecatedDialog::makeAck(const SipMessage& original)
{
   SipMessage* request = makeRequestInternal(ACK);
   copyCSeq(*request);

   // !dcm! should we copy the authorizations? 
   // !jf! will this do the right thing if these headers weren't in original 
   // we should be able to store this stuff in the DeprecatedDialog and not need to pass
   // in the original
   if (original.exists(h_ProxyAuthorizations))
   {
      request->header(h_ProxyAuthorizations) = original.header(h_ProxyAuthorizations);
   }
   if (original.exists(h_Authorizations))
   {    
      request->header(h_Authorizations) = original.header(h_Authorizations);
   }
   request->header(h_CSeq).sequence() = original.header(h_CSeq).sequence();
   return request;
}

SipMessage*
DeprecatedDialog::makeAck()
{
   SipMessage* request = makeRequestInternal(ACK);
   copyCSeq(*request);
   return request;
}

SipMessage*
DeprecatedDialog::makeCancel(const SipMessage& request)
{
   assert (request.header(h_Vias).size() >= 1);
   assert (request.header(h_RequestLine).getMethod() == INVITE);
   
   SipMessage* cancel = new SipMessage;
   
   cancel->header(h_RequestLine) = request.header(h_RequestLine);
   cancel->header(h_RequestLine).method() = CANCEL;
   
   cancel->header(h_CallId) = request.header(h_CallId);
   cancel->header(h_To) = request.header(h_To); 
   cancel->header(h_From) = request.header(h_From);
   cancel->header(h_CSeq) = request.header(h_CSeq);
   cancel->header(h_CSeq).method() = CANCEL;
   cancel->header(h_Vias).push_back(request.header(h_Vias).front());
   
   return cancel;
}


CallId 
DeprecatedDialog::makeReplaces()
{
   return mDialogId;
}

void
DeprecatedDialog::clear()
{
   mCreated = false;
   mEarly = false;
   
   mRouteSet.clear();
   mRemoteTarget = NameAddr();
   mRemoteSequence = 0;
   mRemoteEmpty = true;
   mLocalSequence = 0;
   mLocalEmpty = true;
   mCallId.value() = Data::Empty;
   mLocalTag = Data::Empty;
   mRemoteTag = Data::Empty;
   mRemoteUri = NameAddr();
   mLocalUri = NameAddr();
}

SipMessage*
DeprecatedDialog::makeRequestInternal(MethodTypes method)
{
   SipMessage* request = new SipMessage;
   RequestLine rLine(method);

   if (!mCreated)
   {
      rLine.uri() = mRequestUri;
   }
   else
   {
      rLine.uri() = mRemoteTarget.uri();
   }
   
   request->header(h_RequestLine) = rLine;
   request->header(h_To) = mRemoteUri;
   if ( !mRemoteTag.empty() )
   {
       request->header(h_To).param(p_tag) = mRemoteTag;
   }
   request->header(h_From) = mLocalUri;
   if ( !mLocalTag.empty() )
   {
      request->header(h_From).param(p_tag) = mLocalTag; 
   }
   request->header(h_CallId) = mCallId;
   request->header(h_Routes) = mRouteSet;
   request->header(h_Contacts).push_back(mContact);
   request->header(h_CSeq).method() = method;
   copyCSeq(*request);
   request->header(h_MaxForwards).value() = 70;

   Via via;
   via.param(p_branch); // will create the branch
   request->header(h_Vias).push_front(via);

   Helper::processStrictRoute(*request);
   return request;
}

void
DeprecatedDialog::copyCSeq(SipMessage& request)
{
   if (mLocalEmpty)
   {
      mLocalSequence = 1;
      mLocalEmpty = false;
   }
   request.header(h_CSeq).sequence() = mLocalSequence;
}

void
DeprecatedDialog::incrementCSeq(SipMessage& request)
{
   if (mLocalEmpty)
   {
      mLocalSequence = 1;
      mLocalEmpty = false;
   }
   //DebugLog ( << "mLocalSequence: " << mLocalSequence);
   request.header(h_CSeq).sequence() = ++mLocalSequence;
}

std::ostream&
resip::operator<<(std::ostream& strm, const DeprecatedDialog& d)
{
   strm << "DeprecatedDialog: [" << d.dialogId() 
        << " created=" << d.mCreated 
        << ",remoteTarget=" << d.mRemoteTarget 
        << ", routeset=" << Inserter(d.mRouteSet) 
        << ",remoteSeq=" << d.mRemoteSequence 
        << ",remote=" << d.mRemoteUri 
        << ",remoteTag=" << d.mRemoteTag 
        << ",localSeq=" << d.mLocalSequence
        << ",local=" << d.mLocalUri 
        << ",localTag=" << d.mLocalTag 
        << "]";
   return strm;
}
  
Data 
DeprecatedDialog::dialogId(const SipMessage& msg)
{
   CallID id(msg.header(h_CallId));
   if (msg.isRequest() && msg.isExternal() ||
       msg.isResponse() && !msg.isExternal())
   {
      if (msg.header(h_To).exists(p_tag))
      {
         id.param(p_toTag) = msg.header(h_To).param(p_tag);
      }
      if (msg.header(h_From).exists(p_tag))
      {
         id.param(p_fromTag) = msg.header(h_From).param(p_tag);
      }
   }
   else
   {
      if (msg.header(h_From).exists(p_tag))
      {
         id.param(p_toTag) = msg.header(h_From).param(p_tag);
      }
      if (msg.header(h_To).exists(p_tag))
      {
         id.param(p_fromTag) = msg.header(h_To).param(p_tag);
      }
   }
   return Data::from(id);
}

 
const Data 
DeprecatedDialog::dialogId() const
{
   return Data::from(mDialogId);
}


void 
DeprecatedDialog::setExpirySeconds( int secondsInFuture )
{ 
   expireyTimeAbsoluteMs = Timer::getTimeMs() + 1000*secondsInFuture;
}


int  
DeprecatedDialog::getExpirySeconds()
{
	// !cj! TODO - may be bugs here when result is negative 
   UInt64 delta = ( expireyTimeAbsoluteMs - Timer::getTimeMs() )/1000;

   int ret = (int)delta;
   return ret;
}



/* ====================================================================
 * The Vovida Software License, Version 1.0 
 * 
 * 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 [e-mail].
 *
 * 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/>.
 *
 */