ue-softphone-sdk 2.2.3 → 2.2.4

package/src/api/user-agent.ts

@@ -0,0 +1,1014 @@
+import {
+  Contact,
+  DigestAuthentication,
+  Grammar,
+  IncomingInviteRequest,
+  IncomingMessageRequest,
+  IncomingNotifyRequest,
+  IncomingReferRequest,
+  IncomingRegisterRequest,
+  IncomingRequestMessage,
+  IncomingResponseMessage,
+  IncomingSubscribeRequest,
+  Levels,
+  Logger,
+  LoggerFactory,
+  Parser,
+  TransportError,
+  URI,
+  UserAgentCore,
+  UserAgentCoreConfiguration,
+  UserAgentCoreDelegate
+} from "../core";
+import { createRandomToken, utf8Length } from "../core/messages/utils";
+import { defaultSessionDescriptionHandlerFactory } from "../platform/web/session-description-handler";
+import { Transport as WebTransport } from "../platform/web/transport";
+import { LIBRARY_VERSION } from "../version";
+import { Emitter, EmitterImpl } from "./emitter";
+import { Invitation } from "./invitation";
+import { Inviter } from "./inviter";
+import { InviterOptions } from "./inviter-options";
+import { Message } from "./message";
+import { Notification } from "./notification";
+import { Publisher } from "./publisher";
+import { Registerer } from "./registerer";
+import { Session } from "./session";
+import { Subscription } from "./subscription";
+import { Transport } from "./transport";
+import { UserAgentDelegate } from "./user-agent-delegate";
+import { SIPExtension, UserAgentOptions, UserAgentRegisteredOptionTags } from "./user-agent-options";
+import { UserAgentState } from "./user-agent-state";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+declare const chrome: any;
+
+/**
+ * A user agent sends and receives requests using a `Transport`.
+ *
+ * @remarks
+ * A user agent (UA) is associated with a user via the user's SIP address of record (AOR)
+ * and acts on behalf of that user to send and receive SIP requests. The user agent can
+ * register to receive incoming requests, as well as create and send outbound messages.
+ * The user agent also maintains the Transport over which its signaling travels.
+ *
+ * @public
+ */
+export class UserAgent {
+  /**
+   * Property reserved for use by instance owner.
+   * @defaultValue `undefined`
+   */
+  public data: unknown;
+
+  /**
+   * Delegate.
+   */
+  public delegate: UserAgentDelegate | undefined;
+
+  /** @internal */
+  public _publishers: { [id: string]: Publisher } = {};
+  /** @internal */
+  public _registerers: { [id: string]: Registerer } = {};
+  /** @internal */
+  public _sessions: { [id: string]: Session } = {};
+  /** @internal */
+  public _subscriptions: { [id: string]: Subscription } = {};
+
+  private _contact: Contact;
+  private _state: UserAgentState = UserAgentState.Stopped;
+  private _stateEventEmitter: EmitterImpl<UserAgentState>;
+  private _transport: Transport;
+  private _userAgentCore: UserAgentCore;
+
+  /** Logger. */
+  private logger: Logger;
+  /** LoggerFactory. */
+  private loggerFactory: LoggerFactory;
+  /** Options. */
+  private options: Required<UserAgentOptions>;
+
+  /**
+   * Constructs a new instance of the `UserAgent` class.
+   * @param options - Options bucket. See {@link UserAgentOptions} for details.
+   */
+  public constructor(options: Partial<UserAgentOptions> = {}) {
+    // state emitter
+    this._stateEventEmitter = new EmitterImpl<UserAgentState>();
+
+    // initialize delegate
+    this.delegate = options.delegate;
+
+    // initialize configuration
+    this.options = {
+      // start with the default option values
+      ...UserAgent.defaultOptions(),
+      // add a unique sipjs id for each instance
+      ...{ sipjsId: createRandomToken(5) },
+      // add a unique anonymous uri for each instance
+      ...{ uri: new URI("sip", "anonymous." + createRandomToken(6), "anonymous.invalid") },
+      // add a unique via host for each instance
+      ...{ viaHost: createRandomToken(12) + ".invalid" },
+      // apply any options passed in via the constructor
+      ...UserAgent.stripUndefinedProperties(options)
+    };
+
+    // viaHost is hack
+    if (this.options.hackIpInContact) {
+      if (typeof this.options.hackIpInContact === "boolean" && this.options.hackIpInContact) {
+        const from = 1;
+        const to = 254;
+        const octet: number = Math.floor(Math.random() * (to - from + 1) + from);
+        // random Test-Net IP (http://tools.ietf.org/html/rfc5735)
+        this.options.viaHost = "192.0.2." + octet;
+      } else if (this.options.hackIpInContact) {
+        this.options.viaHost = this.options.hackIpInContact;
+      }
+    }
+
+    // initialize logger & logger factory
+    this.loggerFactory = new LoggerFactory();
+    this.logger = this.loggerFactory.getLogger("sip.UserAgent");
+    this.loggerFactory.builtinEnabled = this.options.logBuiltinEnabled;
+    this.loggerFactory.connector = this.options.logConnector as (
+      level: string,
+      category: string,
+      label: string | undefined,
+      content: string
+    ) => void;
+    switch (this.options.logLevel) {
+      case "error":
+        this.loggerFactory.level = Levels.error;
+        break;
+      case "warn":
+        this.loggerFactory.level = Levels.warn;
+        break;
+      case "log":
+        this.loggerFactory.level = Levels.log;
+        break;
+      case "debug":
+        this.loggerFactory.level = Levels.debug;
+        break;
+      default:
+        break;
+    }
+
+    if (this.options.logConfiguration) {
+      this.logger.log("Configuration:");
+      Object.keys(this.options).forEach((key) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const value = (this.options as any)[key];
+        switch (key) {
+          case "uri":
+          case "sessionDescriptionHandlerFactory":
+            this.logger.log("· " + key + ": " + value);
+            break;
+          case "authorizationPassword":
+            this.logger.log("· " + key + ": " + "NOT SHOWN");
+            break;
+          case "transportConstructor":
+            this.logger.log("· " + key + ": " + value.name);
+            break;
+          default:
+            this.logger.log("· " + key + ": " + JSON.stringify(value));
+        }
+      });
+    }
+
+    // guard deprecated transport options (remove this in version 16.x)
+    if (this.options.transportOptions) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const optionsDeprecated: any = this.options.transportOptions;
+      const maxReconnectionAttemptsDeprecated: number | undefined = optionsDeprecated.maxReconnectionAttempts;
+      const reconnectionTimeoutDeprecated: number | undefined = optionsDeprecated.reconnectionTimeout;
+      if (maxReconnectionAttemptsDeprecated !== undefined) {
+        const deprecatedMessage =
+          `The transport option "maxReconnectionAttempts" as has apparently been specified and has been deprecated. ` +
+          "It will no longer be available starting with SIP.js release 0.16.0. Please update accordingly.";
+        this.logger.warn(deprecatedMessage);
+      }
+      if (reconnectionTimeoutDeprecated !== undefined) {
+        const deprecatedMessage =
+          `The transport option "reconnectionTimeout" as has apparently been specified and has been deprecated. ` +
+          "It will no longer be available starting with SIP.js release 0.16.0. Please update accordingly.";
+        this.logger.warn(deprecatedMessage);
+      }
+
+      // hack
+      if (options.reconnectionDelay === undefined && reconnectionTimeoutDeprecated !== undefined) {
+        this.options.reconnectionDelay = reconnectionTimeoutDeprecated;
+      }
+      if (options.reconnectionAttempts === undefined && maxReconnectionAttemptsDeprecated !== undefined) {
+        this.options.reconnectionAttempts = maxReconnectionAttemptsDeprecated;
+      }
+    }
+
+    // guard deprecated user agent options (remove this in version 16.x)
+    if (options.reconnectionDelay !== undefined) {
+      const deprecatedMessage =
+        `The user agent option "reconnectionDelay" as has apparently been specified and has been deprecated. ` +
+        "It will no longer be available starting with SIP.js release 0.16.0. Please update accordingly.";
+      this.logger.warn(deprecatedMessage);
+    }
+    if (options.reconnectionAttempts !== undefined) {
+      const deprecatedMessage =
+        `The user agent option "reconnectionAttempts" as has apparently been specified and has been deprecated. ` +
+        "It will no longer be available starting with SIP.js release 0.16.0. Please update accordingly.";
+      this.logger.warn(deprecatedMessage);
+    }
+
+    // Initialize Transport
+    this._transport = new this.options.transportConstructor(
+      this.getLogger("sip.Transport"),
+      this.options.transportOptions
+    );
+    this.initTransportCallbacks();
+
+    // Initialize Contact
+    this._contact = this.initContact();
+
+    // Initialize UserAgentCore
+    this._userAgentCore = this.initCore();
+
+    if (this.options.autoStart) {
+      this.start();
+    }
+  }
+
+  /**
+   * Create a URI instance from a string.
+   * @param uri - The string to parse.
+   *
+   * @example
+   * ```ts
+   * const uri = UserAgent.makeURI("sip:edgar@example.com");
+   * ```
+   */
+  public static makeURI(uri: string): URI | undefined {
+    return Grammar.URIParse(uri);
+  }
+
+  /** Default user agent options. */
+  private static defaultOptions(): Required<UserAgentOptions> {
+    return {
+      allowLegacyNotifications: false,
+      authorizationHa1: "",
+      authorizationPassword: "",
+      authorizationUsername: "",
+      autoStart: false,
+      autoStop: true,
+      delegate: {},
+      contactName: "",
+      contactParams: { transport: "ws" },
+      displayName: "",
+      forceRport: false,
+      hackAllowUnregisteredOptionTags: false,
+      hackIpInContact: false,
+      hackViaTcp: false,
+      logBuiltinEnabled: true,
+      logConfiguration: true,
+      logConnector: (): void => {
+        /* noop */
+      },
+      logLevel: "log",
+      noAnswerTimeout: 60,
+      preloadedRouteSet: [],
+      reconnectionAttempts: 0,
+      reconnectionDelay: 4,
+      sendInitialProvisionalResponse: true,
+      sessionDescriptionHandlerFactory: defaultSessionDescriptionHandlerFactory(),
+      sessionDescriptionHandlerFactoryOptions: {},
+      sipExtension100rel: SIPExtension.Unsupported,
+      sipExtensionReplaces: SIPExtension.Unsupported,
+      sipExtensionExtraSupported: [],
+      sipjsId: "",
+      transportConstructor: WebTransport,
+      transportOptions: {},
+      uri: new URI("sip", "anonymous", "anonymous.invalid"),
+      userAgentString: "SIP.js/" + LIBRARY_VERSION,
+      viaHost: ""
+    };
+  }
+
+  /**
+   * Strip properties with undefined values from options.
+   * This is a work around while waiting for missing vs undefined to be addressed (or not)...
+   * https://github.com/Microsoft/TypeScript/issues/13195
+   * @param options - Options to reduce
+   */
+  private static stripUndefinedProperties(options: Partial<UserAgentOptions>): Partial<UserAgentOptions> {
+    return Object.keys(options).reduce((object, key) => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      if ((options as any)[key] !== undefined) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (object as any)[key] = (options as any)[key];
+      }
+      return object;
+    }, {});
+  }
+
+  /**
+   * User agent configuration.
+   */
+  public get configuration(): Required<UserAgentOptions> {
+    return this.options;
+  }
+
+  /**
+   * User agent contact.
+   */
+  public get contact(): Contact {
+    return this._contact;
+  }
+
+  /**
+   * User agent state.
+   */
+  public get state(): UserAgentState {
+    return this._state;
+  }
+
+  /**
+   * User agent state change emitter.
+   */
+  public get stateChange(): Emitter<UserAgentState> {
+    return this._stateEventEmitter;
+  }
+
+  /**
+   * User agent transport.
+   */
+  public get transport(): Transport {
+    return this._transport;
+  }
+
+  /**
+   * User agent core.
+   */
+  public get userAgentCore(): UserAgentCore {
+    return this._userAgentCore;
+  }
+
+  /**
+   * The logger.
+   */
+  public getLogger(category: string, label?: string): Logger {
+    return this.loggerFactory.getLogger(category, label);
+  }
+
+  /**
+   * The logger factory.
+   */
+  public getLoggerFactory(): LoggerFactory {
+    return this.loggerFactory;
+  }
+
+  /**
+   * True if transport is connected.
+   */
+  public isConnected(): boolean {
+    return this.transport.isConnected();
+  }
+
+  /**
+   * Reconnect the transport.
+   */
+  public reconnect(): Promise<void> {
+    if (this.state === UserAgentState.Stopped) {
+      return Promise.reject(new Error("User agent stopped."));
+    }
+    // Make sure we don't call synchronously
+    return Promise.resolve().then(() => this.transport.connect());
+  }
+
+  /**
+   * Start the user agent.
+   *
+   * @remarks
+   * Resolves if transport connects, otherwise rejects.
+   *
+   * @example
+   * ```ts
+   * userAgent.start()
+   *   .then(() => {
+   *     // userAgent.isConnected() === true
+   *   })
+   *   .catch((error: Error) => {
+   *     // userAgent.isConnected() === false
+   *   });
+   * ```
+   */
+  public start(): Promise<void> {
+    if (this.state === UserAgentState.Started) {
+      this.logger.warn(`User agent already started`);
+      return Promise.resolve();
+    }
+    this.logger.log(`Starting ${this.configuration.uri}`);
+
+    // Transition state
+    this.transitionState(UserAgentState.Started);
+
+    // TODO: Review this as it is not clear it has any benefit and at worst causes additional load the server.
+    // On unload it may be best to simply in most scenarios to do nothing. Furthermore and regardless, this
+    // kind of behavior seems more appropriate to be managed by the consumer of the API than the API itself.
+    // Should this perhaps be deprecated?
+    //
+    // Add window unload event listener
+    if (this.options.autoStop) {
+      // Google Chrome Packaged Apps don't allow 'unload' listeners: unload is not available in packaged apps
+      const googleChromePackagedApp = typeof chrome !== "undefined" && chrome.app && chrome.app.runtime ? true : false;
+      if (typeof window !== "undefined" && typeof window.addEventListener === "function" && !googleChromePackagedApp) {
+        window.addEventListener("unload", this.unloadListener);
+      }
+    }
+
+    return this.transport.connect();
+  }
+
+  /**
+   * Stop the user agent.
+   *
+   * @remarks
+   * Resolves when the user agent has completed a graceful shutdown.
+   * ```txt
+   * 1) Sessions terminate.
+   * 2) Registerers unregister.
+   * 3) Subscribers unsubscribe.
+   * 4) Publishers unpublish.
+   * 5) Transport disconnects.
+   * 6) User Agent Core resets.
+   * ```
+   * NOTE: While this is a "graceful shutdown", it can also be very slow one if you
+   * are waiting for the returned Promise to resolve. The disposal of the clients and
+   * dialogs is done serially - waiting on one to finish before moving on to the next.
+   * This can be slow if there are lot of subscriptions to unsubscribe for example.
+   *
+   * THE SLOW PACE IS INTENTIONAL!
+   * While one could spin them all down in parallel, this could slam the remote server.
+   * It is bad practice to denial of service attack (DoS attack) servers!!!
+   * Moreover, production servers will automatically blacklist clients which send too
+   * many requests in too short a period of time - dropping any additional requests.
+   *
+   * If a different approach to disposing is needed, one can implement whatever is
+   * needed and execute that prior to calling `stop()`. Alternatively one may simply
+   * not wait for the Promise returned by `stop()` to complete.
+   */
+  public async stop(): Promise<void> {
+    if (this.state === UserAgentState.Stopped) {
+      this.logger.warn(`User agent already stopped`);
+      return Promise.resolve();
+    }
+    this.logger.log(`Stopping ${this.configuration.uri}`);
+
+    // Transition state
+    this.transitionState(UserAgentState.Stopped);
+
+    // TODO: See comments with associated complimentary code in start(). Should this perhaps be deprecated?
+    // Remove window unload event listener
+    if (this.options.autoStop) {
+      // Google Chrome Packaged Apps don't allow 'unload' listeners: unload is not available in packaged apps
+      const googleChromePackagedApp = typeof chrome !== "undefined" && chrome.app && chrome.app.runtime ? true : false;
+      if (typeof window !== "undefined" && window.removeEventListener && !googleChromePackagedApp) {
+        window.removeEventListener("unload", this.unloadListener);
+      }
+    }
+
+    // Be careful here to use a local references as start() can be called
+    // again before we complete and we don't want to touch new clients
+    // and we don't want to step on the new instances (or vice versa).
+    const publishers = { ...this._publishers };
+    const registerers = { ...this._registerers };
+    const sessions = { ...this._sessions };
+    const subscriptions = { ...this._subscriptions };
+    const transport = this.transport;
+    const userAgentCore = this.userAgentCore;
+
+    //
+    // At this point we have completed the state transition and everything
+    // following will effectively run async and MUST NOT cause any issues
+    // if UserAgent.start() is called while the following code continues.
+    //
+    // TODO: Minor optimization.
+    // The disposal in all cases involves, in part, sending messages which
+    // is not worth doing if the transport is not connected as we know attempting
+    // to send messages will be futile. But none of these disposal methods check
+    // if that's is the case and it would be easy for them to do so at this point.
+
+    // Dispose of Registerers
+    this.logger.log(`Dispose of registerers`);
+    for (const id in registerers) {
+      if (registerers[id]) {
+        await registerers[id].dispose().catch((error: Error) => {
+          this.logger.error(error.message);
+          delete this._registerers[id];
+          throw error;
+        });
+      }
+    }
+
+    // Dispose of Sessions
+    this.logger.log(`Dispose of sessions`);
+    for (const id in sessions) {
+      if (sessions[id]) {
+        await sessions[id].dispose().catch((error: Error) => {
+          this.logger.error(error.message);
+          delete this._sessions[id];
+          throw error;
+        });
+      }
+    }
+
+    // Dispose of Subscriptions
+    this.logger.log(`Dispose of subscriptions`);
+    for (const id in subscriptions) {
+      if (subscriptions[id]) {
+        await subscriptions[id].dispose().catch((error: Error) => {
+          this.logger.error(error.message);
+          delete this._subscriptions[id];
+          throw error;
+        });
+      }
+    }
+
+    // Dispose of Publishers
+    this.logger.log(`Dispose of publishers`);
+    for (const id in publishers) {
+      if (publishers[id]) {
+        await publishers[id].dispose().catch((error: Error) => {
+          this.logger.error(error.message);
+          delete this._publishers[id];
+          throw error;
+        });
+      }
+    }
+
+    // Dispose of the transport (disconnecting)
+    this.logger.log(`Dispose of transport`);
+    await transport.dispose().catch((error: Error) => {
+      this.logger.error(error.message);
+      throw error;
+    });
+
+    // Dispose of the user agent core (resetting)
+    this.logger.log(`Dispose of core`);
+    userAgentCore.dispose();
+  }
+
+  /**
+   * Used to avoid circular references.
+   * @internal
+   */
+  public _makeInviter(targetURI: URI, options?: InviterOptions): Inviter {
+    return new Inviter(this, targetURI, options);
+  }
+
+  /**
+   * Attempt reconnection up to `maxReconnectionAttempts` times.
+   * @param reconnectionAttempt - Current attempt number.
+   */
+  private attemptReconnection(reconnectionAttempt = 1): void {
+    const reconnectionAttempts = this.options.reconnectionAttempts;
+    const reconnectionDelay = this.options.reconnectionDelay;
+
+    if (reconnectionAttempt > reconnectionAttempts) {
+      this.logger.log(`Maximum reconnection attempts reached`);
+      return;
+    }
+
+    this.logger.log(`Reconnection attempt ${reconnectionAttempt} of ${reconnectionAttempts} - trying`);
+    setTimeout(
+      () => {
+        this.reconnect()
+          .then(() => {
+            this.logger.log(`Reconnection attempt ${reconnectionAttempt} of ${reconnectionAttempts} - succeeded`);
+          })
+          .catch((error: Error) => {
+            this.logger.error(error.message);
+            this.logger.log(`Reconnection attempt ${reconnectionAttempt} of ${reconnectionAttempts} - failed`);
+            this.attemptReconnection(++reconnectionAttempt);
+          });
+      },
+      reconnectionAttempt === 1 ? 0 : reconnectionDelay * 1000
+    );
+  }
+
+  /**
+   * Initialize contact.
+   */
+  private initContact(): Contact {
+    const contactName = this.options.contactName !== "" ? this.options.contactName : createRandomToken(8);
+    const contactParams = this.options.contactParams;
+    const contact = {
+      pubGruu: undefined,
+      tempGruu: undefined,
+      uri: new URI("sip", contactName, this.options.viaHost, undefined, contactParams),
+      toString: (contactToStringOptions: { anonymous?: boolean; outbound?: boolean } = {}): string => {
+        const anonymous = contactToStringOptions.anonymous || false;
+        const outbound = contactToStringOptions.outbound || false;
+        let contactString = "<";
+        if (anonymous) {
+          contactString +=
+            this.contact.tempGruu ||
+            `sip:anonymous@anonymous.invalid;transport=${contactParams.transport ? contactParams.transport : "ws"}`;
+        } else {
+          contactString += this.contact.pubGruu || this.contact.uri;
+        }
+        if (outbound) {
+          contactString += ";ob";
+        }
+        contactString += ">";
+        return contactString;
+      }
+    };
+    return contact;
+  }
+
+  /**
+   * Initialize user agent core.
+   */
+  private initCore(): UserAgentCore {
+    // supported options
+    let supportedOptionTags: Array<string> = [];
+    supportedOptionTags.push("outbound"); // TODO: is this really supported?
+    if (this.options.sipExtension100rel === SIPExtension.Supported) {
+      supportedOptionTags.push("100rel");
+    }
+    if (this.options.sipExtensionReplaces === SIPExtension.Supported) {
+      supportedOptionTags.push("replaces");
+    }
+    if (this.options.sipExtensionExtraSupported) {
+      supportedOptionTags.push(...this.options.sipExtensionExtraSupported);
+    }
+    if (!this.options.hackAllowUnregisteredOptionTags) {
+      supportedOptionTags = supportedOptionTags.filter((optionTag) => UserAgentRegisteredOptionTags[optionTag]);
+    }
+    supportedOptionTags = Array.from(new Set(supportedOptionTags)); // array of unique values
+
+    // FIXME: TODO: This was ported, but this is and was just plain broken.
+    const supportedOptionTagsResponse = supportedOptionTags.slice();
+    if (this.contact.pubGruu || this.contact.tempGruu) {
+      supportedOptionTagsResponse.push("gruu");
+    }
+
+    // core configuration
+    const userAgentCoreConfiguration: UserAgentCoreConfiguration = {
+      aor: this.options.uri,
+      contact: this.contact,
+      displayName: this.options.displayName,
+      loggerFactory: this.loggerFactory,
+      hackViaTcp: this.options.hackViaTcp,
+      routeSet: this.options.preloadedRouteSet,
+      supportedOptionTags,
+      supportedOptionTagsResponse,
+      sipjsId: this.options.sipjsId,
+      userAgentHeaderFieldValue: this.options.userAgentString,
+      viaForceRport: this.options.forceRport,
+      viaHost: this.options.viaHost,
+      authenticationFactory: () => {
+        const username = this.options.authorizationUsername
+          ? this.options.authorizationUsername
+          : this.options.uri.user; // if authorization username not provided, use uri user as username
+        const password = this.options.authorizationPassword ? this.options.authorizationPassword : undefined;
+        const ha1 = this.options.authorizationHa1 ? this.options.authorizationHa1 : undefined;
+        return new DigestAuthentication(this.getLoggerFactory(), ha1, username, password);
+      },
+      transportAccessor: () => this.transport
+    };
+
+    const userAgentCoreDelegate: UserAgentCoreDelegate = {
+      onInvite: (incomingInviteRequest: IncomingInviteRequest): void => {
+        const invitation = new Invitation(this, incomingInviteRequest);
+
+        incomingInviteRequest.delegate = {
+          onCancel: (cancel: IncomingRequestMessage): void => {
+            invitation._onCancel(cancel);
+          },
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
+          onTransportError: (error: TransportError): void => {
+            // A server transaction MUST NOT discard transaction state based only on
+            // encountering a non-recoverable transport error when sending a
+            // response.  Instead, the associated INVITE server transaction state
+            // machine MUST remain in its current state.  (Timers will eventually
+            // cause it to transition to the "Terminated" state).
+            // https://tools.ietf.org/html/rfc6026#section-7.1
+
+            // As noted in the comment above, we are to leaving it to the transaction
+            // timers to eventually cause the transaction to sort itself out in the case
+            // of a transport failure in an invite server transaction. This delegate method
+            // is here simply here for completeness and to make it clear that it provides
+            // nothing more than informational hook into the core. That is, if you think
+            // you should be trying to deal with a transport error here, you are likely wrong.
+            this.logger.error("A transport error has occurred while handling an incoming INVITE request.");
+          }
+        };
+
+        // FIXME: Ported - 100 Trying send should be configurable.
+        // Only required if TU will not respond in 200ms.
+        // https://tools.ietf.org/html/rfc3261#section-17.2.1
+        incomingInviteRequest.trying();
+
+        // The Replaces header contains information used to match an existing
+        // SIP dialog (call-id, to-tag, and from-tag).  Upon receiving an INVITE
+        // with a Replaces header, the User Agent (UA) attempts to match this
+        // information with a confirmed or early dialog.
+        // https://tools.ietf.org/html/rfc3891#section-3
+        if (this.options.sipExtensionReplaces !== SIPExtension.Unsupported) {
+          const message = incomingInviteRequest.message;
+          const replaces = message.parseHeader("replaces");
+          if (replaces) {
+            const callId = replaces.call_id;
+            if (typeof callId !== "string") {
+              throw new Error("Type of call id is not string");
+            }
+            const toTag = replaces.replaces_to_tag;
+            if (typeof toTag !== "string") {
+              throw new Error("Type of to tag is not string");
+            }
+            const fromTag = replaces.replaces_from_tag;
+            if (typeof fromTag !== "string") {
+              throw new Error("type of from tag is not string");
+            }
+            const targetDialogId = callId + toTag + fromTag;
+            const targetDialog = this.userAgentCore.dialogs.get(targetDialogId);
+
+            // If no match is found, the UAS rejects the INVITE and returns a 481
+            // Call/Transaction Does Not Exist response.  Likewise, if the Replaces
+            // header field matches a dialog which was not created with an INVITE,
+            // the UAS MUST reject the request with a 481 response.
+            // https://tools.ietf.org/html/rfc3891#section-3
+            if (!targetDialog) {
+              invitation.reject({ statusCode: 481 });
+              return;
+            }
+
+            // If the Replaces header field matches a confirmed dialog, it checks
+            // for the presence of the "early-only" flag in the Replaces header
+            // field.  (This flag allows the UAC to prevent a potentially
+            // undesirable race condition described in Section 7.1.) If the flag is
+            // present, the UA rejects the request with a 486 Busy response.
+            // https://tools.ietf.org/html/rfc3891#section-3
+            if (!targetDialog.early && replaces.early_only === true) {
+              invitation.reject({ statusCode: 486 });
+              return;
+            }
+
+            // Provide a handle on the session being replaced.
+            const targetSession = this._sessions[callId + fromTag] || this._sessions[callId + toTag] || undefined;
+            if (!targetSession) {
+              throw new Error("Session does not exist.");
+            }
+            invitation._replacee = targetSession;
+          }
+        }
+
+        // Delegate invitation handling.
+        if (this.delegate?.onInvite) {
+          if (invitation.autoSendAnInitialProvisionalResponse) {
+            invitation.progress().then(() => {
+              if (this.delegate?.onInvite === undefined) {
+                throw new Error("onInvite undefined.");
+              }
+              this.delegate.onInvite(invitation);
+            });
+            return;
+          }
+          this.delegate.onInvite(invitation);
+          return;
+        }
+
+        // A common scenario occurs when the callee is currently not willing or
+        // able to take additional calls at this end system.  A 486 (Busy Here)
+        // SHOULD be returned in such a scenario.
+        // https://tools.ietf.org/html/rfc3261#section-13.3.1.3
+        invitation.reject({ statusCode: 486 });
+      },
+      onMessage: (incomingMessageRequest: IncomingMessageRequest): void => {
+        if (this.delegate && this.delegate.onMessage) {
+          const message = new Message(incomingMessageRequest);
+          this.delegate.onMessage(message);
+        } else {
+          // Accept the MESSAGE request, but do nothing with it.
+          incomingMessageRequest.accept();
+        }
+      },
+      onNotify: (incomingNotifyRequest: IncomingNotifyRequest): void => {
+        // NOTIFY requests are sent to inform subscribers of changes in state to
+        // which the subscriber has a subscription.  Subscriptions are created
+        // using the SUBSCRIBE method.  In legacy implementations, it is
+        // possible that other means of subscription creation have been used.
+        // However, this specification does not allow the creation of
+        // subscriptions except through SUBSCRIBE requests and (for backwards-
+        // compatibility) REFER requests [RFC3515].
+        // https://tools.ietf.org/html/rfc6665#section-3.2
+        if (this.delegate && this.delegate.onNotify) {
+          const notification = new Notification(incomingNotifyRequest);
+          this.delegate.onNotify(notification);
+        } else {
+          // Per the above which obsoletes https://tools.ietf.org/html/rfc3265,
+          // the use of out of dialog NOTIFY is obsolete, but...
+          if (this.options.allowLegacyNotifications) {
+            incomingNotifyRequest.accept(); // Accept the NOTIFY request, but do nothing with it.
+          } else {
+            incomingNotifyRequest.reject({ statusCode: 481 });
+          }
+        }
+      },
+      onRefer: (incomingReferRequest: IncomingReferRequest): void => {
+        this.logger.warn("Received an out of dialog REFER request");
+        // TOOD: this.delegate.onRefer(...)
+        if (this.delegate && this.delegate.onReferRequest) {
+          this.delegate.onReferRequest(incomingReferRequest);
+        } else {
+          incomingReferRequest.reject({ statusCode: 405 });
+        }
+      },
+      onRegister: (incomingRegisterRequest: IncomingRegisterRequest): void => {
+        this.logger.warn("Received an out of dialog REGISTER request");
+        // TOOD: this.delegate.onRegister(...)
+        if (this.delegate && this.delegate.onRegisterRequest) {
+          this.delegate.onRegisterRequest(incomingRegisterRequest);
+        } else {
+          incomingRegisterRequest.reject({ statusCode: 405 });
+        }
+      },
+      onSubscribe: (incomingSubscribeRequest: IncomingSubscribeRequest): void => {
+        this.logger.warn("Received an out of dialog SUBSCRIBE request");
+        // TOOD: this.delegate.onSubscribe(...)
+        if (this.delegate && this.delegate.onSubscribeRequest) {
+          this.delegate.onSubscribeRequest(incomingSubscribeRequest);
+        } else {
+          incomingSubscribeRequest.reject({ statusCode: 405 });
+        }
+      }
+    };
+
+    return new UserAgentCore(userAgentCoreConfiguration, userAgentCoreDelegate);
+  }
+
+  private initTransportCallbacks(): void {
+    this.transport.onConnect = (): void => this.onTransportConnect();
+    this.transport.onDisconnect = (error?: Error): void => this.onTransportDisconnect(error);
+    this.transport.onMessage = (message: string): void => this.onTransportMessage(message);
+  }
+
+  private onTransportConnect(): void {
+    if (this.state === UserAgentState.Stopped) {
+      return;
+    }
+    if (this.delegate && this.delegate.onConnect) {
+      this.delegate.onConnect();
+    }
+  }
+
+  private onTransportDisconnect(error?: Error): void {
+    if (this.state === UserAgentState.Stopped) {
+      return;
+    }
+    if (this.delegate && this.delegate.onDisconnect) {
+      this.delegate.onDisconnect(error);
+    }
+    // Only attempt to reconnect if network/server dropped the connection.
+    if (error && this.options.reconnectionAttempts > 0) {
+      this.attemptReconnection();
+    }
+  }
+
+  private onTransportMessage(messageString: string): void {
+    const message = Parser.parseMessage(messageString, this.getLogger("sip.Parser"));
+    if (!message) {
+      this.logger.warn("Failed to parse incoming message. Dropping.");
+      return;
+    }
+
+    if (this.state === UserAgentState.Stopped && message instanceof IncomingRequestMessage) {
+      this.logger.warn(`Received ${message.method} request while stopped. Dropping.`);
+      return;
+    }
+
+    // A valid SIP request formulated by a UAC MUST, at a minimum, contain
+    // the following header fields: To, From, CSeq, Call-ID, Max-Forwards,
+    // and Via; all of these header fields are mandatory in all SIP
+    // requests.
+    // https://tools.ietf.org/html/rfc3261#section-8.1.1
+    const hasMinimumHeaders = (): boolean => {
+      const mandatoryHeaders: Array<string> = ["from", "to", "call_id", "cseq", "via"];
+      for (const header of mandatoryHeaders) {
+        if (!message.hasHeader(header)) {
+          this.logger.warn(`Missing mandatory header field : ${header}.`);
+          return false;
+        }
+      }
+      return true;
+    };
+
+    // Request Checks
+    if (message instanceof IncomingRequestMessage) {
+      // This is port of SanityCheck.minimumHeaders().
+      if (!hasMinimumHeaders()) {
+        this.logger.warn(`Request missing mandatory header field. Dropping.`);
+        return;
+      }
+
+      // FIXME: This is non-standard and should be a configurable behavior (desirable regardless).
+      // Custom SIP.js check to reject request from ourself (this instance of SIP.js).
+      // This is port of SanityCheck.rfc3261_16_3_4().
+      if (!message.toTag && message.callId.substr(0, 5) === this.options.sipjsId) {
+        this.userAgentCore.replyStateless(message, { statusCode: 482 });
+        return;
+      }
+
+      // FIXME: This should be Transport check before we get here (Section 18).
+      // Custom SIP.js check to reject requests if body length wrong.
+      // This is port of SanityCheck.rfc3261_18_3_request().
+      const len: number = utf8Length(message.body);
+      const contentLength: string | undefined = message.getHeader("content-length");
+      if (contentLength && len < Number(contentLength)) {
+        this.userAgentCore.replyStateless(message, { statusCode: 400 });
+        return;
+      }
+    }
+
+    // Response Checks
+    if (message instanceof IncomingResponseMessage) {
+      // This is port of SanityCheck.minimumHeaders().
+      if (!hasMinimumHeaders()) {
+        this.logger.warn(`Response missing mandatory header field. Dropping.`);
+        return;
+      }
+
+      // Custom SIP.js check to drop responses if multiple Via headers.
+      // This is port of SanityCheck.rfc3261_8_1_3_3().
+      if (message.getHeaders("via").length > 1) {
+        this.logger.warn("More than one Via header field present in the response. Dropping.");
+        return;
+      }
+
+      // FIXME: This should be Transport check before we get here (Section 18).
+      // Custom SIP.js check to drop responses if bad Via header.
+      // This is port of SanityCheck.rfc3261_18_1_2().
+      if (message.via.host !== this.options.viaHost || message.via.port !== undefined) {
+        this.logger.warn("Via sent-by in the response does not match UA Via host value. Dropping.");
+        return;
+      }
+
+      // FIXME: This should be Transport check before we get here (Section 18).
+      // Custom SIP.js check to reject requests if body length wrong.
+      // This is port of SanityCheck.rfc3261_18_3_response().
+      const len: number = utf8Length(message.body);
+      const contentLength: string | undefined = message.getHeader("content-length");
+      if (contentLength && len < Number(contentLength)) {
+        this.logger.warn("Message body length is lower than the value in Content-Length header field. Dropping.");
+        return;
+      }
+    }
+
+    // Handle Request
+    if (message instanceof IncomingRequestMessage) {
+      this.userAgentCore.receiveIncomingRequestFromTransport(message);
+      return;
+    }
+
+    // Handle Response
+    if (message instanceof IncomingResponseMessage) {
+      this.userAgentCore.receiveIncomingResponseFromTransport(message);
+      return;
+    }
+
+    throw new Error("Invalid message type.");
+  }
+
+  /**
+   * Transition state.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  private transitionState(newState: UserAgentState, error?: Error): void {
+    const invalidTransition = (): void => {
+      throw new Error(`Invalid state transition from ${this._state} to ${newState}`);
+    };
+
+    // Validate state transition
+    switch (this._state) {
+      case UserAgentState.Started:
+        if (newState !== UserAgentState.Stopped) {
+          invalidTransition();
+        }
+        break;
+      case UserAgentState.Stopped:
+        if (newState !== UserAgentState.Started) {
+          invalidTransition();
+        }
+        break;
+      default:
+        throw new Error("Unknown state.");
+    }
+
+    // Update state
+    this.logger.log(`Transitioned from ${this._state} to ${newState}`);
+    this._state = newState;
+    this._stateEventEmitter.emit(this._state);
+  }
+
+  /** Unload listener. */
+  private unloadListener = (): void => {
+    this.stop();
+  };
+}