@babblevoice/babble-drachtio-callmanager 1.6.13 → 1.6.14

package/lib/call.js

@@ -339,7 +339,7 @@ class call {
   }
 
   /**
-   * Set the entity information aainst this call. Itis either set by authentication
+   * Set the entity information against this call. Itis either set by authentication
    * or externally (for example if we auth by network location).
    * Either ( e.uri ) or ( e.realm and e.username ) are required.
    * @param { entity } e
@@ -460,6 +460,7 @@ class call {
 
         if( !parsed ) parsed = {}
         let parseduri = parseuri( parsed.uri )
+        if( !parseduri ) parseduri = { "user": parsed.user, "host": parsed.host }
         if( !parsed.params ) parsed.params = {}
 
         return {
@@ -880,49 +881,6 @@ class call {
     } )
   }
 
-  /**
-    Called from newuac when we are answered and we have a dialog,
-    this = child call (the new call - the bleg)
-    @private
-  */
-  async _onanswer() {
-
-    let hangups = []
-    if( this.parent ) {
-      for( let child of this.parent.children ) {
-        if( child.uuid !== this.uuid ) {
-          child.detach()
-          /* do not await - we do not want to delay the winner in 
-          connecting by waiting for the completion of the hangups */
-          hangups.push( child.hangup( hangupcodes.LOSE_RACE ) )
-        }
-      }
-    }
-
-    if( this.state.destroyed ) return this
-    callstore.set( this )
-
-    if( true === this.options.noAck ) {
-      await this._onlatebridge()
-    } else {
-      await this._onearlybridge()
-    }
-
-    this.established = true
-    this.sip.tags.remote = this._dialog.sip.remoteTag
-
-    let r = this._promises.resolve.newuac
-    this._promises.resolve.newuac = false
-    this._promises.reject.newuac = false
-
-    if( hangups.length > 0 ) {
-      await Promise.all( hangups )
-    }
-
-    if( r ) r( this )
-    return this
-  }
-
   /* A simple implimentation if we are offered candidates */
   static async _parsesdpcandidates( target, sdp ) {
 
@@ -994,6 +952,14 @@ class call {
         }
       }
   
+      /* are we still established? */
+      if( !this.established || this.state.destroyed ) return this
+      if( !this.channels.audio ) {
+        /* something bad has happened */
+        this.hangup( hangupcodes.NOT_ACCEPTABLE )
+        return this
+      }
+
       this.channels.audio.mix( this.parent.channels.audio )
 
       this._em.emit( "call.mix", this )
@@ -1105,7 +1071,7 @@ class call {
       }
     }
 
-    if( this.children.length > 0 ) return this.children[ 0 ]
+    if( this.children.length > 0 ) return this.children.values().next().value
 
     return false
   }
