Changeset 3810

Timestamp:

06/19/2012 03:22:20 PM (11 months ago)

Author:

kurtis.heimerl

Message:

Fixed #932 and #905 in public. OpenBTS now responds negatively to SIP

re-invites, though the specific effect of this depends on the client
sending the re-invite. In the case of FS, it causes the RTP stream to
break. We also now complain when invites time out, sending an alert to the
user about the proxy status.

Location:

openbts/trunk

Files:

• Control/CallControl.cpp (modified) (3 diffs)
• Control/TransactionTable.cpp (modified) (3 diffs)
• Control/TransactionTable.h (modified) (2 diffs)
• SIP/SIPEngine.cpp (modified) (10 diffs)
• SIP/SIPEngine.h (modified) (5 diffs)
• SIP/SIPInterface.cpp (modified) (1 diff)
• SIP/SIPMessage.cpp (modified) (2 diffs)
• SIP/SIPMessage.h (modified) (2 diffs)

openbts/trunk/Control/CallControl.cpp

@@ -138 +138 @@
         else { //we received, respond and then don't send ok
                 //changed state immediately to canceling
-                transaction->MODSendUNAVAIL();
+                transaction->MODSendERROR(NULL, 480, "Temporarily Unavailable", true);
                 //then canceled
-                transaction->MODWaitForUNAVAILACK();
+                transaction->MODWaitForERRORACK(true);
         }
 }
@@ -338 +338 @@
                         }
                         else { //if we received it, send a 4** instead
-                                transaction->MODSendUNAVAIL();
-                                transaction->MODWaitForUNAVAILACK();
+                                transaction->MODSendERROR(NULL, 480, "Temporarily Unavailable", true);
+                                transaction->MODWaitForERRORACK(true);
                         }
                         transaction->GSMState(GSM::NullState);
@@ -867 +867 @@
                                 break;
                         case SIP::Timeout:
-                                LOG(NOTICE) << "SIP:Timeout, reinvite";
+                                LOG(ALERT) << "MOC INVITE Timed out. Is SIP.Proxy.Speech (" << gConfig.getStr("SIP.Proxy.Speech") << ") configured correctly?";
                                 state = transaction->MOCResendINVITE();
                                 break;

openbts/trunk/Control/TransactionTable.cpp

@@ -421 +421 @@
 }
 
