dialogset.cxx

这是国外的resip协议栈

               {
                  mState = Destroying;
                  mDum.destroy(this);
               }
               break;
            case SUBSCRIBE:
               if (code / 100 == 1)
               {
                  // do nothing - wait for final response
               }
               else if (code / 100 == 2)
               {
                  Dialog dialog(mDum, msg, *this);

                  SharedPtr<SipMessage> unsubscribe(new SipMessage(*mCreator->getLastRequest().get()));  // create message from initial request so we get proper headers
                  dialog.makeRequest(*unsubscribe, SUBSCRIBE);
                  unsubscribe->header(h_Expires).value() = 0;
                  dialog.send(unsubscribe);
                  
                  // Note:  Destruction of this dialog object will cause DialogSet::possiblyDie to be called thus invoking mDum.destroy
               }
               else
               {
                  mState = Destroying;
                  mDum.destroy(this);
               }
               break;
            case PUBLISH:
               if (code / 100 == 1)
               {
                  // do nothing - wait for final response
               }
               else if (code / 100 == 2)
               {
                  Dialog dialog(mDum, msg, *this);

                  SharedPtr<SipMessage> unpublish(new SipMessage(*mCreator->getLastRequest().get()));  // create message from initial request so we get proper headers
                  dialog.makeRequest(*unpublish, PUBLISH);
                  unpublish->header(h_Expires).value() = 0;
                  dialog.send(unpublish);
                  
                  // Note:  Destruction of this dialog object will cause DialogSet::possiblyDie to be called thus invoking mDum.destroy
               }
               else
               {
                  mState = Destroying;
                  mDum.destroy(this);
               }
               break;
               // ?slg? shouldn't we handle register, ood and refer here too?
            default:
               mState = Destroying;
               mDum.destroy(this);
               break;
         }
      }
      else
      {
         SharedPtr<SipMessage> response(new SipMessage);         
         mDum.makeResponse(*response, msg, 481);
         mDum.send(response);
      }
      return;
   }

   if (handledByAuthOrRedirect(msg))
   {
      return;
   }

   Dialog* dialog = 0;
   if (!(msg.isResponse() && msg.header(h_StatusLine).statusCode() == 100))  // Don't look for dialog if msg is a 100 response
   {
      DialogMap::iterator i = mDialogs.find(DialogId(msg));
      if (i != mDialogs.end())
      {
         dialog = i->second;
      }
   }
   if (dialog)
   {
      if(dialog->isDestroying())
      {
         if( msg.isRequest() )
         {
            StackLog (<< "Matching dialog is destroying, sending 481 " << endl << msg);
            SharedPtr<SipMessage> response(new SipMessage);
            mDum.makeResponse(*response, msg, 481);
            mDum.send(response);
         }
         else
         {
          StackLog (<< "Matching dialog is destroying, dropping response message " << endl << msg);
         }
         return;
      }
      else
      {
         DebugLog (<< "Found matching dialog " << *dialog << " for " << endl << endl << msg);
      }
   }
   else
   {
      StackLog (<< "No matching dialog for " << endl << endl << msg);
   }
   
   if (msg.isRequest())
   {
      const SipMessage& request = msg;
      switch (request.header(h_CSeq).method())
      {
         case INVITE:
         case CANCEL:  //cancel needs work
         case SUBSCRIBE:
            break; //dialog creating/handled by dialog

         case BYE:
         case INFO:
         case ACK:
         case UPDATE:
            if(!dialog)
            {
               SharedPtr<SipMessage> response(new SipMessage);         
               mDum.makeResponse(*response, msg, 481);
               mDum.send(response);
               return;
            }
            break;
            
         case REFER:
            if (request.header(h_To).exists(p_tag) || findDialog(request))
            {
               DebugLog(<< "in dialog refer request");
               break; // in dialog
            }
            else if (!request.exists(h_ReferSub) || request.header(h_ReferSub).value() == "true")
            {
               DebugLog(<< "out of dialog refer request with refer sub");
               break; // dialog creating
            }
            else // out of dialog & noReferSub=true
            {
               DebugLog(<< "out of dialog refer request with norefersub");
               assert(mServerOutOfDialogRequest == 0);
               mServerOutOfDialogRequest = makeServerOutOfDialog(request);
               mServerOutOfDialogRequest->dispatch(request);
               return;
            }
            break;            
         case NOTIFY:

            // !jf! there shouldn't be a dialogset for ServerOutOfDialogReq
            if (request.header(h_To).exists(p_tag) || findDialog(request))
            {
               break; //dialog creating/handled by dialog
            }
            else // no to tag - unsolicited notify
            {
               // unsolicited - not allowed but commonly implemented
               // by large companies with a bridge as their logo
               assert(mServerOutOfDialogRequest == 0);
               mServerOutOfDialogRequest = makeServerOutOfDialog(request);
               mServerOutOfDialogRequest->dispatch(request);
               return;
            }
            break;

         case PUBLISH:
            assert(false); // handled in DialogUsageManager
            return;
            
         case REGISTER:
            // !jf! move this to DialogUsageManager
            if (mServerRegistration == 0)
            {
               mServerRegistration = makeServerRegistration(request);
            }
            mServerRegistration->dispatch(request);
            return;

         case MESSAGE:
            // !jf! move this to DialogUsageManager
            if(!dialog)
            {
               mServerPagerMessage = makeServerPagerMessage(request);
               mServerPagerMessage->dispatch(request);
               return;
            }
            break;

         default:
            // !jf! move this to DialogUsageManager
            DebugLog ( << "In DialogSet::dispatch, default(ServerOutOfDialogRequest), msg: " << msg );
            // only can be one ServerOutOfDialogReq at a time
            assert(mServerOutOfDialogRequest == 0);
            mServerOutOfDialogRequest = makeServerOutOfDialog(request);
            mServerOutOfDialogRequest->dispatch(request);
            return;
      }
   }
   else // the message is a response
   {
      const SipMessage& response = msg;

      int code = msg.header(h_StatusLine).statusCode();
      if (code == 423
          && msg.header(h_CSeq).method() == SUBSCRIBE
          && msg.exists(h_MinExpires)
          && getCreator()
          && msg.header(h_CSeq) == getCreator()->getLastRequest()->header(h_CSeq))
      {
         getCreator()->getLastRequest()->header(h_CSeq).sequence()++;
         getCreator()->getLastRequest()->header(h_Expires).value() = msg.header(h_MinExpires).value();
         DebugLog( << "Re sending inital(dialog forming) SUBSCRIBE due to 423, MinExpires is: " << msg.header(h_MinExpires).value());
         mDum.send(getCreator()->getLastRequest());
         return;
      }
      
      // We should only do DialogState processing if this is a response to our initial request
      if(getCreator() &&
         msg.header(h_CSeq) == getCreator()->getLastRequest()->header(h_CSeq))
      {
         switch(mState)
         {
            case Initial:
               if (code < 200)
               {
                  mState = ReceivedProvisional;
               }
               else if(code < 300)
               {
                  mState = Established;
               }
               else
               {
                  mState = Established;
                  if (!mDialogs.empty())
                  {
                     dispatchToAllDialogs(msg);
                     return;
                  }
               }
               break;
            case ReceivedProvisional:
               if (code < 200)
               {
                  // fall through
               }
               else if (code < 300)
               {
                  mState = Established;
                  for (DialogMap::iterator it = mDialogs.begin(); it != mDialogs.end(); it++)
                  {
                     if (it->second != dialog) // this is dialog that accepted
                     {
                        it->second->onForkAccepted();
                     }
                  }
               }
               else // failure response
               {
                  mState = Established;
                  if (!mDialogs.empty())
                  {
                     dispatchToAllDialogs(msg);
                     return;
                  }
               }
               break;
            default:
               // !jf!
               break;            
         }
      }

      if (response.header(h_StatusLine).statusCode() == 100)
      {
         if (mDum.mDialogSetHandler)
         {
            mDum.mDialogSetHandler->onTrying(mAppDialogSet->getHandle(), msg);
         }
         return;
      }
      
      switch (response.header(h_CSeq).method())
      {
         case INVITE:
         case SUBSCRIBE:
         case BYE:
         case ACK:
         case CANCEL:
            break; 

         case PUBLISH:
            if (mClientPublication == 0)
            {
               mClientPublication = makeClientPublication(response);
            }
            mClientPublication->dispatch(response);
            return;

         case REGISTER:
            if (mClientRegistration == 0)
            {
               mClientRegistration = makeClientRegistration(response);
            }
            mClientRegistration->dispatch(response);
            return;

         case MESSAGE:
             if (dialog)
            {
                break;
            }
            else if (mClientPagerMessage)
            {
               mClientPagerMessage->dispatch(response);
            }
            return;            

         case INFO:   
         case UPDATE:
            if (dialog)
            {
               break;
            }
            else // not allowed
            {
               return;
            }
         case REFER:
            if (dynamic_cast<SubscriptionCreator*>(getCreator()))
            {
               break;
            }
         case NOTIFY:
            if (dialog)
            {
               break;
            }
            
         default:
         {
            ClientOutOfDialogReq* req = findMatchingClientOutOfDialogReq(response);
            if (req == 0)
            {
               req = makeClientOutOfDialogReq(response);
               mClientOutOfDialogRequests.push_back(req);
            }
            req->dispatch(response);
            return;
         }
      }
   }

   if (dialog == 0)
   {
      if (msg.isRequest() && msg.header(h_RequestLine).method() == CANCEL)
      {
         dispatchToAllDialogs(msg);
         return;
      }

      if (msg.isResponse())
      {
         if( mCreator )
         {
            SharedPtr<SipMessage> lastRequest(mCreator->getLastRequest());