ue-softphone-sdk 2.2.3 → 2.2.4

package/src/core/log/logger-factory.ts

@@ -0,0 +1,119 @@
+import { Levels } from "./levels";
+import { Logger } from "./logger";
+
+/**
+ * Logger.
+ * @public
+ */
+export class LoggerFactory {
+  public builtinEnabled = true;
+
+  private _level: Levels = Levels.log;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private _connector: ((level: string, category: string, label: string | undefined, content: any) => void) | undefined;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private loggers: any = {};
+  private logger: Logger;
+
+  constructor() {
+    this.logger = this.getLogger("sip:loggerfactory");
+  }
+
+  get level(): Levels {
+    return this._level;
+  }
+  set level(newLevel: Levels) {
+    if (newLevel >= 0 && newLevel <= 3) {
+      this._level = newLevel;
+    } else if (newLevel > 3) {
+      this._level = 3;
+      // eslint-disable-next-line no-prototype-builtins
+    } else if (Levels.hasOwnProperty(newLevel)) {
+      this._level = newLevel;
+    } else {
+      this.logger.error("invalid 'level' parameter value: " + JSON.stringify(newLevel));
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  get connector(): ((level: string, category: string, label: string | undefined, content: any) => void) | undefined {
+    return this._connector;
+  }
+  set connector(
+    value:
+      | ((
+          level: string,
+          category: string,
+          label: string | undefined,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          content: any
+        ) => void)
+      | undefined
+  ) {
+    if (!value) {
+      this._connector = undefined;
+    } else if (typeof value === "function") {
+      this._connector = value;
+    } else {
+      this.logger.error("invalid 'connector' parameter value: " + JSON.stringify(value));
+    }
+  }
+
+  public getLogger(category: string, label?: string): Logger {
+    if (label && this.level === 3) {
+      return new Logger(this, category, label);
+    } else if (this.loggers[category]) {
+      return this.loggers[category];
+    } else {
+      const logger = new Logger(this, category);
+      this.loggers[category] = logger;
+      return logger;
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  public genericLog(levelToLog: Levels, category: string, label: string | undefined, content: any): void {
+    if (this.level >= levelToLog) {
+      if (this.builtinEnabled) {
+        this.print(levelToLog, category, label, content);
+      }
+    }
+
+    if (this.connector) {
+      this.connector(Levels[levelToLog], category, label, content);
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private print(levelToLog: Levels, category: string, label: string | undefined, content: any): void {
+    if (typeof content === "string") {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const prefix: Array<any> = [new Date(), category];
+      if (label) {
+        prefix.push(label);
+      }
+      content = prefix.concat(content).join(" | ");
+    }
+    switch (levelToLog) {
+      case Levels.error:
+        // eslint-disable-next-line no-console
+        console.error(content);
+        break;
+      case Levels.warn:
+        // eslint-disable-next-line no-console
+        console.warn(content);
+        break;
+      case Levels.log:
+        // eslint-disable-next-line no-console
+        console.log(content);
+        break;
+      case Levels.debug:
+        // eslint-disable-next-line no-console
+        console.debug(content);
+        break;
+      default:
+        break;
+    }
+  }
+}

package/src/core/log/logger.ts

@@ -0,0 +1,42 @@
+import { Levels } from "./levels";
+import { LoggerFactory } from "./logger-factory";
+
+/**
+ * Logger.
+ * @public
+ */
+export class Logger {
+  private logger: LoggerFactory;
+  private category: string;
+  private label: string | undefined;
+
+  constructor(logger: LoggerFactory, category: string, label?: string) {
+    this.logger = logger;
+    this.category = category;
+    this.label = label;
+  }
+
+  public error(content: string): void {
+    this.genericLog(Levels.error, content);
+  }
+  public warn(content: string): void {
+    this.genericLog(Levels.warn, content);
+  }
+  public log(content: string): void {
+    this.genericLog(Levels.log, content);
+  }
+  public debug(content: string): void {
+    this.genericLog(Levels.debug, content);
+  }
+
+  private genericLog(level: Levels, content: string): void {
+    this.logger.genericLog(level, this.category, this.label, content);
+  }
+
+  get level(): Levels {
+    return this.logger.level;
+  }
+  set level(newLevel: Levels) {
+    this.logger.level = newLevel;
+  }
+}

package/src/core/messages/body.ts

@@ -0,0 +1,171 @@
+import { IncomingRequestMessage } from "./incoming-request-message";
+import { IncomingResponseMessage } from "./incoming-response-message";
+import { OutgoingRequestMessage } from "./outgoing-request-message";
+
+// If the Content-Disposition header field is missing, bodies of
+// Content-Type application/sdp imply the disposition "session", while
+// other content types imply "render".
+// https://tools.ietf.org/html/rfc3261#section-13.2.1
+function contentTypeToContentDisposition(contentType: string): string {
+  if (contentType === "application/sdp") {
+    return "session";
+  } else {
+    return "render";
+  }
+}
+
+/**
+ * Message body.
+ * @remarks
+ * https://tools.ietf.org/html/rfc3261#section-7.4
+ * @public
+ */
+export interface Body {
+  /**
+   * If the Content-Disposition header field is missing, bodies of
+   * Content-Type application/sdp imply the disposition "session", while
+   * other content types imply "render".
+   * https://tools.ietf.org/html/rfc3261#section-13.2.1
+   * For backward-compatibility, if the Content-Disposition header field
+   * is missing, the server SHOULD assume bodies of Content-Type
+   * application/sdp are the disposition "session", while other content
+   * types are "render".
+   * https://tools.ietf.org/html/rfc3261#section-20.11
+   */
+  contentDisposition: string;
+
+  /**
+   * The Content-Type header field indicates the media type of the
+   * message-body sent to the recipient.  The Content-Type header field
+   * MUST be present if the body is not empty.  If the body is empty,
+   * and a Content-Type header field is present, it indicates that the body
+   * of the specific type has zero length (for example, an empty audio file).
+   * https://tools.ietf.org/html/rfc3261#section-20.15
+   */
+  contentType: string;
+
+  /**
+   * Requests, including new requests defined in extensions to this
+   * specification, MAY contain message bodies unless otherwise noted.
+   * The interpretation of the body depends on the request method.
+   * For response messages, the request method and the response status
+   * code determine the type and interpretation of any message body.  All
+   * responses MAY include a body.
+   * https://tools.ietf.org/html/rfc3261#section-7.4
+   */
+  content: string;
+}
+
+/**
+ * Create a Body given a legacy body type.
+ * @param bodyLegacy - Body Object
+ * @internal
+ */
+export function fromBodyLegacy(bodyLegacy: string | { body: string; contentType: string }): Body {
+  const content = typeof bodyLegacy === "string" ? bodyLegacy : bodyLegacy.body;
+  const contentType = typeof bodyLegacy === "string" ? "application/sdp" : bodyLegacy.contentType;
+  const contentDisposition = contentTypeToContentDisposition(contentType);
+  const body: Body = { contentDisposition, contentType, content };
+  return body;
+}
+
+/**
+ * User-Defined Type Guard for Body.
+ * @param body - Body to check.
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function isBody(body: any): body is Body {
+  return body &&
+    typeof body.content === "string" &&
+    typeof body.contentType === "string" &&
+    body.contentDisposition === undefined
+    ? true
+    : typeof body.contentDisposition === "string";
+}
+
+/**
+ * Given a message, get a normalized body.
+ * The content disposition is inferred if not set.
+ * @param message - The message.
+ * @internal
+ */
+export function getBody(
+  message: IncomingRequestMessage | IncomingResponseMessage | OutgoingRequestMessage | Body
+): Body | undefined {
+  let contentDisposition: string | undefined;
+  let contentType: string | undefined;
+  let content: string | undefined;
+
+  // We're in UAS role, receiving incoming request
+  if (message instanceof IncomingRequestMessage) {
+    if (message.body) {
+      // FIXME: Parsing needs typing
+      const parse = message.parseHeader("Content-Disposition");
+      contentDisposition = parse ? parse.type : undefined;
+      contentType = message.parseHeader("Content-Type");
+      content = message.body;
+    }
+  }
+
+  // We're in UAC role, receiving incoming response
+  if (message instanceof IncomingResponseMessage) {
+    if (message.body) {
+      // FIXME: Parsing needs typing
+      const parse = message.parseHeader("Content-Disposition");
+      contentDisposition = parse ? parse.type : undefined;
+      contentType = message.parseHeader("Content-Type");
+      content = message.body;
+    }
+  }
+
+  // We're in UAC role, sending outgoing request
+  if (message instanceof OutgoingRequestMessage) {
+    if (message.body) {
+      contentDisposition = message.getHeader("Content-Disposition");
+      contentType = message.getHeader("Content-Type");
+      if (typeof message.body === "string") {
+        // FIXME: OutgoingRequest should not allow a "string" body without a "Content-Type" header.
+        if (!contentType) {
+          throw new Error("Header content type header does not equal body content type.");
+        }
+        content = message.body;
+      } else {
+        // FIXME: OutgoingRequest should not allow the "Content-Type" header not to match th body content type
+        if (contentType && contentType !== message.body.contentType) {
+          throw new Error("Header content type header does not equal body content type.");
+        }
+        contentType = message.body.contentType;
+        content = message.body.body;
+      }
+    }
+  }
+
+  // We're in UAS role, sending outgoing response
+  if (isBody(message)) {
+    contentDisposition = message.contentDisposition;
+    contentType = message.contentType;
+    content = message.content;
+  }
+
+  // No content, no body.
+  if (!content) {
+    return undefined;
+  }
+
+  if (contentType && !contentDisposition) {
+    contentDisposition = contentTypeToContentDisposition(contentType);
+  }
+  if (!contentDisposition) {
+    throw new Error("Content disposition undefined.");
+  }
+  if (!contentType) {
+    throw new Error("Content type undefined.");
+  }
+
+  return {
+    contentDisposition,
+    contentType,
+    content
+  };
+}

package/src/core/messages/digest-authentication.ts

@@ -0,0 +1,190 @@
+import { Md5 } from "./md5";
+
+import { URI } from "../../grammar";
+import { Logger, LoggerFactory } from "../log";
+import { OutgoingRequestMessage } from "./outgoing-request-message";
+import { createRandomToken } from "./utils";
+
+function MD5(s: string): string {
+  return Md5.hashStr(s);
+}
+
+/**
+ * Digest Authentication.
+ * @internal
+ */
+export class DigestAuthentication {
+  public stale: boolean | undefined;
+
+  private logger: Logger;
+  private ha1: string | undefined;
+  private username: string | undefined;
+  private password: string | undefined;
+  private cnonce: string | undefined;
+  private nc: number;
+  private ncHex: string;
+  private response: string | undefined;
+  private algorithm: string | undefined;
+  private realm: string | undefined;
+  private nonce: string | undefined;
+  private opaque: string | undefined;
+  private qop: string | undefined;
+  private method: string | undefined;
+  private uri: string | URI | undefined;
+
+  /**
+   * Constructor.
+   * @param loggerFactory - LoggerFactory.
+   * @param username - Username.
+   * @param password - Password.
+   */
+  constructor(
+    loggerFactory: LoggerFactory,
+    ha1: string | undefined,
+    username: string | undefined,
+    password: string | undefined
+  ) {
+    this.logger = loggerFactory.getLogger("sipjs.digestauthentication");
+    this.username = username;
+    this.password = password;
+    this.ha1 = ha1;
+    this.nc = 0;
+    this.ncHex = "00000000";
+  }
+
+  /**
+   * Performs Digest authentication given a SIP request and the challenge
+   * received in a response to that request.
+   * @param request -
+   * @param challenge -
+   * @returns true if credentials were successfully generated, false otherwise.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  public authenticate(request: OutgoingRequestMessage, challenge: any, body?: string): boolean {
+    // Inspect and validate the challenge.
+
+    this.algorithm = challenge.algorithm;
+    this.realm = challenge.realm;
+    this.nonce = challenge.nonce;
+    this.opaque = challenge.opaque;
+    this.stale = challenge.stale;
+
+    if (this.algorithm) {
+      if (this.algorithm !== "MD5") {
+        this.logger.warn("challenge with Digest algorithm different than 'MD5', authentication aborted");
+        return false;
+      }
+    } else {
+      this.algorithm = "MD5";
+    }
+
+    if (!this.realm) {
+      this.logger.warn("challenge without Digest realm, authentication aborted");
+      return false;
+    }
+
+    if (!this.nonce) {
+      this.logger.warn("challenge without Digest nonce, authentication aborted");
+      return false;
+    }
+
+    // 'qop' can contain a list of values (Array). Let's choose just one.
+    if (challenge.qop) {
+      if (challenge.qop.indexOf("auth") > -1) {
+        this.qop = "auth";
+      } else if (challenge.qop.indexOf("auth-int") > -1) {
+        this.qop = "auth-int";
+      } else {
+        // Otherwise 'qop' is present but does not contain 'auth' or 'auth-int', so abort here.
+        this.logger.warn("challenge without Digest qop different than 'auth' or 'auth-int', authentication aborted");
+        return false;
+      }
+    } else {
+      this.qop = undefined;
+    }
+
+    // Fill other attributes.
+
+    this.method = request.method;
+    this.uri = request.ruri;
+    this.cnonce = createRandomToken(12);
+    this.nc += 1;
+    this.updateNcHex();
+
+    // nc-value = 8LHEX. Max value = 'FFFFFFFF'.
+    if (this.nc === 4294967296) {
+      this.nc = 1;
+      this.ncHex = "00000001";
+    }
+
+    // Calculate the Digest "response" value.
+    this.calculateResponse(body);
+
+    return true;
+  }
+
+  /**
+   * Return the Proxy-Authorization or WWW-Authorization header value.
+   */
+  public toString(): string {
+    const authParams: Array<string> = [];
+
+    if (!this.response) {
+      throw new Error("response field does not exist, cannot generate Authorization header");
+    }
+
+    authParams.push("algorithm=" + this.algorithm);
+    authParams.push('username="' + this.username + '"');
+    authParams.push('realm="' + this.realm + '"');
+    authParams.push('nonce="' + this.nonce + '"');
+    authParams.push('uri="' + this.uri + '"');
+    authParams.push('response="' + this.response + '"');
+    if (this.opaque) {
+      authParams.push('opaque="' + this.opaque + '"');
+    }
+    if (this.qop) {
+      authParams.push("qop=" + this.qop);
+      authParams.push('cnonce="' + this.cnonce + '"');
+      authParams.push("nc=" + this.ncHex);
+    }
+
+    return "Digest " + authParams.join(", ");
+  }
+  /**
+   * Generate the 'nc' value as required by Digest in this.ncHex by reading this.nc.
+   */
+  private updateNcHex(): void {
+    const hex = Number(this.nc).toString(16);
+    this.ncHex = "00000000".substr(0, 8 - hex.length) + hex;
+  }
+
+  /**
+   * Generate Digest 'response' value.
+   */
+  private calculateResponse(body?: string): void {
+    let ha1, ha2;
+
+    // HA1 = MD5(A1) = MD5(username:realm:password)
+    ha1 = this.ha1;
+    if (ha1 === "" || ha1 === undefined) {
+      ha1 = MD5(this.username + ":" + this.realm + ":" + this.password);
+    }
+
+    if (this.qop === "auth") {
+      // HA2 = MD5(A2) = MD5(method:digestURI)
+      ha2 = MD5(this.method + ":" + this.uri);
+      // response = MD5(HA1:nonce:nonceCount:credentialsNonce:qop:HA2)`
+      this.response = MD5(ha1 + ":" + this.nonce + ":" + this.ncHex + ":" + this.cnonce + ":auth:" + ha2);
+    } else if (this.qop === "auth-int") {
+      // HA2 = MD5(A2) = MD5(method:digestURI:MD5(entityBody))
+      ha2 = MD5(this.method + ":" + this.uri + ":" + MD5(body ? body : ""));
+      // response = MD5(HA1:nonce:nonceCount:credentialsNonce:qop:HA2)
+      this.response = MD5(ha1 + ":" + this.nonce + ":" + this.ncHex + ":" + this.cnonce + ":auth-int:" + ha2);
+    } else if (this.qop === undefined) {
+      // HA2 = MD5(A2) = MD5(method:digestURI)
+      ha2 = MD5(this.method + ":" + this.uri);
+      // response = MD5(HA1:nonce:HA2)
+      this.response = MD5(ha1 + ":" + this.nonce + ":" + ha2);
+    }
+  }
+}

package/src/core/messages/incoming-message.ts

@@ -0,0 +1,152 @@
+import { Grammar, NameAddrHeader } from "../../grammar";
+import { headerize } from "./utils";
+
+/**
+ * Incoming message.
+ * @public
+ */
+export class IncomingMessage {
+  public viaBranch!: string;
+  public method!: string;
+  public body!: string;
+  public toTag!: string;
+  public to!: NameAddrHeader;
+  public fromTag!: string;
+  public from!: NameAddrHeader;
+  public callId!: string;
+  public cseq!: number;
+  public via!: { host: string; port: number };
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  public headers: { [name: string]: Array<{ parsed?: any; raw: string }> } = {};
+  public referTo: string | undefined;
+  public data!: string;
+
+  /**
+   * Insert a header of the given name and value into the last position of the
+   * header array.
+   * @param name - header name
+   * @param value - header value
+   */
+  public addHeader(name: string, value: string): void {
+    const header = { raw: value };
+    name = headerize(name);
+
+    if (this.headers[name]) {
+      this.headers[name].push(header);
+    } else {
+      this.headers[name] = [header];
+    }
+  }
+
+  /**
+   * Get the value of the given header name at the given position.
+   * @param name - header name
+   * @returns Returns the specified header, undefined if header doesn't exist.
+   */
+  public getHeader(name: string): string | undefined {
+    const header = this.headers[headerize(name)];
+
+    if (header) {
+      if (header[0]) {
+        return header[0].raw;
+      }
+    } else {
+      return;
+    }
+  }
+
+  /**
+   * Get the header/s of the given name.
+   * @param name - header name
+   * @returns Array - with all the headers of the specified name.
+   */
+  public getHeaders(name: string): Array<string> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const header: Array<any> = this.headers[headerize(name)];
+    const result: Array<string> = [];
+
+    if (!header) {
+      return [];
+    }
+    for (const headerPart of header) {
+      result.push(headerPart.raw);
+    }
+    return result;
+  }
+
+  /**
+   * Verify the existence of the given header.
+   * @param name - header name
+   * @returns true if header with given name exists, false otherwise
+   */
+  public hasHeader(name: string): boolean {
+    return !!this.headers[headerize(name)];
+  }
+
+  /**
+   * Parse the given header on the given index.
+   * @param name - header name
+   * @param idx - header index
+   * @returns Parsed header object, undefined if the
+   *   header is not present or in case of a parsing error.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  public parseHeader(name: string, idx = 0): any | undefined {
+    name = headerize(name);
+
+    if (!this.headers[name]) {
+      // this.logger.log("header '" + name + "' not present");
+      return;
+    } else if (idx >= this.headers[name].length) {
+      // this.logger.log("not so many '" + name + "' headers present");
+      return;
+    }
+
+    const header = this.headers[name][idx];
+    const value = header.raw;
+
+    if (header.parsed) {
+      return header.parsed;
+    }
+
+    // substitute '-' by '_' for grammar rule matching.
+    const parsed: string | -1 = Grammar.parse(value, name.replace(/-/g, "_"));
+
+    if (parsed === -1) {
+      this.headers[name].splice(idx, 1); // delete from headers
+      // this.logger.warn('error parsing "' + name + '" header field with value "' + value + '"');
+      return;
+    } else {
+      header.parsed = parsed;
+      return parsed;
+    }
+  }
+
+  /**
+   * Message Header attribute selector. Alias of parseHeader.
+   * @param name - header name
+   * @param idx - header index
+   * @returns Parsed header object, undefined if the
+   *   header is not present or in case of a parsing error.
+   *
+   * @example
+   * message.s('via',3).port
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  public s(name: string, idx = 0): any | undefined {
+    return this.parseHeader(name, idx);
+  }
+
+  /**
+   * Replace the value of the given header by the value.
+   * @param name - header name
+   * @param value - header value
+   */
+  public setHeader(name: string, value: string): void {
+    this.headers[headerize(name)] = [{ raw: value }];
+  }
+
+  public toString(): string {
+    return this.data;
+  }
+}

package/src/core/messages/incoming-request-message.ts

@@ -0,0 +1,14 @@
+import { URI } from "../messages";
+import { IncomingMessage } from "./incoming-message";
+
+/**
+ * Incoming request message.
+ * @public
+ */
+export class IncomingRequestMessage extends IncomingMessage {
+  public ruri: URI | undefined;
+
+  constructor() {
+    super();
+  }
+}