sip-lab 1.14.0 → 1.15.0

package/DEV.md

@@ -48,14 +48,14 @@ 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
+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). So do this instead:
 ```
 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 --strip
+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
 ```
 
 #### Running tests

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sip-lab",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "description": "",
   "main": "index.js",
   "engines": {
@@ -30,7 +30,7 @@
     "sip-matching": "^1.5.2"
   },
   "devDependencies": {
-    "prebuildify": "^5.0.1",
+    "prebuildify": "^6.0.0",
     "prebuildify-cross": "github:MayamaTakeshi/prebuildify-cross#use_existing_images",
     "sdp-matching": "^1.3.2"
   },

package/samples/srtp.js

@@ -0,0 +1,346 @@
+// 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 sdp = require('sdp-matching')
+
+// here we create our Zeq instance
+var z = new Zeq()
+
+async function test() {
+    sip.dtmf_aggregation_on(500)
+
+    z.trap_events(sip.event_source, 'event', (evt) => {
+        var e = evt.args[0]
+        return e
+    })
+
+    // Let's ignore '100 Trying'
+    z.add_event_filter({
+        event: 'response',
+        msg: sip_msg({
+            $rs: '100',
+        }),
+    })
+
+    console.log(sip.start((data) => { console.log(data)} ))
+
+    const t1 = sip.transport.create({address: "127.0.0.1"})
+    const t2 = sip.transport.create({address: "127.0.0.1"})
+
+    console.log("t1", t1)
+    console.log("t2", t2)
+
+    const oc = sip.call.create(t1.id, {from_uri: 'sip:alice@test.com', to_uri: `sip:bob@${t2.address}:${t2.port}`,
+        media: [
+            {
+                type: 'audio',
+                secure: true,
+            },
+        ]})
+
+    await z.wait([
+        {
+            event: "incoming_call",
+            call_id: m.collect("call_id"),
+            transport_id: t2.id,
+        },
+    ], 1000)
+
+    const ic = {
+        id: z.store.call_id,
+        sip_call_id: z.store.sip_call_id,
+    }
+
+    sip.call.respond(ic.id, {code: 200, reason: 'OK', media: [
+	{
+            type: 'audio',
+	    secure: true,
+        },
+    ]})
+
+    await z.wait([
+        {
+            event: 'response',
+            call_id: oc.id,
+            method: 'INVITE',
+            msg: sip_msg({
+                $rs: '200',
+                $rr: 'OK',
+                '$(hdrcnt(VIA))': 1,
+                $fU: 'alice',
+                $fd: 'test.com',
+                $tU: 'bob',
+                '$hdr(content-type)': 'application/sdp',
+                $rb: '!{_}a=sendrecv',
+            }),
+        },
+        {
+            event: 'media_update',
+            call_id: oc.id,
+            status: 'ok',
+        },
+        {
+            event: 'media_update',
+            call_id: ic.id,
+            status: 'ok',
+        },
+    ], 1000)
+
+    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)
+
+    sip.call.reinvite(oc.id, {media: [
+	{
+            type: 'audio',
+	    secure: true,
+        },
+    ]})
+
+    await z.wait([
+        {
+            event: 'reinvite',
+            call_id: ic.id,
+        },
+    ], 500)
+
+    sip.call.respond(ic.id, {code: 200, reason: 'OK', media: [
+	{
+            type: 'audio',
+	    secure: true,
+        },
+    ]})
+
+    await z.wait([
+        {
+            event: 'response',
+            call_id: oc.id,
+            method: 'INVITE',
+            msg: sip_msg({
+                $rs: '200',
+                $rb: sdp.jsonpath_matcher({
+                    '$.media.length': [1],
+                    '$.media[*].desc.type': ['audio'],
+                    '$.media[*].desc.port': [m.nonzero],
+                    '$.media[*].desc.protocol': ['RTP/SAVP'],
+                }),
+            }),
+        },
+        {
+            event: 'media_update',
+            call_id: ic.id,
+            status: 'ok',
+            media: m.fm([
+              m.pm({
+                type: 'audio',
+		transport: 'RTP/SAVP',
+                local: {
+                  mode: 'sendrecv'
+                },
+                remote: {
+                  mode: 'sendrecv'
+                },
+                fmt: [
+                  '0 PCMU/8000',
+                  '120 telephone-event/8000'
+                ]
+              }),
+            ]),
+        },
+        {
+            event: 'media_update',
+            call_id: oc.id,
+            status: 'ok',
+            media: m.fm([
+              m.pm({
+                type: 'audio',
+		transport: 'RTP/SAVP',
+                local: {
+                  mode: 'sendrecv'
+                },
+                remote: {
+                  mode: 'sendrecv'
+                },
+                fmt: [
+                  '0 PCMU/8000',
+                  '120 telephone-event/8000'
+                ]
+              }),
+            ]),
+        },
+    ], 1000)
+
+    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)
+
+
+    sip.call.reinvite(ic.id, {media: [
+	{
+            type: 'audio',
+	    secure: true,
+        },
+    ]})
+
+    await z.wait([
+        {
+            event: 'reinvite',
+            call_id: oc.id,
+        },
+    ], 500)
+
+    sip.call.respond(oc.id, {code: 200, reason: 'OK', media: [
+	{
+            type: 'audio',
+	    secure: true,
+        },
+    ]})
+
+    await z.wait([
+        {
+            event: 'response',
+            call_id: ic.id,
+            method: 'INVITE',
+            msg: sip_msg({
+                $rs: '200',
+                $rb: sdp.jsonpath_matcher({
+                    '$.media.length': [1],
+                    '$.media[*].desc.type': ['audio'],
+                    '$.media[*].desc.port': [m.nonzero],
+                    '$.media[*].desc.protocol': ['RTP/SAVP'],
+                }),
+            }),
+        },
+        {
+            event: 'media_update',
+            call_id: oc.id,
+            status: 'ok',
+            media: m.fm([
+              m.pm({
+                type: 'audio',
+		transport: 'RTP/SAVP',
+                local: {
+                  mode: 'sendrecv'
+                },
+                remote: {
+                  mode: 'sendrecv'
+                },
+                fmt: [
+                  '0 PCMU/8000',
+                  '120 telephone-event/8000'
+                ]
+              }),
+            ]),
+        },
+        {
+            event: 'media_update',
+            call_id: ic.id,
+            status: 'ok',
+            media: m.fm([
+              m.pm({
+                type: 'audio',
+		transport: 'RTP/SAVP',
+                local: {
+                  mode: 'sendrecv'
+                },
+                remote: {
+                  mode: 'sendrecv'
+                },
+                fmt: [
+                  '0 PCMU/8000',
+                  '120 telephone-event/8000'
+                ]
+              }),
+            ]),
+        },
+    ], 1000)
+
+    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)
+
+    sip.call.terminate(oc.id)
+
+    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()
+}
+
+
+test()
+.catch(e => {
+    console.error(e)
+    process.exit(1)
+})
+

