drachtio-srf 4.4.61 → 4.4.64

package/lib/dialog.js

@@ -4,7 +4,7 @@ const only = require('only') ;
 const methods = require('sip-methods') ;
 const debug = require('debug')('drachtio:srf') ;
 const SipError = require('./sip_error');
-const { parseUri } = require('drachtio-sip').parser ;
+const { parseUri } = require('./sip-parser/parser');
 const sdpTransform = require('sdp-transform');
 
 
@@ -12,7 +12,7 @@ const sdpTransform = require('sdp-transform');
  * Class representing a SIP Dialog.
  *
  * Note that instances of this class are not created directly by your code;
- * rather they are returned from the {@link Srf#createUAC}, {@link Srf#createUAC}, and {@link Srf#createB2BUA}
+ * rather they are returned from the {@link Srf#createUAC}, {@link Srf#createUAS}, and {@link Srf#createB2BUA}
  * @class
  * @extends EventEmitter
  */
@@ -34,6 +34,7 @@ class Dialog extends Emitter {
     this.type = type ;
     this.req = opts.req ;
     this.res = opts.res ;
+    this.auth = opts.auth;
     this.agent = this.res.agent ;
     this.onHold = false ;
     this.connected = true ;
@@ -171,7 +172,12 @@ class Dialog extends Emitter {
    * or NOTIFY (in the case of SUBSCRIBE)
    * @param {Object} [opts] configuration options
    * @param {Object} [opts.headers] SIP headers to add to the outgoing BYE or NOTIFY
-   * @param  {function} [callback] if provided, callback with signature <code>(err, msg)</code>
+   * @param {Object|Function} [opts.auth] sip credentials to use if challenged,
+   * or a function invoked with (req, res) and returning (err, username, password) where req is the
+   * request that was sent and res is the response that included the digest challenge
+   * @param {string} [opts.auth.username] sip username
+   * @param {string} [opts.auth.password] sip password
+   * @param {function} [callback] if provided, callback with signature <code>(err, msg)</code>
    * that provides the BYE or NOTIFY message that was sent to terminate the dialog
    * @return {Promise|Dialog} if no callback is supplied, otherwise a reference to the Dialog
    */
@@ -183,18 +189,29 @@ class Dialog extends Emitter {
     }
     this.queuedRequests = [];
 
+    const removeDialog = (err, res, callback) => {
+      this.connected = false ;
+      this.srf.removeDialog(this) ;
+      callback(err, res) ;
+      this.removeAllListeners();
+    };
+
     const __x = (callback) => {
       if (this.dialogType === 'INVITE') {
         this.agent.request({
           method: 'BYE',
           headers: opts.headers || {},
           stackDialogId: this.id,
+          auth: opts.auth || this.auth,
           _socket: this.socket
         }, (err, bye) => {
-          this.connected = false ;
-          this.srf.removeDialog(this) ;
-          callback(err, bye) ;
-          this.removeAllListeners();
+          if (err || !bye) {
+            return removeDialog(err, bye, callback);
+          }
+
+          bye.on('response', () => {
+            removeDialog(err, bye, callback);
+          });
         }) ;
         if (this._emitter) {
           Object.assign(this._state, {state: 'terminated'});
@@ -212,10 +229,7 @@ class Dialog extends Emitter {
           stackDialogId: this.id,
           _socket: this.socket
         }, (err, notify) => {
-          this.connected = false ;
-          this.srf.removeDialog(this) ;
-          callback(err, notify) ;
-          this.removeAllListeners();
+          removeDialog(err, notify, callback);
         }) ;
       }
     };
@@ -309,7 +323,7 @@ class Dialog extends Emitter {
           stackDialogId: this.id,
           body: this.local.sdp,
           _socket: this.socket,
-          headers: 
+          headers:
             opts.headers ? opts.headers : {'Contact': this.local.contact}
         }, (err, req) => {
           if (err) {
@@ -367,6 +381,11 @@ class Dialog extends Emitter {
    * @param {string} opts.method - SIP method to use for the request
    * @param {Object} [opts.headers] - SIP headers to apply to the request
    * @param {string} [opts.body] - body of the SIP request
+   * @param {Object|Function} [opts.auth] sip credentials to use if challenged,
+   * or a function invoked with (req, res) and returning (err, username, password) where req is the
+   * request that was sent and res is the response that included the digest challenge
+   * @param {string} [opts.auth.username] sip username
+   * @param {string} [opts.auth.password] sip password
    * @param {function} [callback]  - callback invoked with signature <code>(err, req)</code>
    * when operation has completed
    * @return {Promise|Dialog} if no callback is supplied a Promise that resolves to the response received,
@@ -383,7 +402,7 @@ class Dialog extends Emitter {
         method: method,
         stackDialogId: this.id,
         headers: opts.headers || {},
-        auth: opts.auth,
+        auth: opts.auth || this.auth,
         _socket: this.socket,
         body: opts.body
       }, (err, req) => {

package/lib/drachtio-agent.js

@@ -2,7 +2,7 @@ const Emitter = require('events');
 const debug = require('debug')('drachtio:agent');
 const debugSocket = require('debug')('drachtio:socket');
 const WireProtocol = require('./wire-protocol') ;
-const SipMessage = require('drachtio-sip').SipMessage ;
+const SipMessage = require('./sip-parser/message');
 const Request = require('./request') ;
 const Response = require('./response') ;
 const DigestClient = require('./digest-client') ;
@@ -658,6 +658,10 @@ class DrachtioAgent extends Emitter {
                 this.pendingSipAuthTxnIdUpdate.set(res.req.stackTxnId, {});
                 const client = new DigestClient(res) ;
                 client.authenticate((err, req) => {
+                  if (!req) {
+                    sr.req.emit('response', res, ack);
+                    return;
+                  }
                   // move all listeners from the old request to the new one we just generated
                   res.req.listeners('response').forEach((l) => { req.on('response', l) ; }) ;
                   res.req.emit('authenticate', req) ;

package/lib/request.js

@@ -1,9 +1,9 @@
 const Emitter = require('events').EventEmitter ;
-const sip = require('drachtio-sip') ;
 const delegate = require('delegates') ;
 const assert = require('assert') ;
 const noop = require('node-noop').noop;
 const debug = require('debug')('drachtio:request');
+const SipMessage = require('./sip-parser/message');
 
 class Request extends Emitter {
 
@@ -11,7 +11,7 @@ class Request extends Emitter {
     super() ;
 
     if (msg) {
-      assert(msg instanceof sip.SipMessage) ;
+      assert(msg instanceof SipMessage) ;
       this.msg = msg ;
       this.meta = meta ;
     }
@@ -148,7 +148,7 @@ class Request extends Emitter {
           //add a new response to the array
           const address = meta.address ;
           const port = +meta.port;
-          const msg = new sip.SipMessage(rawMsg) ;
+          const msg = new SipMessage(rawMsg) ;
           const obj = {
             time: meta.time,
             status: msg.status,

package/lib/response.js

@@ -1,17 +1,17 @@
 const Emitter = require('events').EventEmitter ;
-const sip = require('drachtio-sip') ;
 const delegate = require('delegates') ;
 const status_codes = require('sip-status') ;
 const only = require('only') ;
 const noop = require('node-noop').noop;
 const assert = require('assert') ;
 const debug = require('debug')('drachtio:response');
+const SipMessage = require('./sip-parser/message') ;
 class Response extends Emitter {
 
   constructor(agent) {
     super() ;
     this._agent = agent ;
-    this.msg = new sip.SipMessage() ;
+    this.msg = new SipMessage() ;
     this.finished = false ;
   }
 

package/lib/sip-parser/message.js

@@ -0,0 +1,103 @@
+const only = require('only') ;
+const parser = require('./parser') ;
+
+class SipMessage {
+  constructor(msg) {
+
+    this.headers = {};
+
+    if (msg) {
+      if (typeof msg === 'string') {
+        this.raw = msg ;
+        const obj = parser.parseSipMessage(msg, true) ;
+        if (!obj) throw new Error('failed to parse sip message');
+        msg = obj;
+      }
+      Object.assign(this.headers, msg.headers || {});
+      Object.assign(this, only(msg, 'body method version status reason uri payload'));
+    }
+  }
+
+  get type() {
+    if (this.method) return 'request' ;
+    else if (this.status) return 'response' ;
+  }
+
+  get calledNumber() {
+    const user = this.uri.match(/sips?:(.*?)@/) ;
+    if (user && user.length > 1) {
+      return user[1].split(';')[0] ;
+    }
+    return '' ;
+  }
+
+  get callingNumber() {
+    const header = this.has('p-asserted-identity') ? this.get('p-asserted-identity') : this.get('from') ;
+    const user  = header.match(/sips?:(.*?)@/) ;
+    if (user && user.length > 1) {
+      return user[1].split(';')[0] ;
+    }
+    return '' ;
+  }
+
+  get callingName() {
+    const header = this.has('p-asserted-identity') ? this.get('p-asserted-identity') : this.get('from') ;
+    const user  = header.match(/^\"(.+)\"\s*<sips?:.+@/);
+    if (user && user.length > 1) {
+      return user[1];
+    }
+    return '';
+  }
+
+  get canFormDialog() {
+    return ('INVITE' === this.method || 'SUBSCRIBE' === this.method) && !this.get('to').tag ;
+  }
+
+  set(hdr, value) {
+    const hdrs = {} ;
+    if (typeof hdr === 'string') hdrs[hdr] = value ;
+    else {
+      Object.assign(hdrs, hdr);
+    }
+
+    Object.keys(hdrs).forEach((key) => {
+      const name = parser.getHeaderName(key) ;
+      const newValue = hdrs[key] ;
+      let v = '' ;
+      if (name in this.headers) {
+        v += this.headers[name] ;
+        v += ',' ;
+      }
+      v += newValue ;
+      this.headers[name] = v;
+    });
+
+    return this ;
+  }
+
+  get(hdr) {
+    if (this.has(hdr)) { return this.headers[parser.getHeaderName(hdr)] ; }
+  }
+
+  has(hdr) {
+    const name = parser.getHeaderName(hdr) ;
+    return name in this.headers ;
+  }
+
+  getParsedHeader(hdr) {
+    const name = parser.getHeaderName(hdr) ;
+    const v =  this.headers[name] ;
+    const fn = parser.getParser(hdr.toLowerCase()) ;
+    return fn({s:v, i:0}) ;
+  }
+
+  toString() {
+    return parser.stringifySipMessage(this) ;
+  }
+
+}
+
+SipMessage.parseUri = parser.parseUri ;
+
+
+exports = module.exports = SipMessage ;

package/lib/sip-parser/parser.js

@@ -0,0 +1,426 @@
+
+exports = module.exports = {
+  parseSipMessage: parseMessage,
+  stringifySipMessage: stringify,
+  stringifyUri: stringifyUri,
+  parseUri: parseUri,
+  getParser: function(hdr) {
+    return parsers[hdr] || parseGenericHeader ;
+  },
+  getStringifier: function(hdr) {
+    return stringifiers[hdr];
+  },
+  getHeaderName: getHeaderName
+} ;
+
+const headerNames = {
+  'call-id': 'Call-ID',
+  'content-length': 'Content-Length'
+} ;
+
+const customHeaderNames = [
+  'Diversion'
+] ;
+
+function getHeaderName(hdr) {
+  if (0 === hdr.indexOf('X-') ||
+    (0 === hdr.indexOf('P-') && 0 !== hdr.indexOf('P-Asserted')) ||
+    -1 !== customHeaderNames.indexOf(hdr)) return hdr ;
+  const name = unescape(hdr).toLowerCase();
+  return compactForm[name] || name;
+}
+
+function parseResponse(rs, m) {
+  const r = rs.match(/^SIP\/(\d+\.\d+)\s+(\d+)\s*(.*)\s*$/);
+
+  if (r) {
+    m.version = r[1];
+    m.status = +r[2];
+    m.reason = r[3];
+
+    return m;
+  }
+}
+
+function parseRequest(rq, m) {
+  const r = rq.match(/^([\w\-.!%*_+`'~]+)\s([^\s]+)\sSIP\s*\/\s*(\d+\.\d+)/);
+
+  if (r) {
+    m.method = unescape(r[1]);
+    m.uri = r[2];
+    m.version = r[3];
+
+    return m;
+  }
+}
+
+function applyRegex(regex, data) {
+  regex.lastIndex = data.i;
+  const r = regex.exec(data.s);
+
+  if (r && (r.index === data.i)) {
+    data.i = regex.lastIndex;
+    return r;
+  }
+}
+
+function parseParams(data, hdr) {
+  hdr.params = hdr.params || {};
+
+  const re = /\s*;\s*([\w\-.!%*_+`'~]+)(?:\s*=\s*([\w\-.!%*_+`'~]+|"[^"\\]*(\\.[^"\\]*)*"))?/g;
+
+  for (let r = applyRegex(re, data); r; r = applyRegex(re, data)) {
+    hdr.params[r[1].toLowerCase()] = r[2];
+  }
+
+  return hdr;
+}
+
+function parseMultiHeader(parser, d, h) {
+  h = h || [];
+
+  const re = /\s*,\s*/g;
+  do {
+    h.push(parser(d));
+  } while (d.i < d.s.length && applyRegex(re, d));
+
+  return h;
+}
+
+function parseGenericHeader(d, h) {
+  return h ? h + ',' + d.s : d.s;
+}
+
+function parseAOR(data) {
+  // eslint-disable-next-line max-len
+  const r = applyRegex(/((?:[\w\-.!%*_+`'~]+)(?:\s+[\w\-.!%*_+`'~]+)*|"[^"\\]*(?:\\.[^"\\]*)*")?\s*\<\s*([^>]*)\s*\>|((?:[^\s@"<]@)?[^\s;]+)/g, data);
+  return parseParams(data, {name: r[1], uri: r[2] || r[3] || ''});
+}
+
+function parseAorWithUri(data) {
+  const r = parseAOR(data);
+  r.uri = parseUri(r.uri);
+  return r;
+}
+
+function parseVia(data) {
+  const r = applyRegex(/SIP\s*\/\s*(\d+\.\d+)\s*\/\s*([\S]+)\s+([^\s;:]+)(?:\s*:\s*(\d+))?/g, data);
+  return parseParams(data, {version: r[1], protocol: r[2], host: r[3], port: r[4] && +r[4]});
+}
+
+function parseCSeq(d) {
+  const r = /(\d+)\s*([\S]+)/.exec(d.s);
+  return { seq: +r[1], method: unescape(r[2]) };
+}
+
+function parseAuthHeader(d) {
+  const r1 = applyRegex(/([^\s]*)\s+/g, d);
+  const a = {scheme: r1[1]};
+
+  let r2 = applyRegex(/([^\s,"=]*)\s*=\s*([^\s,"]+|"[^"\\]*(?:\\.[^"\\]*)*")\s*/g, d);
+  a[r2[1]] = r2[2];
+
+  while (r2 = applyRegex(/,\s*([^\s,"=]*)\s*=\s*([^\s,"]+|"[^"\\]*(?:\\.[^"\\]*)*")\s*/g, d)) {
+    a[r2[1]] = r2[2];
+  }
+
+  return a;
+}
+
+function parseAuthenticationInfoHeader(d) {
+  const a = {};
+  let r = applyRegex(/([^\s,"=]*)\s*=\s*([^\s,"]+|"[^"\\]*(?:\\.[^"\\]*)*")\s*/g, d);
+  a[r[1]] = r[2];
+
+  while (r = applyRegex(/,\s*([^\s,"=]*)\s*=\s*([^\s,"]+|"[^"\\]*(?:\\.[^"\\]*)*")\s*/g, d)) {
+    a[r[1]] = r[2];
+  }
+  return a;
+}
+
+const compactForm = {
+  i: 'call-id',
+  m: 'contact',
+  e: 'contact-encoding',
+  l: 'content-length',
+  c: 'content-type',
+  f: 'from',
+  s: 'subject',
+  k: 'supported',
+  t: 'to',
+  v: 'via'
+};
+
+const parsers = {
+  'to': parseAOR,
+  'from': parseAOR,
+  'contact': function(v, h) {
+    if (v == '*')
+      return v;
+    else
+      return parseMultiHeader(parseAOR, v, h);
+  },
+  'route': parseMultiHeader.bind(0, parseAorWithUri),
+  'record-route': parseMultiHeader.bind(0, parseAorWithUri),
+  'path': parseMultiHeader.bind(0, parseAorWithUri),
+  'cseq': parseCSeq,
+  'content-length': function(v) { return +v.s; },
+  'via': parseMultiHeader.bind(0, parseVia),
+  'www-authenticate': parseMultiHeader.bind(0, parseAuthHeader),
+  'proxy-authenticate': parseMultiHeader.bind(0, parseAuthHeader),
+  'authorization': parseMultiHeader.bind(0, parseAuthHeader),
+  'proxy-authorization': parseMultiHeader.bind(0, parseAuthHeader),
+  'authentication-info': parseAuthenticationInfoHeader,
+  'refer-to': parseAOR,
+  'referred-by': parseAOR,
+  'p-asserted-identity': parseAOR,
+  'remote-party-id': parseAOR
+};
+
+
+function parse(data, lazy) {
+  data = data.split(/\r\n(?![ \t])/);
+
+  if (data[0] === '')
+    return;
+
+  const m = {};
+
+  if (!(parseResponse(data[0], m) || parseRequest(data[0], m)))
+    return;
+
+  m.headers = {};
+
+  for (let i = 1; i < data.length; ++i) {
+    const r = data[i].match(/^([\S]*?)\s*:\s*([\s\S]*)$/);
+    if (!r) {
+      return;
+    }
+
+    const name = getHeaderName(r[1]) ;
+    const fnParse = parsers[name] || parseGenericHeader ;
+
+    if (lazy === true) {
+      let v = '' ;
+      if (name in m.headers) {
+        v += m.headers[name] ;
+        v += ',' ;
+      }
+      v += r[2] ;
+      m.headers[name] = v ;
+    }
+    else {
+      m.headers[name] = fnParse({s:r[2], i:0}, m.headers[name]) ;
+    }
+  }
+
+  return m;
+}
+
+function parseUri(s) {
+  if (typeof s === 'object')
+    return s;
+
+  // eslint-disable-next-line max-len
+  //const re = /^(sips?):(?:([^\s>:@]+)(?::([^\s@>]+))?@)?([\w\-\.]+)(?::(\d+))?((?:;[^\s=\?>;]+(?:=[^\s?\;]+)?)*)(?:\?(([^\s&=>]+=[^\s&=>]+)(&[^\s&=>]+=[^\s&=>]+)*))?$/;
+  // eslint-disable-next-line max-len
+  const re = /^(sips?):(?:([^\s>:@]+)(?::([^\s@>]+))?@)?(?:(|(?:\[.*\])|(?:[0-9A-Za-z\-_]+\.)+[0-9A-Za-z\-_]+)|(?:\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}))(?::(\d+))?((?:;[^\s=\?>;]+(?:=[^\s?\;]+)?)*)(?:\?(([^\s&=>]+=[^\s&=>]+)(&[^\s&=>]+=[^\s&=>]+)*))?$/;
+
+  const r = re.exec(s);
+
+  if (r) {
+    return {
+      family: /\[.*\]/.test(r[4]) ? 'ipv6' : 'ipv4',
+      scheme: r[1],
+      user: r[2],
+      password: r[3],
+      host: r[4],
+      port: +r[5],
+      params: (r[6].match(/([^;=]+)(=([^;=]+))?/g) || [])
+        .map(function(s) { return s.split('='); })
+        .reduce(function(params, x) { params[x[0]] = x[1] || null; return params;}, {}),
+      headers: ((r[7] || '').match(/[^&=]+=[^&=]+/g) || [])
+        .map(function(s) { return s.split('='); })
+        .reduce(function(params, x) { params[x[0]] = x[1]; return params; }, {})
+    } ;
+  }
+}
+
+function stringifyVersion(v) {
+  return v || '2.0';
+}
+
+function stringifyParams(params) {
+  let s = '';
+  for (const n in params) {
+    s += ';' + n + (params[n] ? '=' + params[n] : '');
+  }
+
+  return s;
+}
+
+function stringifyUri(uri) {
+  if (typeof uri === 'string')
+    return uri;
+
+  let s = (uri.scheme || 'sip') + ':';
+
+  if (uri.user) {
+    if (uri.password)
+      s += uri.user + ':' + uri.password + '@';
+    else
+      s += uri.user + '@';
+  }
+
+  s += uri.host;
+
+  if (uri.port)
+    s += ':' + uri.port;
+
+  if (uri.params)
+    s += stringifyParams(uri.params);
+
+  if (uri.headers) {
+    const h = Object.keys(uri.headers).map(function(x) { return x + '=' + uri.headers[x];}).join('&');
+    if (h.length) s += '?' + h;
+  }
+  return s;
+}
+
+function stringifyAOR(aor) {
+  return (aor.name || '') + ' <' + stringifyUri(aor.uri) + '>' + stringifyParams(aor.params);
+}
+
+function stringifyAuthHeader(a) {
+  const s = [];
+
+  for (const n in a) {
+    if (n !== 'scheme' && a[n] !== undefined) {
+      s.push(n + '=' + a[n]);
+    }
+  }
+
+  return a.scheme ? a.scheme + ' ' + s.join(',') : s.join(',');
+}
+
+exports.stringifyAuthHeader = stringifyAuthHeader;
+
+const stringifiers = {
+  via: function(h) {
+    return h.map(function(via) {
+      return 'Via: SIP/' + stringifyVersion(via.version) + '/' + via.protocol.toUpperCase() + ' ' +
+      via.host + (via.port ? ':' + via.port : '') + stringifyParams(via.params) + '\r\n';
+    }).join('');
+  },
+  to: function(h) {
+    return 'To: ' + stringifyAOR(h) + '\r\n';
+  },
+  from: function(h) {
+    return 'From: ' + stringifyAOR(h) + '\r\n';
+  },
+  contact: function(h) {
+    return 'Contact: ' + ((h !== '*' && h.length) ? h.map(stringifyAOR).join(', ') : '*') + '\r\n';
+  },
+  route: function(h) {
+    return h.length ? 'Route: ' + h.map(stringifyAOR).join(', ') + '\r\n' : '';
+  },
+  'record-route': function(h) {
+    return h.length ? 'Record-Route: ' + h.map(stringifyAOR).join(', ') + '\r\n' : '';
+  },
+  'path': function(h) {
+    return h.length ? 'Path: ' + h.map(stringifyAOR).join(', ') + '\r\n' : '';
+  },
+  cseq: function(cseq) {
+    return 'CSeq: ' + cseq.seq + ' ' + cseq.method + '\r\n';
+  },
+  'www-authenticate': function(h) {
+    return h.map(function(x) { return 'WWW-Authenticate: ' + stringifyAuthHeader(x) + '\r\n'; }).join('');
+  },
+  'proxy-authenticate': function(h) {
+    return h.map(function(x) { return 'Proxy-Authenticate: ' + stringifyAuthHeader(x) + '\r\n'; }).join('');
+  },
+  'authorization': function(h) {
+    return h.map(function(x) { return 'Authorization: ' + stringifyAuthHeader(x) + '\r\n'; }).join('');
+  },
+  'proxy-authorization': function(h) {
+    return h.map(function(x) { return 'Proxy-Authorization: ' + stringifyAuthHeader(x) + '\r\n'; }).join('');
+  },
+  'authentication-info': function(h) {
+    return 'Authentication-Info: ' + stringifyAuthHeader(h) + '\r\n';
+  },
+  'refer-to': function(h) { return 'Refer-To: ' + stringifyAOR(h) + '\r\n'; }
+};
+
+function stringify(m) {
+  let s;
+  if (m.status) {
+    s = 'SIP/' + stringifyVersion(m.version) + ' ' + m.status + ' ' + m.reason + '\r\n';
+  }
+  else {
+    s = m.method + ' ' + stringifyUri(m.uri) + ' SIP/' + stringifyVersion(m.version) + '\r\n';
+  }
+
+  m.headers['content-length'] = (m.body || '').length;
+
+  for (const n in m.headers) {
+    if (typeof m.headers[n] === 'string' || !stringifiers[n])
+      s += (headerNames[n] || n) + ': ' + m.headers[n] + '\r\n';
+    else
+      s += stringifiers[n](m.headers[n].parsed, n);
+  }
+
+  s += '\r\n';
+
+  if (m.body)
+    s += m.body;
+
+  return s;
+}
+
+
+function parseMessage(s, lazy) {
+  const r = s.toString('utf8').split('\r\n\r\n');
+  if (r) {
+    const m = parse(r[0], lazy);
+    if (m) {
+      r.shift() ;
+      if (m.headers['content-length']) {
+        const body = 1 === r.length ? r[0] : r.join('\r\n\r\n') ;
+        const c = Math.max(0, Math.min(m.headers['content-length'], Buffer.byteLength(body, 'utf8')));
+        m.body = body.substring(0, c);
+      }
+      else {
+        m.body = r[0];
+      }
+      m.payload = [] ;
+
+      let arr ;
+      if (r.length > 1 &&
+        m.headers['content-type'] &&
+        -1 !== m.headers['content-type'].indexOf('multipart/') &&
+        (arr = /.*;\s*boundary=\"?(.*?)\"?$/.exec(m.headers['content-type']))) {
+
+        const segments = m.body.split('--' + arr[1]  + '\r\n');
+        if (0 === segments[0].length) {
+          segments.shift() ;
+        }
+        for (let i = 0; i < segments.length; i++) {
+          const ct = /Content-Type:\s*(.*)\r\n/.exec(segments[i]) ;
+          const stanzas = segments[i].split('\r\n\r\n') ;
+          m.payload.push({
+            type: ct ? ct[1] : null,
+            content: stanzas[1]
+          });
+        }
+      }
+      else {
+        m.payload.push({
+          type: m.headers['content-type'],
+          content: m.body
+        }) ;
+      }
+
+      return m;
+    }
+  }
+}

package/lib/srf.js

@@ -3,7 +3,7 @@ const Dialog = require('./dialog') ;
 const assert = require('assert') ;
 const Emitter = require('events') ;
 const delegate = require('delegates') ;
-const parser = require('drachtio-sip').parser ;
+const parser = require('./sip-parser/parser');
 const methods = require('sip-methods') ;
 const SipError = require('./sip_error') ;
 const async = require('async') ;
@@ -557,7 +557,7 @@ class Srf extends Emitter {
                       return new Promise((resolve) => {
                         ack({body: localSdp}) ;
 
-                        const dialog = new Dialog(this, 'uac', {req: req, res: res}) ;
+                        const dialog = new Dialog(this, 'uac', {req: req, res: res, auth: opts.auth}) ;
                         dialog.local.sdp = localSdp ;
                         this.addDialog(dialog) ;
                         resolve(dialog) ;
@@ -582,7 +582,7 @@ class Srf extends Emitter {
 
               if ((200 === res.status && method === 'INVITE') ||
                   ((202 === res.status || 200 === res.status) && method === 'SUBSCRIBE')) {
-                const dialog = new Dialog(this, 'uac', {req: req, res: res}) ;
+                const dialog = new Dialog(this, 'uac', {req: req, res: res, auth: opts.auth}) ;
                 if (req._dialogState) {
                   dialog.stateEmitter = {
                     emitter: opts.dialogStateEmitter,
@@ -1670,7 +1670,7 @@ class Srf extends Emitter {
   }
 
   static get SipMessage() {
-    return require('drachtio-sip').SipMessage;
+    return require('./sip-parser/message');
   }
 
   static get SipRequest() {

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "drachtio-srf",
-  "version": "4.4.61",
+  "version": "4.4.64",
   "description": "drachtio signaling resource framework",
   "main": "lib/srf.js",
   "scripts": {
     "test": "NODE_ENV=test node test/ ",
     "coverage": "./node_modules/.bin/nyc --reporter html --report-dir ./coverage npm run test",
+    "unittests": "./node_modules/.bin/mocha ./test/unit-tests/",
     "jslint": "eslint lib"
   },
   "engines": {
@@ -26,7 +27,6 @@
     "debug": "^3.2.7",
     "delegates": "^0.1.0",
     "deprecate": "^1.1.1",
-    "drachtio-sip": "^0.6.3",
     "node-noop": "0.0.1",
     "only": "0.0.2",
     "sdp-transform": "^2.14.1",
@@ -40,7 +40,10 @@
     "config": "^3.3.3",
     "eslint": "^7.18.0",
     "eslint-plugin-promise": "^4.2.1",
+    "mocha": "^9.2.0",
     "nyc": "^15.1.0",
+    "should": "^13.2.3",
+    "sip-message-examples": "0.0.6",
     "tape": "^5.2.2"
   }
 }

package/test/docker-compose-testbed.yaml

@@ -150,3 +150,14 @@ services:
     networks:
       testbed:
         ipv4_address: 172.29.0.23
+
+  sipp-uas-bye-with-auth:
+    image: drachtio/sipp:latest
+    command: sipp -sf /tmp/uas-bye-with-auth.xml
+    container_name: sipp-uas-bye-with-auth
+    volumes:
+      - ./scenarios:/tmp
+    tty: true
+    networks:
+      testbed:
+        ipv4_address: 172.29.0.24

package/test/index.js

@@ -1,9 +1,21 @@
-require('./docker_start');
-require('./b2b');
-require('./reinvite-tests');
-require('./uac');
-require('./uas');
-require('./proxy');
-require('./utils');
-require('./refer');
-require('./docker_stop');
+const exec = require('child_process').exec;
+
+console.log('Run unit tests');
+
+exec('"npm" run unittests', (err, stdout, stderr) => {
+    console.log(stdout);
+
+    console.log('Run integration tests');
+
+    require('./docker_start');
+    require('./b2b');
+    require('./reinvite-tests');
+    require('./uac');
+    require('./uas');
+    require('./proxy');
+    require('./utils');
+    require('./refer');
+    require('./docker_stop');
+});
+
+

package/test/parser.js

@@ -0,0 +1,8 @@
+const test = require('tape') ;
+const exec = require('child_process').exec ;
+
+test('testing parser functions', (t) => {
+  const Srf = require('..');
+  const {parseUri} = Srf;
+  t.ok(typeof parseUri === 'function');
+});

package/test/scenarios/uas-bye-with-auth.xml

@@ -0,0 +1,164 @@
+<?xml version="1.0" encoding="ISO-8859-1" ?>
+<!DOCTYPE scenario SYSTEM "sipp.dtd">
+
+<!-- This program is free software; you can redistribute it and/or      -->
+<!-- modify it under the terms of the GNU General Public License as     -->
+<!-- published by the Free Software Foundation; either version 2 of the -->
+<!-- License, or (at your option) any later version.                    -->
+<!--                                                                    -->
+<!-- This program is distributed in the hope that it will be useful,    -->
+<!-- but WITHOUT ANY WARRANTY; without even the implied warranty of     -->
+<!-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the      -->
+<!-- GNU General Public License for more details.                       -->
+<!--                                                                    -->
+<!-- You should have received a copy of the GNU General Public License  -->
+<!-- along with this program; if not, write to the                      -->
+<!-- Free Software Foundation, Inc.,                                    -->
+<!-- 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA             -->
+<!--                                                                    -->
+<!--                 Sipp default 'uas' scenario.                       -->
+<!--                                                                    -->
+
+<scenario name="Basic UAS responder">
+  <!-- By adding rrs="true" (Record Route Sets), the route sets         -->
+  <!-- are saved and used for following messages sent. Useful to test   -->
+  <!-- against stateful SIP proxies/B2BUAs.                             -->
+  <recv request="INVITE" crlf="true">
+  </recv>
+
+  <send>
+    <![CDATA[
+
+      SIP/2.0 100 Trying
+      [last_Via:]
+      [last_From:]
+      [last_To:]
+      [last_Call-ID:]
+      [last_CSeq:]
+      Content-Length: 0
+
+    ]]>
+  </send>
+
+  <send retrans="500">
+    <![CDATA[
+
+      SIP/2.0 407 Proxy Authentication Required
+      [last_Via:]
+      [last_From:]
+      [last_To:];tag=[pid]SIPpTag01[call_number]
+      [last_Call-ID:]
+      [last_CSeq:]
+      Proxy-Authenticate: Digest realm="local", nonce="4cdbb733645816512687270b83d2ae5d11e4d9d8"
+      Content-Length: 0
+
+    ]]>
+  </send>
+
+  <recv request="ACK"
+        rtd="true"
+        crlf="true">
+  </recv>
+
+  <recv request="INVITE" crlf="true">
+    <action>
+      <ereg regexp=".*" search_in="hdr" header="Proxy-Authorization:" assign_to="1" />
+    </action>
+  </recv>
+
+  <send>
+    <![CDATA[
+
+      SIP/2.0 180 Ringing
+      [last_Via:]
+      [last_From:]
+      [last_To:];tag=[pid]SIPpTag01[call_number]
+      [last_Call-ID:]
+      [last_CSeq:]
+      Subject:[$1]
+      Content-Length: 0
+
+    ]]>
+  </send>
+
+  <send retrans="500">
+    <![CDATA[
+
+      SIP/2.0 200 OK
+      [last_Via:]
+      [last_From:]
+      [last_To:];tag=[pid]SIPpTag01[call_number]
+      [last_Call-ID:]
+      [last_CSeq:]
+      Contact: <sip:[local_ip]:[local_port];transport=[transport]>
+      Content-Type: application/sdp
+      Content-Length: [len]
+
+      v=0
+      o=user1 53655765 2353687637 IN IP[local_ip_type] [local_ip]
+      s=-
+      c=IN IP[media_ip_type] [media_ip]
+      t=0 0
+      m=audio [media_port] RTP/AVP 0
+      a=rtpmap:0 PCMU/8000
+
+    ]]>
+  </send>
+
+  <recv request="ACK"
+        optional="true"
+        rtd="true"
+        crlf="true">
+  </recv>
+  <recv request="BYE">
+  </recv>
+
+  <send retrans="500">
+    <![CDATA[
+
+      SIP/2.0 407 Proxy Authentication Required
+      [last_Via:]
+      [last_From:]
+      [last_To:];tag=[pid]SIPpTag01[call_number]
+      [last_Call-ID:]
+      [last_CSeq:]
+      Proxy-Authenticate: Digest realm="local", nonce="4cdbb733645816512687270b83d2ae5d11e4d9d8"
+      Content-Length: 0
+
+    ]]>
+  </send>
+  
+  <recv request="BYE">
+   <action>
+      <ereg regexp=".*" search_in="hdr" header="Proxy-Authorization:" assign_to="1" />
+    </action>
+  </recv>
+
+  <send>
+    <![CDATA[
+
+      SIP/2.0 200 OK
+      [last_Via:]
+      [last_From:]
+      [last_To:]
+      [last_Call-ID:]
+      [last_CSeq:]
+      Contact: <sip:[local_ip]:[local_port];transport=[transport]>
+      Content-Length: 0
+
+    ]]>
+  </send>
+
+  <!-- Keep the call open for a while in case the 200 is lost to be     -->
+  <!-- able to retransmit it if we receive the BYE again.               -->
+  <timewait milliseconds="4000"/>
+
+
+  <!-- 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/uac.js

@@ -10,7 +10,7 @@ process.on('unhandledRejection', (reason, p) => {
 function connect(srf) {
   return new Promise((resolve, reject) => {
     srf.connect(config.get('drachtio-sut'));
-    srf.on('connect', () => { resolve();});
+    srf.on('connect', () => { resolve(); });
   });
 }
 
@@ -40,7 +40,7 @@ test('UAC', (t) => {
         headers: {
           To: 'sip:dhorton@sip.drachtio.org',
           From: 'sip:dhorton@sip.drachtio.org'
-        }, 
+        },
         followRedirects: true,
         keepUriOnRedirect: true
       });
@@ -60,7 +60,7 @@ test('UAC', (t) => {
         }
       });
     })
-  .then((uac) => {
+    .then((uac) => {
       srf.disconnect();
       return t.pass('Srf#createUAC returns a Promise that resolves with the uac dialog');
     })
@@ -94,52 +94,52 @@ test('UAC', (t) => {
     })
     .then(() => {
       return srf.createUAC('sip:sipp-uas', {
-          method: 'INVITE',
-          callingNumber: '12345',
-          headers: {
-            'Subject': 'sending Contact based on callingNumber'
-          }
-        });
+        method: 'INVITE',
+        callingNumber: '12345',
+        headers: {
+          'Subject': 'sending Contact based on callingNumber'
+        }
+      });
     })
     .then((uac) => uac.destroy())
     .then(() => {
       srf.disconnect();
       return t.pass('Srf#createUAC accepts opts.callingNumber');
     })
-    
+
     .then(() => {
       srf = new Srf();
       return connect(srf);
     })
     .then(() => {
       return srf.createUAC('sip:sipp-uas', {
-          method: 'INVITE',
-          callingNumber: '12345',
-          headers: {
-            'Subject': 'sending explicit Contact',
-            'Contact': 'sip:foo@localhost'
-          }
-        });
+        method: 'INVITE',
+        callingNumber: '12345',
+        headers: {
+          'Subject': 'sending explicit Contact',
+          'Contact': 'sip:foo@localhost'
+        }
+      });
     })
     .then((uac) => uac.destroy())
     .then(() => {
       srf.disconnect();
       return t.pass('Srf#createUAC accepts opts.callingNumber');
     })
-    
+
     .then(() => {
       srf = new Srf();
       return connect(srf);
     })
     .then(() => {
       return srf.createUAC('sip:sipp-uas', {
-          method: 'INVITE',
-          callingNumber: '12345',
-          headers: {
-            'Subject': 'sending explicit contact',
-            'contact': 'sip:foo@localhost'
-          }
-        });
+        method: 'INVITE',
+        callingNumber: '12345',
+        headers: {
+          'Subject': 'sending explicit contact',
+          'contact': 'sip:foo@localhost'
+        }
+      });
     })
     .then((uac) => uac.destroy())
     .then(() => {
@@ -215,6 +215,29 @@ test('UAC', (t) => {
       srf.disconnect();
       return t.pass('Srf#createUAC can handle digest authentication');
     })
+    .then(() => {
+      srf = new Srf();
+      return connect(srf);
+    })
+    .then(() => {
+      return srf.createUAC('sip:172.29.0.24', {
+        method: 'INVITE',
+        headers: {
+          To: 'sip:dhorton@sip.drachtio.org',
+          From: 'sip:dhorton@sip.drachtio.org'
+        },
+        auth: {
+          username: 'foo',
+          password: 'bar'
+        }
+      });
+    })
+    .then((uac) => {
+      return uac.destroy().then(() => {
+        srf.disconnect();
+        return t.pass('Srf#createUAC can handle bye with digest authentication');
+      });
+    })
 
     .then(() => {
       srf = new Srf();
@@ -266,15 +289,15 @@ test('UAC', (t) => {
             password: 'bar'
           }
         })
-        .then((req) => {
-          req.on('response', (res) => {
-            if (res.status === 200) return resolve();
-            reject(new Error(`REGISTER was rejected after auth with ${res.status}`));
+          .then((req) => {
+            req.on('response', (res) => {
+              if (res.status === 200) return resolve();
+              reject(new Error(`REGISTER was rejected after auth with ${res.status}`));
+            });
+          })
+          .catch((err) => {
+            t.end(err, 'Srf#request returns a Promise');
           });
-        })
-        .catch((err) => {
-          t.end(err, 'Srf#request returns a Promise');
-        });
       });
     })
     .then((uac) => {
@@ -301,15 +324,15 @@ test('UAC', (t) => {
             password: 'bar'
           }
         })
-        .then((req) => {
-          req.on('response', (res) => {
-            if (res.status === 200) return resolve();
-            reject(new Error(`REGISTER was rejected after auth with ${res.status}`));
+          .then((req) => {
+            req.on('response', (res) => {
+              if (res.status === 200) return resolve();
+              reject(new Error(`REGISTER was rejected after auth with ${res.status}`));
+            });
+          })
+          .catch((err) => {
+            t.end(err, 'srf.request accepts opts.uri');
           });
-        })
-        .catch((err) => {
-          t.end(err, 'srf.request accepts opts.uri');
-        });
       });
     })
     .then((uac) => {
@@ -364,7 +387,7 @@ test('UAC', (t) => {
           cbRequest: (err, req) => inviteSent = req,
           cbProvisional: (response) => {
             if (response.status < 200) {
-              inviteSent.cancel({headers: {'Reason': 'SIP;cause=200;text="Call completed elsewhere"'}});
+              inviteSent.cancel({ headers: { 'Reason': 'SIP;cause=200;text="Call completed elsewhere"' } });
             }
           }
         }, (err, dlg) => {
@@ -386,4 +409,4 @@ test('UAC', (t) => {
       t.error(err);
     });
 
-  });
+});

package/test/unit-tests/parser.js

@@ -0,0 +1,150 @@
+require('assert');
+require('mocha');
+require('should');
+
+const assert = require('assert');
+const examples = require('sip-message-examples');
+const SipMessage = require('../../lib/sip-parser/message');
+const parser = require('../../lib/sip-parser/parser');
+const parseUri = parser.parseUri;
+const Srf = require('../..');
+assert.ok(typeof parseUri === 'function');
+assert.ok(typeof Srf.parseUri === 'function');
+console.log(`typeof parseUri is ${typeof parseUri}`);
+console.log(`typeof Srf.parseUri is ${typeof Srf.parseUri}`);
+
+describe('Parser', function () {
+  it('should provide headers as string values', function () {
+    var msg = new SipMessage(examples('invite'));
+    (typeof msg.get('from')).should.eql('string');
+  });
+  it('should optionally provide a parsed header', function () {
+    var msg = new SipMessage(examples('invite'));
+    var obj = msg.getParsedHeader('from');
+    obj.should.be.type('object');
+    obj.should.have.property('uri');
+  });
+
+  it('getting a header should return the same value provided to set', function () {
+    var msg = new SipMessage();
+    msg.set('From', '<sip:daveh@localhost>;tag=1234');
+    msg.get('From').should.eql('<sip:daveh@localhost>;tag=1234');
+  });
+  it('setting a header should be case insensitive', function () {
+    var msg = new SipMessage();
+    msg.set('from', '<sip:daveh@localhost>;tag=1234');
+    msg.get('From').should.eql('<sip:daveh@localhost>;tag=1234');
+  });
+  it('getting a header should be case insensitive', function () {
+    var msg = new SipMessage();
+    msg.set('From', '<sip:daveh@localhost>;tag=1234');
+    msg.get('from').should.eql('<sip:daveh@localhost>;tag=1234');
+  });
+  it('should parse multiple headers into an array', function () {
+    var msg = new SipMessage(examples('invite'));
+    var via = msg.getParsedHeader('via');
+    via.should.be.an.array;
+    via.should.have.length(2);
+  });
+  it('should coalesce multiple calls to set', function () {
+    var msg = new SipMessage();
+    msg.set('via', 'SIP/2.0/UDP 10.1.10.101;branch=z9hG4bKac619477600');
+    msg.set('via', 'SIP/2.0/UDP 10.1.10.103;branch=z9hG4bKac619477603');
+    var via = msg.getParsedHeader('via');
+    via.should.be.an.array;
+    via.should.have.length(2);
+    parser.getStringifier('via')([via[1]]).should.eql('Via: SIP/2.0/UDP 10.1.10.103;branch=z9hG4bKac619477603\r\n');
+  });
+  it('should set multiple headers at once', function () {
+    var msg = new SipMessage();
+    msg.set({
+      to: '<sip:5753606@10.1.10.1>',
+      i: '619455480112200022407@10.1.10.101'
+    });
+    msg.get('call-id').should.eql('619455480112200022407@10.1.10.101');
+    msg.get('to').should.eql('<sip:5753606@10.1.10.1>');
+  })
+  it('should parse an invite request', function () {
+
+    var msg = new SipMessage(examples('invite'));
+    (msg.getParsedHeader('from').uri === null).should.be.false;
+    msg.type.should.eql('request');
+    (msg.body === null).should.be.false;
+    msg.canFormDialog.should.be.true;
+  });
+  it('should parse compact headers', function () {
+
+    var msg = new SipMessage(examples('invite-compact'));
+    msg.getParsedHeader('from').should.be.an.object;
+    msg.getParsedHeader('to').should.be.an.object;
+    msg.getParsedHeader('via').should.be.an.array;
+  });
+  it('should parse a response', function () {
+    var msg = new SipMessage(examples('200ok'));
+    msg.type.should.eql('response');
+    (msg.body === null).should.be.false;
+  });
+  it('should parse called number', function () {
+    var msg = new SipMessage(examples('invite'));
+    msg.calledNumber.should.eql('5753606');
+  });
+  it('should parse calling number', function () {
+    var msg = new SipMessage(examples('invite'));
+    msg.callingNumber.should.eql('4083084809');
+  });
+  it('should parse ipv4 dot decimal sip uri', function () {
+    var uri = parseUri('sip:104461@10.1.0.100:61219;rinstance=39ccb7d8db4387b1;transport=tcp');
+    uri.family.should.eql('ipv4');
+    uri.host.should.eql('10.1.0.100');
+    uri.port.should.eql(61219);
+  });
+  it('should parse ipv4 hostname sip uri', function () {
+    var uri = parseUri('sip:104461@foo.bar.com:61219;rinstance=39ccb7d8db4387b1;transport=tcp');
+    uri.family.should.eql('ipv4');
+    uri.host.should.eql('foo.bar.com');
+    uri.port.should.eql(61219);
+  });
+  it('should parse ipv6 sip uri', function () {
+    var uri = parseUri('sip:104461@[2601:182:cd00:d4c6:604b:16f1:3f5a:44f8]:61219;rinstance=39ccb7d8db4387b1;transport=tcp');
+    uri.family.should.eql('ipv6');
+    uri.host.should.eql('[2601:182:cd00:d4c6:604b:16f1:3f5a:44f8]');
+    uri.port.should.eql(61219);
+  });
+  it('should parse a sip uri with a dash or underscore', function () {
+    var uri = parseUri('sip:116751x0@cor10-san.sip.phone.com');
+    uri.family.should.eql('ipv4');
+    uri.host.should.eql('cor10-san.sip.phone.com');
+    uri.user.should.eql('116751x0');
+  });
+  it('should parse a sips uri', function () {
+    var uri = parseUri('sips:116751x0@cor10-san.sip.phone.com');
+    uri.family.should.eql('ipv4');
+    uri.host.should.eql('cor10-san.sip.phone.com');
+    uri.user.should.eql('116751x0');
+    uri.scheme.should.eql('sips');
+  });
+  it('should parse a multi-part header', function () {
+    var msg = new SipMessage(examples('siprec'));
+    msg.payload.length.should.eql(2);
+  });
+  it('should parse a multi-part header with whitespace before boundary', function () {
+    var msg = new SipMessage(examples('siprec2'));
+    msg.payload.length.should.eql(2);
+  });
+  it('should parse a multi-part header with quoted boundary', function () {
+    var msg = new SipMessage(examples('siprec3'));
+    msg.payload.length.should.eql(2);
+  });
+  it('should parse a sip uri with a dash or underscore', function () {
+    var uri = parseUri('sip:service@test_sipp-uas_1.com');
+    uri.family.should.eql('ipv4');
+    uri.host.should.eql('test_sipp-uas_1.com');
+  });
+  it('should parse calling name', function () {
+    var msg = new SipMessage();
+    msg.set('From', '"Dave" <sip:daveh@localhost>;tag=1234');
+    msg.get('From').should.eql('"Dave" <sip:daveh@localhost>;tag=1234');
+    msg.callingName.should.eql('Dave');
+  });
+});
+