-SIP::SIPState TransactionEntry::MODSendUNAVAIL()
-{
-        ScopedLock lock(mLock);
-        SIP::SIPState state = mSIP.MODSendUNAVAIL();
+SIP::SIPState TransactionEntry::MODSendERROR(osip_message_t * cause, int code, const char * reason, bool cancel)
+{
+        ScopedLock lock(mLock);
+        SIP::SIPState state = mSIP.MODSendERROR(cause, code, reason, cancel);
         echoSIPState(state);
         return state;
@@ -453 +453 @@
 }
 
-SIP::SIPState TransactionEntry::MODResendUNAVAIL()
-{
-        ScopedLock lock(mLock);
-        SIP::SIPState state = mSIP.MODResendUNAVAIL();
+SIP::SIPState TransactionEntry::MODResendERROR(bool cancel)
+{
+        ScopedLock lock(mLock);
+        SIP::SIPState state = mSIP.MODResendERROR(cancel);
         echoSIPState(state);
         return state;
@@ -477 +477 @@
 }
 
-SIP::SIPState TransactionEntry::MODWaitForUNAVAILACK()
-{
-        ScopedLock lock(mLock);
-        SIP::SIPState state = mSIP.MODWaitForUNAVAILACK();
+SIP::SIPState TransactionEntry::MODWaitForERRORACK(bool cancel)
+{
+        ScopedLock lock(mLock);
+        SIP::SIPState state = mSIP.MODWaitForERRORACK(cancel);
         echoSIPState(state);
         return state;

openbts/trunk/Control/TransactionTable.h

@@ -203 +203 @@
 
         SIP::SIPState MODSendBYE();
-        SIP::SIPState MODSendUNAVAIL();
+        SIP::SIPState MODSendERROR(osip_message_t * cause, int code, const char * reason, bool cancel);
         SIP::SIPState MODSendCANCEL();
         SIP::SIPState MODResendBYE();
         SIP::SIPState MODResendCANCEL();
-        SIP::SIPState MODResendUNAVAIL();
+        SIP::SIPState MODResendERROR(bool cancel);
         SIP::SIPState MODWaitForBYEOK();
         SIP::SIPState MODWaitForCANCELOK();
-        SIP::SIPState MODWaitForUNAVAILACK();
+        SIP::SIPState MODWaitForERRORACK(bool cancel);
         SIP::SIPState MODWaitFor487();
 
@@ -242 +242 @@
                 { ScopedLock lock(mLock); mSIP.saveBYE(bye,local); }
 
+        bool sameINVITE(osip_message_t * msg)
+                { ScopedLock lock(mLock); return mSIP.sameINVITE(msg); }
+
         //@}
 

openbts/trunk/SIP/SIPEngine.cpp

@@ -97 +97 @@
         mSIPIP(gConfig.getStr("SIP.Local.IP")),
         mINVITE(NULL), mLastResponse(NULL), mBYE(NULL),
-        mCANCEL(NULL), mUNAVAIL(NULL), mSession(NULL), 
+        mCANCEL(NULL), mERROR(NULL), mSession(NULL), 
         mTxTime(0), mRxTime(0), mState(NullState),
         mDTMF('\0'),mDTMFDuration(0)
@@ -134 +134 @@
         if (mBYE!=NULL) osip_message_free(mBYE);
         if (mCANCEL!=NULL) osip_message_free(mCANCEL);
-        if (mUNAVAIL!=NULL) osip_message_free(mUNAVAIL);
+        if (mERROR!=NULL) osip_message_free(mERROR);
         // FIXME -- Do we need to dispose of the RtpSesion *mSesison?
 }
@@ -202 +202 @@
 }
 
-void SIPEngine::saveUNAVAIL(const osip_message_t *UNAVAIL, bool mine)
+void SIPEngine::saveERROR(const osip_message_t *ERROR, bool mine)
 {
         // Instead of cloning, why not just keep the old one?
         // Because that doesn't work in all calling contexts.
         // This simplifies the call-handling logic.
-        if (mUNAVAIL!=NULL) osip_message_free(mUNAVAIL);
-        osip_message_clone(UNAVAIL,&mUNAVAIL);
+        if (mERROR!=NULL) osip_message_free(mERROR);
+        osip_message_clone(ERROR,&mERROR);
 }
 
@@ -579 +579 @@
 }
 
-SIPState SIPEngine::MODSendUNAVAIL()
-{
-        LOG(INFO) << "user " << mSIPUsername << " state " << mState;
-        assert(mINVITE);
-
-        osip_message_t * unavail = sip_temporarily_unavailable(mINVITE, mSIPIP.c_str(),
-                                                               mSIPUsername.c_str(), mSIPPort);
+SIPState SIPEngine::MODSendERROR(osip_message_t * cause, int code, const char * reason, bool cancel)
+{
+        LOG(INFO) << "user " << mSIPUsername << " state " << mState;
+        if (NULL == cause){
+                assert(mINVITE);
+                cause = mINVITE;
+        }
+        
+        /* 480 is unavail */
+        osip_message_t * unavail = sip_error(cause, mSIPIP.c_str(),
+                                             mSIPUsername.c_str(), mSIPPort, 
+                                             code, reason);
         gSIPInterface.write(&mProxyAddr,unavail);
-        saveUNAVAIL(unavail, true);
+        saveERROR(unavail, true);
         osip_message_free(unavail);
-        mState = MODCanceling;
+        if (cancel){
+                mState = MODCanceling;
+        }
         return mState;
 }
@@ -626 +633 @@
 }
 
-SIPState SIPEngine::MODResendUNAVAIL()
-{
-        LOG(INFO) << "user " << mSIPUsername << " state " << mState;
-        assert(mState==MODCanceling);
-        assert(mUNAVAIL);
-        gSIPInterface.write(&mProxyAddr,mUNAVAIL);
+SIPState SIPEngine::MODResendERROR(bool cancel)
+{
+        LOG(INFO) << "user " << mSIPUsername << " state " << mState;
+        if (cancel){
+                if (mState!=MODCanceling) LOG(ERR) << "incorrect state for this method";
+        }
+        assert(mERROR);
+        gSIPInterface.write(&mProxyAddr,mERROR);
         return mState;
 }
@@ -727 +736 @@
 }
 
-SIPState SIPEngine::MODWaitForUNAVAILACK()
+SIPState SIPEngine::MODWaitForERRORACK(bool cancel)
 {
         LOG(INFO) << "user " << mSIPUsername << " state " << mState;
@@ -738 +747 @@
                         saveResponse(ack);
                         if ((NULL == ack->sip_method) || !strncmp(ack->sip_method,"ACK", 4)) {
-                                LOG(WARNING) << "unexpected response to UNAVAIL, from proxy " << mProxyIP << ":" << mProxyPort << ". Assuming other end has cleared";
+                                LOG(WARNING) << "unexpected response to ERROR, from proxy " << mProxyIP << ":" << mProxyPort << ". Assuming other end has cleared";
                         }
                         osip_message_free(ack);
@@ -744 +753 @@
                 }
                 catch (SIPTimeout& e) {
-                        LOG(NOTICE) << "response timeout, resending UNAVAIL";
-                        MODResendUNAVAIL();
+                        LOG(NOTICE) << "response timeout, resending ERROR";
+                        MODResendERROR(cancel);
                 }
         }
@@ -751 +760 @@
         if (!responded) { LOG(ALERT) << "lost contact with proxy " << mProxyIP << ":" << mProxyPort; }
 
