sip-lab 1.40.1 → 1.41.0

package/DEV.md

@@ -8,10 +8,11 @@ Basic tasks for development:
 ```
 sudo apt install build-essential automake autoconf libtool libspeex-dev libopus-dev libsdl2-dev libavdevice-dev libswscale-dev libv4l-dev libopencore-amrnb-dev libopencore-amrwb-dev libvo-amrwbenc-dev libvo-amrwbenc-dev libboost-dev libtiff-dev libpcap-dev libssl-dev uuid-dev cmake flite-dev
 
+nvm use v16.13.1 # other versions might work.
 npm install
 ```
 
-Thne confirm it is working:
+Then confirm it is working:
 ```
 node samples/simple.js
 ```
@@ -44,15 +45,8 @@ npm install
 Then perform code changes and tests. When you are satisfied with them, update build_deps.sh with the new commit IDs.
 
 #### prebuild binaries
-Previously we would do:
 
-```
-nvm use v16.13.1 # if we try with v17 it will fail to build for -t 15.0.0
-npx prebuildify --strip -t 15.0.0 -t 16.0.0 -t 17.0.0 -t 18.0.0 19.0.0 20.0.0 21.0.0
-```
-However the above will build the addon to run on the current OS.
-
-Instead we will force the build on debian11 (using docker) using prebuildify-cross. So do this instead:
+We will use prebuildify-cross to generate the images for different architectures.
 
 Make sure you have the docker image built (the image must be rebuilt whenever we update build_deps.sh)
 
@@ -73,10 +67,10 @@ If it fails due to proxy problems, check if you have proxy configured in ~/.dock
 
 ```
 
-After the image is built you can pass them to prebuildify-cross:
+The to prebuild the addon versions:
 ```
 nvm use v16.13.1
