drachtio-srf 4.5.31 → 4.5.32

package/lib/@types/index.d.ts

@@ -1,69 +1,143 @@
 declare module 'drachtio-srf' {
     import { Socket } from 'net';
     import { EventEmitter } from 'events';
-  
+
     type SipMethod = 'ACK' | 'BYE' | 'CANCEL' | 'INFO' | 'INVITE' | 'MESSAGE' | 'NOTIFY' | 'OPTIONS' | 'PRACK' | 'PUBLISH' | 'REFER' | 'REGISTER' | 'SUBSCRIBE' | 'UPDATE';
-  
+    type SipMessageHeaders = Record<string, string>;
+    type AOR = { name: string; uri: string; params?: Record<string, any>; };
+
     export interface SrfConfig {
       apiSecret?: string;
       host?: string;
       port?: number;
       secret?: string;
     }
-  
+
+    export function parseUri(uri: string): { user: string; host: string; params?: Record<string, any>; };
+    export function stringifyUri(uri: object): string;
+
     export interface SipMessage {
-      headers: {[name: string]: string | string[]};
-      raw: string;
+      type: "request" | "response";
       body: string;
-      method: SipMethod;
-      version: string;
-      uri: string;
       payload: object[];
+      source: "network" | "application";
+      source_address: string;
+      source_port: string;
+      protocol: string;
+      stackTime: string;
+      calledNumber: string;
+      callingNumber: string;
+      raw: string;
       get(name: string): string;
+      has(name: string): boolean;
+      set(name: string, value: string);
+      getParsedHeader(name: "contact" | "Contact"): Array<AOR>;
+      getParsedHeader(name: "via" | "Via"): Array<Via>;
+      getParsedHeader(name: "To" | "to" | "From" | "from" | "refer-to" | "referred-by" | "p-asserted-identity" | "remote-party-id"): AOR;
+      getParsedHeader(name: string): string;
     }
-    
-    export interface SrfRequest {
-      headers: {[name: string]: any};
-      msg: any;
+
+    export interface SrfRequest extends SipMessage {
       method: SipMethod;
-      uri: string;
-      from: string;
-      to: string;
-      callId: string;
+      isNewInvite(): boolean
+      cancel(callback: () => {})
       branch: string;
+      callId: string;
+      from: string;
+      headers: Record<string, string>;
+      msg: any;
       sdp: string;
-      get(name: string): string;
-      has(name: string): boolean;
+      srf: any;
+      to: string;
+      uri: string;
+      registration?: {
+        type: "unregister" | "register";
+        expires: number;
+        contact: Array<AOR>;
+        aor: string;
+      };
     }
-  
-    export interface SrfResponse {
-      headers: {[name: string]: any};
+
+    export interface SrfResponse extends SipMessage {
       status: number;
-      send(sdp?: string): void;
-      end(): void;
-      set(name: string, value: string | number): void;
-      get(name: string): string;
+      statusCode: number;
+      reason: string;
+      finalResponseSent: boolean;
+      send(status: number);
+      send(status: number, opts: object);
+      send(status: number, reason: string, opts: object);
+      send(status: number, reason: string, opts: object, callback: (err, msg) => {});
+      end();
+    }
+
+    export interface Dialog {
+      sip: { callId: string; localTag: string; remoteTag: string; };
+      onHold: boolean;
+      other: Dialog;
+      type: "uac" | "uas";
+      local: { uri: string; sdp: string; };
+      remote: { uri: string; sdp: string; };
+      req: SrfRequest;
+      destroy(opts?: { headers: Record<string, string>; }, callback?: (err, msg) => {}): void;
+      modify(sdp, callback?: (err: any, msg: SrfResponse) => void): void;
+      modify({ noAck: boolean }, callback?: (err: any, resp: any, resAck: any) => void): void;
+      ack(string): void;
+      on(messageType: "ack", callback: (msg: SrfResponse) => void): void;
+      on(messageType: "destroy", callback: (msg: SrfRequest) => void): void;
+      on(messageType: "info", callback: (req: SrfRequest, res: SrfResponse) => void): void;
+      on(messageType: "message", callback: (req: SrfRequest, res: SrfResponse) => void): void;
+      on(messageType: "modify", callback: (req: SrfRequest, res: SrfResponse) => void): void;
+      on(messageType: "notify", callback: (req: SrfRequest, res: SrfResponse) => void): void;
+      on(messageType: "options", callback: (req: SrfRequest, res: SrfResponse) => void): void;
+      on(messageType: "refer", callback: (req: SrfRequest, res: SrfResponse) => void): void;
+      on(messageType: "refresh", callback: (msg: SrfResponse) => void): void;
+      on(messageType: "update", callback: (req: SrfRequest, res: SrfResponse) => void): void;
+      on(messageType: "modify", callback: (req: SrfRequest, res: SrfResponse) => void): void;
+      once(messageType: string, callback: (msg: SrfResponse) => void): void;
+      listeners(messageType: string): any[];
+      request(opts?: { method: SipMethod; headers?: Record<string, string | number>; body?: string; }, callback?: (err, msg) => {});
+    }
+
+    export interface CreateUASOptions {
+      localSdp: string;
+      headers?: SipMessageHeaders;
+    }
+
+    export interface CreateUACOptions {
+      headers?: SipMessageHeaders;
+      uri?: string;
+      noAck?: boolean;
+      localSdp?: string;
+      proxy?: string;
+      auth?: { username: string; password: string; };
+    }
+
+    export interface CreateB2BUAOptions {
+      headers?: SipMessageHeaders;
+      responseHeaders?: SipMessageHeaders | ((uacRes: SipMessageHeaders, headers: SipMessageHeaders) => SipMessageHeaders | null);
+      localSdpA?: string | ((sdp: string, res: SrfResponse) => string | Promise<string>);
+      localSdpB?: string | ((sdp: string) => string | Promise<string>);
+      proxyRequestHeaders?: string[];
+      proxyResponseHeaders?: string[];
+      passFailure?: boolean;
+      passProvisionalResponses?: boolean;
+      proxy?: string;
+      auth?: { username: string; password: string; };
     }
-  
+
     class Srf extends EventEmitter {
       constructor();
       constructor(tags: string | string[]);
       connect(config?: SrfConfig): Promise<void>;
       disconnect(): void;
-      register(options: any): void;
-      invite(sipUri: string, options: any): void;
-      bye(request: SrfRequest, options: any): void;
-      cancel(request: SrfRequest, options: any): void;
-      ack(request: SrfRequest, options: any): void;
-      info(request: SrfRequest, options: any): void;
-      message(request: SrfRequest, options: any): void;
-      notify(request: SrfRequest, options: any): void;
-      options(request: SrfRequest, options: any): void;
-      prack(request: SrfRequest, options: any): void;
-      publish(request: SrfRequest, options: any): void;
-      refer(request: SrfRequest, target: string, options: any): void;
-      subscribe(request: SrfRequest, target: string, options: any): void;
-      update(request: SrfRequest, options: any): void;
+      use(callback: (req: SrfRequest, res: SrfResponse, next: Function) => void): void;
+      use(messageType: string, callback: (req: SrfRequest, res: SrfResponse, next: Function) => void): void;
+      invite(callback: (req: SrfRequest, res: SrfResponse) => void): void;
+      request(uri: string, opts, method, [body], callback?: (err, requestSent: SrfRequest) => void);
+      proxyRequest(req: SrfRequest, destination: string | string[], [opts], callback?: (err, results) => {}): void;
+      createUAS(req: SrfRequest, res: SrfResponse, opts: CreateUASOptions, callback?: (err, dialog: Dialog) => void): Promise<Dialog>;
+      createUAC(uri: string | CreateUACOptions, opts?: CreateUACOptions, progressCallbacks?: { cbRequest?: (req: SrfRequest) => void; cbProvisional?: (provisionalRes: SrfResponse) => void; }, callback?: (err, dialog: Dialog) => void): Promise<Dialog>;
+      createB2BUA(req: SrfRequest, res: SrfResponse, uri: string, opts: CreateB2BUAOptions, progressCallbacks?: { cbRequest?: (req: SrfRequest) => void; cbProvisional?: (provisionalRes: Response) => void; cbFinalizedUac?: (uac: Dialog) => void; }, callback?: (err, dialog: Dialog) => {}): Promise<{ uas: Dialog; uac: Dialog }>;
       on(event: 'connect', listener: (err: Error, hostPort: string) => void): this;
       on(event: 'error', listener: (err: Error) => void): this;
       on(event: 'disconnect', listener: () => void): this;
@@ -76,7 +150,6 @@ declare module 'drachtio-srf' {
       locals: {[name: string]: any};
       socket: Socket;
     }
-  
+
     export default Srf
-  }
-  
+}

package/lib/request.js

@@ -273,6 +273,7 @@ module.exports = Request ;
 delegate(Request.prototype, 'msg')
   .method('get')
   .method('has')
+  .method('getHeaderName')
   .method('getParsedHeader')
   .method('set')
   .access('method')

package/lib/response.js

@@ -191,6 +191,7 @@ module.exports = Response ;
 delegate(Response.prototype, 'msg')
   .method('get')
   .method('has')
+  .method('getHeaderName')
   .method('getParsedHeader')
   .method('set')
   .access('headers')

package/lib/sip-parser/message.js

@@ -53,6 +53,11 @@ class SipMessage {
     return ('INVITE' === this.method || 'SUBSCRIBE' === this.method) && !this.get('to').tag ;
   }
 
+  getHeaderName(hdr) {
+    const hdrLowerCase = hdr.toLowerCase();
+    return Object.keys(this.headers).find((h) => h.toLowerCase() === hdrLowerCase);
+  }
+
   set(hdr, value) {
     const hdrs = {} ;
     if (typeof hdr === 'string') hdrs[hdr] = value ;
@@ -76,17 +81,18 @@ class SipMessage {
   }
 
   get(hdr) {
-    if (this.has(hdr)) { return this.headers[parser.getHeaderName(hdr)] ; }
+    const headerName = this.getHeaderName(parser.getHeaderName(hdr));
+    if (headerName) {
+      return this.headers[headerName];
+    }
   }
 
   has(hdr) {
-    const name = parser.getHeaderName(hdr) ;
-    return name in this.headers ;
+    return !!this.getHeaderName(hdr);
   }
 
   getParsedHeader(hdr) {
-    const name = parser.getHeaderName(hdr) ;
-    const v =  this.headers[name];
+    const v = this.get(hdr);
 
     if (!v) {
       throw new Error('header not available');

package/lib/srf.js

@@ -814,8 +814,14 @@ class Srf extends Emitter {
       const reqHeaders = req.headers;
       possiblyRemoveHeaders(proxyRequestHeaders.slice(1), reqHeaders);
       copyAllHeaders(reqHeaders, opts.headers);
+    } else {
+      proxyRequestHeaders.forEach((hdr) => {
+        const headerName = req.getHeaderName(hdr);
+        if (headerName) {
+          opts.headers[headerName] = req.get(hdr);
+        }
+      });
     }
-    else proxyRequestHeaders.forEach((hdr) => { if (req.has(hdr)) opts.headers[hdr] = req.get(hdr);}) ;
 
     if (!(opts.headers.from || opts.headers.From) && !opts.callingNumber) { opts.callingNumber = req.callingNumber; }
     if (!(opts.headers.from || opts.headers.From) && !opts.callingName) { opts.callingName = req.callingName; }
@@ -912,9 +918,10 @@ class Srf extends Emitter {
       else {
         proxyResponseHeaders.forEach((hdr) => {
           debug(`copyUACHeadersToUAS: hdr ${hdr}`);
-          if (uacRes.has(hdr)) {
+          const headerName = uacRes.getHeaderName(hdr);
+          if (headerName) {
             debug(`copyUACHeadersToUAS: adding ${hdr}: uacRes.get(hdr)`);
-            headers[hdr] = uacRes.get(hdr) ;
+            headers[headerName] = uacRes.get(hdr);
           }
         });
       }
@@ -1221,8 +1228,11 @@ class Srf extends Emitter {
   _b2bRequestWithinDialog(dlg, req, res, proxyRequestHeaders, proxyResponseHeaders, callback) {
     callback = callback || noop ;
     let headers = {} ;
-    proxyRequestHeaders.forEach((h) => {
-      if (req.has(h)) { headers[h] = req.get(h); }
+    proxyRequestHeaders.forEach((hdr) => {
+      const headerName = req.getHeaderName(hdr);
+      if (headerName) {
+        headers[headerName] = req.get(hdr);
+      }
     }) ;
     dlg.request({
       method: req.method,
@@ -1230,8 +1240,13 @@ class Srf extends Emitter {
       body: req.body
     }, (err, response) => {
       headers = {} ;
-      proxyResponseHeaders.forEach((h) => {
-        if (!!response && response.has(h)) { headers[h] = response.get(h); }
+      proxyResponseHeaders.forEach((hdr) => {
+        if (!!response && response.has(hdr)) {
+          const headerName = response.getHeaderName(hdr);
+          if (headerName) {
+            headers[headerName] = response.get(hdr);
+          }
+        }
       }) ;
 
       if (err) {

package/package.json

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

package/test/unit-tests/parser.js

@@ -40,6 +40,16 @@ describe('Parser', function () {
     msg.set('From', '<sip:daveh@localhost>;tag=1234');
     msg.get('from').should.eql('<sip:daveh@localhost>;tag=1234');
   });
+  it('getting a private header should be case insensitive', function () {
+    var msg = new SipMessage();
+    msg.set('P-Called-Party-ID', '"Dave" <sip:daveh@localhost>');
+    msg.get('p-called-party-id').should.eql('"Dave" <sip:daveh@localhost>');
+  });
+  it('getting a custom header should be case insensitive', function () {
+    var msg = new SipMessage();
+    msg.set('X-Foo', 'bar');
+    msg.get('x-foo').should.eql('bar');
+  });
   it('should not parse a header when not available', function () {
     var msg = new SipMessage();
     should.throws(msg.getParsedHeader.bind(msg, 'contact'));