@babblevoice/projectrtp 2.3.5 → 2.3.7

package/.github/workflows/ccpp.yml

@@ -0,0 +1,26 @@
+name: C/C++ CI
+
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    
+    steps:
+    - uses: actions/checkout@v1
+    - name: update
+      run: sudo apt update
+    - name: submodules
+      run: git submodule update --init --recursive
+    - name: Install apt dependencies
+      run: sudo apt install libboost-dev libboost-system-dev libspandsp-dev gnutls-dev libsrtp2-dev cmake ccache
+    - name: Build ilbc 
+      run: |
+            cd libilbc
+            cmake . -DCMAKE_INSTALL_LIBDIR=/lib -DCMAKE_INSTALL_INCLUDEDIR=/usr/include; cmake --build .; sudo cmake --install .
+            cd ..
+    - name: Build project
+      run: |
+            cd src
+            make

package/.github/workflows/cppcheck.yml

@@ -0,0 +1,19 @@
+name: Run Linters 
+
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    
+    steps:
+    - uses: actions/checkout@v1
+    - name: update
+      run: sudo apt update
+    - name: submodules
+      run: sudo apt install cppcheck 
+    - name: Run cppcheck
+      run: |
+            cppcheck ./src
+            

package/README.md

@@ -116,9 +116,9 @@ Build ilbc from the sub module plus install other dependancies.
 
 ```bash
 
-apt install libboost-dev libspandsp-dev gnutls-dev libsrtp2-dev cmake 
+apt install libboost-dev libboost-system-dev libspandsp-dev gnutls-dev libsrtp2-dev cmake ccache
 
-cd ilbc
+cd libilbc
 cmake . -DCMAKE_INSTALL_LIBDIR=/lib -DCMAKE_INSTALL_INCLUDEDIR=/usr/include; cmake --build .; cmake --install .
 cd ..
 ```

package/index.js

@@ -468,6 +468,10 @@ class projectrtp {
       else chan.id = uuidv4()
 
       chan.uuid = uuidv4()
+
+      /* ensure we are identicle to the node version of this object */
+      chan.openchannel = this.openchannel.bind( this )
+      
       return chan
     }
   }

package/lib/node.js

