/[resiprocate]/main/sip/resiprocate/dum/Dialog.cxx
ViewVC logotype

Diff of /main/sip/resiprocate/dum/Dialog.cxx

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 2611 by jason, Tue Apr 13 21:17:16 2004 UTC revision 2612 by jason, Tue Apr 13 22:09:44 2004 UTC
# Line 138  Line 138 
138                 if (isEqualNoCase(contact.uri().scheme(), Symbols::Sips) ||                 if (isEqualNoCase(contact.uri().scheme(), Symbols::Sips) ||
139                     isEqualNoCase(contact.uri().scheme(), Symbols::Sip))                     isEqualNoCase(contact.uri().scheme(), Symbols::Sip))
140                 {                 {
141                    BaseCreator& creator = mDum.findCreator(mId);                    BaseCreator* creator = mDum.findCreator(mId);
142                    mLocalContact = creator.getLastRequest().header(h_Contacts).front();                    assert(creator);// !jf! throw or something here
143                      
144                      mLocalContact = creator->getLastRequest().header(h_Contacts).front();
145                    mRemoteTarget = contact;                    mRemoteTarget = contact;
146                 }                 }
147                 else                 else
# Line 180  Line 182 
182     return mId;     return mId;
183  }  }
184    
 // !dlb! merge this stub in  
 #if 0  
 void  
 Dialog::dispatch(const SipMessage& msg)  
 {  
    if (msg.isRequest())  
    {  
       switch (request.header(h_RequestLine).getMethod())  
       {  
          // a NOTIFY is the only request that can  
          // create a full dialog (when the 2xx from the  
          // SUBSCRIBE arrives *after* the NOTIFY  
          case NOTIFY :  
             processNotify(msg);  
             break;  
   
          case REFER:  
             // !jf! wierdo  
             // affects an InvSession and a ServerSubscription  
             break;  
   
          case SUBSCRIBE:  
             processSubscribe(msg);  
             break;  
   
          case CANCEL:  
             // should only occur when canceling a re-INVITE  
          case INVITE:    
             // should only occur for a re-INVITE  
          case ACK:  
          case PRACK:  
          case BYE:  
          case UPDATE:  
          case INFO:  
             processInviteRelated(msg);  
             break;  
           
          case REGISTER:  
          {  
             assert(0); // already handled  
             break;  
          }  
         
          case PUBLISH:  
             assert(0);  
             break;                        
   
          case MESSAGE:  
          case OPTIONS:  
             assert(0);  
             break;  
           
          default:  
             assert(0);  
             break;  
       }  
    }  
    else if (msg.isResponse())  
    {  
         
    }  
    else  
    {  
       assert(0);  
    }  
 }  
 #endif  
   