-npx prebuildify-cross -i mayamatakeshi/sip-lab-debian11:latest -t 15.0.0 -t 16.0.0 -t 17.0.0 -t 18.0.0 -t 19.0.0 -t 20.0.0 -t 21.0.0 --strip
+./gen_prebuilds.sh
 ```
 Obs: however the above will fail if you are behind proxy (solution pending).
 

package/binding.gyp

@@ -25,13 +25,14 @@
           ],
           'conditions': [
             [ 'OS!="win"', {
-              'cflags': ['-g', '-DPJ_HAS_SSL_SOCK=1'],
+              'cflags': ['-g', '-DPJ_HAS_SSL_SOCK=1', '-DNAPI_VERSION=6'],
               'cflags_cc': [
                 '-g',
                 '-DPJ_HAS_SSL_SOCK=1',
                 '-fexceptions',
                 '-Wno-maybe-uninitialized',
                 '-fPIC',
+		'-DNAPI_VERSION=6',
               ],
               'ldflags_cc': [
                 '-all-static',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sip-lab",
-  "version": "1.40.1",
+  "version": "1.41.0",
   "description": "",
   "main": "index.js",
   "engines": {
@@ -34,7 +34,7 @@
   },
   "devDependencies": {
     "prebuildify": "^5.0.1",
-    "prebuildify-cross": "github:MayamaTakeshi/prebuildify-cross#use_existing_images"
+    "prebuildify-cross": "github:MayamaTakeshi/prebuildify-cross#820133ce7fdbc92525b5b0d7149ed6497860a11b"
   },
   "files": [
     "index.js",
@@ -49,5 +49,10 @@
     "prebuilds",
     "pocketsphinx",
     "runtests"
-  ]
+  ],
+  "binary": {
+    "napi_versions": [
+      6
+    ]
+  }
 }

package/runtests

@@ -45,13 +45,24 @@ while getopts "gef:a:h" o; do
 done
 shift $((OPTIND-1))
 
-successful_tests=()
+passed_on_first_try=()
+passed_on_retry=()
 failed_tests=()
 
-function output_successful_tests() {
-    if [ ${#successful_tests[@]} -ne 0 ]; then
-        echo "Successful tests:"
-        for t in "${successful_tests[@]}"
+function output_passed_on_first_try_tests() {
+    if [ ${#passed_on_first_try[@]} -ne 0 ]; then
+        echo "Passed on first try:"
+        for t in "${passed_on_first_try[@]}"
+        do
+            echo "  - $t"
+        done
+    fi
+}
+
+function output_passed_on_retry_tests() {
+    if [ ${#passed_on_retry[@]} -ne 0 ]; then
+        echo "Passed on retry (flaky tests):"
+        for t in "${passed_on_retry[@]}"
         do
             echo "  - $t"
         done
@@ -127,11 +138,12 @@ do
         formatted_duration=$(printf "%.2f seconds" $duration)
         
         success_message="$i: duration=$formatted_duration"
-        # The variable c comes from the retry loop
         if [[ $c -gt 1 ]]; then
             success_message+=" (succeeded after $c attempts)"
+            passed_on_retry+=("$success_message")
+        else
+            passed_on_first_try+=("$success_message")
         fi
-        successful_tests+=("$success_message")
     fi
     echo
 done
@@ -139,7 +151,9 @@ done
 echo
 
 if [ ${#failed_tests[@]} -ne 0 ]; then
-    output_successful_tests
+    output_passed_on_first_try_tests
+    echo
+    output_passed_on_retry_tests
     echo
     output_failed_tests
     echo
@@ -149,7 +163,9 @@ if [ ${#failed_tests[@]} -ne 0 ]; then
 else
     echo "Success. All tests passed"
     echo
-    output_successful_tests
+    output_passed_on_first_try_tests
+    echo
+    output_passed_on_retry_tests
     echo
     echo "Everything OK"
     echo

package/samples/call_with_authentication.js

@@ -0,0 +1,278 @@
+// This test creates 2 UDP SIP endpoints, makes a call between them and disconeects.
+
+const sip = require ('../index.js')
+const Zeq = require('@mayama/zeq')
+const m = require('data-matching')
+const sip_msg = require('sip-matching')
+
+const crypto = require('crypto');
+
+function generateDigestResponse({
+    username, password, realm, nonce, uri,
+    method = 'INVITE', qop = 'auth', nc = '00000001',
+    cnonce 
+}) {
+    const md5 = (str) => crypto.createHash('md5').update(str).digest('hex');
+
+    // Fallback to random ONLY if one isn't provided (for tests)
+    const finalCnonce = cnonce || crypto.randomBytes(8).toString('hex');
+
+    const ha1 = md5(`${username}:${realm}:${password}`);
+    const ha2 = md5(`${method}:${uri}`);
+    const response = md5(`${ha1}:${nonce}:${nc}:${finalCnonce}:${qop}:${ha2}`);
+
+    return { response, cnonce: finalCnonce };
+}
+
+// here we create our Zeq instance
+var z = new Zeq()
+
+
+async function test() {
+    // here we set DTMF aggregation mode to 500 ms
+    sip.dtmf_aggregation_on(500)
+
+    // here we set our Zeq instance to trap events generated by sip-lab event_source
+    z.trap_events(sip.event_source, 'event', (evt) => {
+        var e = evt.args[0]
+        return e
+    })
+
+    sip.set_codecs("pcmu/8000/1:128,pcma/8000/1:128,gsm/8000/1:128")
+
+    // here we start sip-lab
+    console.log(sip.start((data) => { console.log(data)} ))
+
+    // Here we create the SIP endpoints (transports).
+    // Since we don't specify the port, an available port will be allocated.
+    // Since we don't specify the type ('udp' or 'tcp' or 'tls'), 'udp' will be used by default.
+    const t1 = sip.transport.create({address: "127.0.0.1"})
+    const t2 = sip.transport.create({address: "127.0.0.1"})
+
+    // here we just print the transports
+    console.log("t1", t1)
+    console.log("t2", t2)
+
+    max_forwards = '18'
+
+    var username = 'alice'
+    var password = 'secret'
+    var realm = 'test.com'
+
+    // make the call from t1 to t2 with some custom heaaders
+    const oc = sip.call.create(t1.id, {
+        from_uri: 'sip:alice@test.com',
+        to_uri: `sip:bob@${t2.address}:${t2.port}`,
+        auth: {
+            username,
+            password,
+            realm,
+        },
+    })
+
+    // Here we will wait for the call to arrive at t2
+    // We will also get a '100 Trying' that is sent by sip-lab automatically
+    // We will wait for at most 1000ms. If all events don't arrive within 1000ms, an exception will be thrown and the test will fail due to timeout.
+    await z.wait([
+        {
+            event: "incoming_call",
+            call_id: m.collect("call_id"),
+            transport_id: t2.id,
+            msg: sip_msg({
+                $rU: 'bob',
+                $fU: 'alice',
+                $tU: 'bob',
+                $fd: 'test.com',
+                $ru: m.collect('ruri'),
+                hds_call_id: m.collect('sip_call_id'),
+            })
+        },
+        {
+            event: 'response',
+            call_id: oc.id,
+            method: 'INVITE',
+            msg: sip_msg({
+                $rs: '100',
+                $rr: 'Trying',
+            }),
+        },
+    ], 1000)
+
+    // Here we store data for the incoming call
+    // just to organize our code (not really needed)
+    var ic = {
+        id: z.$call_id,
+        sip_call_id: z.$sip_call_id,
+    }
+
+    // Now we challenge the caller.
+    var nonce = "dcd98b7102dd2f0e8b11d0f600bfb0c093"
+    var qop = 'auth'
+    var algorithm = 'MD5'
+    var uri = z.$ruri
+    sip.call.respond(ic.id, {
+        code: 407,
+        reason: 'Proxy Authentication Required',
+        headers: {
+            'Proxy-Authenticate': `Digest realm="${realm}", nonce="${nonce}", algorithm=${algorithm}, qop="${qop}"`,
+        },
+    })
+
+    // the caller gets the challenge and the call ends at t2.
+    await z.wait([
+        {
+            event: 'response',
+            call_id: oc.id,
+            method: 'INVITE',
+            msg: sip_msg({
+                $rs: '407',
+                $rr: 'Proxy Authentication Required',
+                hdr_proxy_authenticate: `Digest realm="${realm}",nonce="${nonce}",algorithm=${algorithm},qop="${qop}"`,
+            }),
+        },
+        {
+            event: 'call_ended',
+            call_id: ic.id,
+        }
+    ], 1000)
+
+    z.store.call_id = null
+    z.store.sip_call_id = null
+ 
+    // Then we wait for INVITE with header Authorization
+    await z.wait([
+        {
+            event: "incoming_call",
+            call_id: m.collect("call_id"),
+            transport_id: t2.id,
+            msg: sip_msg({
+                $rU: 'bob',
+                $fU: 'alice',
+                $tU: 'bob',
+                $fd: 'test.com',
+                hdr_proxy_authorization: 'Digest username="!{username}", realm="!{realm}", nonce="!{nonce}", uri="!{uri}", response="!{response}", algorithm=!{algorithm}, cnonce="!{cnonce}", qop=!{qop}, nc=!{nc}',
+                hdr_call_id: m.collect('sip_call_id'),
+            })
+        },
+        {
+            event: 'response',
+            call_id: oc.id,
+            method: 'INVITE',
+            msg: sip_msg({
+                $rs: '100',
+                $rr: 'Trying',
+            }),
+        },
+    ], 1000)
+
+    var expectedResponse = generateDigestResponse({
+        username,
+        password,
+        realm,
+        nonce,
+        uri,
+        method: 'INVITE',
+        qop,
+        nc: z.$nc,
+        cnonce: z.$cnonce,
+    })
+
+    if(z.$response != expectedResponse.response) {
+        throw new Error(`Incorrect digest response. Expected ${expectedResponse.response} but got ${z.$response}`)
+    }
+
+    ic = {
+        id: z.$call_id,
+        sip_call_id: z.$sip_call_id,
+    }
+
+    // now we answer the call
+    sip.call.respond(ic.id, {
+        code: 200,
+        reason: 'OK',
+    })
+
+    // Then we wait for the '200 OK' at the t1 side 
+    // We will also get event 'media_update' for both sides indicating media streams (RTP) were set up successfully
+    await z.wait([
+        {
+            event: 'response',
+            call_id: oc.id,
+            method: 'INVITE',
+            msg: sip_msg({
+                $rs: '200',
+                $rr: 'OK',
+            }),
+        },
+        {
+            event: 'media_update',
+            call_id: oc.id,
+            status: 'ok',
+        },
+        {
+            event: 'media_update',
+            call_id: ic.id,
+            status: 'ok',
+        },
+    ], 1000)
+
+    sip.call.start_inband_dtmf_detection(oc.id)
+    sip.call.start_inband_dtmf_detection(ic.id)
+
+    sip.call.send_dtmf(oc.id, {digits: '1234', mode: 1})
+    sip.call.send_dtmf(ic.id, {digits: '1234', mode: 1})
+
+    await z.wait([
+        {
+            event: 'dtmf',
+            call_id: ic.id,
+            digits: '1234',
+            mode: 1,
+            media_id: 0,
+        },
+        {
+            event: 'dtmf',
+            call_id: oc.id,
+            digits: '1234',
+            mode: 1,
+            media_id: 0,
+        },
+    ], 2000)
+
+    // now we terminate the call from t1 side
+    sip.call.terminate(oc.id)
+
+    // and wait for termination events
+    await z.wait([
+        {
+            event: 'response',
+            call_id: oc.id,
+            method: 'BYE',
+            msg: sip_msg({
+                $rs: '200',
+                $rr: 'OK',
+            }),
+        },
+        {
+            event: 'call_ended',
+            call_id: oc.id,
+        },
+        {
+            event: 'call_ended',
+            call_id: ic.id,
+        },
+    ], 1000)
+
+    console.log("Success")
+
+    sip.stop()
+    process.exit(0)
+}
+
+
+test()
+.catch(e => {
+    console.error(e)
+    process.exit(1)
+})
+

package/samples/{t → speex.js}

@@ -24,8 +24,9 @@ async function test() {
     console.log("t1", t1)
     console.log("t2", t2)
 
-    console.log(sip.get_codecs())
-    sip.set_codecs("opus/48000/2:128")
+    assert(sip.get_codecs().indexOf("speex/8000/1") > 0)
+
+    sip.set_codecs("speex/8000/1:128")
 
     flags = 0
 
@@ -188,18 +189,8 @@ async function test() {
     oc_stat = JSON.parse(oc_stat)
     ic_stat = JSON.parse(ic_stat)
 
-    assert(oc_stat.CodecInfo == 'opus/8000/1')
-    assert(ic_stat.CodecInfo == 'opus/8000/1')
-
-    await z.sleep(100)
-
-    sip.call.start_inband_dtmf_detection(oc.id)
-    sip.call.start_inband_dtmf_detection(ic.id)
-
-    sip.call.send_dtmf(oc.id, {digits: '12', mode: 1})
-    sip.call.send_dtmf(ic.id, {digits: '21', mode: 1})
-
-    await z.sleep(1000)
+    assert(oc_stat.CodecInfo == 'speex/8000/1')
+    assert(ic_stat.CodecInfo == 'speex/8000/1')
 
     sip.call.stop_record_wav(oc.id)
     sip.call.stop_record_wav(ic.id)