ue-softphone-sdk 2.2.4 → 2.2.6

package/src/core/transactions/non-invite-server-transaction.ts

@@ -1,241 +0,0 @@
-import { TransportError } from "../exceptions";
-import { IncomingRequestMessage } from "../messages";
-import { Timers } from "../timers";
-import { Transport } from "../transport";
-import { ServerTransaction } from "./server-transaction";
-import { TransactionState } from "./transaction-state";
-import { ServerTransactionUser } from "./transaction-user";
-
-/**
- * Non-INVITE Server Transaction.
- * @remarks
- * https://tools.ietf.org/html/rfc3261#section-17.2.2
- * @public
- */
-export class NonInviteServerTransaction extends ServerTransaction {
-  private lastResponse: string | undefined;
-  private J: number | undefined;
-
-  /**
-   * Constructor.
-   * After construction the transaction will be in the "trying": state and the transaction
-   * `id` will equal the branch parameter set in the Via header of the incoming request.
-   * https://tools.ietf.org/html/rfc3261#section-17.2.2
-   * @param request - Incoming Non-INVITE request from the transport.
-   * @param transport - The transport.
-   * @param user - The transaction user.
-   */
-  constructor(request: IncomingRequestMessage, transport: Transport, user: ServerTransactionUser) {
-    super(request, transport, user, TransactionState.Trying, "sip.transaction.nist");
-  }
-
-  /**
-   * Destructor.
-   */
-  public dispose(): void {
-    if (this.J) {
-      clearTimeout(this.J);
-      this.J = undefined;
-    }
-    super.dispose();
-  }
-
-  /** Transaction kind. Deprecated. */
-  get kind(): string {
-    return "nist";
-  }
-
-  /**
-   * Receive requests from transport matching this transaction.
-   * @param request - Request matching this transaction.
-   */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public receiveRequest(request: IncomingRequestMessage): void {
-    switch (this.state) {
-      case TransactionState.Trying:
-        // Once in the "Trying" state, any further request retransmissions are discarded.
-        // https://tools.ietf.org/html/rfc3261#section-17.2.2
-        break;
-      case TransactionState.Proceeding:
-        // If a retransmission of the request is received while in the "Proceeding" state,
-        // the most recently sent provisional response MUST be passed to the transport layer for retransmission.
-        // https://tools.ietf.org/html/rfc3261#section-17.2.2
-        if (!this.lastResponse) {
-          throw new Error("Last response undefined.");
-        }
-        this.send(this.lastResponse).catch((error: TransportError) => {
-          this.logTransportError(error, "Failed to send retransmission of provisional response.");
-        });
-        break;
-      case TransactionState.Completed:
-        // While in the "Completed" state, the server transaction MUST pass the final response to the transport
-        // layer for retransmission whenever a retransmission of the request is received. Any other final responses
-        // passed by the TU to the server transaction MUST be discarded while in the "Completed" state.
-        // https://tools.ietf.org/html/rfc3261#section-17.2.2
-        if (!this.lastResponse) {
-          throw new Error("Last response undefined.");
-        }
-        this.send(this.lastResponse).catch((error: TransportError) => {
-          this.logTransportError(error, "Failed to send retransmission of final response.");
-        });
-        break;
-      case TransactionState.Terminated:
-        break;
-      default:
-        throw new Error(`Invalid state ${this.state}`);
-    }
-  }
-
-  /**
-   * Receive responses from TU for this transaction.
-   * @param statusCode - Status code of response. 101-199 not allowed per RFC 4320.
-   * @param response - Response to send.
-   */
-  public receiveResponse(statusCode: number, response: string): void {
-    if (statusCode < 100 || statusCode > 699) {
-      throw new Error(`Invalid status code ${statusCode}`);
-    }
-
-    // An SIP element MUST NOT send any provisional response with a
-    // Status-Code other than 100 to a non-INVITE request.
-    // An SIP element MUST NOT respond to a non-INVITE request with a
-    // Status-Code of 100 over any unreliable transport, such as UDP,
-    // before the amount of time it takes a client transaction's Timer E to be reset to T2.
-    // An SIP element MAY respond to a non-INVITE request with a
-    // Status-Code of 100 over a reliable transport at any time.
-    // https://tools.ietf.org/html/rfc4320#section-4.1
-    if (statusCode > 100 && statusCode <= 199) {
-      throw new Error("Provisional response other than 100 not allowed.");
-    }
-
-    switch (this.state) {
-      case TransactionState.Trying:
-        // While in the "Trying" state, if the TU passes a provisional response
-        // to the server transaction, the server transaction MUST enter the "Proceeding" state.
-        // The response MUST be passed to the transport layer for transmission.
-        // https://tools.ietf.org/html/rfc3261#section-17.2.2
-        this.lastResponse = response;
-        if (statusCode >= 100 && statusCode < 200) {
-          this.stateTransition(TransactionState.Proceeding);
-          this.send(response).catch((error: TransportError) => {
-            this.logTransportError(error, "Failed to send provisional response.");
-          });
-          return;
-        }
-        if (statusCode >= 200 && statusCode <= 699) {
-          this.stateTransition(TransactionState.Completed);
-          this.send(response).catch((error: TransportError) => {
-            this.logTransportError(error, "Failed to send final response.");
-          });
-          return;
-        }
-        break;
-      case TransactionState.Proceeding:
-        // Any further provisional responses that are received from the TU while
-        // in the "Proceeding" state MUST be passed to the transport layer for transmission.
-        // If the TU passes a final response (status codes 200-699) to the server while in
-        // the "Proceeding" state, the transaction MUST enter the "Completed" state, and
-        // the response MUST be passed to the transport layer for transmission.
-        // https://tools.ietf.org/html/rfc3261#section-17.2.2
-        this.lastResponse = response;
-        if (statusCode >= 200 && statusCode <= 699) {
-          this.stateTransition(TransactionState.Completed);
-          this.send(response).catch((error: TransportError) => {
-            this.logTransportError(error, "Failed to send final response.");
-          });
-          return;
-        }
-        break;
-      case TransactionState.Completed:
-        // Any other final responses passed by the TU to the server
-        // transaction MUST be discarded while in the "Completed" state.
-        // https://tools.ietf.org/html/rfc3261#section-17.2.2
-        return;
-      case TransactionState.Terminated:
-        break;
-      default:
-        throw new Error(`Invalid state ${this.state}`);
-    }
-
-    const message = `Non-INVITE server transaction received unexpected ${statusCode} response from TU while in state ${this.state}.`;
-    this.logger.error(message);
-    throw new Error(message);
-  }
-
-  /**
-   * First, the procedures in [4] are followed, which attempt to deliver the response to a backup.
-   * If those should all fail, based on the definition of failure in [4], the server transaction SHOULD
-   * inform the TU that a failure has occurred, and SHOULD transition to the terminated state.
-   * https://tools.ietf.org/html/rfc3261#section-17.2.4
-   */
-  protected onTransportError(error: Error): void {
-    if (this.user.onTransportError) {
-      this.user.onTransportError(error);
-    }
-    this.stateTransition(TransactionState.Terminated, true);
-  }
-
-  /** For logging. */
-  protected typeToString(): string {
-    return "non-INVITE server transaction";
-  }
-
-  private stateTransition(newState: TransactionState, dueToTransportError = false): void {
-    // Assert valid state transitions.
-    const invalidStateTransition = (): void => {
-      throw new Error(`Invalid state transition from ${this.state} to ${newState}`);
-    };
-
-    switch (newState) {
-      case TransactionState.Trying:
-        invalidStateTransition();
-        break;
-      case TransactionState.Proceeding:
-        if (this.state !== TransactionState.Trying) {
-          invalidStateTransition();
-        }
-        break;
-      case TransactionState.Completed:
-        if (this.state !== TransactionState.Trying && this.state !== TransactionState.Proceeding) {
-          invalidStateTransition();
-        }
-        break;
-      case TransactionState.Terminated:
-        if (this.state !== TransactionState.Proceeding && this.state !== TransactionState.Completed) {
-          if (!dueToTransportError) {
-            invalidStateTransition();
-          }
-        }
-        break;
-      default:
-        invalidStateTransition();
-    }
-
-    // When the server transaction enters the "Completed" state, it MUST set Timer J to fire
-    // in 64*T1 seconds for unreliable transports, and zero seconds for reliable transports.
-    // https://tools.ietf.org/html/rfc3261#section-17.2.2
-    if (newState === TransactionState.Completed) {
-      this.J = window.setTimeout(() => this.timerJ(), Timers.TIMER_J);
-    }
-
-    // The server transaction MUST be destroyed the instant it enters the "Terminated" state.
-    // https://tools.ietf.org/html/rfc3261#section-17.2.2
-    if (newState === TransactionState.Terminated) {
-      this.dispose();
-    }
-
-    this.setState(newState);
-  }
-
-  /**
-   * The server transaction remains in this state until Timer J fires,
-   * at which point it MUST transition to the "Terminated" state.
-   * https://tools.ietf.org/html/rfc3261#section-17.2.2
-   */
-  private timerJ(): void {
-    this.logger.debug(`Timer J expired for NON-INVITE server transaction ${this.id}.`);
-    if (this.state === TransactionState.Completed) {
-      this.stateTransition(TransactionState.Terminated);
-    }
-  }
-}