185  void  void
186  Dialog::dispatch(const SipMessage& msg)  Dialog::dispatch(const SipMessage& msg)
187  {  {
# Line 263  Line 197 
197           switch (msg.header(h_CSeq).method())           switch (msg.header(h_CSeq).method())
198           {           {
199              case INVITE:  // new INVITE              case INVITE:  // new INVITE
200                   if (mInviteSession == 0)
201                   {
202                 mInviteSession = mDum.makeServerInviteSession(*this, msg);                 mInviteSession = mDum.makeServerInviteSession(*this, msg);
203                   }
204                   mInviteSession->dispatch(msg);
205                 break;                 break;
206                                
207              case ACK:              case ACK:
208              case CANCEL:              case CANCEL:
209                   if (mInviteSession == 0)
210                   {
211                 InfoLog (<< "Drop stray ACK or CANCEL in dialog on the floor");                 InfoLog (<< "Drop stray ACK or CANCEL in dialog on the floor");
212                 DebugLog (<< msg);                 DebugLog (<< msg);
213                   }
214                   else
215                   {
216                      mInviteSession->dispatch(msg);
217                   }
218                 break;                 break;
219    
220              case SUBSCRIBE:              case SUBSCRIBE:
221              case REFER: //!jf! does this create a server subs?              case REFER: //!jf! does this create a server subs?
222                   if (mServerSubscription == 0)
223                   {
224                 mServerSubscription = mDum.makeServerSubscription(*this, msg);                 mServerSubscription = mDum.makeServerSubscription(*this, msg);
225                   }
226                  
227                   mServerSubscription->dispatch(msg);
228                 break;                 break;
229                                
230              case NOTIFY:              case NOTIFY:
231                 mClientSubscriptions.push_back(mDum.makeClientSubscription(*this, msg));                 if (msg.header(h_To).exists(p_tag))
232                   {
233                      ClientSubscription* client = findMatchingClientSub(msg);
234                      if (client)
235                      {
236                         client->dispatch(msg);
237                      }
238                      else
239                      {
240                         BaseCreator* creator = mDum.findCreator(mId);
241                         if (creator)
242                         {
243                            sub = mDum.makeClientSubscription(*this, msg);
244                            mClientSubscriptions.push_back(sub);
245                            sub->dispatch(msg);
246                         }
247                         else
248                         {
249                            std::auto_ptr<SipMessage> failure(Helper::makeResponse(request, 481));
250                            mDum.send(*failure);
251                            return;
252                         }
253                      }
254                   }
255                   else // no to tag - unsolicited notify
256                   {
257                      assert(mServerOutOfDialogReq == 0);
258                      mServerOutOfDialogReq = mDum.makeServerOutOfDialog(*this, msg);
259                      mServerOutOfDialogReq->dispatch(msg);
260                   }
261                 break;                 break;
262                                
263              case PUBLISH:              case PUBLISH:
264                   if (mServerPublication == 0)
265                   {
266                 mServerPublication = mDum.makeServerPublication(*this, msg);                 mServerPublication = mDum.makeServerPublication(*this, msg);
267                   }
268                   mServerPublication->dispatch(msg);
269                 break;                 break;
270                                
271              case REGISTER:              case REGISTER:
272                   if (mServerRegistration == 0)
273                   {
274                 mServerRegistration = mDum.makeServerRegistration(*this, msg);                 mServerRegistration = mDum.makeServerRegistration(*this, msg);
275                   }
276                   mServerRegistration->dispatch(msg);
277                 break;                 break;
278                                
279              default:              default:
280                   // only can be one ServerOutOfDialogReq at a time
281                   assert(mServerOutOfDialogReq == 0);
282                 mServerOutOfDialogReq = mDum.makeServerOutOfDialog(*this, msg);                 mServerOutOfDialogReq = mDum.makeServerOutOfDialog(*this, msg);
283                   mServerOutOfDialogReq->dispatch(msg);
284                 break;                 break;
285           }           }
286        }        }
# Line 300  Line 290 
290           switch (msg.header(h_CSeq).method())           switch (msg.header(h_CSeq).method())
291           {           {
292              case INVITE:                case INVITE:  
293                   if (mInviteSession == 0)
294                   {
295                      BaseCreator* creator = mDum.findCreator(mId);
296                      assert (creator);
297                      creator->dispatch(msg);
298                      if (msg.header(h_StatusLine).statusCode() != 100)
299                      {
300                 mInviteSession = mDum.makeClientInviteSession(*this, msg);                 mInviteSession = mDum.makeClientInviteSession(*this, msg);
301                         mInviteSession->dispatch(msg);
302                      }
303                   }
304                   else
305                   {
306                      mInviteSession->dispatch(msg);
307                   }
308                 break;                 break;
309                                
310              case ACK:              case ACK:
311              case CANCEL:              case CANCEL:
312                 // Drop on the floor                 if (mInviteSession != 0)
313                   {
314                      mInviteSession->dispatch(msg);
315                   }
316                   // else drop on the floor
317                 break;                 break;
318                                
319              case SUBSCRIBE:              case SUBSCRIBE:
320              case REFER: //!jf! does this create a server subs?              case REFER:
321                 mClientSubscriptions.push_back(mDum.makeClientSubscription(*this, msg));              {
322                 break;                 ClientSubscription* client = findMatchingClientSub(msg);
323                                 if (client)
324              case NOTIFY:                 {
325                 mClientSubscriptions.push_back(mDum.makeClientSubscription(*this, msg));                    client->dispatch(msg);
326                   }
327                   else
328                   {
329                      ClientSubscription* sub = mDum.makeClientSubscription(*this, msg);
330                      mClientSubscriptions.push_back(sub);
331                      sub->dispatch(msg);
332                   }
333                 break;                 break;
334                }
335                                
336              case PUBLISH:              case PUBLISH:
337                   if (mClientPublication == 0)
338                   {
339                 mClientPublication = mDum.makeClientPublication(*this, msg);                 mClientPublication = mDum.makeClientPublication(*this, msg);
340                   }
341                   mClientPublication->dispatch(msg);
342                 break;                 break;
343                                
344              case REGISTER:              case REGISTER:
345                   if (mClientRegistration == 0)
346                   {
347                 mClientRegistration = mDum.makeClientRegistration(*this, msg);                 mClientRegistration = mDum.makeClientRegistration(*this, msg);
348                   }
349                   mClientRegistration->dispatch(msg);
350                 break;                 break;
351                                
352                   // unsolicited - not allowed but commonly implemented
353                   // by large companies with a bridge as their logo
354                case NOTIFY:
355                case INFO:  
356                  
357              default:              default:
358                 mClientOutOfDialogReq = mDum.makeClientOutOfDialog(*this, msg);              {
359                   ClientOutOfDialogReq* req = findMatchingClientOutOfDialogReq(msg);
360                   if (req == 0)
361                   {
362                      req = mDum.makeClientOutOfDialog(*this, msg);
363                      mClientOutOfDialogRequests.push_back(req);
364                   }
365                   req->dispatch(msg);
366                 break;                 break;
367           }           }
368        }        }
369     }     }
370  }  }
371    
 BaseUsage*  
 Dialog::findUsage(const SipMessage& msg)  
 {  
    switch (msg.header(h_CSeq).method())  
    {  
       case INVITE:  // new INVITE  
       case CANCEL:  
       case ACK:  
          return mInviteSession;  
372    
373        case SUBSCRIBE:  ClientSubscription*
374        case REFER:  Dialog::findMatchingClientSub(const SipMessage& msg)
375        case NOTIFY:  {
376           for (std::vector<ClientSubscription*>::iterator i = mClientSubscriptions.begin();           for (std::vector<ClientSubscription*>::iterator i = mClientSubscriptions.begin();
377                i != mClientSubscriptions.end(); ++i)                i != mClientSubscriptions.end(); ++i)
378           {           {
379              if ((*i)->matches(msg))        if (i->matches(msg))
380              {              {
381                 return *i;           i->dispatch(msg);
382             return;
383              }              }
384           }           }
          break;  
       case REGISTER:  
          InfoLog (<< "Received REGISTER inside an existing dialog. This is not supported. ");  
          DebugLog (<< msg);  
          break;  
           
       case PUBLISH:  
          if (msg.isRequest())  
          {  
             return mServerPublication;  
385           }           }
          else if (msg.isRequest())  
          {  
             return mClientPublication;  
          }  
          break;  
386    
387        default:  ClientOutOfDialogRequest*
388           if (msg.isRequest())  Dialog::findMatchingClientOutOfDialogReq(const SipMessage& msg)
389           {           {
390              return mServerOutOfDialogReq;     for (std::vector<ClientOutOfDialogRequest*>::iterator i=mClientOutOfDialogRequests.begin();
391           }          i != mClientOutOfDialogRequests.end(); ++i)
392           else if (msg.isRequest())     {
393          if (i->matches(msg))
394           {           {
395              return mClientOutOfDialogReq;           i->dispatch(msg);
396             return;
397           }           }
          break;  
398     }     }
    return 0;  
399  }  }
400    
401    
402  InviteSession::Handle  InviteSession::Handle
403  Dialog::findInviteSession()  Dialog::findInviteSession()
404  {  {
# Line 525  Line 539 
539        }        }
540     }     }
541  }  }
   
 void  
 Dialog::processSubscribe(const SipMessage& subscribe)  
 {  
    for (std::list<BaseUsage*>::iterator i=mUsages.begin(); i!=mUsages.end(); i++)  
    {  
       ServerSubscription* sub = dynamic_cast<ServerSubscription*>(*i);  
       if (sub && sub->matches(subscribe))  
       {  
          sub->process(subscribe); // a resubscribe or unsubscribe  
          return;  
       }  
    }  
     
    // a subscribe on an existing dialog with a different BaseUsage  
    ServerSubscription* sub = new ServerSubscription(mDum, subscribe);  
 }  
   
 void  
 Dialog::processInviteRelated(const SipMessage& msg)  
 {  
    for (std::list<BaseUsage*>::iterator i=mUsages.begin(); i!=mUsages.end(); i++)  
    {  
       ServerInvSession* server = dynamic_cast<ServerInvSession*>(*i);  
       ClientInvSession* client = dynamic_cast<ClientInvSession*>(*i);  
       if (server)  
       {  
          server->process(msg);  
          break;  
       }  
       else if (client)  
       {  
          client->process(msg);  
          break;  
       }  
    }  
 }  
542  #endif  #endif
543    
544    
545  Dialog::Exception::Exception(const Data& msg, const Data& file, int line)  Dialog::Exception::Exception(const Data& msg, const Data& file, int line)
546     : BaseException(msg, file, line)     : BaseException(msg, file, line)
547  {}  {}

Legend:
Removed from v.2611  
changed lines
  Added in v.2612

webmaster AT resiprocate DOT org
ViewVC Help
Powered by ViewVC 1.1.27