drachtio-srf 5.0.26 → 5.0.27

package/lib/srf.js

@@ -587,6 +587,35 @@ class Srf extends Emitter {
                         resolve(dialog);
                       });
                     },
+                    // teardown for the case where the caller (e.g. createB2BUA)
+                    // needs to abandon this answered-but-not-yet-acked B leg:
+                    // ACK the 200 OK (echoing the remote answer back as our
+                    // offer to complete the transaction) then BYE the dialog.
+                    // Without this the un-acked 200 OK is retransmitted by the
+                    // far end and the B-leg dialog leaks.
+                    destroy: async() => {
+                      try {
+                        // NOTE: if the caller reaches destroy() after the ack()
+                        // closure above already sent an ACK (e.g. ackFunction
+                        // rejected on the no-Contact path *after* ack'ing), this
+                        // sends a second ACK. Duplicate ACKs are tolerated by
+                        // the far end, so this is harmless. The common failure
+                        // path (localSdpB/localSdpA throwing before ackFunction
+                        // runs) reaches here having sent no ACK at all.
+                        ack({body: res.body});
+                        if (!res.has('Contact')) {
+                          // cannot form in-dialog BYE without a Contact; the
+                          // ACK above is the best we can do to release it.
+                          return;
+                        }
+                        const dialog = new Dialog(this, 'uac', {req, res, auth: opts.auth});
+                        dialog.local.sdp = res.body;
+                        this.addDialog(dialog);
+                        await dialog.destroy().catch(() => {});
+                      } catch(err) {
+                        debug(`createUAC: error tearing down 3pcc B leg: ${err}`);
+                      }
+                    },
                     res
                   });
                 }
@@ -1118,14 +1147,28 @@ class Srf extends Emitter {
         if (is3pcc) {
           debug('createB2BUA: successfully created UAS..but this is 3pcc, so a bit more work to do');
           uas.once('ack', async(ackRequest) => {
-            debug(`createB2BUA: got ACK from UAS, pass on sdp: ${ackRequest.body}`);
-            const sdp = await (typeof opts.localSdpB === 'function' ?
-              opts.localSdpB(ackRequest.body) : Promise.resolve(ackRequest.body));
-            uac = await ackFunction(sdp);
-            uac.other = uas;
-            uas.other = uac;
-            debug('createB2BUA: successfully created bot dialogs in 3pcc!');
-            return callback(null, {uac, uas});  // successfully connected!  resolve promise with both dialogs
+            // this handler runs after __x has already returned, so any throw
+            // here escapes the createB2BUA promise chain and would become an
+            // unhandled rejection. catch it, tear both legs down, and route
+            // the error back to the caller's callback (which rejects the
+            // returned promise).
+            try {
+              debug(`createB2BUA: got ACK from UAS, pass on sdp: ${ackRequest.body}`);
+              const sdp = await (typeof opts.localSdpB === 'function' ?
+                opts.localSdpB(ackRequest.body) : Promise.resolve(ackRequest.body));
+              uac = await ackFunction(sdp);
+              uac.other = uas;
+              uas.other = uac;
+              debug('createB2BUA: successfully created bot dialogs in 3pcc!');
+              return callback(null, {uac, uas});  // successfully connected!  resolve promise with both dialogs
+            } catch(err) {
+              debug({err}, 'createB2BUA: failed finalizing 3pcc dialogs on ACK');
+              if (uac && typeof uac.destroy === 'function') {
+                Promise.resolve(uac.destroy()).catch(() => {});
+              }
+              uas.destroy().catch(() => {});
+              return callback(err);
+            }
           });
           return;
         }
@@ -1140,21 +1183,49 @@ class Srf extends Emitter {
         return callback(null, {uac, uas});  // successfully connected!  resolve promise with both dialogs
       } catch(err) {
         debug({err}, 'createB2BUA: failed creating UAS..done!');
-        uac && uac.destroy().catch(() => {});  // failed A leg after success on B: tear down B
+        // failed A leg after success on B: tear down B.
+        // in normal mode `uac` is a Dialog; in 3pcc/no-offer mode it is the
+        // {sdp, ack, res, destroy} object from createUAC (the real dialog is
+        // not created until the A-leg ACK). both expose destroy(), which for
+        // the 3pcc object ACKs then BYEs the answered B leg so it is released
+        // rather than leaked. the typeof guard is retained for safety in case
+        // uac is ever some other shape.
+        if (uac && typeof uac.destroy === 'function') {
+          Promise.resolve(uac.destroy()).catch(() => {});
+        }
         return callback(err);
       }
     };
 
