@babblevoice/babble-drachtio-callmanager 2.2.2 → 2.2.4

package/lib/call.js

@@ -1105,7 +1105,7 @@ class call {
         .rtcpmux()
     }
 
-    this._dialog = await this._dialog.ack( this.sdp.local.toString() )
+    this.#setdialog( await this._dialog.ack( this.sdp.local.toString() ) )
     this._addevents( this._dialog )
 
     await this.#answerparent()
@@ -1478,8 +1478,7 @@ class call {
         }
       } )
 
-      this.established = true
-      this._dialog = dialog
+      this.#setdialog( dialog )
       this.sip.tags.local = dialog.sip.localTag
       callstore.set( this )
 
@@ -1759,16 +1758,52 @@ class call {
       } )
   }
 
+  swapchannel( other ){
+
+    const this_audio = this.channels.audio
+    const this_sdp = this.sdp.local
+    const this_chem = this.channels.audio.em
+    const other_chem = other.channels.audio.em
+
+    this.channels.audio = other.channels.audio
+    this.channels.audio.em = this_chem
+    this.sdp.local = other.sdp.local
+
+    other.channels.audio = this_audio
+    other.channels.audio.em = other_chem
+    other.sdp.local = this_sdp
+  }
+
   /**
     Send out modified SDP to get the audio to the new location.
     @private
   */
-  async _modifyforxfer() {
-    this.sdp.local.setaudiodirection( "sendrecv" )
-    await this._dialog.modify( this.sdp.local.toString() )
+  async reinvite() {
+
+    this.sdp.local
+      .clearcodecs()
+      .addcodecs( this.selectedcodec )
+      .select( this.selectedcodec )
+      .setaudiodirection( "sendrecv" )
+
+    if( true === callmanager.options.rfc2833 ) {
+      this.sdp.local.addcodecs( "2833" )
+    }
+
+    const remotesdp = await this._dialog.modify( this.sdp.local.toString() )
       .catch( ( e ) => {
         console.trace( e )
       } )
+
+    if( remotesdp )
+      this.sdp.remote = sdpgen.create( remotesdp )
+
+    const target = this.sdp.remote.getaudio()
+    if( target ) /* we should always get in here */
+      this.channels.audio.remote( call._createchannelremotedef( target.address, target.port, this.selectedcodec ).remote )
+
+    /* Now inform our RTP server also - we might need to wait until the target has completed so need a notify mechanism */
+    this.channels.audio.direction( { "send": true, "recv": true } )
   }
 
   /**
@@ -1842,6 +1877,7 @@ class call {
     }, callmanager.options.seexpire )
 
     dialog.on( "destroy", ( /* req */ ) => {
+      if( this._state._hangup ) return
       this._onhangup( "wire" )
     } )
 
