@babblevoice/babble-drachtio-callmanager 3.6.9 → 3.6.10

package/lib/call.js

@@ -52,6 +52,21 @@ function keynameslower( obj ) {
   }, {} )
 }
 
+/**
+ * @summary Finds the correct key in a case-insensitive manner and retrieves the key and value.
+ * @param {Object} headers - The headers object.
+ * @param {string} targetKey - The key to search for.
+ * @return {Object|undefined} - Returns an object with the correct key and value, or undefined if not found.
+ */
+function getheadervalue( headers, targetKey ) {
+  const lowerCaseTargetKey = targetKey.toLowerCase()
+  for(const key in headers) {
+    if( key.toLowerCase() === lowerCaseTargetKey) {
+      return { key, value: headers[key] }
+    }
+  }
+}
+
 /*
 Enum for different reasons for hangup.
 */
@@ -173,6 +188,7 @@ class call {
       "trying": false,
       "early": false,
       "ringing": false,
+      "establishing": false, /** we have received 200 but we send ack - late neg only */
       "established": false,
       "canceled": false,
       "destroyed": false,
@@ -364,6 +380,8 @@ class call {
      * @type { string }
      */
     this.referingtouri
+
+    this.errors = []
   }
 
   /**
@@ -1207,26 +1225,30 @@ class call {
   */
   async _onearly() {
 
-    if( this.state.established ) return
-    if( !this._res || !this._res.msg || !this._res.msg.body ) return
-
-    /* we have this._res */
-    this.sdp.remote = sdpgen.create( this._res.msg.body )
-    this.#parsesrtpsetup()
-    await this.answer( { "early": true } )
-
-    if( !this.parent || this.parent.state.established ) return
-
-    await this.parent.answer( { "early": true } )
-    await this.channels.audio.mix( this.parent.channels.audio )
-
-    this.parent._res.send( 183, {
-      headers: {
-        "User-Agent": "project",
-        "Supported": "replaces"
-      },
-      "body": this.parent.sdp.local.toString()
-    } )
+    try {
+      if( this.state.established ) return
+      if( !this._res || !this._res.msg || !this._res.msg.body ) return
+  
+      /* we have this._res */
+      this.sdp.remote = sdpgen.create( this._res.msg.body )
+      this.#parsesrtpsetup()
+      await this.answer( { "early": true } )
+  
+      if( !this.parent || this.parent.state.established ) return
+  
+      await this.parent.answer( { "early": true } )
+      await this.channels.audio.mix( this.parent.channels.audio )
+  
+      this.parent._res.send( 183, {
+        headers: {
+          "User-Agent": "project",
+          "Supported": "replaces"
+        },
+        "body": this.parent.sdp.local.toString()
+      } )
+    } catch( e ) {
+      throw new Error( e )
+    }
   }
 
   async #answerparent() {
@@ -1329,7 +1351,7 @@ class call {
     await this.#openrelatedchannel( channeldef )
 
     if ( !this.channels.audio ) {
-      this.hangup( hangupcodes.SERVER_ERROR )
+      this.#servererror( "Failed to open channel" )
       return
     }
 
@@ -1351,7 +1373,8 @@ class call {
         .rtcpmux()
     }
 
-    this.#setdialog( await this._dialog.ack( this.sdp.local.toString() ) )
+    this._dialog = await this._dialog.ack( this.sdp.local.toString() )
+    this.established = true
     this._addevents( this._dialog )
 
     await this.#answerparent()
@@ -1666,7 +1689,7 @@ class call {
 
       await this.#openrelatedchannel( channeldef )
       if( !this.channels.audio ) {
-        this.hangup( hangupcodes.SERVER_ERROR )
+        this.#servererror( "Failed to open channel" )
         return
       }
 
@@ -1720,6 +1743,10 @@ class call {
     if( this.canceled || this.established ) return
 
     await this.#choosecodecforanswer()
+    if( !this.channels.audio ) {
+      this.#servererror( "Failed to open channel" )
+      return
+    }
 
     if( this.canceled ) return
 
@@ -1730,7 +1757,7 @@ class call {
     } else {
 
       if ( !this.sdp.local ) {
-        this.hangup( hangupcodes.SERVER_ERROR )
+        this.#servererror( "No local SDP" )
         return
       }
 
@@ -2155,25 +2182,10 @@ class call {
     @private
   */
   async mix( othercall ) {
-    if ( othercall.channels.audio
-        && othercall.channels.audio.connection.instance
-          != this.channels.audio.connection.instance ) {
-
-      const channeldef = await othercall.#createchannelremotedef()
-
-      const oldchannel = othercall.channels.audio
-      const newchannel = await this.#openchannel( channeldef, othercall )
-      if( !newchannel ) {
-        this.hangup( hangupcodes.SERVER_ERROR )
-        return
-      }
-
-      await othercall.bond( this ).reinvite( channeldef, newchannel )
-
-      await oldchannel.unmix()
-      oldchannel.close()
-    }
+    if( !othercall.channels.audio ) return
+    if( !this.channels.audio ) return
 
+    await this.#mixdifferentnode( othercall )
     await this.channels.audio.mix( othercall.channels.audio )
 
     this._em.emit( "call.mix", this )
@@ -2185,6 +2197,51 @@ class call {
     othercall.epochs.mix = Math.floor( +new Date() / 1000 )
   }
 
+  /**
+   * hangs up and throws exception to get out
+   * @param { string } reason 
+   */
+  #servererror( reason ) {
+    this.hangup( hangupcodes.SERVER_ERROR )
+    this.errors.push( { now: +new Date(), reason } )
+
+    const ourerror = Error( reason )
+    // @ts-ignore
+    ourerror.normalandsilent = true
+    throw ourerror
+  }
+
+  /**
+   * 
+   * @param { call } othercall 
+   * @returns { Promise }
+   */
+  async #mixdifferentnode( othercall ) {
+
+    if( !othercall.channels.audio.connection ) return
+    if( !othercall.channels.audio.connection.instance ) return
+
+    if( !this.channels.audio.connection ) return
+    if( !this.channels.audio.connection.instance ) return
+
+    if( othercall.channels.audio.connection.instance == this.channels.audio.connection.instance ) return
+
+    const channeldef = await othercall.#createchannelremotedef()
+
+    const oldchannel = othercall.channels.audio
+    const newchannel = await this.#openchannel( channeldef, othercall )
+    if( !newchannel ) {
+      this.#servererror( "Failed to open channel" )
+      return
+    }
+
+    await othercall.bond( this ).reinvite( channeldef, newchannel )
+
+    await oldchannel.unmix()
+    oldchannel.close()
+
+  }
+
   /**
     Mix two calls. If the two calls are on a different node
     the second call is bonded and reinvited.
@@ -2193,22 +2250,29 @@ class call {
   */
   async #openchannel( channeldef, bindcall ) {
 
-    let chan = undefined
+    try {
+      let chan
+      let bind
+      if( bindcall ) bind = bindcall
+      else bind = this
+
+      if ( this.channels.audio ) {
+        chan = await this.channels.audio.openchannel(
+          channeldef, bind._handlechannelevents.bind( bind ) )
+      } else {
+        chan = await projectrtp.openchannel(
+          channeldef, bind._handlechannelevents.bind( bind ) )
+      }
 
-    if ( !bindcall || !this.channels.audio ) {
-      chan = await projectrtp.openchannel(
-        channeldef, this._handlechannelevents.bind( this ) )
-    } else {
-      chan = await this.channels.audio.openchannel(
-        channeldef, bindcall._handlechannelevents.bind( bindcall ) )
+      bind.channels.count++
+  
+      return chan
+    } catch( e ) {
+      if( this.channels.audio )
+        console.trace( "problem opening channel on related channel", e )
+      else
+        console.trace( "problem opening channel on prtp", e )
     }
-
-    if ( bindcall )
-      bindcall.channels.count++
-    else
-      this.channels.count++
-
-    return chan
   }
 
   /**
@@ -2527,7 +2591,7 @@ class call {
       b_1.channels.audio.unmix()
       await b_1.waitforanyevent( { "action": "mix", "event": "finished" }, 0.5 )
     }
-    b_1.hangup( b_1.hangupcodes.ATTENDED_TRANSFER )
+    b_1.hangup( hangupcodes.ATTENDED_TRANSFER )
   }
 
   /**
@@ -2758,7 +2822,14 @@ class call {
   async #createchannelremotedef() {
 
     const iswebrtc = this._iswebrtc
-    const target = await this.#getremotetarget( iswebrtc )
+
+    let target
+    try{ 
+      target = await this.#getremotetarget( iswebrtc )
+    } catch( e ) {
+      throw new Error( e )
+    }
+    
 
     if( !target ) return
     const address = target.address
@@ -2856,7 +2927,7 @@ class call {
       callmanager.options.em.emit( "call.reporting", this )
 
       return 0
-    } ).catch( () => {} )
+    } ).catch( ( e ) => { console.error( e ) } )
   }
 
   /**
@@ -2883,7 +2954,6 @@ class call {
   */
   // eslint-disable-next-line complexity
   async _onhangup( src = "us", reason ) {
-
     if( this._state._onhangup ) {
       await this.waitforhangup()
       return
@@ -2891,32 +2961,7 @@ class call {
     this._state._onhangup = true
 
     this._sethangupcause( src, reason )
-
-    if( "wire" == src ) {
-      /* 
-      1. Hangup our children regardless of our state
-      2. If we are established and the only child child - hangup our parent (unless otherwise told not to: parent.continueonotherhangup)
-       */
-      const hangups = []
-      if( this.options.hangupchildrenonhangup ) {
-        for( const child of this.children ) {
-          if( !child.options.continueonotherhangup ) {
-            hangups.push( child.hangup( this.hangup_cause ) )
-          }
-        }
-      }
-
-      if( this.established && this.options.hangupparentonhangup && this.parent ) {
-        if( !this.parent.options.continueonotherhangup && 2 > this.parent.children.size ) {
-          hangups.push( this.parent.hangup( this.hangup_cause ) )
-        }
-      }
-
-      /* wait for all relatives to complete their hangup */
-      if( 0 < hangups.length ) {
-        await Promise.all( hangups )
-      }
-    }
+    await this.#handlewirehangup( src )
 
     /* flag destroyed so when we receive our close event we know what to do */
     this.destroyed = true
@@ -2928,11 +2973,69 @@ class call {
         an event on the event listener so we can safely return here and not call _cleanup */
         if( "object" == typeof cl ) return
       } catch( e ) {
-        console.error( "timed out waiting for channel close" )
+        console.error( "timed out waiting for channel close", e )
       }
     }
 
-    this._cleanup()
+    try {
+      this._cleanup()
+    } catch( e ) {
+      throw new Error( e )
+    }
+  }
+
+  /**
+   * 
+   * @param { "us"|"wire" } src 
+   * @returns 
+   */
+  async #handlewirehangup( src ) {
+
+    if( "wire" != src ) return
+
+    /* 
+    1. Hangup our children regardless of our state
+    2. If we are established and the only child child - hangup our parent (unless otherwise told not to: parent.continueonotherhangup)
+      */
+    const hangups = this.#hangupchildren()
+    this.#hangupparent( hangups )
+
+    /* wait for all relatives to complete their hangup */
+    if( 0 < hangups.length ) {
+      try{
+        await Promise.all( hangups )
+      } catch( e ) {
+        throw new Error( e )
+      }
+    }
+  }
+
+  /**
+   * If options allow hangup parent
+   * @param { Array } hangups
+   */
+  #hangupparent( hangups ) {
+    if( this.established && this.options.hangupparentonhangup && this.parent ) {
+      if( !this.parent.options.continueonotherhangup && 2 > this.parent.children.size ) {
+        hangups.push( this.parent.hangup( this.hangup_cause ) )
+      }
+    }
+  }
+
+  /**
+   * If options allow - hangup other children
+   * @returns { Array< Promise > }
+   */
+  #hangupchildren() {
+    const hangups = []
+    if( this.options.hangupchildrenonhangup ) {
+      for( const child of this.children ) {
+        if( !child.options.continueonotherhangup ) {
+          hangups.push( child.hangup( this.hangup_cause ) )
+        }
+      }
+    }
+    return hangups
   }
 
   /**
@@ -2943,29 +3046,61 @@ class call {
    * 
    */
   async hangup( reason, tone = false, source = "us" ) {
+    try {
+      if( this._state._hangup || this._state._onhangup ) {
+        await this.waitforhangup()
+        return
+      }
 
-    if( this._state._hangup || this._state._onhangup ) {
-      await this.waitforhangup()
-      return
+      this._sethangupcause( source, reason )
+      this._state._hangup = true
+      if( this.state.established ) {
+        if( this.#hangupestablish( reason, tone ) ) return
+      } else if( "uac" === this.type && this.state.trying ) {
+        this.#hangupnotestablish()
+        await this._onhangup( source, reason )
+        return
+      } else if( this._res ) {
+        this._res.send( this.hangup_cause.sip )
+        await this._onhangup( source, reason )
+        return
+      }
+
+      await this.#destroydialog()
+    } catch( e ) { 
+      console.trace( e ) 
     }
 
-    this._sethangupcause( source, reason )
+    await this._onhangup( source, reason )
+  }
 
-    if( this.state.established ) {
-      if( this.#hangupestablish( reason, tone ) ) return
-    } else if( "uac" === this.type && this.state.trying ) {
-      this.#hangupnotestablish()
-    } else if( this._res ) {
-      this._res.send( this.hangup_cause.sip )
-    }
+  /**
+   * 
+   * @returns { Promise }
+   */
+  async #destroydialog() {
+    if( !this._dialog ) return
+    if( !this._dialog.destroy ) return
 
-    this._state._hangup = true
+    await this._dialog.destroy()
+  }
 
-    try {
-      if( this._dialog ) await this._dialog.destroy()
-    } catch( e ) { console.trace( e ) }
+  /**
+   * We have played a tone - give it a limit.
+   */
+  #scheduledelayedhangup() {
 
-    await this._onhangup( source, reason )
+    this._timers.delayedhangup = setTimeout( async () => {
+      if( this._state._onhangup ) return
+      try {
+        await this.#destroydialog()
+      } catch ( e ) {
+        console.trace( e )
+      }
+
+      await this._onhangup()
+
+    }, 5000 )
   }
 
   /**
@@ -2973,19 +3108,30 @@ class call {
    * @param { boolean } tone 
    */
   #hangupestablish( reason, tone ) {
-    if( undefined != reason && tone ) {
-      switch( reason.sip ) {
-      case 486:
-        this.play( this.engagedsoup )
-        return true
-      case 480:
-        this.play( this.unobtainablesoup )
-        return true
-      }
+    if( !reason ) return false
+    if( !tone ) return false
+    if( "object" != typeof reason ) return false
+
+    switch( reason.sip ) {
+    case 486:
+      this._state._hangup = false
+      this.play( this.engagedsoup )
+      this.#scheduledelayedhangup()
+      return true
+    case 480:
+      this._state._hangup = false
+      this.play( this.unobtainablesoup )
+      this.#scheduledelayedhangup()
+      return true
     }
+
     return false
+
   }
 
+  /**
+   * The call is not established so send a cancel.
+   */
   #hangupnotestablish() {
     try {
       this.canceled = true
@@ -3071,19 +3217,21 @@ class call {
    */
   async newuac( options, callbacks = {} ) {
 
-    /* If max-forwards is not specified then we decrement the parent and pass on */
     if( !( "headers" in options ) ) options.headers = {}
+    /* If max-forwards is not specified then we decrement the parent and pass on */
+    
+    const ouroptionsmaxforwards = getheadervalue( options.headers, "max-forwards" )
+    const ourimportsmaxforwards = getheadervalue( this.propagate.headers, "max-forwards" )
 
-    let maxforwards = 70
-    if( !options.headers[ Object.keys( options.headers ).find( key => "max-forwards" === key.toLowerCase() ) ] ) {
+    if( !ouroptionsmaxforwards && !ourimportsmaxforwards ) {
+      let maxforwards = 70
       if( this._req.has( "Max-Forwards" ) ) {
         maxforwards = parseInt( this._req.get( "Max-Forwards" ) ) - 1
         if( isNaN( maxforwards ) || 0 >= maxforwards ) return false
       }
+      options.headers[ "max-forwards" ] = maxforwards
     }
 
-    options.headers[ "max-forwards" ] = maxforwards
-    
     if( !options.orphan && !options.parent ) {
       options.parent = this
     }
@@ -3201,26 +3349,30 @@ class call {
    */
   async #openrelatedchannel( channeldef ) {
 
-    if( this.channels.audio ) return
-
-    const othercall = this.other
-    /* TODO: this is a hack. projectrtp has become too complicated with both a listen and connect 
-    mechanism. This is causing problems in code like this. There is no interface to 
-    detect which mode the channel is in - but the channels property will exist on a connect
-    style channel. projectrtp will getrelatives a rewrite to support only one. */
-    if( othercall && othercall.channels.audio ) {
-      this.channels.audio = await othercall.#openchannel( channeldef, this )
-      return
-    }
+    try {
+      if( this.channels.audio ) return
 
-    for( const other of this.relatives ) {
-      if( other.channels && other.channels.audio ) {
-        this.channels.audio = await other.#openchannel( channeldef, this )
+      const othercall = this.other
+      /* TODO: this is a hack. projectrtp has become too complicated with both a listen and connect 
+      mechanism. This is causing problems in code like this. There is no interface to 
+      detect which mode the channel is in - but the channels property will exist on a connect
+      style channel. projectrtp will getrelatives a rewrite to support only one. */
+      if( othercall && othercall.channels.audio ) {
+        this.channels.audio = await othercall.#openchannel( channeldef, this )
         return
       }
+  
+      for( const other of this.relatives ) {
+        if( other.channels && other.channels.audio ) {
+          this.channels.audio = await other.#openchannel( channeldef, this )
+          return
+        }
+      }
+  
+      this.channels.audio = await this.#openchannel( channeldef )
+    } catch( e ) {
+      console.trace( e )
     }
-
-    this.channels.audio = await this.#openchannel( channeldef )
   }
 
   /**
@@ -3247,7 +3399,7 @@ class call {
 
       await this.#openrelatedchannel( channeldef )
       if( !this.channels.audio ) {
-        this.hangup( hangupcodes.SERVER_ERROR )
+        this.#servererror( "Failed to open channel" )
         return
       }
 
@@ -3308,10 +3460,17 @@ class call {
       console.trace( e )
     }
 
-    if( true === this.#noack ) {
-      await this._onlatebridge()
-    } else {
-      await this._onearlybridge()
+    try {
+      if( true === this.#noack ) {
+        await this._onlatebridge()
+      } else {
+        await this._onearlybridge()
+      }
+    } catch ( e ) {
+      console.trace( e )
+      if( this.destroyedcancelledorhungup ) {
+        return
+      }
     }
 
     try {
@@ -3635,6 +3794,11 @@ class call {
     newcall.#setdialog( newdialog )
     await newcall.#onnewuacsuccess( callbacks )
 
+    if( newcall.destroyedcancelledorhungup ) {
+      callstore.delete( newcall )
+      if( callbacks.fail ) callbacks.fail( newcall )
+    }
+
     return newcall
   }
 
@@ -3649,6 +3813,11 @@ class call {
     if( this.destroyedcancelledorhungup ) return
 
     this._dialog = d
+
+    /* not established until we ack */
+    this.state.establishing = true
+    if( this.#noack ) return
+
     this.established = true
   }
 

package/lib/callmanager.js

@@ -35,6 +35,7 @@ class callmanager {
     Parse invite maessages from drachtio.
     @private
   */
+  // eslint-disable-next-line complexity
   async _oninvite( req, res, next ) {
     if( "INVITE" !== req.msg.method ) return next()
 
@@ -59,15 +60,22 @@ class callmanager {
       try {
         await this.onnewcall( c )
       } catch( e ) {
-        /* auth failed or timed out excluded as this is noral(ish) */
-        if( 403 === e.code ) return
-        if( 408 === e.code ) return
-        if( true === e.normalandsilent ) return
-
-        console.trace( e )
-
-        if( c.destroyed ) return
-        c.hangup( this.hangupcodes.SERVER_ERROR )
+        try{
+          /* auth failed or timed out excluded as this is noral(ish) */
+          if( "object" === typeof e ) {
+            if( 403 === e.code ) return
+            if( 408 === e.code ) return
+            if( true === e.normalandsilent ) return
+          }
+
+          console.trace( e )
+
+          if( c.destroyedcancelledorhungup ) return
+        
+          c.hangup( this.hangupcodes.SERVER_ERROR )
+        } catch( e ) {
+          console.error( e )
+        }
       }
     }
   }

package/package.json

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