+    // wrap the callback so __x can invoke it exactly once; a late async throw
+    // routed through .catch() must not double-invoke it.
+    const once = (cb) => {
+      let called = false;
+      return (...args) => {
+        if (called) return;
+        called = true;
+        return cb(...args);
+      };
+    };
+
     if (callback) {
-      __x(callback);
+      const cb = once(callback);
+      // __x is async; if it throws after returning (e.g. a cleanup failure or
+      // a throw in the detached 3pcc ack handler) surface it through the
+      // callback instead of leaking a process-level unhandledRejection.
+      __x(cb).catch((err) => cb(err));
       return this;
     }
 
     return new Promise((resolve, reject) => {
-      __x((err, dialogs) => {
+      const settle = once((err, dialogs) => {
         if (err) return reject(err);
         resolve(dialogs);
       });
+      // __x is async; if it throws after the callback path (e.g. a cleanup
+      // failure), surface it as a promise rejection to the caller's
+      // try/catch instead of leaking a process-level unhandledRejection.
+      __x(settle).catch(settle);
     });
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drachtio-srf",
-  "version": "5.0.26",
+  "version": "5.0.27",
   "description": "drachtio signaling resource framework",
   "main": "lib/srf.js",
   "types": "lib/@types/index.d.ts",

package/test/b2b.js

@@ -1,5 +1,6 @@
 const test = require('tape');
-const { output, sippUac } = require('./sipp')('test_testbed');
+const { output, sippUac, sippUas } = require('./sipp')('test_testbed');
+const { matchesUacDestroyCrash } = require('./scripts/crash-signatures');
 const B2b = require('./scripts/b2b');
 const debug = require('debug')('drachtio:test');
 
@@ -390,6 +391,59 @@ test('B2B', (t) => {
       });
     })
 