package/src/core/transactions/server-transaction.ts

@@ -1,47 +0,0 @@
-import { IncomingRequestMessage } from "../messages";
-import { Transport } from "../transport";
-import { Transaction } from "./transaction";
-import { TransactionState } from "./transaction-state";
-import { ServerTransactionUser } from "./transaction-user";
-
-/**
- * Server Transaction.
- * @remarks
- * The server transaction is responsible for the delivery of requests to
- * the TU and the reliable transmission of responses.  It accomplishes
- * this through a state machine.  Server transactions are created by the
- * core when a request is received, and transaction handling is desired
- * for that request (this is not always the case).
- * https://tools.ietf.org/html/rfc3261#section-17.2
- * @public
- */
-export abstract class ServerTransaction extends Transaction {
-  protected constructor(
-    private _request: IncomingRequestMessage,
-    transport: Transport,
-    protected user: ServerTransactionUser,
-    state: TransactionState,
-    loggerCategory: string
-  ) {
-    super(transport, user, _request.viaBranch, state, loggerCategory);
-  }
-
-  /** The incoming request the transaction handling. */
-  get request(): IncomingRequestMessage {
-    return this._request;
-  }
-
-  /**
-   * Receive incoming requests from the transport which match this transaction.
-   * @param request - The incoming request.
-   */
-  public abstract receiveRequest(request: IncomingRequestMessage): void;
-
-  /**
-   * Receive outgoing responses to this request from the transaction user.
-   * Responses will be delivered to the transport as necessary.
-   * @param statusCode - Response status code.
-   * @param response - Response.
-   */
-  public abstract receiveResponse(statusCode: number, response: string): void;
-}