package/src/sip.cpp

@@ -384,6 +384,7 @@ struct MediaEndpoint {
   pj_str_t addr;
   int port;
   int field_count;
+  bool secure;
   char *field[MAX_ATTRS];
 
   union {
@@ -630,7 +631,7 @@ void close_media_endpoint(MediaEndpoint *me);
 
 void close_media(Call *c);
 
-bool process_media(Call *c, pjsip_dialog *dlg, Document &document);
+bool process_media(Call *c, pjsip_dialog *dlg, Document &document, bool answer);
 
 typedef pj_status_t (*audio_endpoint_stop_op_t)(Call *call, AudioEndpoint *ae);
 
@@ -685,6 +686,13 @@ const char *translate_pjsip_inv_state(int state) {
   }
 }
 
+static pj_bool_t create_transport_srtp(pjmedia_transport *med_transport, pjmedia_transport **srtp) {
+	pjmedia_srtp_setting opt;
+	pjmedia_srtp_setting_default(&opt);
+	printf("calling pjmedia_transport_srtp_create\n");
+	return pjmedia_transport_srtp_create(g_med_endpt, med_transport, &opt, srtp);
+}
+
 static int
 find_endpoint_by_inband_dtmf_media_stream(Call *call,
                                           pjmedia_stream *med_stream) {
@@ -2072,17 +2080,21 @@ int pjw_call_respond(long call_id, const char *json) {
   }
 
   if (183 == code || (code >= 200 && code < 300)) {
-    if (!process_media(call, call->inv->dlg, document)) {
-      goto out;
-    }
-
     // process_media above set call->local_sdp based on document.
 
     if (call->pending_rdata && call->pending_rdata->msg_info.msg->body &&
         call->pending_rdata->msg_info.msg->body->len) {
+      if (!process_media(call, call->inv->dlg, document, true)) {
+        goto out;
+      }
+
       status = pjsip_inv_set_sdp_answer(call->inv, call->local_sdp);
     } else {
       // delayed media. we need to sned the offer
+      if (!process_media(call, call->inv->dlg, document, false)) {
+        goto out;
+      }
+
       status = pjmedia_sdp_neg_create_w_local_offer(
           call->inv->dlg->pool, call->local_sdp, &call->inv->neg);
       if (status != PJ_SUCCESS) {
@@ -2824,7 +2836,7 @@ int call_create(Transport *t, unsigned flags, pjsip_dialog *dlg,
 
   pjmedia_sdp_session *sdp = 0;
 
-  if (!process_media(call, dlg, document)) {
+  if (!process_media(call, dlg, document, false)) {
     close_media(call);
     return -1;
   }
@@ -3117,7 +3129,7 @@ int pjw_call_reinvite(long call_id, const char *json) {
     }
   }
 
-  if (!process_media(call, inv->dlg, document)) {
+  if (!process_media(call, inv->dlg, document, false)) {
     goto out;
   }
 
@@ -4064,7 +4076,7 @@ int find_sdp_media_by_media_endpt(const pjmedia_sdp_session *sdp,
   printf("find_sdp_media_by_media_endpt %x\n", me);
   for (int i = 0; i < sdp->media_count; i++) {
     pjmedia_sdp_media *media = sdp->media[i];
-    printf("i=%d media=%x\n", i, media);
+    printf("i=%d me->port=%i media->desc.port=%i me->media=%.*s media->desc.media=%.*s\n", i, me->port, media->desc.port, me->media.slen, me->media.ptr, media->desc.media.slen, media->desc.media.ptr);
 
     if ((me->port == media->desc.port) &&
         (pj_strcmp(&me->media, &media->desc.media) == 0)) {
@@ -4116,10 +4128,10 @@ void gen_media_json(char *dest, int len, Call *call,
     if(!me->port) {
       switch (me->type) {
         case ENDPOINT_TYPE_AUDIO:
-          p += sprintf(p, "{\"type\": \"audio\", \"port\": 0}");
+          p += sprintf(p, "{\"type\": \"audio\", \"transport\": \"%.*s\", \"port\": 0}", me->transport.slen, me->transport.ptr);
           break;
         case ENDPOINT_TYPE_MRCP:
-          p += sprintf(p, "{\"type\": \"mrcp\", \"port\": 0}");
+          p += sprintf(p, "{\"type\": \"mrcp\", \"transport\": \"%.*s\", \"port\": 0}", me->transport.slen, me->transport.ptr);
           break;
         default:  
           p += sprintf(p, "{\"type\": \"unknown\", \"port\": 0}");
@@ -4151,9 +4163,10 @@ void gen_media_json(char *dest, int len, Call *call,
       pj_str_t *remote_addr = &remote_conn->addr;
 
       p += sprintf(p,
-                   "{\"type\": \"audio\", \"local\": {\"addr\": \"%.*s\", "
+                   "{\"type\": \"audio\", \"transport\": \"%.*s\", \"local\": {\"addr\": \"%.*s\", "
                    "\"port\": %d, \"mode\": \"%s\"}, \"remote\": {\"addr\": "
                    "\"%.*s\", \"port\": %d, \"mode\": \"%s\"}, \"fmt\": [",
+                   me->transport.slen, me->transport.ptr,
                    local_addr->slen, local_addr->ptr, local_media->desc.port,
                    local_mode, remote_addr->slen, remote_addr->ptr,
                    remote_media->desc.port, remote_mode);
@@ -4175,8 +4188,9 @@ void gen_media_json(char *dest, int len, Call *call,
     }
     case ENDPOINT_TYPE_MRCP: {
       p += sprintf(p,
-                   "{\"type\": \"mrcp\", \"local\": {\"port\": %d}, "
+                   "{\"type\": \"mrcp\", \"transport\": \"%.*s\", \"local\": {\"port\": %d}, "
                    "\"remote\": {\"port\": %d}}",
+                   me->transport.slen, me->transport.ptr,
                    local_sdp->media[idx]->desc.port,
                    remote_sdp->media[idx]->desc.port);
       break;
@@ -4342,13 +4356,24 @@ bool restart_media_stream(Call *call, MediaEndpoint *me,
   status = pjmedia_stream_set_dtmf_callback(ae->med_stream, &on_dtmf, call);
   if (status != PJ_SUCCESS) {
     make_evt_media_update(evt, sizeof(evt), call->id,
-                          "setup_failed (pjmedi_stream_set_dtmf_callback)", "");
+                          "setup_failed (pjmedia_stream_set_dtmf_callback)", "");
     dispatch_event(evt);
     return false;
   }
 
   /* Start the UDP media transport */
-  pjmedia_transport_media_start(ae->med_transport, 0, 0, 0, 0);
+  status = pjmedia_transport_media_start(ae->med_transport, call->inv->pool, local_sdp, remote_sdp, idx);
+  if (status != PJ_SUCCESS) {
+    printf("status=%i\n", status);
+    char err[1024];
+    pj_strerror(status, err, sizeof(err));
+    printf("pjmedia_transport_media_start status: %s\n", err);
+
+    make_evt_media_update(evt, sizeof(evt), call->id,
+                          "setup_failed (pjmedia_transport_media_start failed)", "");
+    dispatch_event(evt);
+    return false;
+  }
 
   pjmedia_port *stream_port;
   status = pjmedia_stream_get_port(ae->med_stream, &stream_port);
@@ -5827,8 +5852,36 @@ bool create_media_endpoint(Call *call, Document &document, Value &descr,
     med_endpt->type = ENDPOINT_TYPE_AUDIO;
     pj_strdup2(dlg->pool, &med_endpt->media, "audio");
     pj_strdup(dlg->pool, &med_endpt->addr, &str_addr);
-    pj_strdup2(dlg->pool, &med_endpt->transport, "RTP/AVP");
+
+    if (descr.HasMember("secure")) {
+      if (!descr["secure"].IsBool()) {
+        set_error("Parameter secure must be a boolean");
+        return false;
+      }
+      med_endpt->secure = descr["secure"].GetBool();
+    }
+    
+    if(med_endpt->secure){
+      pjmedia_transport *srtp;
+      pj_status_t status = create_transport_srtp(audio_endpt->med_transport, &srtp);
+      if(status != PJ_SUCCESS) {
+        set_error("create_transport_srtp failed");
+        return false;
+      }
+      audio_endpt->med_transport = srtp;
+
+      status = pjmedia_transport_media_create(audio_endpt->med_transport, dlg->pool, NULL, NULL, 0);
+      if(status != PJ_SUCCESS) {
+        set_error("pjmedia_transport_media_create failed"); 
+        return false;
+      }
+      pj_strdup2(dlg->pool, &med_endpt->transport, "RTP/SAVP");
+    } else {
+      pj_strdup2(dlg->pool, &med_endpt->transport, "RTP/AVP");
+    }
+
     med_endpt->port = allocated_port;
+    printf("med_endtp->port=%i\n", med_endpt->port);
     med_endpt->endpoint.audio = audio_endpt;
   } else if (strcmp("mrcp", type) == 0) {
     MrcpEndpoint *mrcp_endpt = (MrcpEndpoint *)pj_pool_zalloc(dlg->pool, sizeof(MrcpEndpoint));
@@ -6019,7 +6072,7 @@ pjmedia_sdp_media *create_sdp_media(MediaEndpoint *me, pjsip_dialog *dlg) {
   return media;
 }
 
-bool process_media(Call *call, pjsip_dialog *dlg, Document &document) {
+bool process_media(Call *call, pjsip_dialog *dlg, Document &document, bool answer) {
   printf("process_media call_id=%d\n", call->id);
 
   bool in_use_chart[PJMEDIA_MAX_SDP_MEDIA] = {false};
@@ -6099,6 +6152,17 @@ bool process_media(Call *call, pjsip_dialog *dlg, Document &document) {
   Value media = document["media"].GetArray();
   assert(media.Size() <= PJMEDIA_MAX_SDP_MEDIA);
 
+  const pjmedia_sdp_session *rem_sdp = NULL;
+  if(answer) {
+    if(call->inv && call->inv->neg) {
+      status = pjmedia_sdp_neg_get_neg_remote(call->inv->neg, &rem_sdp);
+      if(status != PJ_SUCCESS) {
+        addon_log(L_DBG, "Internal Server Error (pjmedia_sdp_neg_get_neg_remote failed)");
+        return false;
+      }
+    }
+  }
+
   for (SizeType i = 0; i < media.Size(); i++) {
     Value descr = media[i].GetObject();
 
@@ -6166,6 +6230,18 @@ bool process_media(Call *call, pjsip_dialog *dlg, Document &document) {
 
       sdp->media[sdp->media_count++] = media;
     }
+
+    if(me->secure && me->endpoint.audio) {
+      pj_status_t status = pjmedia_transport_encode_sdp(me->endpoint.audio->med_transport, dlg->pool, sdp, rem_sdp, i);
+      if(status != PJ_SUCCESS) {
+        addon_log(L_DBG, "pjmedia_transport_encode_sdp failed");
+        return false;
+      }
+
+      // The below must be done after pjmedia_transport_encode_sdp() because although at this point med_transport is a transport_srtp, it calls the transport_encode_sdp of the underlying transpor_udp and it will fail when it sees "RTP/SAVP" instead of "RTP/AVP"
+      // So we change from RTP/AVP to RTP/SAVP after we add the crypto lines.
+      pj_strdup2(dlg->pool, &sdp->media[i]->desc.transport, "RTP/SAVP");
+    }
   }
 
   call->local_sdp = sdp;

package/samples/t

@@ -1,457 +0,0 @@
-var sip = require ('../index.js')
-var Zeq = require('@mayama/zeq')
-var z = new Zeq()
-var m = require('data-matching')
-var sip_msg = require('sip-matching')
-var sdp = require('sdp-matching')
-
-async function test() {
-    sip.set_log_level(9)
-
-    //sip.set_log_level(6)
-    sip.dtmf_aggregation_on(500)
-
-    // Let's ignore '100 Trying'
-    z.add_event_filter({
-        event: 'response',
-        msg: sip_msg({
-            $rs: '100',
-        }),
-    })
-
-    z.trap_events(sip.event_source, 'event', (evt) => {
-        var e = evt.args[0]
-        return e
-    })
-
-    console.log(sip.start((data) => { console.log(data)} ))
-
-    t1 = sip.transport.create({address: "127.0.0.1", port: 5090, type: 'udp'})
-    t2 = sip.transport.create({address: "127.0.0.1", port: 5092, type: 'udp'})
-
-    console.log("t1", t1)
-    console.log("t2", t2)
-
-    oc = sip.call.create(t1.id, {from_uri: 'sip:alice@test.com', to_uri: `sip:bob@${t2.address}:${t2.port}`, media: "audio,audio"})
-
-    await z.wait([
-        {
-            event: "incoming_call",
-            call_id: m.collect("call_id"),
-        },
-    ], 1000)
-
-    ic = {
-        id: z.store.call_id,
-        sip_call_id: z.store.sip_call_id,
-    }
-
-    sip.call.respond(ic.id, {code: 200, reason: 'OK', media: "audio"})
-
-    await z.wait([
-        {
-            event: 'response',
-            call_id: oc.id,
-            method: 'INVITE',
-            msg: sip_msg({
-                $rs: '200',
-                $rr: 'OK',
-                '$(hdrcnt(VIA))': 1,
-                $fU: 'alice',
-                $fd: 'test.com',
-                $tU: 'bob',
-                '$hdr(content-type)': 'application/sdp',
-                $rb: '!{_}a=sendrecv',
-            }),
-        },
-        {
-            event: 'media_update',
-            call_id: oc.id,
-            status: 'ok',
-            media: [
-              {
-                type: 'audio',
-                local: {},
-              },
-              {
-                type: 'audio',
-                port: 0,
-              }
-            ],
-        },
-        {
-            event: 'media_update',
-            call_id: ic.id,
-            status: 'ok',
-            media: [
-              {
-                type: 'audio',
-                local: {},
-              },
-              {
-                type: 'audio',
-                port: 0,
-              }
-            ],
-        },
-    ], 1000)
-
-    sip.call.send_dtmf(oc.id, {digits: '1234', mode: 0})
-    sip.call.send_dtmf(ic.id, {digits: '4321', mode: 1})
-
-    await z.wait([
-        {
-            event: 'dtmf',
-            call_id: ic.id,
-            digits: '1234',
-            mode: 0,
-            media_id: 0
-        },
-        {
-            event: 'dtmf',
-            call_id: oc.id,
-            digits: '4321',
-            mode: 1,
-            media_id: 0
-        },
-    ], 2000)
-
-    // now reinvite with two media
-    sip.call.reinvite(oc.id, {media: "audio,audio"})
-
-    await z.wait([
-        {
-            event: 'reinvite',
-            call_id: ic.id,
-        },
-    ], 1000)
-
-    sip.call.respond(ic.id, {code: 200, reason: 'OK', media: "audio,audio"})
-
-    await z.wait([
-        {
-            event: 'response',
-            call_id: oc.id,
-            method: 'INVITE',
-            msg: sip_msg({
-                $rs: '200',
-            }),
-        },
-        {
-            event: 'media_update',
-            call_id: ic.id,
-            status: 'ok',
-            media: [
-              {
-                type: 'audio',
-                local: {
-                  mode: 'sendrecv'
-                },
-                remote: {
-                  mode: 'sendrecv'
-                },
-                fmt: [
-                  '0 PCMU/8000',
-                  '120 telephone-event/8000'
-                ]
-              },
-              {
-                type: 'audio',
-                local: {
-                  mode: 'sendrecv'
-                },
-                remote: {
-                  mode: 'sendrecv'
-                },
-                fmt: [
-                  '0 PCMU/8000',
-                  '120 telephone-event/8000'
-                ]
-              }
-            ]
-        },
-        {
-            event: 'media_update',
-            call_id: oc.id,
-            status: 'ok',
-            media: [
-              {
-                type: 'audio',
-                local: {
-                  mode: 'sendrecv'
-                },
-                remote: {
-                  mode: 'sendrecv'
-                },
-                fmt: [
-                  '0 PCMU/8000',
-                  '120 telephone-event/8000'
-                ]
-              },
-              {
-                type: 'audio',
-                local: {
-                  mode: 'sendrecv'
-                },
-                remote: {
-                  mode: 'sendrecv'
-                },
-                fmt: [
-                  '0 PCMU/8000',
-                  '120 telephone-event/8000'
-                ]
-              }
-            ]
-        },
-    ], 1000)
-
-    await z.sleep(100)
-
-    // Now change to single media
-    sip.call.reinvite(oc.id, {media: "audio"})
-
-    await z.wait([
-        {
-            event: 'reinvite',
-            call_id: ic.id,
-        },
-    ], 1000)
-
-    sip.call.respond(ic.id, {code: 200, reason: 'OK', media: "audio,audio"})
-
-    await z.wait([
-        {
-            event: 'response',
-            call_id: oc.id,
-            method: 'INVITE',
-            msg: sip_msg({
-                $rs: '200',
-            }),
-        },
-        {
-            event: 'media_update',
-            call_id: ic.id,
-            status: 'ok',
-            media: [
-              {
-                type: 'audio',
-                local: {
-                  mode: 'sendrecv'
-                },
-                remote: {
-                  mode: 'sendrecv'
-                },
-                fmt: [
-                  '0 PCMU/8000',
-                  '120 telephone-event/8000'
-                ]
-              },
-              {
-                type: 'audio',
-		port: 0,
-              },
-            ]
-        },
-        {
-            event: 'media_update',
-            call_id: oc.id,
-            status: 'ok',
-            media: [
-              {
-                type: 'audio',
-                local: {
-                  mode: 'sendrecv'
-                },
-                remote: {
-                  mode: 'sendrecv'
-                },
-                fmt: [
-                  '0 PCMU/8000',
-                  '120 telephone-event/8000'
-                ]
-              },
-              {
-                type: 'audio',
-		port: 0,
-              },
-            ]
-        },
-    ], 1000)
-
-    sip.call.send_dtmf(oc.id, {digits: '1234', mode: 0})
-    sip.call.send_dtmf(ic.id, {digits: '4321', mode: 1})
-
-    await z.wait([
-        {
-            event: 'dtmf',
-            call_id: ic.id,
-            digits: '1234',
-            mode: 0,
-            media_id: 0
-        },
-        {
-            event: 'dtmf',
-            call_id: oc.id,
-            digits: '4321',
-            mode: 1,
-            media_id: 0
-        },
-    ], 1500)
-
-    // now switch back to two media
-    sip.call.reinvite(oc.id, {media: "audio,audio"})
-
-    await z.wait([
-        {
-            event: 'reinvite',
-            call_id: ic.id,
-        },
-    ], 1000)
-
-    sip.call.respond(ic.id, {code: 200, reason: 'OK', media: "audio,audio"})
-
-    await z.wait([
-        {
-            event: 'response',
-            call_id: oc.id,
-            method: 'INVITE',
-            msg: sip_msg({
-                $rs: '200',
-            }),
-        },
-        {
-            event: 'media_update',
-            call_id: ic.id,
-            status: 'ok',
-            media: [
-              {
-                type: 'audio',
-                local: {
-                  mode: 'sendrecv'
-                },
-                remote: {
-                  mode: 'sendrecv'
-                },
-                fmt: [
-                  '0 PCMU/8000',
-                  '120 telephone-event/8000'
-                ]
-              },
-              {
-                type: 'audio',
-                local: {
-                  mode: 'sendrecv'
-                },
-                remote: {
-                  mode: 'sendrecv'
-                },
-                fmt: [
-                  '0 PCMU/8000',
-                  '120 telephone-event/8000'
-                ]
-              }
-            ]
-        },
-        {
-            event: 'media_update',
-            call_id: oc.id,
-            status: 'ok',
-            media: [
-              {
-                type: 'audio',
-                local: {
-                  mode: 'sendrecv'
-                },
-                remote: {
-                  mode: 'sendrecv'
-                },
-                fmt: [
-                  '0 PCMU/8000',
-                  '120 telephone-event/8000'
-                ]
-              },
-              {
-                type: 'audio',
-                local: {
-                  mode: 'sendrecv'
-                },
-                remote: {
-                  mode: 'sendrecv'
-                },
-                fmt: [
-                  '0 PCMU/8000',
-                  '120 telephone-event/8000'
-                ]
-              }
-            ]
-        },
-    ], 1000)
-
-    sip.call.send_dtmf(oc.id, {digits: '1234', mode: 0})
-    sip.call.send_dtmf(ic.id, {digits: '4321', mode: 1})
-
-    await z.wait([
-        {
-            event: 'dtmf',
-            call_id: ic.id,
-            digits: '1234',
-            mode: 0,
-            media_id: 0
-        },
-        {
-            event: 'dtmf',
-            call_id: oc.id,
-            digits: '4321',
-            mode: 1,
-            media_id: 0
-        },
-        {
-            event: 'dtmf',
-            call_id: ic.id,
-            digits: '1234',
-            mode: 0,
-            media_id: 1
-        },
-        {
-            event: 'dtmf',
-            call_id: oc.id,
-            digits: '4321',
-            mode: 1,
-            media_id: 1
-        },
-    ], 2000)
-
-    sip.call.terminate(oc.id)
-
-    await z.wait([
-        {
-            event: 'call_ended',
-            call_id: oc.id,
-        },
-        {
-            event: 'call_ended',
-            call_id: ic.id,
-        },
-        {
-            event: 'response',
-            call_id: oc.id,
-            method: 'BYE',
-            msg: sip_msg({
-                $rs: '200',
-                $rr: 'OK',
-            }),
-        },
-    ], 1000)
-
-    console.log("Success")
-
-    sip.stop()
-}
-
-
-test()
-.catch(e => {
-    console.error(e)
-    process.exit(1)
-})
-