@@ -1921,7 +1957,13 @@ class call {
 
         /* Auth the request - todo make a way of allow un authed refer - but we should nudge to secure */
         if( this.referauthrequired ) {
-          await this.auth()
+          if( this._auth.has( this._req ) ) {
+            /* If the client has included an auth header check it immediatly */
+            if( ! await this._onauth( this._req, this._res ) ) return
+          } else {
+            await this.auth()
+          }
+
           if( this.destroyed ) return
         }
 
@@ -1973,6 +2015,12 @@ class call {
       this.detach()
       if( this.channels.audio ) this.channels.audio.unmix()
       if( othercall.channels.audio ) othercall.channels.audio.unmix()
+
+      await Promise.all( [
+        this.waitforanyevent( { "action": "mix", "event": "finished" }, 0.5 ),
+        othercall.waitforanyevent( { "action": "mix", "event": "finished" }, 0.5 ),
+      ] )
+
       if( othercall.channels.audio && this.moh ) othercall.channels.audio.play( this.moh )
 
       res.send( 202 )
@@ -2040,16 +2088,17 @@ class call {
       return
     }
 
-    const searchfor = { "callid": replaces[ 1 ], "tags": { "local": totag[ 1 ], "remote": fromtag[ 1 ] } }
-    let failed = false
+    let b_1
+    try {
+      const searchfor = { "callid": replaces[ 1 ], "tags": { "local": totag[ 1 ], "remote": fromtag[ 1 ] } }
+      b_1 = await callstore.getbycallid( searchfor )
+    } catch( e ) {
+      console.trace( e )
+      res.send( 400, e )
+      return
+    }
 
-    const b_1 = await callstore.getbycallid( searchfor )
-      .catch( ( e ) => {
-        console.trace( e )
-        res.send( 400, e )
-        failed = true
-      } )
-    if( failed || !b_1 ) return res.send( 400, "No call matches that call id" )
+    if( !b_1 ) return res.send( 400, "No call matches that call id" )
     if( !b_1.sdp.remote ) return res.send( 400, "No remote sdp negotiated (b_1)!" )
     const b_2 = this /* so we can follow the above terminology */
 
@@ -2073,37 +2122,14 @@ class call {
     b_2.channels.audio.unmix()
     c_1.channels.audio.unmix()
 
-    /* Swap channels and update */
-
-    /* copy all first */
-    const a_1_audio = a_1.channels.audio
-    const a_1_sdp = a_1.sdp.local
-    const a_1_chem = a_1.channels.audio.em
-    const b_2_chem = b_2.channels.audio.em
+    await Promise.all( [
+      a_1.waitforanyevent( { "action": "mix", "event": "finished" }, 0.5 ),
+      b_1.waitforanyevent( { "action": "mix", "event": "finished" }, 0.5 ),
+      b_2.waitforanyevent( { "action": "mix", "event": "finished" }, 0.5 ),
+      c_1.waitforanyevent( { "action": "mix", "event": "finished" }, 0.5 ),
+    ] )
 
-    a_1.channels.audio = b_2.channels.audio
-    a_1.channels.audio.em = a_1_chem
-    a_1.sdp.local = b_2.sdp.local
-
-    a_1.sdp.local
-      .clearcodecs()
-      .addcodecs( a_1.selectedcodec )
-      .select( a_1.selectedcodec )
-      .setaudiodirection( "sendrecv" )
-
-    if( true === callmanager.options.rfc2833 ) {
-      a_1.sdp.local.addcodecs( "2833" )
-    }
-
-    /* Link logically */
-    a_1.adopt( c_1 )
-
-    /* this one will be hung up soon anyway - so it to has to close the correct one  */
-    b_2.channels.audio = a_1_audio
-    b_2.channels.audio.em = b_2_chem
-    b_2.sdp.local = a_1_sdp
-
-    failed = false
+    a_1.swapchannel( b_2 )
 
     await new Promise( ( resolve ) => {
       res.send( 202, "Refering", {}, ( /* err, response */ ) => {
@@ -2112,32 +2138,20 @@ class call {
     } )
 
     const id = this._req.get( "cseq" ).match( /(\d+)/ )[ 0 ]
-    await this._notifyreferstart( id )
-      .catch( ( e ) => {
-        console.trace( e )
-        this._notifyreferfail( id )
-        failed = true
-      } )
-
-    if( failed ) return
+    try {
+      await this._notifyreferstart( id )
+    } catch( e ) {
+      console.trace( e )
+      this._notifyreferfail( id )
+      return
+    }
 
     /* modify ports and renegotiate codecs */
-    await a_1._modifyforxfer()
-
-    const target = a_1.sdp.remote.getaudio()
-    if( target ) {
-      /* we should always get in here */
-      a_1.channels.audio.remote( call._createchannelremotedef( target.address, target.port, a_1.selectedcodec ).remote )
+    await a_1.reinvite()
 
-      /* there might be situations where mix is not the correct thing - perhaps a pop push application? */
-      a_1.channels.audio.mix( c_1.channels.audio )
-
-      /* Now inform our RTP server also - we might need to wait untl the target has completed so need a notify mechanism */
-      a_1.channels.audio.direction( { "send": false, "recv": false } )
-
-      a_1._em.emit( "call.mix", a_1 )
-      callmanager.options.em.emit( "call.mix", a_1 )
-    }
+    /* there might be situations where mix is not the correct thing - perhaps a pop push application? */
+    /* Link logically and mix */
+    a_1.adopt( c_1, true )
 
     this._notifyrefercomplete( id )
 
@@ -2311,15 +2325,17 @@ class call {
           } )
         }
       } catch( e ) { console.trace( e ) }
-    } else {
-      try {
-        this._res.send( this.hangup_cause.sip )
-      } catch( e ) { console.trace( e ) }
+    } else if( this._res ) {
+      this._res.send( this.hangup_cause.sip )
     }
 
     await this._onhangup( "us", reason )
   }
 
+  /**
+   * 
+   * @returns { Promise }
+   */
   async waitforhangup() {
 
     if( !this._promises.promise.hangup ) {
@@ -2465,17 +2481,20 @@ class call {
    * @returns { Promise< boolean | object > }
    */
   static async #callcontactfornewuac( options, callbacks ) {
-    if( !await call.#checkmaxcallsforentity( options ) ) return false
+
+    if( !( await call.#checkmaxcallsforentity( options ) ) ) return false
+
     /* If we have an entity - we need to look them up */
     if( !callmanager.options.registrar ) return false
     if( !options.entity ) return false
 
     const contactinfo = await callmanager.options.registrar.contacts( options.entity )
+
     if( !contactinfo || 0 == contactinfo.contacts.length ) {
       return false
     }
 
-    const numcontacts = contactinfo.contacts.length
+    let numcontacts = 0
     const ourcallbacks = {}
     let failcount = 0
 
@@ -2505,16 +2524,15 @@ class call {
         waitonchildrenresolve( c )
         waitonchildrenresolve = false
         if( callbacks.confirm ) callbacks.confirm( c )
-        return
       }
-      c.hangup( hangupcodes.LOSE_RACE )
-      if( callbacks.fail ) callbacks.fail( c )
     }
     
     for( const contact of contactinfo.contacts ) {
       if( undefined === contact ) continue
       const newoptions = { ...options }
+      
       if( contact.contact && "string" == typeof contact.contact ) {
+        numcontacts++
         newoptions.contact = contact.contact
         call.newuac( newoptions, ourcallbacks )
       }
@@ -2591,16 +2609,12 @@ class call {
    * @returns 
    */
   async #onnewuacsuccess( callbacks ) {
-    clearTimeout( this._timers.newuac )
-    this._timers.newuac = false
 
     if( this.destroyedcancelledorhungup ) {
-      if( callbacks && callbacks.fail ) callbacks.fail( this )
       return this
     }
 
     this.sdp.remote = sdpgen.create( this._dialog.remote.sdp )
-    this.established = true
 
     if( this.parent ) {
       for( const child of this.parent.children ) {
@@ -2695,6 +2709,14 @@ class call {
     }
   }
 
+  #confignetwork( options, ) {
+    const addressparts = parseuri( options.contact )
+    if( addressparts ) {
+      this.network.remote.address = addressparts.host
+      if( addressparts.port ) this.network.remote.port = addressparts.port
+    }
+  }
+
   /**
   @summary Creates a new SIP dialog(s). Returns a promise which resolves
   when the dialog is either answered (or cancelled for some reason).
@@ -2761,12 +2783,7 @@ class call {
     newcall.options = { ...callmanager.options, ...newcall.options, ...options }
     newcall.options.headers = tmpheaders
 
-    const addressparts = parseuri( options.contact )
-    if( addressparts ) {
-      newcall.network.remote.address = addressparts.host
-      if( addressparts.port ) newcall.network.remote.port = addressparts.port
-    }
-
+    newcall.#confignetwork( options )
     await newcall.#openchannelsfornewuac()
 
     let newdialog
@@ -2776,13 +2793,18 @@ class call {
 
           if( !req ) {
             newcall.state.destroyed = true
+            newcall.hangup( hangupcodes.SERVER_ERROR )
             console.trace( "No req object??", err )
             return
           }
 
-          newcall._timers.newuac = setTimeout( () => {
-            newcall.hangup( hangupcodes.REQUEST_TIMEOUT )
-          }, newcall.options.uactimeout )
+          /* set new uac timeout */
+          newcall.uactimeout = newcall.options.uactimeout
+
+          /* extend our parent ring timeout if necasary */
+          if( options.parent ) {
+            options.parent.uactimeout = Math.max( callmanager.options.uactimeout, newcall.options.uactimeout )
+          }
 
           newcall._req = req
           newcall.state.trying = true
@@ -2815,19 +2837,31 @@ class call {
       } )
     } catch ( err ) {
       newcall.#onnewuaccatch( err )
-    } finally {
-      newcall.#setdialog( newdialog )
-      await newcall.#onnewuacsuccess( callbacks )
     }
+
+    if( !newdialog ) {
+      if( callbacks.fail ) callbacks.fail( newcall )
+      return newcall
+    }
+
+    newcall.#setdialog( newdialog )
+    await newcall.#onnewuacsuccess( callbacks )
+
     return newcall
   }
 
   /**
-   * Helper to indicate not race condition
+   * assign our dialog and related items
    * @param { object } d 
    */
   #setdialog( d ) {
+    clearTimeout( this._timers.newuac )
+    this._timers.newuac = false
+
+    if( this.destroyedcancelledorhungup ) return
+
     this._dialog = d
+    this.established = true
   }
 
   /**
@@ -2862,13 +2896,15 @@ class call {
     @private
     */
     c._req = req
-    c._req.on( "cancel", () => c._oncanceled.bind( c ) )
+
     /**
     @member
     @private
     */
     c._res = res
 
+    c._req.on( "cancel", () => c._oncanceled.bind( c ) )
+
     await callstore.set( c )
     callmanager.options.em.emit( "call.new", c )
 
@@ -2876,6 +2912,9 @@ class call {
       c.sdp.remote = sdpgen.create( c._req.msg.body )
     }
 
+    /* set a timer using the default */
+    c.uactimeout = callmanager.options.uactimeout
+
     return c
 
   }
@@ -2884,6 +2923,20 @@ class call {
   static setcallmanager( cm ) {
     callmanager = cm
   }
+
+  /**
+   * @param { number } ms - timeout for new call
+   */
+  set uactimeout( ms ) {
+    if( this.established ) return
+    const msi = parseInt( ms )
+    if( isNaN( msi ) ) return
+
+    clearTimeout( this._timers.newuac )
+    this._timers.newuac = setTimeout( () => {
+      this.hangup( hangupcodes.REQUEST_TIMEOUT )
+    }, msi )
+  }
 }
 
 module.exports = call

package/lib/callmanager.js

@@ -80,6 +80,14 @@ class callmanager {
     this.options.em.on( event, cb )
   }
 
+  once( event, cb ) {
+    this.options.em.once( event, cb )
+  }
+
+  off( event, cb ) {
+    this.options.em.off( event, cb )
+  }
+
   /**
     Return dict of hangup-codes
   */

package/lib/store.js

@@ -103,10 +103,17 @@ function fixentity( c ) {
  *  @param {string} c.sip.tags.remote - the remote tag
  *  @param {object} c.entity - entity object
  *  @param {object} c.entity.uri
+ *  @param {object} c._entity
+ *  @param {object} [ c._state ]
+ *  @param {boolean} [ c._state._hangup ]
  *  @return {Promise} - which resolves on completion (for future in case we support redis or similar)
  */
 module.exports.set = async ( c ) => {
   if( !iscallobjectgood( c ) ) return false
+  if( c._state && c._state._hangup ) {
+    module.exports.delete( c )
+    return false
+  }
 
   storebyuuid.set( c.uuid, c )
   addtocallidset( c )

package/package.json

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

package/test/interface/call.js

@@ -298,23 +298,28 @@ describe( "call object", function() {
     } )
 
     const child = await inboundcall.newuac( { "entity": { "uri": "1000@dummy", "max": 1 } } )
-    const child2 = await call.newuac( { "entity": { "uri": "1000@dummy", "max": 1 } } )
 
+    const child2 = await call.newuac( { "entity": { "uri": "1000@dummy", "max": 1 } } )
     expect( await callstore.stats() ).to.deep.include( {
       "storebycallid": 2,
       "storebyuuid": 2,
       "storebyentity": 1
     } )
 
-    const child3 = await call.newuac( { "entity": { "uri": "1000@dummy" } } )
+    const child3newcalls = []
+    await call.newuac( { "entity": { "uri": "1000@dummy" } }, { early:( c ) => child3newcalls.push( c ) } )
 
     expect( await callstore.stats() ).to.deep.include( {
-      "storebycallid": 3,
-      "storebyuuid": 3,
+      "storebycallid": 4,
+      "storebyuuid": 4,
       "storebyentity": 1
     } )
 
-    await child3.hangup()
+    await Promise.all( [
+      child3newcalls[ 0 ].hangup(),
+      child3newcalls[ 1 ].hangup()
+    ] )
+
     await inboundcall.hangup()
 
     expect( await callstore.stats() ).to.deep.include( {
@@ -327,7 +332,8 @@ describe( "call object", function() {
     expect( child2 ).to.be.false
 
     expect( child.state.cleaned ).to.be.true
-    expect( child3.state.cleaned ).to.be.true
+    expect( child3newcalls[ 0 ].state.cleaned ).to.be.true
+    expect( child3newcalls[ 1 ].state.cleaned ).to.be.true
 
   } )
 
@@ -524,13 +530,14 @@ describe( "call object", function() {
       eventhappened = true
     } )
 
-    await new Promise( ( resolve ) => {
+    const inbound = await new Promise( ( resolve ) => {
       srfscenario.oncall( async ( call ) => { resolve( call ) } )
       srfscenario.inbound()
     } )
 
     expect( eventhappened ).to.be.true
 
+    await inbound.hangup()
   } )
 
   it( "uas.newuac - ringing event", async function() {
@@ -555,6 +562,8 @@ describe( "call object", function() {
 
     expect( eventhappened ).to.be.true
 
+    await c.hangup()
+
   } )
 
   it( "uas.newuac - destroyed event", async function() {

package/test/interface/callmanager.js

@@ -39,10 +39,12 @@ describe( "callmanager", function() {
       }
     }
     const c = await callmanager.callmanager( options )
+    let ourcall
+    c.once( "call.new", ( c ) => ourcall = c )
 
     expect( usecalled ).to.be.true
 
-    const res = {}
+    const res = { send: () => {} }
     const next = () => {}
     /* present our pretend call */
     await invitecb( req, res, next )
@@ -53,6 +55,8 @@ describe( "callmanager", function() {
       "storebyuuid": 1,
       "storebyentity": 0
     } )
+
+    await ourcall.hangup()
   } )
 
   it( "create new callmanager object test for listening rtp server", async function() {

package/test/mock/srf.js

@@ -368,7 +368,7 @@ class dialog {
     }
 
     return new Promise( ( resolve ) => {
-      resolve( this )
+      resolve( this.remote.sdp )
     } )
   }
 }

package/test/unit/call.js

@@ -1,18 +1,18 @@
+
 const expect = require( "chai" ).expect
-const callstore = require( "../../lib/call.js" )
 const srf = require( "../mock/srf.js" )
 
 describe( "call.js", function() {
 
-  it( `set remote name and id`, async function() {
-    let srfscenario = new srf.srfscenario()
+  it( "set remote name and id", async function() {
+    const srfscenario = new srf.srfscenario()
 
     let newcallcalled = false
     srfscenario.options.em.on( "call.new", ( /*newcall*/ ) => {
       newcallcalled = true
     } )
 
-    let call = await new Promise( ( resolve ) => {
+    const call = await new Promise( ( resolve ) => {
       srfscenario.oncall( async ( call ) => { resolve( call ) } )
       srfscenario.inbound()
     } )
@@ -24,6 +24,9 @@ describe( "call.js", function() {
     // the names mismatch and can be confusing, we might consider some polishing here?
     expect(call.remote.name).equals("foo")
     expect(call.remote.user).equals("123456789")
+    expect( newcallcalled ).to.be.true
+
+    await call.hangup()
 } )
 
 } )