sip-lab 1.12.38 → 1.13.0

package/samples/mrcp_and_audio.switching_order.js

@@ -0,0 +1,273 @@
+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')
+
+async function test() {
+    sip.set_log_level(9)
+
+    //sip.set_log_level(6)
+    sip.dtmf_aggregation_on(500)
+
+    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: [{type: 'mrcp'}, {type: 'audio'}]})
+
+    await z.wait([
+        {
+            event: "incoming_call",
+            call_id: m.collect("call_id"),
+        },
+        {
+            event: 'response',
+            call_id: oc.id,
+            method: 'INVITE',
+            msg: sip_msg({
+                $rs: '100',
+                $rr: 'Trying',
+                '$(hdrcnt(via))': 1,
+                '$hdr(call-id)': m.collect('sip_call_id'),
+                $fU: 'alice',
+                $fd: 'test.com',
+                $tU: 'bob',
+                '$hdr(l)': '0',
+            }),
+        },
+    ], 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: [{type: 'audio'}, {type: 'mrcp'}]})
+
+    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: 'mrcp',
+                local: {
+                  port: 9
+                },
+                remote: {
+                  port: m.collect('mrcp_server_port')
+                }
+              },
+              {
+                type: 'audio',
+                local: {
+                  port: 10000,
+                  mode: 'sendrecv'
+                },
+                remote: {
+                  port: 10002,
+                  mode: 'sendrecv'
+                }
+              },
+            ],
+        },
+        {
+            event: 'media_update',
+            call_id: ic.id,
+            status: 'ok',
+            media: [
+              {
+                type: 'mrcp',
+                local: {
+                  port: m.collect('mrcp_server_port')
+                },
+                remote: {
+                  port: 9
+                }
+              },
+              {
+                type: 'audio',
+                local: {
+                  port: 10002,
+                  mode: 'sendrecv'
+                },
+                remote: {
+                  port: 10000,
+                  mode: 'sendrecv'
+                }
+              },
+            ],
+        },
+    ], 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: 1
+        },
+        {
+            event: 'dtmf',
+            call_id: oc.id,
+            digits: '4321',
+            mode: 1,
+            media_id: 1
+        },
+    ], 1500)
+
+    for(i=0 ;i< 1; i++) {
+        //await z.sleep(100)
+        sip.call.reinvite(oc.id, {media: [{type: 'mrcp'}, {type: 'audio'}]})
+
+        await z.wait([
+            {
+                event: 'reinvite',
+                call_id: ic.id,
+            },
+        ], 500)
+
+        sip.call.respond(ic.id, {code: 200, reason: 'OK', media: [{type: 'audio'}, {type: 'mrcp'}]})
+
+        await z.wait([
+            {
+                event: 'response',
+                call_id: oc.id,
+                method: 'INVITE',
+                msg: sip_msg({
+                    $rs: '100',
+                }),
+            },
+            {
+                event: 'response',
+                call_id: oc.id,
+                method: 'INVITE',
+                msg: sip_msg({
+                    $rs: '200',
+                    $rr: 'OK',
+                    $rb: '!{_}a=sendrecv',
+                }),
+            },
+            {
+                event: 'media_update',
+                call_id: oc.id,
+                status: 'ok',
+            },
+            {
+                event: 'media_update',
+                call_id: ic.id,
+                status: 'ok',
+            },
+        ], 500)
+
+        //await z.sleep(100)
+        sip.call.reinvite(ic.id, {media: [{type: 'mrcp'}, {type: 'audio'}]})
+
+        await z.wait([
+            {
+                event: 'reinvite',
+                call_id: oc.id,
+            },
+        ], 500)
+
+        sip.call.respond(oc.id, {code: 200, reason: 'OK', media: [{type: 'audio'}, {type: 'mrcp'}]})
+
+        await z.wait([
+            {
+                event: 'response',
+                call_id: ic.id,
+                method: 'INVITE',
+                msg: sip_msg({
+                    $rs: '100',
+                }),
+            },
+            {
+                event: 'response',
+                call_id: ic.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',
+            },
+        ], 500)
+
+        //await z.sleep(100)
+    }
+
+    await z.sleep(1000) // we need this delay otherwise, frequently the app will crash after this point.
+
+    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)
+})
+

package/samples/options.js

@@ -0,0 +1,82 @@
+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 assert = require('assert')
+
+async function test() {
+    sip.set_log_level(9)
+    sip.dtmf_aggregation_on(500)
+
+    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)
+
+    var server = `${t2.address}:${t2.port}`
+    var domain = 'test1.com'
+
+    var uac_req = sip.request.create(t1.id, {
+        method: 'OPTIONS',
+        from_uri: `sip:alice@${domain}`,
+        to_uri: `sip:bob@${domain}`,
+        request_uri: `sip:bob@${t2.address}:${t2.port}`,
+        headers: {
+            'X-MyHeader1': 'aaa',
+            'X-MyHeader2': 'bbb',
+        },
+    })
+
+    await z.wait([
+        {
+            event: 'non_dialog_request',
+            request_id: m.collect('uas_req_id'),
+            msg: sip_msg({
+                $rm: 'OPTIONS',
+                $fU: 'alice',
+                $fd: domain,
+                $tU: 'bob',
+                $td: domain,
+                '$hdr(X-MyHeader1)': 'aaa',
+                'hdr_x_myheader2': 'bbb',
+            }),
+        },
+    ], 1000)
+
+    sip.request.respond(z.store.uas_req_id, {code: 200, reason: 'OK', headers: {'X-SomeHeader1': 'ccc', 'X-SomeHeader2': 'ddd'}})
+
+    await z.wait([
+        {
+            event: 'response',
+            request_id: uac_req.id,
+            method: 'OPTIONS',
+            msg: sip_msg({
+                $rs: '200',
+                $rr: 'OK',
+                hdr_x_someheader1: 'ccc',
+                hdr_x_someheader2: 'ddd',
+            }),
+        },
+    ], 1000)
+
+    console.log("Success")
+
+    sip.stop()
+}
+
+
+test()
+.catch(e => {
+    console.error(e)
+    process.exit(1)
+})
+