package/src/core/transactions/transaction-state.ts

@@ -1,13 +0,0 @@
-/**
- * Transaction state.
- * @public
- */
-export enum TransactionState {
-  Accepted = "Accepted",
-  Calling = "Calling",
-  Completed = "Completed",
-  Confirmed = "Confirmed",
-  Proceeding = "Proceeding",
-  Terminated = "Terminated",
-  Trying = "Trying"
-}

package/src/core/transactions/transaction-user.ts

@@ -1,82 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-interface */
-import { TransportError } from "../exceptions";
-import { LoggerFactory } from "../log";
-import { IncomingResponseMessage } from "../messages";
-import { TransactionState } from "./transaction-state";
-
-/**
- * Transaction User (TU).
- * @remarks
- * The layer of protocol processing that resides above the transaction layer.
- * Transaction users include the UAC core, UAS core, and proxy core.
- * https://tools.ietf.org/html/rfc3261#section-5
- * https://tools.ietf.org/html/rfc3261#section-6
- * @public
- */
-export interface TransactionUser {
-  /**
-   * Logger factory.
-   */
-  loggerFactory: LoggerFactory;
-
-  /**
-   * Callback for notification of transaction state changes.
-   *
-   * Not called when transaction is constructed, so there is
-   * no notification of entering the initial transaction state.
-   * Otherwise, called once for each transaction state change.
-   * State changes adhere to the following RFCs.
-   * https://tools.ietf.org/html/rfc3261#section-17
-   * https://tools.ietf.org/html/rfc6026
-   */
-  onStateChange?: (newState: TransactionState) => void;
-
-  /**
-   * Callback for notification of a transport error.
-   *
-   * If a fatal transport error is reported by the transport layer
-   * (generally, due to fatal ICMP errors in UDP or connection failures in
-   * TCP), the condition MUST be treated as a 503 (Service Unavailable)
-   * status code.
-   * https://tools.ietf.org/html/rfc3261#section-8.1.3.1
-   * https://tools.ietf.org/html/rfc3261#section-17.1.4
-   * https://tools.ietf.org/html/rfc3261#section-17.2.4
-   * https://tools.ietf.org/html/rfc6026
-   */
-  onTransportError?: (error: TransportError) => void;
-}
-
-/**
- * UAC Core Transaction User.
- * @public
- */
-export interface ClientTransactionUser extends TransactionUser {
-  /**
-   * Callback for request timeout error.
-   *
-   * When a timeout error is received from the transaction layer, it MUST be
-   * treated as if a 408 (Request Timeout) status code has been received.
-   * https://tools.ietf.org/html/rfc3261#section-8.1.3.1
-   * TU MUST be informed of a timeout.
-   * https://tools.ietf.org/html/rfc3261#section-17.1.2.2
-   */
-  onRequestTimeout?: () => void;
-
-  /**
-   * Callback for delegation of valid response handling.
-   *
-   * Valid responses are passed up to the TU from the client transaction.
-   * https://tools.ietf.org/html/rfc3261#section-17.1
-   */
-  receiveResponse?: (response: IncomingResponseMessage) => void;
-}
-
-/**
- * UAS Core Transaction User.
- * @public
- */
-export interface ServerTransactionUser extends TransactionUser {
-  /**
-   * For completeness. Same as `TransactionUser` at this point.
-   */
-}