@@ -37,6 +37,7 @@ class rtpnode {
     this.address = address
     this.port = port
     this.instance = uuidv4()
+    this.connections = new Map()
     this.messagestate = message.newstate()
 
     /* pre callbacks are called when we receive an instruction from
@@ -70,11 +71,17 @@ class rtpnode {
 
     return new Promise( resolve => {
       this._onsocketreadypromiseresolve = resolve
-      this.connection = net.createConnection( this.port, this.host )
+      const connection = net.createConnection( this.port, this.host )
+      this.connection = connection
       this.connection.setKeepAlive( true )
-
       this.connection.on( "connect", this._onsocketconnect.bind( this ) )
-      this.connection.on( "data", this._onsocketdata.bind( this ) )
+      const con = {
+        connectionid: uuidv4(),
+        connection,
+        "connectionlength": 0
+      }
+      this.connections[ con.connectionid ] = con
+      this.connection.on( "data", this._onsocketdata.bind( this, con ) )
       this.connection.on( "error", this._onsocketerror.bind( this ) )
       this.connection.on( "close", this._onsocketclose.bind( this ) )
     } )
@@ -87,9 +94,14 @@ class rtpnode {
     let listenresolve
     const listenpromise = new Promise( ( r ) => listenresolve = r )
     this.server = net.createServer( ( connection ) => {
-      this.connection = connection
-      this.connection.setKeepAlive( true )
-      this.connection.on( "data", this._onsocketdata.bind( this ) )
+      const con = {
+        connectionid: uuidv4(),
+        connection,
+        "connectionlength": 0
+      }
+      this.connections[ con.connectionid ] = con
+      connection.setKeepAlive( true )
+      connection.on( "data", this._onsocketdata.bind( this, con ) )
     } )
 
     this.server.listen( this.port, this.address )
@@ -104,7 +116,7 @@ class rtpnode {
    */
   _onsocketconnect( /* sock */ ) {
     console.log( "Connected to " + this.host + ":" + this.port )
-    this.send( {} )
+    this.send( {}, this.connection )
     this._onsocketreadypromiseresolve( this )
     this._reconnecttime = 500 /* mS */
   }
@@ -148,14 +160,15 @@ class rtpnode {
   /**
    * Send a message back to the main server, include stats to help with load balancing.
    * @param { object } msg
+   * @param { object } connection
    * @returns { void }
    */
-  send( msg ) {
+  send( msg, connection ) {
     this._post( msg, ( modifiedmsg ) => {
       if( this._destroying ) return
       msg.status = this.prtp.stats()
       msg.status.instance = instance
-      this.connection.write( message.createmessage( modifiedmsg ) )
+      connection.write( message.createmessage( modifiedmsg ) )
     } )
   }
 
@@ -168,17 +181,21 @@ class rtpnode {
     nodeinterface.clean()
 
     if( this._reconnecttimerid ) clearTimeout( this._reconnecttimerid )
-    this.connection.destroy()
+    if( this.connection ) this.connection.destroy()
+    this.connections.forEach( ( connection ) => {
+      connection.destroy()
+    } )
     if ( this.server ) this.server.close()
   }
 
   /**
    * 
    * @param { object } msg 
+   * @param { object } con
    * @returns { Promise< Boolean > }
    */
-  async _processmessage( msg ) {
-    return ( await this._openchannel( msg ) || this._updatechannel( msg ) )
+  async _processmessage( msg, con ) {
+    return ( await this._openchannel( msg, con ) || this._updatechannel( msg, con ) )
   }
 
   /**
@@ -244,15 +261,16 @@ class rtpnode {
   }
 
   /**
-   * @private
-   * @param { Buffer } data 
+   * @privateopenchannel
+   * @param { Buffer } data
+   * @param { object } con 
    * @returns { void }
    */
-  _onsocketdata( data ) {
+  _onsocketdata( con, data ) {
     message.parsemessage( this.messagestate, data, ( msg ) => {
       try {
         this._pre( msg, ( modifiedmsg ) => {
-          this._processmessage( modifiedmsg )
+          this._processmessage( modifiedmsg, con )
         } )
       } catch( e ) {
         console.error( "Unhandled exception in babble-rtp", e )
@@ -262,30 +280,40 @@ class rtpnode {
 
   /**
    * @private
-   * @param { object } msg 
+   * @param { object } msg
+   * @param { object } con
    * @returns { Promise< Boolean > }
    */
-  async _openchannel( msg ) {
+  async _openchannel( msg, con ) {
     if( "open" !== msg.channel ) return false
+    con.connectionlength += 1
     msg.forcelocal = true
 
     const chan = await this.prtp.openchannel( msg, ( x ) => {
-      if( "close" === x.action ) channels.delete( chan.uuid )
-      this.send( { ...{ "id": chan.id, "uuid": chan.uuid }, ...x } )
+      this.send( { ...{ "id": chan.id, "uuid": chan.uuid }, ...x }, con.connection )
+      if( "close" === x.action )  {
+        con.connectionlength -= 1
+        channels.delete( chan.uuid )
+
+        if( 0 == con.connectionlength ) {
+          this.connections.delete( con.instance )
+          con.connection.destroy()
+        }
+      }
     } )
-
     channels.set( chan.uuid, chan )
-    this.send( { ...chan, ...{ "action": "open" } } )
+    this.send( { ...chan, ...{ "action": "open" } }, con.connection )
 
     return true
   }
 
   /**
    * @private
-   * @param { object } msg 
+   * @param { object } msg
+   * @param { object } con 
    * @returns boolean
    */
-  _updatechannel( msg ) {
+  _updatechannel( msg, con ) {
 
     if( undefined === msg.channel ) return false
     if( undefined === msg.uuid ) return false
@@ -300,7 +328,7 @@ class rtpnode {
         "id": msg.id,
         "uuid": msg.uuid
       }
-      this.send( { ...{ "error": "Unknown method" }, ...channelidentifiers } )
+      this.send( { ...{ "error": "Unknown method" }, ...channelidentifiers }, con.connection )
     }
 
     return true

package/lib/server.js

@@ -243,12 +243,7 @@ class channel {
             if ( receivedmsg.id === chnl.id ) chnl._on( receivedmsg )
           }
 
-          /* find channel and indicate connect */
-          if( openresolve && "open" == receivedmsg.action ) {
-            newchannel.uuid = receivedmsg.uuid
-            newchannel.local = receivedmsg.local
-            openresolve( newchannel )
-          }
+          if ( openresolve ) openresolve( newchannel )
         } )
       } )
 
@@ -304,7 +299,7 @@ class channel {
 
     /* any outstanding to remove where unmix was not called first? */
     this._removebridge()
-
+    
     /* close us */
     this._write( {
       "channel": "close",
@@ -582,13 +577,12 @@ class channel {
    */
   _runopen( msg ) {
     if( "open" !== msg.action ) return false
-    if( !this.openresolve ) return true
 
     this.local = msg.local
     this.action = msg.action
-
     this.uuid = msg.uuid
 
+    if( !this.openresolve ) return true
     this.openresolve( this )
     delete this.openresolve
     delete this.openreject
@@ -604,6 +598,12 @@ class channel {
    */
   _runclose( msg ) {
     if( "close" !== msg.action ) return
+    
+    if( undefined !== this.openresolve ) {
+      this.openresolve()
+      delete this.openresolve
+      delete this.openreject
+    }
 
     if( this.channels ) { 
       // adjust with filter
@@ -612,11 +612,6 @@ class channel {
       if( 0 === this.channels.length && this.connection.sock ) this.connection.sock.destroy()
     }
 
-    if( undefined !== this.openresolve ) {
-      this.openresolve()
-      delete this.openresolve
-      delete this.openreject
-    }
     if( this.connection && this.connection.sock && !this.channels ) {
       this.connection.sock.destroy()
       delete this.connection.sock
@@ -633,7 +628,6 @@ class channel {
   _on( msg ) {
     msg.timestamp = ( new Date ).getTime()
     this.history.push( msg )
-
     if( this._runopen( msg ) ) return
 
     this.em.emit( "all", msg )
@@ -654,7 +648,7 @@ class channel {
     if( "" !== uuid ) {
       msg.uuid = uuid
     }
-    
+
     this.connection.sock.write( message.createmessage( msg ) )
     
     msg.timestamp = ( new Date ).getTime()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babblevoice/projectrtp",
-  "version": "2.3.5",
+  "version": "2.3.7",
   "description": "A scalable Node addon RTP server",
   "main": "index.js",
   "directories": {

package/src/binding.gyp

@@ -3,6 +3,7 @@
     {
       "target_name": "projectrtp",
       "defines": [ "NODE_MODULE", "BOOST_NO_EXCEPTIONS", "BOOST_EXCEPTION_DISABLE" ],
+      "cflags_cc!": [ "-fno-rtti" ],
       "cflags_cc": [
         "-O3",
         "-g",

package/src/makefile

@@ -1,8 +1,8 @@
 # -O3 includes -fopt-info-vec -fopt-info-vec-missed
 DEBUG:= -DDEBUG -g
 RELEASE:=-O3
-CCOPTS:=-Wall -fstack-protector-all -std=c++17 -fconcepts -fsanitize=address -fsanitize=leak -DTESTSUITE
-LL:=-lboost_system -lpthread -lrt -L./build/Debug/test/ -lspandsp -lilbc -lgnutls -lsrtp2 -lm -fsanitize=address -fsanitize=leak
+CCOPTS:=-Wall -fstack-protector-all -std=c++20 -fconcepts -fsanitize=address,leak -DTESTSUITE
+LL:=-lboost_system -lpthread -lrt -L./build/Debug/test/ -lspandsp -lilbc -lgnutls -lsrtp2 -lm -fsanitize=address,leak
 
 COMPILER:=g++
 LINKER:=g++

package/stress/dtls.scenario.js

@@ -56,4 +56,8 @@ module.exports = async ( mstimeout ) => {
   expect( clienta.play( { "loop": true, "files": [ { "wav": "/tmp/ukringing.wav" } ] } ) ).to.be.true
   expect( channela.echo() ).to.be.true
 
-}
+  setTimeout( () => {
+    clienta.close()
+  }, mstimeout )
+
+}

package/test/interface/rtpproxyserver.js

@@ -589,7 +589,7 @@ describe( "rtpproxy server", function() {
     expect( openreceived ).to.be.true
   } )
 
-  it( "Node as listener server to test", async () => {
+  it( "1 channel, node as listener server to test", async () => {
 
     const ourport = getnextport()
     prtp.server.clearnodes()
@@ -604,6 +604,41 @@ describe( "rtpproxy server", function() {
     n.destroy()
   } )
 
+  it( "2 channels, node as listener server to test", async () => {
+
+    const ourport = getnextport()
+    prtp.server.clearnodes()
+    prtp.server.addnode( { host: "127.0.0.1", port: ourport } )
+
+    const ournode = node.create( prtp )
+
+    const n = await ournode.listen( "127.0.0.1", ourport )
+    const chnl = await prtp.openchannel()
+    const chnl2 = await prtp.openchannel()
+    await chnl.close()
+    await chnl2.close()
+    await new Promise( ( resolve ) => { setTimeout( () => resolve(), 100 ) } )
+    n.destroy()
+  } )
+
+  it( "2 channels, node as listener server to test - open a channel through another one", async () => {
+
+    const ourport = getnextport()
+    prtp.server.clearnodes()
+    prtp.server.addnode( { host: "127.0.0.1", port: ourport } )
+
+    const ournode = node.create( prtp )
+
+    const n = await ournode.listen( "127.0.0.1", ourport )
+    const chnl = await prtp.openchannel()
+    const chnl2 = await chnl.openchannel()
+    await new Promise( ( resolve ) => { setTimeout( () => resolve(), 100 ) } )
+    await chnl.close()
+    await chnl2.close()
+    await new Promise( ( resolve ) => { setTimeout( () => resolve(), 100 ) } )
+    n.destroy()
+  } )
+
   it( "Ensure we receive middle messages", async() => {
     /*
       i.e. messages we receive inbetween an open and close