package/samples/refer.js

@@ -0,0 +1,247 @@
+// 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')
+
+// here we create our Zeq instance
+var z = new Zeq()
+
+
+async function test() {
+    // 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
+    })
+
+    // 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)
+
+    // make the call from t1 to t2
+    const oc = sip.call.create(t1.id, {from_uri: 'sip:alice@test.com', to_uri: `sip:bob@${t2.address}:${t2.port}`})
+
+    // 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,
+        },
+        {
+            event: 'response',
+            call_id: oc.id,
+            method: 'INVITE',
+            msg: sip_msg({
+                $rs: '100',
+                $rr: 'Trying',
+                '$(hdrcnt(via))': 1,
+                '$hdr(call-id)': m.collect('sip_call_id'),
+                $fU: 'alice',
+                $fd: 'test.com',
+                $tU: 'bob',
+                '$hdr(l)': '0',
+            }),
+        },
+    ], 1000)
+    // Details about zeq wait(list_of_events_to_wait_for, timeout_in_ms):
+    // The order of events in the list is irrelevant.
+    // What matters is that all events arrive within the specified timeout.
+    // When specifying events, you can be as detailed or succinct as you need.
+    // For example, the above event 'response' is waiting for a SIP '100 Trying' to arrive,
+    // but we are specifying things to match just to show that we can be very detailed when performing a match.
+    // But it could have been just like this:
+    //
+    //  {
+    //      event: 'response',
+    //      call_id: oc.id,
+    //      method: 'INVITE',
+    //      msg: sip_msg({
+    //          $rs: '100',
+    //      }),
+    //  }
+    // Regarding the function sip_msg() this is a special matching function provided by https://github.com/MayamaTakeshi/sip-matching that makes it 
+    // easy to match a SIP message using openser/kamailio/opensips pseudo-variables syntax.
+ 
+
+    // Here we store data for the incoming call
+    // just to organize our code (not really needed)
+    const ic = {
+        id: z.store.call_id,
+        sip_call_id: z.store.sip_call_id,
+    }
+
+    // Now we answer the call at t2 side
+    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',
+                '$(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_request(oc.id, {method: 'REFER', headers: {'Refer-To': '0312341234'}})
+
+    await z.wait([
+        {
+            event: 'request',
+            call_id: ic.id,
+            msg: sip_msg({
+                $rm: 'REFER',
+                hdr_refer_to: '0312341234',
+            }),
+        },
+    ], 1000)
+
+    sip.call.respond(ic.id, {code: 202, reason: 'Accepted'})
+
+    await z.wait([
+        {
+            event: 'response',
+            call_id: oc.id,
+            msg: sip_msg({
+                $rm: 'REFER',
+                $rs: '202',
+                $rr: 'Accepted',
+            }),
+        },
+    ], 1000)
+
+    sip.call.send_request(ic.id, {method: 'NOTIFY', headers: {
+        'Event': 'refer',
+        'Subscription-State': 'active;expires=60',
+    }, body: 'SIP/2.0 100 Trying', ct_type: 'message', ct_subtype: 'sipfrag;version=2.0'})
+
+    await z.wait([
+        {
+            event: 'request',
+            call_id: oc.id,
+            msg: sip_msg({
+                $rm: 'NOTIFY',
+                hdr_subscription_state: 'active;expires=60',
+                hdr_content_type: 'message/sipfrag;version=2.0',
+                $rb: 'SIP/2.0 100 Trying',
+            }),
+        },
+    ], 1000)
+
+    sip.call.respond(oc.id, {code: 200, reason: 'OK'})
+
+    await z.wait([
+        {
+            event: 'response',
+            call_id: ic.id,
+            msg: sip_msg({
+                $rm: 'NOTIFY',
+                $rs: '200',
+                $rr: 'OK',
+            }),
+        },
+    ], 1000)
+
+    sip.call.send_request(ic.id, {method: 'NOTIFY', headers: {'Event': 'refer',
+        'Subscription-State': 'terminated;reason=noresource',
+    }, body: 'SIP/2.0 200 OK', ct_type: 'message', ct_subtype: 'sipfrag;version=2.0'})
+
+    await z.wait([
+        {
+            event: 'request',
+            call_id: oc.id,
+            msg: sip_msg({
+                $rm: 'NOTIFY',
+                hdr_subscription_state: 'terminated;reason=noresource',
+                hdr_content_type: 'message/sipfrag;version=2.0',
+                $rb: 'SIP/2.0 200 OK',
+            }),
+        },
+    ], 1000)
+
+    sip.call.respond(oc.id, {code: 200, reason: 'OK'})
+
+    await z.wait([
+        {
+            event: 'response',
+            call_id: ic.id,
+            msg: sip_msg({
+                $rm: 'NOTIFY',
+                $rs: '200',
+                $rr: 'OK',
+            }),
+        },
+    ], 1000)
+
+    await z.sleep(100)
+
+    // 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()
+}
+
+
+test()
+.catch(e => {
+    console.error(e)
+    process.exit(1)
+})
+