package/src/core/transactions/transaction.ts

@@ -1,149 +0,0 @@
-import { TransportError } from "../exceptions";
-import { Logger } from "../log";
-import { Transport } from "../transport";
-import { TransactionState } from "./transaction-state";
-import { TransactionUser } from "./transaction-user";
-
-/**
- * Transaction.
- * @remarks
- * SIP is a transactional protocol: interactions between components take
- * place in a series of independent message exchanges.  Specifically, a
- * SIP transaction consists of a single request and any responses to
- * that request, which include zero or more provisional responses and
- * one or more final responses.  In the case of a transaction where the
- * request was an INVITE (known as an INVITE transaction), the
- * transaction also includes the ACK only if the final response was not
- * a 2xx response.  If the response was a 2xx, the ACK is not considered
- * part of the transaction.
- * https://tools.ietf.org/html/rfc3261#section-17
- * @public
- */
-export abstract class Transaction {
-  protected logger: Logger;
-
-  private listeners = new Array<() => void>();
-
-  protected constructor(
-    private _transport: Transport,
-    private _user: TransactionUser,
-    private _id: string,
-    private _state: TransactionState,
-    loggerCategory: string
-  ) {
-    this.logger = _user.loggerFactory.getLogger(loggerCategory, _id);
-    this.logger.debug(`Constructing ${this.typeToString()} with id ${this.id}.`);
-  }
-
-  /**
-   * Destructor.
-   * Once the transaction is in the "terminated" state, it is destroyed
-   * immediately and there is no need to call `dispose`. However, if a
-   * transaction needs to be ended prematurely, the transaction user may
-   * do so by calling this method (for example, perhaps the UA is shutting down).
-   * No state transition will occur upon calling this method, all outstanding
-   * transmission timers will be cancelled, and use of the transaction after
-   * calling `dispose` is undefined.
-   */
-  public dispose(): void {
-    this.logger.debug(`Destroyed ${this.typeToString()} with id ${this.id}.`);
-  }
-
-  /** Transaction id. */
-  get id(): string {
-    return this._id;
-  }
-
-  /** Transaction kind. Deprecated. */
-  get kind(): string {
-    throw new Error("Invalid kind.");
-  }
-
-  /** Transaction state. */
-  get state(): TransactionState {
-    return this._state;
-  }
-
-  /** Transaction transport. */
-  get transport(): Transport {
-    return this._transport;
-  }
-
-  /**
-   * Sets up a function that will be called whenever the transaction state changes.
-   * @param listener - Callback function.
-   * @param options - An options object that specifies characteristics about the listener.
-   *                  If once true, indicates that the listener should be invoked at most once after being added.
-   *                  If once true, the listener would be automatically removed when invoked.
-   */
-  public addStateChangeListener(listener: () => void, options?: { once?: boolean }): void {
-    const onceWrapper = (): void => {
-      this.removeStateChangeListener(onceWrapper);
-      listener();
-    };
-    options?.once === true ? this.listeners.push(onceWrapper) : this.listeners.push(listener);
-  }
-
-  /**
-   * This is currently public so tests may spy on it.
-   * @internal
-   */
-  public notifyStateChangeListeners(): void {
-    this.listeners.slice().forEach((listener) => listener());
-  }
-
-  /**
-   * Removes a listener previously registered with addStateListener.
-   * @param listener - Callback function.
-   */
-  public removeStateChangeListener(listener: () => void): void {
-    this.listeners = this.listeners.filter((l) => l !== listener);
-  }
-
-  protected logTransportError(error: TransportError, message: string): void {
-    this.logger.error(error.message);
-    this.logger.error(`Transport error occurred in ${this.typeToString()} with id ${this.id}.`);
-    this.logger.error(message);
-  }
-
-  /**
-   * Pass message to transport for transmission. If transport fails,
-   * the transaction user is notified by callback to onTransportError().
-   * @returns
-   * Rejects with `TransportError` if transport fails.
-   */
-  protected send(message: string): Promise<void> {
-    return this.transport.send(message).catch((error) => {
-      // If the transport rejects, it SHOULD reject with a TransportError.
-      // But the transport may be external code, so we are careful
-      // make sure we convert it to a TransportError if need be.
-      if (error instanceof TransportError) {
-        this.onTransportError(error);
-        throw error;
-      }
-      let transportError: TransportError;
-      if (error && typeof error.message === "string") {
-        transportError = new TransportError(error.message);
-      } else {
-        transportError = new TransportError();
-      }
-      this.onTransportError(transportError);
-      throw transportError;
-    });
-  }
-
-  protected setState(state: TransactionState): void {
-    this.logger.debug(`State change to "${state}" on ${this.typeToString()} with id ${this.id}.`);
-    this._state = state;
-    if (this._user.onStateChange) {
-      this._user.onStateChange(state);
-    }
-    this.notifyStateChangeListeners();
-  }
-
-  protected typeToString(): string {
-    return "UnknownType";
-  }
-
-  protected abstract onTransportError(error: TransportError): void;
-}

