clientsubscription.cxx

这是国外的resip协议栈

   {
      if (timer.type() == DumTimeout::SubscriptionRetry)
      {
         // this indicates that the ClientSubscription was created by a 408
         if (mOnNewSubscriptionCalled)
         {
            InfoLog(<< "ClientSubscription: application retry refresh");
            requestRefresh();
         }
         else
         {
            InfoLog(<< "ClientSubscription: application retry new request");
  
            if (mDialog.mRemoteTarget.uri().host().empty())
            {
               SharedPtr<SipMessage> sub = mDum.makeSubscription(mLastRequest->header(h_To), getEventType());
               mDum.send(sub);
            }
            else
            {
               SharedPtr<SipMessage> sub = mDum.makeSubscription(mDialog.mRemoteTarget, getEventType(), getAppDialogSet()->reuse());
               mDum.send(sub);
            }
            
            delete this;
         }
      }
      else
      {
         requestRefresh();
      }
   }
   else
   {
      if (timer.type() == DumTimeout::SendNextNotify)
      {
         DebugLog(<< "got DumTimeout::SendNextNotify");
         processNextNotify();
      }
   }
}

void
ClientSubscription::requestRefresh(UInt32 expires)
{
   if (!mEnded)
   {
      if (mRefreshing)
      {
         DebugLog(<< "queue up refresh request");
         mHaveQueuedRefresh = true;
         mQueuedRefreshInterval = expires;
         return;
      }

      mDialog.makeRequest(*mLastRequest, SUBSCRIBE);
      //!dcm! -- need a mechanism to retrieve this for the event package...part of
      //the map that stores the handlers, or part of the handler API
      if(expires > 0)
      {
         mLastRequest->header(h_Expires).value() = expires;
      }
      mExpires = 0;
      InfoLog (<< "Refresh subscription: " << mLastRequest->header(h_Contacts).front());
      mRefreshing = true;
      send(mLastRequest);
   }
}

class ClientSubscriptionRefreshCommand : public DumCommandAdapter
{
public:
   ClientSubscriptionRefreshCommand(ClientSubscription& clientSubscription, UInt32 expires)
      : mClientSubscription(clientSubscription),
        mExpires(expires)
   {

   }
   virtual void executeCommand()
   {
      mClientSubscription.requestRefresh(mExpires);
   }

   virtual std::ostream& encodeBrief(std::ostream& strm) const
   {
      return strm << "ClientSubscriptionRefreshCommand";
   }
private:
   ClientSubscription& mClientSubscription;
   UInt32 mExpires;
};

void
ClientSubscription::requestRefreshCommand(UInt32 expires)
{
   mDum.post(new ClientSubscriptionRefreshCommand(*this, expires));
}

void
ClientSubscription::end()
{
   InfoLog (<< "End subscription: " << mLastRequest->header(h_RequestLine).uri());

   if (!mEnded)
   {
      mDialog.makeRequest(*mLastRequest, SUBSCRIBE);
      mLastRequest->header(h_Expires).value() = 0;
      mEnded = true;
      send(mLastRequest);
   }
}

class ClientSubscriptionEndCommand : public DumCommandAdapter
{
public:
   ClientSubscriptionEndCommand(ClientSubscription& clientSubscription)
      :mClientSubscription(clientSubscription)
   {

   }

   virtual void executeCommand()
   {
      mClientSubscription.end();
   }

   virtual std::ostream& encodeBrief(std::ostream& strm) const
   {
      return strm << "ClientSubscriptionEndCommand";
   }
private:
   ClientSubscription& mClientSubscription;
};

void
ClientSubscription::endCommand()
{
   mDum.post(new ClientSubscriptionEndCommand(*this));
}

void 
ClientSubscription::acceptUpdate(int statusCode)
{
   assert(!mQueuedNotifies.empty());
   if (mQueuedNotifies.empty())
   {
      InfoLog(<< "No queued notify to accept");
      return;
   }

   QueuedNotify* qn = mQueuedNotifies.front();
   mQueuedNotifies.pop_front();
   mDustbin.push_back(qn);
   mDialog.makeResponse(*mLastResponse, qn->notify(), statusCode);
   send(mLastResponse);
}

class ClientSubscriptionAcceptUpdateCommand : public DumCommandAdapter
{
public:
   ClientSubscriptionAcceptUpdateCommand(ClientSubscription& clientSubscription, int statusCode)
      : mClientSubscription(clientSubscription),
        mStatusCode(statusCode)
   {

   }

   virtual void executeCommand()
   {
      mClientSubscription.acceptUpdate(mStatusCode);
   }