+    // 3PCC no-offer INVITE where UAS leg fails after B leg succeeds.
+    // Regression test for `uac.destroy is not a function` crash: the
+    // cleanup path must reject cleanly instead of throwing a TypeError
+    // that escapes as an unhandledRejection and crashes the worker.
+    //
+    // It ALSO pins the B-leg teardown: the sipp-uas scenario (uas.xml)
+    // sends 200 OK then requires ACK + BYE before it completes with exit 0.
+    // If createB2BUA failed to tear down the answered B leg (the residual
+    // leak), sipp-uas would never see the ACK/BYE and time out -> the
+    // sippUasB probe below rejects and this test fails.
+    .then(() => {
+      debug('starting sipp');
+      let sawCrashSignature = false;
+      // the bug surfaces as a process-level unhandledRejection (the promise
+      // wrapper around __x does not catch async throws); a correct fix
+      // surfaces it, if at all, as an app-side error event.
+      const onError = (err) => { if (matchesUacDestroyCrash(err)) sawCrashSignature = true; };
+      const onRejection = (reason) => { if (matchesUacDestroyCrash(reason)) sawCrashSignature = true; };
+      b2b.on('error', onError);
+      process.on('unhandledRejection', onRejection);
+      b2b.expect3pccUasFailure('sip:sipp-uas-b-teardown');
+      // start the B-leg UAS probe: it answers 200 OK and REQUIRES the
+      // subsequent ACK + BYE (from createB2BUA's 3pcc teardown) to succeed.
+      const sippUasB = sippUas('uas.xml', 'sipp-uas-b-teardown');
+      // give the UAS container a moment to start listening before the A-leg
+      // INVITE triggers the B-leg INVITE towards it.
+      return new Promise((resolve) => setTimeout(resolve, 1500))
+        .then(() => sippUac('uac-3pcc-nosdp.xml'))
+        .catch(() => {})  // A-leg gets a 480; its own exit code is not the assertion
+        .then(() => new Promise((resolve) => setTimeout(resolve, 250)))  // let any late rejection surface
+        .then(() => {
+          b2b.removeListener('error', onError);
+          process.removeListener('unhandledRejection', onRejection);
+          if (sawCrashSignature) {
+            throw new Error('createB2BUA leaked `uac.destroy is not a function` on 3pcc UAS failure');
+          }
+          // the B-leg UAS must have received ACK + BYE (proving teardown).
+          return sippUasB;
+        });
+    })
+    .then(() => {
+      return t.pass('b2b 3pcc UAS failure does not crash and tears down the B leg');
+    })
+    .then(() => {
+      b2b.disconnect();
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          b2b = new B2b();
+          resolve();
+        }, 100);
+      });
+    })
+
     // very fast reinvite from B, before ACK from A
     .then(() => {
       debug('starting sipp');

package/test/scenarios/uac-3pcc-nosdp.xml

@@ -0,0 +1,78 @@
+<?xml version="1.0" encoding="ISO-8859-1" ?>
+<!DOCTYPE scenario SYSTEM "sipp.dtd">
+
+<!--                                                                    -->
+<!-- 3PCC / no-offer UAC scenario.                                      -->
+<!--                                                                    -->
+<!-- Sends an INVITE with NO SDP body (Content-Length: 0).  This forces -->
+<!-- drachtio-srf createB2BUA down the 3PCC (no-offer) path, where the  -->
+<!-- B-leg UAC dialog is not finalized until the A-leg ACK carries the  -->
+<!-- answer SDP.                                                        -->
+<!--                                                                    -->
+<!-- Used to reproduce the `uac.destroy is not a function` crash: when  -->
+<!-- the UAS leg fails AFTER the B leg has produced its {ack, res}      -->
+<!-- object, the createB2BUA cleanup path calls uac.destroy() on an     -->
+<!-- object that has no destroy() method.                               -->
+<!--                                                                    -->
+
+<scenario name="3PCC no-offer UAC">
+  <send retrans="500">
+    <![CDATA[
+
+      INVITE sip:[service]@[remote_ip]:[remote_port] SIP/2.0
+      Via: SIP/2.0/[transport] [local_ip]:[local_port];branch=[branch]
+      From: sipp <sip:sipp@[local_ip]:[local_port]>;tag=[pid]SIPpTag00[call_number]
+      To: [service] <sip:[service]@[remote_ip]:[remote_port]>
+      Call-ID: [call_id]
+      CSeq: 1 INVITE
+      Contact: sip:sipp@[local_ip]:[local_port]
+      Max-Forwards: 70
+      Subject: uac-3pcc-nosdp
+      Content-Length: 0
+
+    ]]>
+  </send>
+
+  <recv response="100" optional="true">
+  </recv>
+
+  <recv response="180" optional="true">
+  </recv>
+
+  <recv response="183" optional="true">
+  </recv>
+
+  <!-- Because the UAS leg fails, the B2BUA app rejects and sends a 480  -->
+  <!-- failure final response to the A leg.  The important assertion     -->
+  <!-- (worker did not crash on uac.destroy) is made on the drachtio-srf -->
+  <!-- application side; here we simply complete the transaction.        -->
+  <recv response="480" rtd="true">
+  </recv>
+
+  <!-- ACK the non-2xx final response to complete the INVITE            -->
+  <!-- transaction (RFC 3261 - ACK for a failure response uses the same -->
+  <!-- branch/CSeq as the INVITE).                                      -->
+  <send>
+    <![CDATA[
+
+      ACK sip:[service]@[remote_ip]:[remote_port] SIP/2.0
+      [last_Via]
+      From: sipp <sip:sipp@[local_ip]:[local_port]>;tag=[pid]SIPpTag00[call_number]
+      To: [service] <sip:[service]@[remote_ip]:[remote_port]>[peer_tag_param]
+      Call-ID: [call_id]
+      CSeq: 1 ACK
+      Contact: sip:sipp@[local_ip]:[local_port]
+      Max-Forwards: 70
+      Subject: uac-3pcc-nosdp
+      Content-Length: 0
+
+    ]]>
+  </send>
+
+  <!-- definition of the response time repartition table (unit is ms)   -->
+  <ResponseTimeRepartition value="10, 20, 30, 40, 50, 100, 150, 200"/>
+
+  <!-- definition of the call length repartition table (unit is ms)     -->
+  <CallLengthRepartition value="10, 50, 100, 500, 1000, 5000, 10000"/>
+
+</scenario>

package/test/scripts/b2b.js

@@ -2,6 +2,7 @@ const Emitter = require('events');
 const Srf = require('../..');
 const config = require('config');
 const debug = require('debug')('drachtio:test');
+const { matchesUacDestroyCrash } = require('./crash-signatures');
 
 class App extends Emitter {
   constructor() {
@@ -106,6 +107,58 @@ class App extends Emitter {
     });
   }
 
+  // Shared invite -> createB2BUA scaffold used by the expect* helpers.
+  // onConnected(dialogs, req, res) runs on success; onFailure(err, req, res)
+  // runs on rejection. Removes the duplicated invite/createB2BUA/then/catch
+  // boilerplate from each caller.
+  _inviteB2BUA(uri, opts, {onConnected, onFailure} = {}) {
+    this.srf.invite((req, res) => {
+      this.srf.createB2BUA(req, res, uri, opts)
+        .then((dialogs) => {
+          if (onConnected) return onConnected(dialogs, req, res);
+          this.emit('connected', dialogs);
+        })
+        .catch((err) => {
+          if (onFailure) return onFailure(err, req, res);
+          throw err;
+        });
+    });
+  }
+
+  // Reproduces the `uac.destroy is not a function` crash.
+  //
+  // The A leg INVITE arrives with no SDP, so createB2BUA takes the 3PCC
+  // (no-offer) path.  The B leg UAC succeeds and returns a {ack, res}
+  // object (NOT a finalized dialog).  We then force the UAS leg to fail
+  // by supplying a localSdpA function that throws.  This drives execution
+  // into the createB2BUA catch block while `uac` is still the {ack, res}
+  // object, exercising the guarded uac.destroy() cleanup.
+  //
+  // Before the fix this threw a synchronous TypeError inside the catch,
+  // which surfaced as an unhandledRejection and crashed the worker.
+  // After the fix the promise rejects cleanly and this onFailure runs.
+  expect3pccUasFailure(uri) {
+    this._inviteB2BUA(uri, {
+      localSdpA: () => {
+        throw new Error('simulated SDP/route processing failure on UAS leg');
+      }
+    }, {
+      onConnected: () => {
+        this.emit('error', new Error('unexpected dialog success - expected UAS leg failure'));
+      },
+      onFailure: (err, req, res) => {
+        debug(`expect3pccUasFailure: got expected error ${err}`);
+        if (matchesUacDestroyCrash(err)) {
+          // the original bug leaked back to the app as a rejection
+          this.emit('error', err);
+          return;
+        }
+        this.emit('failed', err);
+        if (!res.finalResponseSent) res.send(480);
+      }
+    });
+  }
+
   immediateReinviteFromB(uri) {
     this.srf.invite((req, res) => {
 

package/test/scripts/crash-signatures.js

@@ -0,0 +1,15 @@
+// Single source of truth for the crash signature the 3pcc regression test
+// watches for. Referenced by both the app-side helper (scripts/b2b.js) and
+// the test assertion (b2b.js) so the two cannot drift out of sync.
+//
+// NOTE: this matches on the V8 TypeError wording. The underlying defect is
+// "uac was the {ack,res} 3pcc object, not a Dialog", so if a future engine
+// rewords the message this regex must be updated here (one place).
+const UAC_DESTROY_CRASH = /uac\.destroy is not a function/;
+
+const matchesUacDestroyCrash = (reason) => {
+  const message = typeof reason === 'string' ? reason : reason && reason.message;
+  return UAC_DESTROY_CRASH.test(message || '');
+};
+
+module.exports = { UAC_DESTROY_CRASH, matchesUacDestroyCrash };

package/test/sipp.js

@@ -25,7 +25,6 @@ obj.output = () => {
 };
 
 obj.sippUac = (file) => {
-  const cmd = 'docker';
   const args = [
     'run', '--rm', '--net', `${network}`,
     '-v', `${__dirname}/scenarios:/tmp/scenarios`,
@@ -38,9 +37,29 @@ obj.sippUac = (file) => {
   ];
 
   clearOutput();
+  return runSipp(args);
+};
+
+// Run a sipp UAS as a named, DNS-resolvable container on the test network so
+// the SUT can route a B-leg INVITE to `sip:<containerName>`. Resolves when the
+// scenario completes (exit 0), e.g. uas.xml requires INVITE -> 200 -> ACK -> BYE,
+// so a resolved promise proves the B leg was answered AND torn down.
+obj.sippUas = (file, containerName) => {
+  const args = [
+    'run', '--rm', '--net', `${network}`, '--name', `${containerName}`,
+    '-v', `${__dirname}/scenarios:/tmp/scenarios`,
+    'drachtio/sipp', 'sipp', '-sf', `/tmp/scenarios/${file}`,
+    '-m', '1',
+    '-nostdin'
+    // no target host: UAS listens for incoming calls
+  ];
+
+  return runSipp(args);
+};
 
+function runSipp(args) {
   return new Promise((resolve, reject) => {
-    const child_process = spawn(cmd, args, {stdio: ['inherit', 'pipe', 'pipe']});
+    const child_process = spawn('docker', args, {stdio: ['inherit', 'pipe', 'pipe']});
 
     child_process.on('exit', (code, signal) => {
       if (code === 0) {
@@ -54,12 +73,10 @@ obj.sippUac = (file) => {
     });
 
     child_process.stdout.on('data', (data) => {
-      //debug(`stdout: ${data}`);
       addOutput(data.toString());
     });
-    child_process.stdout.on('data', (data) => {
-      //debug(`stdout: ${data}`);
+    child_process.stderr.on('data', (data) => {
       addOutput(data.toString());
     });
   });
-};
+}