-        mState = Canceled;
+        if (cancel){
+                mState = Canceled;
+        }
 
         return mState;
@@ -1213 +1224 @@
 };
 
-
-
+/* reinvite stuff */
+/* return true if this is the same invite as the one we have stored */
+bool SIPEngine::sameINVITE(osip_message_t * msg){
+        assert(mINVITE);
+        if (NULL == msg){
+                return false;
+        }
+        char* old_inv;
+        size_t old_len;
+        char* new_inv;
+        size_t new_len;
+        int res = 0; //does not match
+        //this sometimes fails even though mINVITE is real. No idea -k
+        osip_message_to_str(mINVITE, &old_inv, &old_len);
+        osip_message_to_str(msg, &new_inv, &new_len);
+        if (old_inv && new_inv){
+                res = !(strncmp(old_inv, new_inv, old_len));
+        }
+        if (old_inv){
+                free(old_inv);
+        }
+        if (new_inv){
+                free(new_inv);
+        }
+        return res;
+}
 
 // vim: ts=4 sw=4

openbts/trunk/SIP/SIPEngine.h

@@ -114 +114 @@
         osip_message_t * mBYE;          ///< the BYE message for this transaction
         osip_message_t * mCANCEL;       ///< the CANCEL message for this transaction
-        osip_message_t * mUNAVAIL;      ///< the UNAVAIL message for this transaction
+        osip_message_t * mERROR;        ///< the ERROR message for this transaction
         //@}
 
@@ -280 +280 @@
         SIPState MODSendBYE();
 
-        SIPState MODSendUNAVAIL();
+        SIPState MODSendERROR(osip_message_t * cause, int code, const char * reason, bool cancel);
 
         SIPState MODSendCANCEL();
@@ -288 +288 @@
         SIPState MODResendCANCEL();
 
-        SIPState MODResendUNAVAIL();
+        SIPState MODResendERROR(bool cancel);
 
         SIPState MODWaitForBYEOK();
@@ -294 +294 @@
         SIPState MODWaitForCANCELOK();
 
-        SIPState MODWaitForUNAVAILACK();
+        SIPState MODWaitForERRORACK(bool cancel);
 
         SIPState MODWaitFor487();
@@ -356 +356 @@
         void saveCANCEL(const osip_message_t *CANCEL, bool mine);
 
-        /** Save a copy of a UNAVAIL message in the engine. */
-        void saveUNAVAIL(const osip_message_t *UNAVAIL, bool mine);
-
-
+        /** Save a copy of a ERROR message in the engine. */
+        void saveERROR(const osip_message_t *ERROR, bool mine);
+
+        
+        /** Determine if this invite matches the saved one */
+        bool sameINVITE(osip_message_t * msg);
 
         private:

openbts/trunk/SIP/SIPInterface.cpp

@@ -380 +380 @@
                         return false;
                 }
+                //if this is not the saved invite, it's a RE-invite. Respond saying we don't support it. 
+                if (!transaction->sameINVITE(msg)){
+                  /* don't cancel the call */
+                        transaction->MODSendERROR(msg, 488, "Not Acceptable Here", false);
+                        /* I think we'd need to create a new transaction for this ack. Right now, just assume the ack makes it back. 
+                           if not, we'll hear another INVITE */
+                        //transaction->MODWaitForERRORACK(false); //don't cancel the call
+                        return false;
+                }
                 // There is transaction already.  Send trying.
                 transaction->MTCSendTrying();

openbts/trunk/SIP/SIPMessage.cpp

@@ -600 +600 @@
 }
 
-osip_message_t * SIP::sip_temporarily_unavailable( osip_message_t * invite,  const char * host, const char * username, short  port)
+osip_message_t * SIP::sip_error(osip_message_t * invite,  const char * host, const char * username, short port, short code, const char* reason)
 {
 
@@ -611 +611 @@
         unavail->message_property = 2;
         //header stuff first
-        unavail->status_code = 480;
-        unavail->reason_phrase = strdup("Temporarily Unavailable");
+        unavail->status_code = code;
+        unavail->reason_phrase = strdup(reason);
         osip_message_set_version(unavail, strdup("SIP/2.0"));
 

openbts/trunk/SIP/SIPMessage.h

@@ -56 +56 @@
 osip_message_t * sip_okay( osip_message_t * inv, const char * sip_username, const char * local_ip, short wlocal_port);
 
-osip_message_t * sip_temporarily_unavailable( osip_message_t * invite,  const char * host, const char * username, short  port);
+osip_message_t * sip_error( osip_message_t * invite,  const char * host, const char * username, short port, short code, const char* reason);
 
 osip_message_t * sip_info(unsigned info, const char *dialed_number, short rtp_port,const char * sip_username, short local_port, const char * local_ip, const char * proxy_ip, const char * from_tag, const char * via_branch, const osip_call_id_t* call_id_header, int cseq);
@@ -70 +70 @@
 };
 #endif
-