@babblevoice/babble-drachtio-callmanager 3.0.0 → 3.2.0

package/lib/call.js

@@ -40,6 +40,18 @@ function parseuri( s ) {
   return {}
 }
 
+/**
+ * Util to convert key names to lowercase
+ * @param { object } obj 
+ * @returns 
+ */
+function keynameslower( obj ) {
+  return Object.keys( obj ).reduce( ( accumulator, currentvalue ) => {
+    accumulator[ currentvalue.toLowerCase() ] = obj[ currentvalue ]
+    return accumulator
+  }, {} )
+}
+
 /*
 Enum for different reasons for hangup.
 */
@@ -357,6 +369,44 @@ class call {
     this.referingtouri
   }
 
+  /**
+   * 
+   * @returns { entity }
+   */
+  #getentityforuac() {
+    if( "uac" == this.type ) {
+      return this.options.entity
+    }
+  }
+
+  /**
+   * 
+   * @returns { entity }
+   */
+  #getentityforuas() {
+    if( !this._entity ) return
+
+    if( this._entity.uri ) {
+      if( !this._entity.username ) {
+        const uriparts = this._entity.uri.split( "@" )
+        this._entity.username = uriparts[ 0 ]
+        if( 1 < uriparts.length )
+          this._entity.realm = uriparts[ 1 ]
+      }
+    }
+
+    if( !this._entity.uri && this._entity.username && this._entity.realm ) {
+      this._entity.uri = this._entity.username + "@" + this._entity.realm
+    }
+
+    return {
+      "username": this._entity.username,
+      "realm": this._entity.realm,
+      "uri": this._entity.uri,
+      "display": this._entity.display?this._entity.display:""
+    }
+  }
+
   /**
   * Returns the entity if known (i.e. outbound or inbound authed).
   * @returns { Promise< entity > }
@@ -364,32 +414,23 @@ class call {
   get entity() {
 
     return ( async () => {
-      if( !this._entity ) return
-
-      if( this._entity.uri ) {
-        if( !this._entity.username ) {
-          const uriparts = this._entity.uri.split( "@" )
-          this._entity.username = uriparts[ 0 ]
-          if( 1 < uriparts.length )
-            this._entity.realm = uriparts[ 1 ]
-        }
-      }
 
-      if( !this._entity.uri && this._entity.username && this._entity.realm ) {
-        this._entity.uri = this._entity.username + "@" + this._entity.realm
+      let e
+      if( "uac" == this.type ) {
+        e = this.#getentityforuac()
+      } else {
+        e = this.#getentityforuas()
       }
-  
+
+      if( !e ) return
+
       const entitycalls = await callstore.getbyentity( this._entity.uri )
       let entitycallcount = 0
       if( false !== entitycalls ) entitycallcount = entitycalls.size
+      e.ccc = entitycallcount
+
+      return e
 
-      return {
-        "username": this._entity.username,
-        "realm": this._entity.realm,
-        "uri": this._entity.uri,
-        "display": this._entity.display?this._entity.display:"",
-        "ccc": entitycallcount
-      }
     } )()
   }
 
@@ -438,8 +479,6 @@ class call {
       parsed = this._req.getParsedHeader( "p-asserted-identity" )
     } else if( this._req.has( "remote-party-id" ) ) {
       parsed = this._req.getParsedHeader( "remote-party-id" )
-    } else {
-      parsed = this._req.getParsedHeader( "from" )
     }
     return parsed
   }
@@ -468,119 +507,219 @@ class call {
    * We make an outbound call. i.e. we send an INVITE
    * 
    * Exceptions
-   * clicktocall - we send an INVITE but that is an inbound call
+   * partycalled/clicktocall - we send an INVITE but that is an inbound call
    * so the invite is i nthe opposie direction.
    * @returns { "inbound" | "outbound" }
    */
   get direction() {
-    if( this.options.clicktocall ) return "inbound"
+    if( this.options.partycalled ) return "inbound"
     return "uas"==this.type?"inbound":"outbound"
   }
 