   virtual std::ostream& encodeBrief(std::ostream& strm) const
   {
      return strm << "ClientSubscriptionAcceptUpdateCommand";
   }
private:
   ClientSubscription& mClientSubscription;
   int mStatusCode;
};

void 
ClientSubscription::acceptUpdateCommand(int statusCode)
{
   mDum.post(new ClientSubscriptionAcceptUpdateCommand(*this, statusCode));
}

void 
ClientSubscription::send(SharedPtr<SipMessage> msg)
{
   DialogUsage::send(msg);

   if (!mEnded)
   {
      if (!mQueuedNotifies.empty() && msg->isResponse())
      {
         mDum.addTimer(DumTimeout::SendNextNotify, 
                       0, 
                       getBaseHandle(),
                       0);
      }
   }

}

void 
ClientSubscription::rejectUpdate(int statusCode, const Data& reasonPhrase)
{
   ClientSubscriptionHandler* handler = mDum.getClientSubscriptionHandler(mEventType);
   assert(handler);   
   assert(!mQueuedNotifies.empty());
   if (mQueuedNotifies.empty())
   {
      InfoLog(<< "No queued notify to reject");
      return;
   }

   QueuedNotify* qn = mQueuedNotifies.front();
   mQueuedNotifies.pop_front();
   mDustbin.push_back(qn);

   mDialog.makeResponse(*mLastResponse, qn->notify(), statusCode);
   if (!reasonPhrase.empty())
   {
      mLastResponse->header(h_StatusLine).reason() = reasonPhrase;
   }
   
   send(mLastResponse);
   switch (Helper::determineFailureMessageEffect(*mLastResponse))
   {
      case Helper::TransactionTermination:
      case Helper::RetryAfter:
         break;            
      case Helper::OptionalRetryAfter:
      case Helper::ApplicationDependant: 
         throw UsageUseException("Not a reasonable code to reject a NOTIFY with inside an established dialog.", 
                                 __FILE__, __LINE__);
         break;            
      case Helper::DialogTermination: //?dcm? -- throw or destroy this?
      case Helper::UsageTermination:
         mEnded = true;
         handler->onTerminated(getHandle(), *mLastResponse);
         delete this;
         break;
   }
}

class ClientSubscriptionRejectUpdateCommand : public DumCommandAdapter
{
public:
   ClientSubscriptionRejectUpdateCommand(ClientSubscription& clientSubscription, int statusCode, const Data& reasonPhrase)
      : mClientSubscription(clientSubscription),
        mStatusCode(statusCode),
        mReasonPhrase(reasonPhrase)
   {
   }

   virtual void executeCommand()
   {
      mClientSubscription.rejectUpdate(mStatusCode, mReasonPhrase);
   }

   virtual std::ostream& encodeBrief(std::ostream& strm) const
   {
      return strm << "ClientSubscriptionRejectUpdateCommand";
   }
private:
   ClientSubscription& mClientSubscription;
   int mStatusCode;
   Data mReasonPhrase;
};

void 
ClientSubscription::rejectUpdateCommand(int statusCode, const Data& reasonPhrase)
{
   mDum.post(new ClientSubscriptionRejectUpdateCommand(*this, statusCode, reasonPhrase));
}

void ClientSubscription::dialogDestroyed(const SipMessage& msg)
{
   ClientSubscriptionHandler* handler = mDum.getClientSubscriptionHandler(mEventType);
   assert(handler);   
   mEnded = true;
   handler->onTerminated(getHandle(), msg);
   delete this;   
}

std::ostream&
ClientSubscription::dump(std::ostream& strm) const
{
   strm << "ClientSubscription " << mLastRequest->header(h_From).uri();
   return strm;
}

void ClientSubscription::onReadyToSend(SipMessage& msg)
{
   ClientSubscriptionHandler* handler = mDum.getClientSubscriptionHandler(mEventType);
   assert(handler);
   handler->onReadyToSend(getHandle(), msg);
}

void
ClientSubscription::sendQueuedRefreshRequest()
{
   assert(!mRefreshing);

   if (mHaveQueuedRefresh)
   {
      DebugLog(<< "send queued refresh request");
      mHaveQueuedRefresh = false;
      requestRefresh(mQueuedRefreshInterval);
   }
}

void
ClientSubscription::clearDustbin()
{
   for (Dustbin::iterator it = mDustbin.begin(); it != mDustbin.end(); ++it)
   {
      delete *it;
   }

   mDustbin.clear();

}

/* ====================================================================
 * 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/>.
 *
 */