@babblevoice/babble-drachtio-callmanager 2.3.21 → 2.3.22

package/lib/call.js

@@ -1019,39 +1019,14 @@ class call {
     } )
   }
 
-  /* A simple implimentation if we are offered candidates */
-  static async _parsesdpcandidates( target, sdp ) {
-
-    if( Array.isArray( sdp.media[ 0 ].candidates ) ) {
-      let candidates = sdp.media[ 0 ].candidates
-      if( 0 < candidates.length ) {
-        if( callmanager.options.ignoreipv6candidates ) {
-          candidates = candidates.filter( ( c ) => { 
-            const ismatch = ipv6regex.test( c.ip )
-            return !ismatch
-          } )
-        }
-        
-        candidates.sort( ( l, r ) => { return r.priority - l.priority } )
-        target.port = candidates[ 0 ].port
-
-        await new Promise( ( resolve ) => {
-          dns.lookup( candidates[ 0 ].ip, ( err, result ) => {
-            if( !err ) target.address = result
-            resolve()
-          } )
-        } )
-      }
-    }
-  }
-
   async #answerparent() {
     if( this.parent ) {
       if( !this.parent.established ) {
-        await this.parent.answer()
-          .catch( ( err ) => {
-            console.trace( err )
-          } )
+        try {
+          await this.parent.answer()
+        } catch( e ) {
+          console.trace( e )
+        }
   
         if( !this.parent.established ) {
           return this.hangup( hangupcodes.USER_GONE )
@@ -1091,35 +1066,19 @@ class call {
     this._addevents( this._dialog )
 
     this.sdp.remote = sdpgen.create( this._dialog.remote.sdp )
-    this.selectedcodec = this.sdp.remote.intersection( this.options.preferedcodecs, true )
-    if( !this.selectedcodec ) {
+
+    if( !this.sdp.remote.intersection( this.options.preferedcodecs, true ) ) {
       return this.hangup( hangupcodes.INCOMPATIBLE_DESTINATION )
     }
 
-    const target = this.sdp.remote.getaudio()
-    if( !target ) return
+    this.sdp.remote.setdynamepayloadtypes( this.sdp.local )
 
-    let channeldef
-    if( this._iswebrtc ) {
-      let actpass = "active"
-      if( "active" == this.sdp.remote.sdp.media[ 0 ].setup ) actpass = "passive" /* act|pass|actpass */
-
-      await call._parsesdpcandidates( target, this.sdp.remote.sdp )
-
-      channeldef = call._createchannelremotedef( 
-        target.address,
-        target.port,
-        target.audio.payloads[ 0 ],
-        this.sdp.remote.sdp.media[ 0 ].fingerprint.hash,
-        actpass ).remote
-    } else {
-      channeldef = call._createchannelremotedef( target.address, target.port, target.audio.payloads[ 0 ] ).remote
-    }
-
-    this.channels.audio.remote( channeldef )
+    const channeldef = await this.#createchannelremotedef()
+    if( !channeldef )
+      return this.hangup( hangupcodes.INCOMPATIBLE_DESTINATION )
 
+    this.channels.audio.remote( channeldef.remote )
     await this.#answerparent()
-
     return this
   }
 
@@ -1132,38 +1091,24 @@ class call {
   */
   async _onlatebridge() {
 
-    /* Calculate the best codec for both legs - find a common codec if possible
-    if not - transcode */
     this.sdp.remote = sdpgen.create( this._req.msg.body )
 
-    this.selectedcodec = this.sdp.remote.intersection( this.options.preferedcodecs, true )
-    if( !this.selectedcodec ) {
+    const selectedcodec = this.sdp.remote.intersection( this.options.preferedcodecs, true )
+    if( !selectedcodec ) {
       return this.hangup( hangupcodes.INCOMPATIBLE_DESTINATION )
     }
 
-    const target = this.sdp.remote.getaudio()
-    if( !target ) return
-    let channeldef 
-    if( this._iswebrtc ) {
-      let actpass = "active"
-      if( "act" == this.sdp.remote.sdp.media[ 0 ].setup ) actpass = "passive" /* act|pass|actpass */
-
-      channeldef = call._createchannelremotedef( 
-        target.address, 
-        target.port, 
-        target.audio.payloads[ 0 ],
-        this.sdp.remote.sdp.media[ 0 ].fingerprint.hash,
-        actpass ) 
-    } else {
-      channeldef = call._createchannelremotedef( target.address, target.port, target.audio.payloads[ 0 ] ) 
-    }
+    const channeldef = await this.#createchannelremotedef()
+    if( !channeldef )
+      return this.hangup( hangupcodes.INCOMPATIBLE_DESTINATION )
 
     await this.#openrelatedchannel()
 
     this.sdp.local = sdpgen.create()
-      .addcodecs( this.selectedcodec )
+      .addcodecs( selectedcodec )
       .setconnectionaddress( this.channels.audio.local.address )
       .setaudioport( this.channels.audio.local.port )
+      .setdynamepayloadtypes( this.sdp.remote )
 
     if( true === this.options.rfc2833 ) {
       this.sdp.local.addcodecs( "2833" )
@@ -1476,9 +1421,10 @@ class call {
       await this.#openrelatedchannel( channeldef )
 
       this.sdp.local = sdpgen.create()
-        .addcodecs( this.selectedcodec )
+        .addcodecs( this.sdp.remote.selected.name )
         .setconnectionaddress( this.channels.audio.local.address )
         .setaudioport( this.channels.audio.local.port )
+        .setdynamepayloadtypes( this.sdp.remote )
 
       this.#checkandadd2833()
 
@@ -1498,30 +1444,14 @@ class call {
    */
   async #choosecodecforanswer() {
     if( this._req.msg && this._req.msg.body ) {
-      this.selectedcodec = this.sdp.remote.intersection( this.options.preferedcodecs, true )
-      if( !this.selectedcodec ) {
-        return this.hangup( hangupcodes.INCOMPATIBLE_DESTINATION )
-      }
 
-      this.sdp.remote.select( this.selectedcodec )
-      
-      const remoteaudio = this.sdp.remote.getaudio()
-      if( !remoteaudio ) {
+      if( !this.sdp.remote.intersection( this.options.preferedcodecs, true ) ) {
         return this.hangup( hangupcodes.INCOMPATIBLE_DESTINATION )
       }
-      
-      await call._parsesdpcandidates( remoteaudio, this.sdp.remote.sdp )
-
-      const channeldef = call._createchannelremotedef( remoteaudio.address, remoteaudio.port, remoteaudio.audio.payloads[ 0 ] )
-
-      if( this._iswebrtc ) {
-        channeldef.remote.dtls = {
-          "fingerprint": this.sdp.remote.sdp.media[ 0 ].fingerprint,
-          "mode": "passive" === this.sdp.remote.sdp.media[ 0 ].setup?"active":"passive" /* prefer passive for us */
-        }
 
-        channeldef.remote.icepwd = this.sdp.remote.sdp.media[ 0 ].icePwd
-      }
+      const channeldef = await this.#createchannelremotedef()
+      if( !channeldef )
+        return this.hangup( hangupcodes.INCOMPATIBLE_DESTINATION )
 
       /* We might have already opened our audio when we received 183 (early). */
       await this.#openchannelsforanswer( channeldef )
@@ -1669,6 +1599,7 @@ class call {
     } )
 
     this._timers.anyevent = setTimeout( () => {
+
       const r = this._promises.resolve.channelevent
       this._promises.promise.channelevent = undefined
       this._promises.resolve.channelevent = undefined
@@ -1861,7 +1792,7 @@ class call {
   }
 
   /**
-    Send out modified SDP to get the audio to the new location.
+    Send out pre-modified SDP to get the audio to the new location.
     This method might be use, but there are problems - so when it is used
     it can be re-written but should use a mthod to create a codec - which is the 
     same as used elsewhere.
@@ -1869,35 +1800,22 @@ class call {
   */
   async reinvite() {
 
-    this.sdp.local = sdpgen.create().addcodecs( this.selectedcodec )
-    this.sdp.local.setaudioport( this.channels.audio.local.port )
-      .setconnectionaddress( this.channels.audio.local.address )
-
-    this.#checkandadd2833()
-
-    /* DTLS is only supported ( outbound ) on websocket connections */
-    if( this._iswebrtc ) {
-      this.sdp.local
-        .addssrc( this.channels.audio.local.ssrc )
-        .secure( this.channels.audio.local.dtls.fingerprint ,"passive" )
-        .addicecandidates( this.channels.audio.local.address, this.channels.audio.local.port, this.channels.audio.local.icepwd )
-        .rtcpmux()
-    }
-
     const remotesdp = await this._dialog.modify( this.sdp.local.toString() )
       .catch( ( e ) => {
         console.trace( e )
       } )
+    
+    if( this.destroyed ) return
 
-    if( remotesdp )
+    if( remotesdp ) {
       this.sdp.remote = sdpgen.create( remotesdp )
+      this.sdp.remote.setdynamepayloadtypes( this.sdp.local )
+    }
 
-    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 )
+    const channeldef = await this.#createchannelremotedef()
+    if( channeldef ) /* we should always get in here */
+      this.channels.audio.remote( channeldef.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 } )
   }
 
   /**
@@ -2270,29 +2188,81 @@ class call {
   }
 
   /**
-  Helper function to create a channel target definition
-  @private
-  @param { string } address - remote address (ip)
-  @param { number } port - remote port
-  @param { number } codec
-  @param { string } [ fingerprint ] - remote sha 256 fingerprint
-  @param { string } [ mode ] - "active"|"passive"
-  */
-  static _createchannelremotedef( address, port, codec, fingerprint, mode /* active|passive */ ) {
-    const chandef = {
-      "remote": {
-        "address": address,
-        "port": port,
-        "codec": codec
+   * Obtain IP address from SDP - including looking at candidates if required
+   * @param { boolean } parsecandidates - check the candidates in sdp also
+   * @returns { Promise< object | undefined  > }
+   */
+  async #getremotetarget( parsecandidates ) {
+
+    const target = this.sdp.remote.getaudio()
+    if( !target ) return
+    if( !parsecandidates ) return target
+
+    const sdp = this.sdp.remote.sdp
+
+    if( Array.isArray( sdp.media[ 0 ].candidates ) ) {
+      let candidates = sdp.media[ 0 ].candidates
+      if( 0 < candidates.length ) {
+        if( callmanager.options.ignoreipv6candidates ) {
+          candidates = candidates.filter( ( c ) => { 
+            const ismatch = ipv6regex.test( c.ip )
+            return !ismatch
+          } )
+        }
+
+        candidates.sort( ( l, r ) => { return r.priority - l.priority } )
+        target.port = candidates[ 0 ].port
+
+        await new Promise( ( resolve ) => {
+          dns.lookup( candidates[ 0 ].ip, ( err, result ) => {
+            if( !err ) target.address = result
+            resolve()
+          } )
+        } )
       }
     }
 
-    if( fingerprint ) {
-      chandef.remote.dtls = {
-        "fingerprint": {
-          "hash": fingerprint
-        },
-        "mode": mode
+    return target
+  }
+
+  /**
+   * Returns and object we can pass into an openchannel function, 
+   * { remote: {} } - the remote can be passed into set remote on
+   * an already open channel.
+   * @returns { Promise< object | undefined > }
+   */
+  async #createchannelremotedef() {
+
+    const iswebrtc = this._iswebrtc
+    const target = await this.#getremotetarget( iswebrtc )
+
+    if( !target ) return
+    const address = target.address
+    const port = target.port
+
+    const codec = this.sdp.remote.selected
+    if( !codec ) return
+
+    const chandef = {
+      "remote": { address, port, codec: codec.pt }
+    }
+
+    /* dynamic payload types */
+    const dpts = this.sdp.remote.getdynamicpayloadtypes()
+    if( "rfc2833" in dpts ) chandef.remote.rfc2833pt = dpts.rfc2833.payload
+    if( "ilbc" in dpts ) chandef.remote.ilbcpt = dpts.ilbc.payload
+
+    if( iswebrtc ) {
+
+      const hash = this.sdp.remote.sdp.media[ 0 ].fingerprint.hash
+      let mode = "active"
+      if( "active" == this.sdp.remote.sdp.media[ 0 ].setup ) mode = "passive" /* act|pass|actpass */
+  
+      if( hash ) {
+        chandef.remote.dtls = {
+          "fingerprint": { hash },
+          mode
+        }
       }
     }
     return chandef
@@ -2340,11 +2310,11 @@ class call {
     this._promises.resolve.auth = undefined
     if( authreject ) authreject( new SipError( hangupcodes.REQUEST_TIMEOUT, "Auth timed out (cleanup)" ) )
 
-    const chanev = this._promises.reject.channelevent
+    const chanev = this._promises.resolve.channelevent
     this._promises.resolve.channelevent = undefined
     this._promises.reject.channelevent = undefined
     this._promises.promise.channelevent = undefined
-    if( chanev ) chanev( Error( "Call hungup" ) )
+    if( chanev ) chanev()
 
     const resolves = []
     for ( const [ key, value ] of Object.entries( this._promises.resolve ) ) {
@@ -2729,8 +2699,9 @@ class call {
 
       await this.#openrelatedchannel( channeldef )
 
-      this.sdp.local = sdpgen.create().addcodecs( this.options.preferedcodecs )
-      this.sdp.local.setaudioport( this.channels.audio.local.port )
+      this.sdp.local = sdpgen.create()
+        .addcodecs( this.options.preferedcodecs )
+        .setaudioport( this.channels.audio.local.port )
         .setconnectionaddress( this.channels.audio.local.address )
 
       this.#checkandadd2833()
@@ -2761,8 +2732,6 @@ class call {
       return this
     }
 
-    this.sdp.remote = sdpgen.create( this._dialog.remote.sdp )
-
     if( this.parent ) {
       for( const child of this.parent.children ) {
         if( child.uuid !== this.uuid && !child.state.established ) {
@@ -3144,6 +3113,7 @@ class call {
 
     if( c._req.msg && c._req.msg.body ) {
       c.sdp.remote = sdpgen.create( c._req.msg.body )
+      c.sdp.remote.intersection( callmanager.options.preferedcodecs, true )
     }
 
     /* set a timer using the default */

package/lib/sdp.js

@@ -11,6 +11,15 @@ const crypto = require( "crypto" )
 */
 let sessionidcounter = Math.floor( Math.random() * 100000 )
 
+
+const prtpcodecpts = {
+  "pcmu": 0,
+  "pcma": 8,
+  "g722": 9,
+  "ilbc": 97,
+  "2833": 101
+}
+
 class codecconv {
 
   #pt2name = {
@@ -174,6 +183,7 @@ function getconfigforpt( audio, pt ) {
 class sdp {
 
   #dynamicpts
+  #selected
 
   constructor( sdp ) {
 
@@ -296,8 +306,8 @@ class sdp {
     if ( m ) {
 
       let payloads = m.payloads
-      if ( this.selected !== undefined ) {
-        payloads = [ this.selected ]
+      if ( this.#selected !== undefined ) {
+        payloads = [ this.#selected ]
       }
 
       let address
@@ -353,13 +363,31 @@ class sdp {
   select( codec ) {
     if ( isNaN( codec ) ) {
       if ( undefined === this.#dynamicpts.hascodec( codec ) ) return
-      codec = this.#dynamicpts.getcodec( codec )
+      codec = this.#dynamicpts.getpt( codec )
     }
-    this.selected = Number( codec )
+    this.#selected = codec
 
     return this
   }
 
+  /**
+   * @returns { object | undefined }
+   * @property { string } name - the name of the codec - i.e. pcma
+   * @property { number } pt - the payload type (static) used for prtp
+   * @property { number } dpt - the dynamic payload type negotiated for this session
+   */
+  get selected() {
+
+    if( undefined === this.#selected ) return undefined
+
+    const name = this.#dynamicpts.getcodec( this.#selected )
+    return {
+      name,
+      pt: prtpcodecpts[ name ],
+      dpt: this.#selected
+    }
+  }
+
   static create( from ) {
     return new sdp( from )
   }
@@ -619,6 +647,59 @@ class sdp {
 
   }
 
+  /**
+   * @returns { object } an object of codec name to payload type
+   * i.e.
+   * {
+   *   "ilbc": { payload: 101, codec: "iLBC", rate: 8000 }
+   * }
+   * NB: it only returns a) our supported codecs and b) dynamic codecs - pcma, pcmu, g722 are statically defined
+   */
+  getdynamicpayloadtypes() {
+    const retval = {}
+
+    this.sdp.media.forEach( ( v ) => {
+      if( "rtp" in v ) {
+        v.rtp.forEach( r => {
+          const cname = r.codec.toLowerCase()
+          switch( cname ) {
+          case "ilbc":
+            if( 8000 == r.rate )
+              retval[ cname ] = r
+            break
+          case "telephone-event":
+            if( 8000 == r.rate )
+              retval[ "rfc2833" ] = r
+          }
+        } )
+      }
+    } )
+
+    return retval
+  }
+
+  /**
+   * Takes an object as returned by getdynamicpayloadtypes on another object
+   * to set the dynameic payloadtypes on this object
+   * @param { sdp } othersdp
+   */
+  setdynamepayloadtypes( othersdp ) {
+
+    if( !othersdp ) return this
+
+    const o = othersdp.getdynamicpayloadtypes()
+
+    if( "ilbc" in o && 8000 == o.ilbc.rate ) {
+      this.#dynamicpts.setdynamicpt( "ilbc", "ilbc", o.ilbc.payload )
+    }
+
+    if( "rfc2833" in o && 8000 == o.rfc2833.rate ) {
+      this.#dynamicpts.setdynamicpt( "2833", "telephone-event", o.rfc2833.payload )
+    }
+
+    return this
+  }
+
   toString() {
 
     /* We need to convert payloads back to string to stop a , being added */

package/package.json

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

package/test/interface/callsdp.js

@@ -18,16 +18,16 @@ describe( "call sdp generation", function() {
     let callnumber = 0
     const callcount = 6
     const codecsselected = []
-    const c = await new Promise( ( done ) => {
+    await new Promise( ( resolve ) => {
       srfscenario.oncall( async ( call ) => {
         await call.answer()
 
-        codecsselected.push( call.selectedcodec )
+        codecsselected.push( call.sdp.remote.selected.name )
         callnumber++
 
         call.hangup()
 
-        if( callcount == callnumber ) done()
+        if( callcount == callnumber ) resolve()
       } )
 
       for( let i = 0; i < callcount; i++ ) {

package/test/interface/sdp.js

@@ -2,8 +2,6 @@
 
 const expect = require( "chai" ).expect
 const sdp = require( "../../lib/sdp" )
-const call = require( "../../lib/call" )
-const callmanager = require( "../../index" )
 
 describe( "sdp", function() {
 
@@ -325,11 +323,9 @@ a=rtpmap:8 PCMA/8000`
     const oursdp = sdp.create( testsdp )
     const remoteaudio = oursdp.getaudio()
 
-    const def = call._createchannelremotedef( remoteaudio.address, remoteaudio.port, remoteaudio.audio.payloads[ 0 ] )
-
-    expect( def.remote.address ).to.equal( "213.166.4.136" )
-    expect( def.remote.port ).to.equal( 48380 )
-    expect( def.remote.codec ).to.equal( 8 )
+    expect( remoteaudio.address ).to.equal( "213.166.4.136" )
+    expect( remoteaudio.port ).to.equal( 48380 )
+    expect( remoteaudio.audio.payloads[ 0 ] ).to.equal( 8 )
   } )
 
   it( "another real life example", async function() {
@@ -686,11 +682,11 @@ a=rtpmap:126 telephone-event/8000
 a=ssrc:222390620 cname:q7Is0hRbTrTbcMJM
 a=ssrc:222390620 msid:a46039f4-1857-410e-b1cc-215c09878068 ce8c9c25-2ea0-4079-aaa5-54f771d53310
     `
-    callmanager.callmanager( { srf: { use: () => {} } } )
+
     const sdpobj = sdp.create( sdpstr )
-    const target = {}
-    await call._parsesdpcandidates( target, sdpobj.sdp )
-    sdpobj.intersection( "g722", true )
+    const target = sdpobj.getaudio()
+
+    expect( sdpobj.intersection( "g722", true ) ).to.equal( "g722" )
 
     /* our default is to ignore IPv6 addresses (until projectrtp supports it) */
     expect( target.port ).to.equal( 41645 )
@@ -799,9 +795,45 @@ a=rtpmap:127 telephone-event/8000`
 
     const sdpilbc = sdp.create( ilbcpt )
 
+    const expectdps = {
+      ilbc: { payload: 110, codec: "iLBC", rate: 8000 },
+      rfc2833: { payload: 127, codec: "telephone-event", rate: 8000 }
+    }
+
+    expect( sdpilbc.getdynamicpayloadtypes() ).to.deep.equal( expectdps )
+
     expect( sdpilbc.has( "ilbc" ) ).to.be.true
     expect( sdpilbc.has( "pcma" ) ).to.be.true
     expect( sdpilbc.has( "pcmu" ) ).to.be.true
     expect( sdpilbc.has( "g722" ) ).to.be.true
+
+    const othersdp = sdp.create().addcodecs( "ilbc 2833" ).setdynamepayloadtypes( sdpilbc )
+
+    expect( othersdp.toString() ).to.match( new RegExp( `v=0
+o=- \\d+ 0 IN IP4 127.0.0.1
+s=project
+c=IN IP4 127.0.0.1
+t=0 0
+m=audio 0 RTP/AVP 97 101
+a=rtpmap:110 ilbc/8000
+a=rtpmap:127 telephone-event/8000
+a=fmtp:110 mode=20
+a=fmtp:127 0-16
+a=ptime:20
+a=sendrecv
+`.replace( /\r\n/g, "\n" ).replace( /\n/g, "\r\n" ) ) )
+
+    sdpilbc.select( "pcma" )
+
+    const audio = sdpilbc.getaudio()
+
+    expect( audio.port ).to.equal( 63000 )
+    expect( audio.address ).to.equal( "82.19.206.102" )
+    expect( audio.audio.payloads[ 0 ] ).to.equal( 8 )
+
+    expect( sdpilbc.selected ).to.deep.equal( { name: "pcma", pt: 8, dpt: 8 } )
+    sdpilbc.select( "ilbc" )
+    expect( sdpilbc.selected ).to.deep.equal( { name: "ilbc", pt: 97, dpt: 110 } )
+
   } )
 } )