+  #overridecallerid( startingpoint ) {
+
+    if( this.options.callerid ) {
+      if( "number" in this.options.callerid ) startingpoint.user = this.options.callerid.number
+      if( "name" in this.options.callerid ) startingpoint.name = this.options.callerid.name
+      if( "host" in this.options.callerid ) startingpoint.host = this.options.callerid.host
+    }
+  }
+
+  #overridecalledid( startingpoint ) {
+    startingpoint.privacy = this.options.privacy
+
+    if( this.options.calledid ) {
+      if( "number" in this.options.calledid ) {
+        startingpoint.user = this.options.calledid.number
+        startingpoint.uri = this.options.calledid.number + "@" + startingpoint.host
+      }
+      if( "name" in this.options.calledid ) startingpoint.name = this.options.calledid.name
+    }
+  }
+
+  #fromremoteheaders( startingpoint ) {
+    const parsed = this.#fixparseduriobj( this.#getremotefromheaders() )
+    if( parsed.uri ) startingpoint.uri = parsed.uri
+    if( parsed.user ) startingpoint.user = parsed.user
+    if( parsed.host ) startingpoint.host = parsed.host
+  }
+
+  #fromcontact( startingpoint ) {
+    const dest = parseuri( this.options.contact )
+    if( !dest ) return
+    startingpoint.uri = dest.uri
+    startingpoint.user = dest.user
+    startingpoint.host = dest.host
+  }
+
+  #fromdestination( startingpoint ) {
+    const dest = this.destination
+    startingpoint.user = dest.user
+    startingpoint.host = dest.host
+  }
+
+  #fromoutentity( startingpoint ) {
+
+    const entity = this.options.entity
+    if( entity ) {
+      startingpoint.name = entity.display
+      startingpoint.uri = entity.uri
+      startingpoint.user = entity.username
+      startingpoint.host = entity.realm
+      return true
+    }
+
+    return false
+  }
+
+  #frominentity( startingpoint ) {
+    const entity = this._entity
+
+    if( entity ) {
+      startingpoint.name = entity.display
+      startingpoint.uri = entity.uri
+      startingpoint.user = entity.username
+      startingpoint.host = entity.realm
+      return true
+    }
+
+    return false
+  }
+
+  #fromentity( startingpoint ) {
+
+    if( this.#fromoutentity( startingpoint ) ) return true
+    if( this.#frominentity( startingpoint ) ) return true
+
+    return false
+  }
+
+
   /**
-   * Returns the called object. i.e.
-   * If we are inbound then this is the destination
-   * If we are outbound then this is the entity we are calling
-   * @returns { remoteid }
+   * We have received an INVITE
+   * @param { object } startingpoint 
    */
-  get calledid() {
+  #calledidforuas( startingpoint ) {
+    this.#fromdestination( startingpoint )
+  }
+
+  /**
+   * We have sent an INVITE - which could also be 3rd party
+   * @param { object } startingpoint 
+   */
+  #calledidforuac( startingpoint ) {
+    if( !this.#fromoutentity( startingpoint ) ) {
+      this.#fromcontact( startingpoint )
+    }
+  }
+
+
+  /**
+   * We have sent an INVITE - but it could be 3rd party
+   * @param { object } startingpoint
+   * @returns 
+   */
+  #calleridforuac( startingpoint ) {
+    if( !this.#fromoutentity( startingpoint ) ) {
+      this.#fromcontact( startingpoint )
+    }
+  }
+
+  /** 
+   * We have received an INVITE - so caller ID comes from headers / auth 
+   * * @param { object } startingpoint
+   */
+  #calleridforuas( startingpoint ) {
+    this.#frominentity( startingpoint )
+    this.#fromremoteheaders( startingpoint )
+  }
 
+  #callerid() {
     const startingpoint = {
       "name": "",
       "uri": "",
       "user": "0000000000",
       "host": "localhost.localdomain",
       "privacy": true === this.options.privacy,
-      "type": "calledid"
+      "type": "callerid"
     }
 