package/src/core/transport.ts

@@ -1,32 +0,0 @@
-/**
- * Transport layer interface expected by the user agent core.
- *
- * @remarks
- * The transport layer is responsible for the actual transmission of
- * requests and responses over network transports.  This includes
- * determination of the connection to use for a request or response in
- * the case of connection-oriented transports.
- * https://tools.ietf.org/html/rfc3261#section-18
- *
- * @public
- */
-export interface Transport {
-  /**
-   * The transport protocol.
-   *
-   * @remarks
-   * Formatted as defined for the Via header sent-protocol transport.
-   * https://tools.ietf.org/html/rfc3261#section-20.42
-   */
-  readonly protocol: string;
-
-  /**
-   * Send a message.
-   *
-   * @remarks
-   * Resolves once message is sent. Otherwise rejects with an Error.
-   *
-   * @param message - Message to send.
-   */
-  send(message: string): Promise<void>;
-}

package/src/core/user-agent-core/allowed-methods.ts

@@ -1,19 +0,0 @@
-import { C } from "../messages";
-
-/**
- * FIXME: TODO: Should be configurable/variable.
- */
-export const AllowedMethods = [
-  C.ACK,
-  C.BYE,
-  C.CANCEL,
-  C.INFO,
-  C.INVITE,
-  C.MESSAGE,
-  C.NOTIFY,
-  C.OPTIONS,
-  C.PRACK, // FIXME: Only if 100rel Supported
-  C.REFER,
-  C.REGISTER,
-  C.SUBSCRIBE
-];

package/src/core/user-agent-core/index.ts

@@ -1,3 +0,0 @@
-export * from "./user-agent-core";
-export * from "./user-agent-core-configuration";
-export * from "./user-agent-core-delegate";