@@ -2260,18 +2226,21 @@ class call {
 
     this._sethangupcause( "us", reason )
 
-    if( this.established ) {
+    if( this.state.established ) {
       try {
         await this._dialog.destroy()
       } catch( e ) { console.trace( e ) }
 
-    } else if( "uac" === this.type ) {
+    } else if( "uac" === this.type && 
+               this.state.trying ) {
       try {
-        if( this._req ) this._req.cancel()
+        this.canceled = true
+        if( this._req ) {
+          this._req.cancel( ( err, cancel ) => {
+            if( err ) console.trace( err )
+          } )
+        }
       } catch( e ) { console.trace( e ) }
-
-      this.canceled = true
-
     } else {
       try {
         this._res.send( this.hangup_cause.sip )
@@ -2431,7 +2400,7 @@ class call {
   @param { earlycallback } [ callbacks.early ] - callback to provide a call object with early call (pre dialog)
   @param { confirmcallback } [ callbacks.confirm ] - called when a dialog is confirmed but before it is bridged with a parent - this provides an opportunity for another call to adopt this call
   @param { failcallback } [ callbacks.fail ] - Called when child is terminated
-  @return { Promise< call | false > } - returns a promise which resolves to a new call object if a dialog has been confirmed. If none are confirmed ten return false. Each attempt is fed into callbacks.early.
+  @return { Promise< call | false > } - returns a promise which resolves to a new call object if a dialog has been confirmed. If none are confirmed then return false. Each attempt is fed into callbacks.early.
   */
   static async newuac( options, callbacks = {} ) {
 
@@ -2461,7 +2430,7 @@ class call {
         return false
       }
 
-      let othercalls = []
+      const numcontacts = contactinfo.contacts.length
       let ourcallbacks = {}
       let failcount = 0
 
@@ -2471,22 +2440,30 @@ class call {
       } )
 
       ourcallbacks.early = ( c ) => {
-        othercalls.push( c )
         if( callbacks.early ) callbacks.early( c )
       }
 
       ourcallbacks.fail = ( c ) => {
         failcount++
-        if( failcount >= othercalls.length ) {
+        if( failcount >= numcontacts ) {
           /* we have no more to try */
-          waitonchildrenresolve( c )
+          if( false !== waitonchildrenresolve ) {
+            waitonchildrenresolve( false )
+            waitonchildrenresolve = false
+          }
         }
         if( callbacks.fail ) callbacks.fail( c )
       }
 
       ourcallbacks.confirm = ( c ) => {
-        waitonchildrenresolve( c )
-        if( callbacks.confirm ) callbacks.confirm( c )
+        if( false !== waitonchildrenresolve ) {
+          waitonchildrenresolve( c )
+          waitonchildrenresolve = false
+          if( callbacks.confirm ) callbacks.confirm( c )
+          return
+        }
+        c.hangup( hangupcodes.LOSE_RACE )
+        if( callbacks.fail ) callbacks.fail( c )
       }
       
       for( let contact of contactinfo.contacts ) {
@@ -2499,17 +2476,6 @@ class call {
       }
 
       let child = await waitonchildrenpromise
-
-      if( child && !child.parent ) {
-        /* we have to terminate other calls we generated as this 
-        will not happen in the call object without a parent */
-        for( let other of othercalls ) {
-          if( other.uuid !== child.uuid ) {
-            other.detach()
-            other.hangup( hangupcodes.LOSE_RACE )
-          }
-        }
-      }
       return child
     }
 
@@ -2579,10 +2545,6 @@ class call {
     newcall.options = { ...callmanager.options, ...newcall.options, ...options }
     newcall.options.headers = tmpheaders
 
-    newcall._timers.newuac = setTimeout( () => {
-      newcall.hangup( hangupcodes.REQUEST_TIMEOUT )
-    }, newcall.options.uactimeout )
-
     if( newcall.options.late ) {
       newcall.options.noAck = true /* this is a MUST for late negotiation */
     } else {
@@ -2612,67 +2574,101 @@ class call {
       if( addressparts.port ) newcall.network.remote.port = addressparts.port
     }
 
-    newcall._dialog = await callmanager.options.srf.createUAC( options.contact, newcall.options, {
-      cbRequest: ( err, req ) => {
+    try {
+      newcall._dialog = await callmanager.options.srf.createUAC( options.contact, newcall.options, {
+        cbRequest: ( err, req ) => {
 
-        if( !req ) {
-          newcall.state.destroyed = true
-          console.trace( "No req object??", err )
-          return
-        }
+          if( !req ) {
+            newcall.state.destroyed = true
+            console.trace( "No req object??", err )
+            return
+          }
 
-        newcall._req = req
-        newcall.state.trying = true
+          newcall._timers.newuac = setTimeout( () => {
+            newcall.hangup( hangupcodes.REQUEST_TIMEOUT )
+          }, newcall.options.uactimeout )
 
-        newcall.sip = {
-          "callid": req.getParsedHeader( "call-id" ),
-          "tags": {
-            "local": req.getParsedHeader( "from" ).params.tag,
-            "remote": ""
-          },
-          "contact": [ { "uri": options.contact } ]
-        }
+          newcall._req = req
+          newcall.state.trying = true
 
-        callstore.set( newcall )
-        if( callbacks && callbacks.early ) callbacks.early( newcall )
-        callmanager.options.em.emit( "call.new", newcall )
-      },
-      cbProvisional: async ( res ) => {
-        newcall._res = res
-        if( 180 === res.status ) {
-          newcall._onring()
-        } else if( 183 === res.status ) {
-          await newcall._onearly()
+          newcall.sip = {
+            "callid": req.getParsedHeader( "call-id" ),
+            "tags": {
+              "local": req.getParsedHeader( "from" ).params.tag,
+              "remote": ""
+            },
+            "contact": [ { "uri": options.contact } ]
+          }
+
+          callstore.set( newcall )
+          if( callbacks && callbacks.early ) callbacks.early( newcall )
+          callmanager.options.em.emit( "call.new", newcall )
+        },
+        cbProvisional: async ( res ) => {
+          newcall._res = res
+          if( 180 === res.status ) {
+            newcall._onring()
+          } else if( 183 === res.status ) {
+            await newcall._onearly()
+          }
+
+          if( newcall.canceled ) {
+            newcall.hangup()
+          }
         }
+      } )
+    } catch ( err ) {
+
+      if( !newcall._state._hangup ) {
+        if ( undefined !== err.status ) {
+          let reason = hangupcodes.REQUEST_TERMINATED
+          if( err.status in inboundsiperros ) reason = inboundsiperros[ err.status ]
 
-        if( newcall.canceled ) {
-          newcall.hangup()
+          newcall.state.destroyed = true
+          if( newcall ) newcall._onhangup( "wire", reason )
+        } else {
+          console.trace( err )
         }
       }
-    } ).catch( ( err ) => {
-      if ( undefined !== err.status ) {
-        let reason = hangupcodes.REQUEST_TERMINATED
-        if( err.status in inboundsiperros ) reason = inboundsiperros[ err.status ]
+    } finally {
+      
+      if( newcall._timers.newuac ) clearTimeout( newcall._timers.newuac )
+      newcall._timers.newuac = false
 
-        if( newcall ) newcall._onhangup( "wire", reason )
-      } else {
-        console.trace( err )
+      if( newcall.state.destroyed || newcall.state.canceled || newcall._state._hangup ) {
+        if( callbacks && callbacks.fail ) callbacks.fail( newcall )
+        return newcall
       }
-    } )
 
-    if( newcall._timers.newuac ) clearTimeout( newcall._timers.newuac )
-    newcall._timers.newuac = false
+      newcall.sdp.remote = sdpgen.create( newcall._dialog.remote.sdp )
 
-    if( newcall.state.destroyed ) {
+      if( newcall.state.destroyed ) return this
+      newcall.established = true
 
-      if( callbacks && callbacks.fail ) callbacks.fail( newcall )
-      return newcall
-    }
+      if( newcall.parent ) {
+        for( const child of newcall.parent.children ) {
+          if( child.uuid !== newcall.uuid && !child.state.established ) {
+            child.detach()
+            /* do not await - we do not want to delay the winner in 
+            connecting by waiting for the completion of the hangups */
+            child.hangup( hangupcodes.LOSE_RACE )
+          }
+        }
+      }
 
-    newcall.sdp.remote = sdpgen.create( newcall._dialog.remote.sdp )
+      callstore.set( newcall )
 
-    if( callbacks.confirm ) await callbacks.confirm( newcall )
-    return await newcall._onanswer()
+      newcall.sip.tags.remote = newcall._dialog.sip.remoteTag
+
+      if( true === newcall.options.noAck ) {
+        await newcall._onlatebridge()
+      } else {
+        await newcall._onearlybridge()
+      }
+
+      if( callbacks.confirm ) await callbacks.confirm( newcall )
+      return newcall
+    }
   }
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babblevoice/babble-drachtio-callmanager",
-  "version": "1.6.13",
+  "version": "1.6.14",
   "description": "Call processing to create a PBX",
   "main": "index.js",
   "scripts": {

package/test/interface/call.js

@@ -205,7 +205,7 @@ describe( "call object", function() {
     expect( call.state.cleaned ).to.be.true
   } )
 
-  it( `uas.newuac - create uac by entity with registrar #123`, async function() {
+  it( `uas.newuac - create uac by entity with registrar`, async function() {
 
     let options = {
       "registrar": {
@@ -228,6 +228,15 @@ describe( "call object", function() {
       srfscenario.inbound()
     } )
 
+    call._req.setparsedheader( "remote-party-id", {
+      "name": "",
+      "uri": "",
+      "user": "0123456789",
+      "host": "someotherrealm.com",
+      "params": { "privacy": false },
+      "type": "callerid"
+    } )
+
     let child = await call.newuac( { "entity": { "uri": "1000@dummy" } } )
 
     expect( await callstore.stats() ).to.deep.include( {
@@ -248,7 +257,7 @@ describe( "call object", function() {
     child.update()
 
     expect( requestoptions.method ).to.equal( "update" )
-    expect( requestoptions.headers[ "P-Preferred-Identity" ] ).to.equal( `"" <sip:1000@dummy.com>` )
+    expect( requestoptions.headers[ "P-Preferred-Identity" ] ).to.equal( `"" <sip:0123456789@someotherrealm.com>` )
 
     await call.hangup()
 

package/test/interface/early.js

@@ -311,15 +311,20 @@ a=sendrecv`.replace(/(\r\n|\n|\r)/gm, "\r\n")
 
   it( `Create call and send 183 - early - SAVPF and 200 ok`, async () => {
 
-    /*
-    Phone (SAVPF)         BV                   Gateway
-    |---------INVITE------>|                      |(1)
-    |                      |---------INVITE------>|(2)
-    |                      |<--------183 (w-sdp)--|(3)
-    |<--------183 (w-sdp)--|                      |(4)
-    |                      |<--------200 (w-sdp)--|(5)
-    |<--------200 (w-sdp)--|                      |(6)
-    */
+    /**
+     * Markdown - mermaid
+       sequenceDiagram
+        participant Phone
+        participant babble
+        participant Gateway
+
+        Phone->>babble: INVITE (1)
+        babble->>Gateway: INVITE (2)
+        Gateway->>babble: 183 w-sdp (3)
+        babble->>Phone: 183 w-sdp (4)
+        Gateway->>babble: Ok w-sdp (200)(5)
+        babble->>Phone: Ok w-sdp (200) (6)
+     */
 
     /* Setup the mock RTP server */ 
     let srfscenario = new srf.srfscenario( { savpf: true } )
@@ -447,9 +452,10 @@ a=sendrecv`.replace(/(\r\n|\n|\r)/gm, "\r\n")
     expect( channelmessages[ 2 ].remote.port ).to.equal( 48356 )
     expect( channelmessages[ 2 ].remote.address ).to.equal( "82.19.206.102" )
     expect( channelmessages[ 3 ].channel ).to.equal( "mix" )
-
-    expect( channelmessages[ 6 ].channel ).to.equal( "close" )
+    /* with 183 we now get a second duplicate mix - this could be tidied but it is safe */
+    expect( channelmessages[ 6 ].channel ).to.equal( "mix" )
     expect( channelmessages[ 7 ].channel ).to.equal( "close" )
+    expect( channelmessages[ 8 ].channel ).to.equal( "close" )
 
     expect( msginfo.body ).to.include( "UDP/TLS/RTP/SAVPF" )