-    if( "outbound" === this.direction ) {
-      if( this.parent ) {
-        const dest = this.parent.destination
-        startingpoint.user = dest.user
-        startingpoint.host = dest.host
+    if( "uas" == this.type ) this.#calleridforuas( startingpoint )
+    else {
+      if( this.options.partycalled ) {
+        this.#calleridforuac( startingpoint )
       } else {
-        const dest = parseuri( this.options.contact )
-        startingpoint.user = dest.user
-        startingpoint.host = dest.host
-      }
-      
-    } else { /* inbound */
-      if( this.parent ) {
-        const dest = this.parent.destination
-        startingpoint.user = dest.user
-        startingpoint.host = dest.host
-      } else {
-        const dest = this.destination
-        startingpoint.user = dest.user
-        startingpoint.host = dest.host
-      }
-    }
-
-    startingpoint.privacy = this.options.privacy
+        const other = this.other
 
-    if( this.options.calledid ) {
-      if( "number" in this.options.calledid ) {
-        startingpoint.user = this.options.calledid.number
-        startingpoint.uri = this.options.calledid.number + "@" + startingpoint.host
+        if( other ) {
+          if( "uas" == other.type ) {
+            other.#calleridforuas( startingpoint )
+            other.#overridecallerid( startingpoint )
+          } else {
+            other.#calledidforuac( startingpoint )
+          }
+        } else {
+          this.#calleridforuac( startingpoint )
+        }
       }
-      if( "name" in this.options.calledid ) startingpoint.name = this.options.calledid.name
     }
 
+    this.#overridecallerid( startingpoint )
     return startingpoint
   }
 
   /**
    * @returns { remoteid }
    */
-  // eslint-disable-next-line complexity
   get callerid() {
+    return this.#callerid()
+  }
 
-    let startingpoint = {
+  #calledid() {
+    const startingpoint = {
       "name": "",
       "uri": "",
       "user": "0000000000",
       "host": "localhost.localdomain",
       "privacy": true === this.options.privacy,
-      "type": "callerid"
+      "type": "calledid"
     }
 
-    if( "outbound" === this.direction ) {
-      if( this.parent ) {
-        startingpoint = this.parent.callerid
-      } else {
-        const parseduri = parseuri( this.options.contact )
-        if( parseduri.user ) {
-          startingpoint.uri = this.options.contact
-          startingpoint.user = parseduri.user
-          startingpoint.host = parseduri.host
+    if( "uas" == this.type ) this.#calledidforuas( startingpoint )
+    else {
+      if( !this.options.partycalled ) this.#calledidforuac( startingpoint )
+
+      const other = this.other
+
+      if( other ) {
+        if( "uas" == other.type ) {
+          if( this.options.partycalled ) {
+            other.#calleridforuas( startingpoint )
+          } else {
+            other.#calledidforuas( startingpoint )
+          }
+        } else {
+          other.#calledidforuac( startingpoint )
         }
-      }
-    } else { /* inbound */
-      if( this._entity ) {
-        startingpoint.name = this._entity.display
-        startingpoint.uri = this._entity.uri
-        startingpoint.user = this._entity.username
-        startingpoint.host = this._entity.realm
-      } else { 
-        let parsed = this.#getremotefromheaders()
-        parsed = this.#fixparseduriobj( parsed )
-
-        startingpoint.uri = parsed.uri
-        startingpoint.user = parsed.user
-        startingpoint.host = parsed.host
+        other.#overridecalledid( startingpoint )
       }
     }
 
-    if( this.options.callerid ) {
-      if( "number" in this.options.callerid ) startingpoint.user = this.options.callerid.number
-      if( "name" in this.options.callerid ) startingpoint.name = this.options.callerid.name
-      if( "host" in this.options.callerid ) startingpoint.host = this.options.callerid.host
-    }
+    this.#overridecalledid( startingpoint )
 
     return startingpoint
   }
 
+  /**
+ * Returns the called object. i.e.
+ * If we are inbound then this is the destination
+ * If we are outbound then this is the entity we are calling
+ * @returns { remoteid }
+ */
+  get calledid() {
+    return this.#calledid()
+  }
+
   /**
    * @param { string } c
    */
@@ -997,6 +1136,7 @@ class call {
   adopt( other, mix ) {
     other.parent = this
     this.children.add( other )
+    other.moh = this.moh
 
     /* maintain privacy */
     other.options.privacy = this.options.privacy
@@ -1196,7 +1336,13 @@ class call {
   */
   get other() {
     if( this.parent ) return this.parent
+    return this.child
+  }
 
+  /**
+   * Return specifically first child - prefer established otherwise first
+   */
+  get child() {
     /* first established */
     for( const child of this.children ) {
       if( child.established ) {
@@ -1714,7 +1860,7 @@ class call {
    * @returns { Promise } resolves on timeout or when unmix happens
    * @private
    */
-  _hold( direction = "recvonly" ) {
+  _hold( direction = "inactive" ) {
 
     if( this.state.held ) return
     this.state.held = true
@@ -1855,10 +2001,15 @@ class call {
     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.
+    same as used elsewhere. If a bond has been attached to the call, we will
+    try to reuse an existing channel.
+    @param { object } [ channeldef ]
     @private
   */
-  async reinvite() {
+  async reinvite( channeldef ) {
+
+    if ( !channeldef )
+      channeldef = await this.#createchannelremotedef()
 
     const remotesdp = await this._dialog.modify( this.sdp.local.toString() )
       .catch( ( e ) => {
@@ -1872,10 +2023,31 @@ class call {
       this.sdp.remote.setdynamepayloadtypes( this.sdp.local )
     }
 
-    const channeldef = await this.#createchannelremotedef()
-    if( channeldef ) /* we should always get in here */
-      this.channels.audio.remote( channeldef.remote )
+  }
+
+  /**
+    Mix two calls. If the two calls are on a different node
+    the second call is bonded and reinvited.
+    @param { call } othercall - our call object which is early
+    @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
+      // eslint-disable-next-line require-atomic-updates
+      othercall.channels.audio = await this.channels.audio.openchannel( channeldef, othercall._handlechannelevents.bind( othercall ) )
+
+      await othercall.bond( this ).reinvite( channeldef )
 
+      await oldchannel.close()
+    }
+
+    await this.channels.audio.mix( othercall.channels.audio )
   }
 
   /**
@@ -2256,19 +2428,24 @@ class call {
       } )
     } )
 
+    /*
+    TODO - this is wrong. If we want to include this - it is not the REFER CSEQ that jssip
+    is looking for - it is the cseq of the INVITE.
     const id = this._req.get( "cseq" ).match( /(\d+)/ )[ 0 ]
+    Leave out for now - as this works for us.
+    */
     try {
-      await this._notifyreferstart( id )
+      await this._notifyreferstart()
     } catch( e ) {
       console.trace( e )
-      this._notifyreferfail( id )
+      this._notifyreferfail()
       return
     }
 
     /* Link logically and mix */
     a_1.adopt( c_1, true )
 
-    this._notifyrefercomplete( id )
+    this._notifyrefercomplete()
 
     a_1.state.refered = true
 
@@ -2579,7 +2756,7 @@ class call {
       }
     }
 
-    options.headers[ "Max-Forwards" ] = maxforwards
+    options.headers[ "max-forwards" ] = maxforwards
     
     if( !options.orphan && !options.parent ) {
       options.parent = this
@@ -2700,7 +2877,7 @@ class call {
     /* 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 get a rewrite to support only one. */
+    style channel. projectrtp will getrelatives a rewrite to support only one. */
     if( relatedcall && relatedcall.channels.audio && relatedcall.channels.audio.channels ) {
       this.channels.audio = await this.other.channels.audio.openchannel( channeldef, this._handlechannelevents.bind( this ) )
       return
@@ -2818,10 +2995,16 @@ class call {
   }
 
   /**
+   * https://www.ietf.org/proceedings/50/I-D/sip-privacy-01.txt
    * @returns { object }
    */
   #configcalleridfornewuac() {
 
+    let party = ";party=calling"
+    if( this.options.partycalled ) {
+      party = ";party=called"
+    }
+
     const callerid = this.callerid
     const calleridstr = `"${callerid.name}" <sip:${callerid.user}@${callerid.host}>`
 
@@ -2834,12 +3017,20 @@ class call {
       RFC 3325 - should we also consider the P-Preferred-Identity header?
       P-Asserted-Identity?
     */
-    this.options.headers[ "Remote-Party-ID" ] = calleridstr + ";party=calling;screen=yes" + privacy
-    this.options.headers[ "From" ] = calleridstr
+    this.options.headers[ "remote-party-id" ] = calleridstr + party + ";screen=yes" + privacy
+    this.options.headers[ "from" ] = calleridstr
 
     return { user: callerid.user, realm: callerid.host }
   }
 
+
+  #configureto() {
+    if( this.options.headers[ "to" ] ) return
+    if( !this.options.entity ) return
+    
+    this.options.headers[ "to" ] = "<sip:" + this.options.entity.uri + ">"
+  }
+
   /**
    * 
    * @param { string } contactstr
@@ -2848,16 +3039,19 @@ class call {
 
     const parts = parseuri( contactstr )
 
-    if( this.options.clicktocall ) this.options.autoanswer = true
+    if( this.options.clicktocall ) {
+      this.options.partycalled = true
+      this.options.autoanswer = true
+    }
 
     if( !this.options.contactparams ) this.options.contactparams = ""
     if( true === this.options.autoanswer ) {
-      this.options.headers[ "Call-Info" ] = `<sip:${parts.host}>;answer-after=0`
-      this.options.headers[ "Alert-Info" ] = "auto-answer"
+      this.options.headers[ "call-info" ] = `<sip:${parts.host}>;answer-after=0`
+      this.options.headers[ "alert-info" ] = "auto-answer"
       this.options.contactparams += ";intercom=true"
     } else if ( "number" == typeof this.options.autoanswer ) {
-      this.options.headers[ "Call-Info" ] = `<sip:${parts.host}>;answer-after=${this.options.autoanswer}`
-      this.options.headers[ "Alert-Info" ] = "auto-answer"
+      this.options.headers[ "call-info" ] = `<sip:${parts.host}>;answer-after=${this.options.autoanswer}`
+      this.options.headers[ "alert-info" ] = "auto-answer"
       this.options.contactparams += ";intercom=true"
     }
   }
@@ -2914,6 +3108,7 @@ class call {
    * @property { object } [ uactimeout ] - override the deault timeout
    * @property { true | number } [ autoanswer ] - if true add call-info to auto answer, if number delay to add
    * @property { boolean } [ clicktocall ] - if set to true, will set autoanswer to true and swap the source and desination on caller ID
+   * @property { boolean } [ partycalled ] - reverses the direction of the call from the invite
    * @property { boolean } [ late ] - late negotiation
    * @property { boolean } [ privacy ] - sets the privacy
    * @property { entity } [ entity ] - used to store this call against and look up a contact string if not supplied.
@@ -2964,6 +3159,7 @@ class call {
    * @param { newuaccallbacks } [ callbacks ]
    * @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.
    */
+  // eslint-disable-next-line complexity
   static async newuac( options, callbacks = {} ) {
 
     if( !options.contact && !options.entity ) return false
@@ -2982,24 +3178,26 @@ class call {
 
     newcall.bond( options.bond )
 
+    // spread is not recursive
+    newcall.options = { ...newcall.options, ...options }
+    const tmpheaders =  { ...callmanager.options.headers, ...newcall.options.headers, ...options.headers }
+    newcall.options.headers = keynameslower( tmpheaders )
+
     if( options.entity ) {
       newcall.entity = options.entity
       callstore.set( newcall )
+      
     }
 
-    // spread is not recursive
-    newcall.options = { ...newcall.options, ...options }
-    const tmpheaders =  { ...callmanager.options.headers, ...newcall.options.headers, ...options.headers }
-    newcall.options.headers = tmpheaders
-
     newcall.#configcalleridfornewuac()
+    newcall.#configureto()
     newcall.import()
 
     newcall.#configautoanswerfornewuac( options.contact )
 
-    newcall.options.headers[ "Allow-Events" ] = "talk, hold, presence, as-feature-event, dialog, call-info, sla, include-session-description, message-summary, refer"
-    newcall.options.headers[ "Allow" ] = "INVITE, ACK, BYE, CANCEL, OPTIONS, MESSAGE, INFO, UPDATE, REGISTER, REFER, NOTIFY, PUBLISH, SUBSCRIBE"
-    newcall.options.headers[ "Supported" ] = "timer, path, replaces"
+    newcall.options.headers[ "allow-events" ] = "talk, hold, presence, as-feature-event, dialog, call-info, sla, include-session-description, message-summary, refer"
+    newcall.options.headers[ "allow" ] = "INVITE, ACK, BYE, CANCEL, OPTIONS, MESSAGE, INFO, UPDATE, REGISTER, REFER, NOTIFY, PUBLISH, SUBSCRIBE"
+    newcall.options.headers[ "supported" ] = "timer, path, replaces"
     
     newcall.#confignetwork( options )
     await newcall.#openchannelsfornewuac()

package/package.json

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