@webex/plugin-meetings 3.8.0-next.5 → 3.8.0-next.51

package/src/member/index.ts

@@ -23,6 +23,7 @@ export default class Member {
   isInMeeting: any;
   isModerator: any;
   isModeratorAssignmentProhibited: any;
+  isPresenterAssignmentProhibited: any;
   isMutable: any;
   isNotAdmitted: any;
   isRecording: any;
@@ -257,6 +258,14 @@ export default class Member {
      */
     this.isModeratorAssignmentProhibited = null;
 
+    /**
+     * @instance
+     * @type {Boolean}
+     * @public
+     * @memberof Member
+     */
+    this.isPresenterAssignmentProhibited = null;
+
     /**
      * @instance
      * @type {IExternalRoles}
@@ -309,6 +318,8 @@ export default class Member {
       this.isModerator = MemberUtil.isModerator(participant);
       this.isModeratorAssignmentProhibited =
         MemberUtil.isModeratorAssignmentProhibited(participant);
+      this.isPresenterAssignmentProhibited =
+        MemberUtil.isPresenterAssignmentProhibited(participant);
       this.processStatus(participant);
       this.processRoles(participant as ParticipantWithRoles);
       // must be done last

package/src/member/util.ts

@@ -127,6 +127,9 @@ MemberUtil.isDevice = (participant: any) => participant && participant.type ===
 MemberUtil.isModeratorAssignmentProhibited = (participant) =>
   participant && participant.moderatorAssignmentNotAllowed;
 
+MemberUtil.isPresenterAssignmentProhibited = (participant) =>
+  participant && participant.presenterAssignmentNotAllowed;
+
 /**
  * checks to see if the participant id is the same as the passed id
  * there are multiple ids that can be used

package/src/metrics/constants.ts

@@ -48,10 +48,19 @@ const BEHAVIORAL_METRICS = {
   UPLOAD_LOGS_FAILURE: 'js_sdk_upload_logs_failure',
   UPLOAD_LOGS_SUCCESS: 'js_sdk_upload_logs_success',
   RECEIVE_TRANSCRIPTION_FAILURE: 'js_sdk_receive_transcription_failure',
+  MEETING_IS_IN_PROGRESS_ERROR: 'js_sdk_meeting_is_in_progress_error',
+  STATIC_MEETING_LINK_ALREADY_EXISTS_ERROR: 'js_sdk_static_meeting_link_already_exists_error',
   FETCH_MEETING_INFO_V1_SUCCESS: 'js_sdk_fetch_meeting_info_v1_success',
   FETCH_MEETING_INFO_V1_FAILURE: 'js_sdk_fetch_meeting_info_v1_failure',
+  ENABLE_STATIC_METTING_LINK_SUCCESS: 'js_sdk_enable_static_meeting_link_success',
+  ENABLE_STATIC_METTING_LINK_FAILURE: 'js_sdk_enable_static_meeting_link_failure',
+  DISABLE_STATIC_MEETING_LINK_SUCCESS: 'js_sdk_disable_static_meeting_link_success',
+  DISABLE_STATIC_MEETING_LINK_FAILURE: 'js_sdk_disable_static_meeting_link_failure',
   ADHOC_MEETING_SUCCESS: 'js_sdk_adhoc_meeting_success',
   ADHOC_MEETING_FAILURE: 'js_sdk_adhoc_meeting_failure',
+  FETCH_STATIC_MEETING_LINK_SUCCESS: 'js_sdk_fetch_static_meeting_link_success',
+  FETCH_STATIC_MEETING_LINK_FAILURE: 'js_sdk_fetch_static_meeting_link_failure',
+  MEETING_LINK_DOES_NOT_EXIST_ERROR: 'js_sdk_meeting_link_does_not_exist_error',
   VERIFY_PASSWORD_SUCCESS: 'js_sdk_verify_password_success',
   VERIFY_PASSWORD_ERROR: 'js_sdk_verify_password_error',
   VERIFY_CAPTCHA_ERROR: 'js_sdk_verify_captcha_error',

package/src/reachability/clusterReachability.ts

@@ -6,7 +6,7 @@ import {convertStunUrlToTurn, convertStunUrlToTurnTls} from './util';
 import EventsScope from '../common/events/events-scope';
 
 import {CONNECTION_STATE, Enum, ICE_GATHERING_STATE} from '../constants';
-import {ClusterReachabilityResult} from './reachability.types';
+import {ClusterReachabilityResult, NatType} from './reachability.types';
 
 // data for the Events.resultReady event
 export type ResultEventData = {
@@ -22,9 +22,14 @@ export type ClientMediaIpsUpdatedEventData = {
   clientMediaIPs: string[];
 };
 
+export type NatTypeUpdatedEventData = {
+  natType: NatType;
+};
+
 export const Events = {
   resultReady: 'resultReady', // emitted when a cluster is reached successfully using specific protocol
   clientMediaIpsUpdated: 'clientMediaIpsUpdated', // emitted when more public IPs are found after resultReady was already sent for a given protocol
+  natTypeUpdated: 'natTypeUpdated', // emitted when NAT type is determined
 } as const;
 
 export type Events = Enum<typeof Events>;
@@ -41,8 +46,10 @@ export class ClusterReachability extends EventsScope {
   private pc?: RTCPeerConnection;
   private defer: Defer; // this defer is resolved once reachability checks for this cluster are completed
   private startTimestamp: number;
+  private srflxIceCandidates: RTCIceCandidate[] = [];
   public readonly isVideoMesh: boolean;
   public readonly name;
+  public readonly reachedSubnets: Set<string> = new Set();
 
   /**
    * Constructor for ClusterReachability
@@ -228,27 +235,13 @@ export class ClusterReachability extends EventsScope {
    */
   private registerIceGatheringStateChangeListener() {
     this.pc.onicegatheringstatechange = () => {
-      const {COMPLETE} = ICE_GATHERING_STATE;
-
-      if (this.pc.iceConnectionState === COMPLETE) {
+      if (this.pc.iceGatheringState === ICE_GATHERING_STATE.COMPLETE) {
         this.closePeerConnection();
         this.finishReachabilityCheck();
       }
     };
   }
 
-  /**
-   * Checks if we have the results for all the protocols (UDP and TCP)
-   *
-   * @returns {boolean} true if we have all results, false otherwise
-   */
-  private haveWeGotAllResults(): boolean {
-    return ['udp', 'tcp', 'xtls'].every(
-      (protocol) =>
-        this.result[protocol].result === 'reachable' || this.result[protocol].result === 'untested'
-    );
-  }
-
   /**
    * Saves the latency in the result for the given protocol and marks it as reachable,
    * emits the "resultReady" event if this is the first result for that protocol,
@@ -258,9 +251,15 @@ export class ClusterReachability extends EventsScope {
    * @param {string} protocol
    * @param {number} latency
    * @param {string|null} [publicIp]
+   * @param {string|null} [serverIp]
    * @returns {void}
    */
-  private saveResult(protocol: 'udp' | 'tcp' | 'xtls', latency: number, publicIp?: string | null) {
+  private saveResult(
+    protocol: 'udp' | 'tcp' | 'xtls',
+    latency: number,
+    publicIp?: string | null,
+    serverIp?: string | null
+  ) {
     const result = this.result[protocol];
 
     if (result.latencyInMilliseconds === undefined) {
@@ -288,6 +287,48 @@ export class ClusterReachability extends EventsScope {
     } else {
       this.addPublicIP(protocol, publicIp);
     }
+
+    if (serverIp) {
+      this.reachedSubnets.add(serverIp);
+    }
+  }
+
+  /**
+   * Determines NAT Type.
+   *
+   * @param {RTCIceCandidate} candidate
+   * @returns {void}
+   */
+  private determineNatType(candidate: RTCIceCandidate) {
+    this.srflxIceCandidates.push(candidate);
+
+    if (this.srflxIceCandidates.length > 1) {
+      const portsFound: Record<string, Set<number>> = {};
+
+      this.srflxIceCandidates.forEach((c) => {
+        const key = `${c.address}:${c.relatedPort}`;
+        if (!portsFound[key]) {
+          portsFound[key] = new Set();
+        }
+        portsFound[key].add(c.port);
+      });
+
+      Object.entries(portsFound).forEach(([, ports]) => {
+        if (ports.size > 1) {
+          // Found candidates with the same address and relatedPort, but different ports
+          this.emit(
+            {
+              file: 'clusterReachability',
+              function: 'determineNatType',
+            },
+            Events.natTypeUpdated,
+            {
+              natType: NatType.SymmetricNat,
+            }
+          );
+        }
+      });
+    }
   }
 
   /**
@@ -307,19 +348,25 @@ export class ClusterReachability extends EventsScope {
 
       if (e.candidate) {
         if (e.candidate.type === CANDIDATE_TYPES.SERVER_REFLEXIVE) {
-          this.saveResult('udp', latencyInMilliseconds, e.candidate.address);
+          let serverIp = null;
+          if ('url' in e.candidate) {
+            const stunServerUrlRegex = /stun:([\d.]+):\d+/;
+
+            const match = (e.candidate as any).url.match(stunServerUrlRegex);
+            if (match) {
+              // eslint-disable-next-line prefer-destructuring
+              serverIp = match[1];
+            }
+          }
+
+          this.saveResult('udp', latencyInMilliseconds, e.candidate.address, serverIp);
+
+          this.determineNatType(e.candidate);
         }
 
         if (e.candidate.type === CANDIDATE_TYPES.RELAY) {
           const protocol = e.candidate.port === TURN_TLS_PORT ? 'xtls' : 'tcp';
-          this.saveResult(protocol, latencyInMilliseconds);
-          // we don't add public IP for TCP, because in the case of relay candidates
-          // e.candidate.address is the TURN server address, not the client's public IP
-        }
-
-        if (this.haveWeGotAllResults()) {
-          this.closePeerConnection();
-          this.finishReachabilityCheck();
+          this.saveResult(protocol, latencyInMilliseconds, null, e.candidate.address);
         }
       }
     };

package/src/reachability/index.ts

@@ -23,11 +23,13 @@ import {
   ReachabilityResultsForBackend,
   TransportResultForBackend,
   GetClustersTrigger,
+  NatType,
 } from './reachability.types';
 import {
   ClientMediaIpsUpdatedEventData,
   ClusterReachability,
   Events,
+  NatTypeUpdatedEventData,
   ResultEventData,
 } from './clusterReachability';
 import EventsScope from '../common/events/events-scope';
@@ -64,6 +66,7 @@ export default class Reachability extends EventsScope {
   resultsCount = {videoMesh: {udp: 0}, public: {udp: 0, tcp: 0, xtls: 0}};
   startTime = undefined;
   totalDuration = undefined;
+  natType = NatType.Unknown;
 
   protected lastTrigger?: string;
 
@@ -135,6 +138,60 @@ export default class Reachability extends EventsScope {
     }
   }
 
+  /**
+   * Checks if the given subnet is reachable
+   * @param {string} mediaServerIp - media server ip
+   * @returns {boolean | null} true if reachable, false if not reachable, null if mediaServerIp is not provided
+   * @public
+   * @memberof Reachability
+   */
+  public isSubnetReachable(mediaServerIp?: string): boolean | null {
+    if (!mediaServerIp) {
+      LoggerProxy.logger.error(`Reachability:index#isSubnetReachable --> mediaServerIp is null`);
+
+      return null;
+    }
+
+    const subnetFirstOctet = mediaServerIp.split('.')[0];
+
+    LoggerProxy.logger.info(
+      `Reachability:index#isSubnetReachable --> Looking for subnet: ${subnetFirstOctet}.X.X.X`
+    );
+
+    const matchingReachedClusters = Object.values(this.clusterReachability).reduce(
+      (acc, cluster) => {
+        const reachedSubnetsArray = Array.from(cluster.reachedSubnets);
+
+        let logMessage = `Reachability:index#isSubnetReachable --> Cluster ${cluster.name} reached [`;
+        for (let i = 0; i < reachedSubnetsArray.length; i += 1) {
+          const subnet = reachedSubnetsArray[i];
+          const reachedSubnetFirstOctet = subnet.split('.')[0];
+
+          if (subnetFirstOctet === reachedSubnetFirstOctet) {
+            acc.add(cluster.name);
+          }
+
+          logMessage += `${subnet}`;
+          if (i < reachedSubnetsArray.length - 1) {
+            logMessage += ',';
+          }
+        }
+        logMessage += `]`;
+
+        LoggerProxy.logger.info(logMessage);
+
+        return acc;
+      },
+      new Set<string>()
+    );
+
+    LoggerProxy.logger.info(
+      `Reachability:index#isSubnetReachable --> Found ${matchingReachedClusters.size} clusters that use the subnet ${subnetFirstOctet}.X.X.X`
+    );
+
+    return matchingReachedClusters.size > 0;
+  }
+
   /**
    * Gets a list of media clusters from the backend and performs reachability checks on all the clusters
    * @param {string} trigger - explains the reason for starting reachability
@@ -143,6 +200,10 @@ export default class Reachability extends EventsScope {
    * @memberof Reachability
    */
   public async gatherReachability(trigger: string): Promise<ReachabilityResults> {
+    // @ts-ignore
+    if (!this.webex.config.meetings.enableReachabilityChecks) {
+      throw new Error('enableReachabilityChecks is disabled in config');
+    }
     // Fetch clusters and measure latency
     try {
       this.lastTrigger = trigger;
@@ -281,7 +342,7 @@ export default class Reachability extends EventsScope {
         {}
       );
       this.sendMetric(true);
-      this.resolveReachabilityPromise();
+      this.resolveReachabilityPromise(false);
     }
   }
 
@@ -305,6 +366,7 @@ export default class Reachability extends EventsScope {
       reachability_vmn_tcp_failed: 0,
       reachability_vmn_xtls_success: 0,
       reachability_vmn_xtls_failed: 0,
+      natType: this.natType,
     };
 
     const updateStats = (clusterType: 'public' | 'vmn', result: ClusterReachabilityResult) => {
@@ -963,6 +1025,13 @@ export default class Reachability extends EventsScope {
         }
       );
 
+      this.clusterReachability[key].on(
+        Events.natTypeUpdated,
+        async (data: NatTypeUpdatedEventData) => {
+          this.natType = data.natType;
+        }
+      );
+
       this.clusterReachability[key].start(); // not awaiting on purpose
     });
   }

package/src/reachability/reachability.types.ts

@@ -7,6 +7,11 @@ export type TransportResult = {
   clientMediaIPs?: string[];
 };
 
+export enum NatType {
+  Unknown = 'unknown',
+  SymmetricNat = 'symmetric-nat',
+}
+
 // reachability result for a specific media cluster
 export type ClusterReachabilityResult = {
   udp: TransportResult;
@@ -27,6 +32,7 @@ export type ReachabilityMetrics = {
   reachability_vmn_tcp_failed: number;
   reachability_vmn_xtls_success: number;
   reachability_vmn_xtls_failed: number;
+  natType: NatType;
 };
 
 /**

package/src/reachability/request.ts

@@ -45,6 +45,9 @@ class ReachabilityRequest {
     joinCookie: any;
     discoveryOptions?: Record<string, any>;
   }> => {
+    const appType = this.webex?.config?.support?.appType;
+    const appVersion = this.webex?.config?.support?.appVersion;
+
     // we only measure latency for the initial startup call, not for other triggers
     const callWrapper =
       trigger === 'startup'
@@ -67,6 +70,10 @@ class ReachabilityRequest {
               'early-call-min-clusters': true,
             },
             'previous-report': previousReport,
+            ...(appType &&
+              appVersion && {
+                'client-environment': {components: {[appType]: appVersion}},
+              }),
             trigger,
           },
           timeout: this.webex.config.meetings.reachabilityGetClusterTimeout,

package/src/reconnection-manager/index.ts

@@ -591,9 +591,9 @@ export default class ReconnectionManager {
 
     const iceServers = [];
 
-    if (turnServerResult.turnServerInfo?.url) {
+    if (turnServerResult.turnServerInfo?.urls.length > 0) {
       iceServers.push({
-        urls: turnServerResult.turnServerInfo.url,
+        urls: turnServerResult.turnServerInfo.urls,
         username: turnServerResult.turnServerInfo.username || '',
         credential: turnServerResult.turnServerInfo.password || '',
       });

package/src/recording-controller/util.ts

@@ -6,33 +6,37 @@ const canUserStart = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START) ||
-    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_START)) &&
-  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START) &&
+    MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies)) ||
+  (displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_START) &&
+    MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_PREMISE_RECORD, userPolicies));
 
 const canUserPause = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE) ||
-    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_PAUSE)) &&
-  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE) &&
+    MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies)) ||
+  (displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_PAUSE) &&
+    MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_PREMISE_RECORD, userPolicies));
 
 const canUserResume = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME) ||
-    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_RESUME)) &&
-  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME) &&
+    MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies)) ||
+  (displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_RESUME) &&
+    MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_PREMISE_RECORD, userPolicies));
 
 const canUserStop = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP) ||
-    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_STOP)) &&
-  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP) &&
+    MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies)) ||
+  (displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_STOP) &&
+    MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_PREMISE_RECORD, userPolicies));
 
 const isPremiseRecordingEnabled = (
   displayHints: Array<string>,
@@ -42,7 +46,7 @@ const isPremiseRecordingEnabled = (
     displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_PAUSE) ||
     displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_STOP) ||
     displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_RESUME)) &&
-  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
+  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_PREMISE_RECORD, userPolicies);
 
 const extractLocusId = (url: string) => {
   return url?.split('/').pop();

package/src/roap/index.ts

@@ -5,17 +5,13 @@ import {ROAP} from '../constants';
 import LoggerProxy from '../common/logs/logger-proxy';
 
 import RoapRequest from './request';
-import TurnDiscovery, {TurnDiscoveryResult} from './turnDiscovery';
+import TurnDiscovery from './turnDiscovery';
+import {TurnDiscoveryResult} from './types';
 import Meeting from '../meeting';
-import MeetingUtil from '../meeting/util';
 import Metrics from '../metrics';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 
-export {
-  type TurnDiscoveryResult,
-  type TurnServerInfo,
-  type TurnDiscoverySkipReason,
-} from './turnDiscovery';
+export {type TurnDiscoveryResult, type TurnServerInfo, type TurnDiscoverySkipReason} from './types';
 
 /**
  * Roap options

package/src/roap/turnDiscovery.ts

@@ -4,11 +4,11 @@ import {Defer} from '@webex/common';
 import Metrics from '../metrics';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import LoggerProxy from '../common/logs/logger-proxy';
-import {ROAP, Enum} from '../constants';
+import {ROAP} from '../constants';
 
 import RoapRequest from './request';
 import Meeting from '../meeting';
-import MeetingUtil from '../meeting/util';
+import {TurnDiscoverySkipReason, TurnServerInfo, TurnDiscoveryResult} from './types';
 
 const TURN_DISCOVERY_TIMEOUT = 10; // in seconds
 
@@ -18,28 +18,6 @@ const TURN_DISCOVERY_TIMEOUT = 10; // in seconds
 // and do the SDP offer with seq=1
 const TURN_DISCOVERY_SEQ = 0;
 
-const TurnDiscoverySkipReason = {
-  missingHttpResponse: 'missing http response', // when we asked for the TURN discovery response to be in the http response, but it wasn't there
-  reachability: 'reachability', // when udp reachability to public clusters is ok, so we don't need TURN (this doens't apply when joinWithMedia() is used)
-  alreadyInProgress: 'already in progress', // when we try to start TURN discovery while it's already in progress
-} as const;
-
-export type TurnDiscoverySkipReason =
-  | Enum<typeof TurnDiscoverySkipReason> // this is a kind of FYI, because in practice typescript will infer the type of TurnDiscoverySkipReason as a string
-  | string // used in case of errors, contains the error message
-  | undefined; // used when TURN discovery is not skipped
-
-export type TurnServerInfo = {
-  url: string;
-  username: string;
-  password: string;
-};
-
-export type TurnDiscoveryResult = {
-  turnServerInfo?: TurnServerInfo;
-  turnDiscoverySkippedReason: TurnDiscoverySkipReason;
-};
-
 /**
  * Handles the process of finding out TURN server information from Linus.
  * This is achieved by sending a TURN_DISCOVERY_REQUEST.
@@ -53,6 +31,17 @@ export default class TurnDiscovery {
 
   private responseTimer?: ReturnType<typeof setTimeout>;
 
+  /** Resets the turnInfo structure to the defaults
+   * @returns {void}
+   */
+  private resetTurnInfo() {
+    this.turnInfo = {
+      urls: [],
+      username: '',
+      password: '',
+    };
+  }
+
   /**
    * Constructor
    *
@@ -60,11 +49,7 @@ export default class TurnDiscovery {
    */
   constructor(roapRequest: RoapRequest) {
     this.roapRequest = roapRequest;
-    this.turnInfo = {
-      url: '',
-      username: '',
-      password: '',
-    };
+    this.resetTurnInfo();
   }
 
   /**
@@ -134,21 +119,29 @@ export default class TurnDiscovery {
     }
 
     const expectedHeaders = [
-      {headerName: 'x-cisco-turn-url', field: 'url'},
-      {headerName: 'x-cisco-turn-username', field: 'username'},
-      {headerName: 'x-cisco-turn-password', field: 'password'},
+      {headerName: 'x-cisco-turn-url', field: 'urls', multipleAllowed: true},
+      {headerName: 'x-cisco-turn-username', field: 'username', multipleAllowed: false},
+      {headerName: 'x-cisco-turn-password', field: 'password', multipleAllowed: false},
     ];
 
-    let foundHeaders = 0;
+    const foundHeaders = {};
+
+    this.resetTurnInfo();
 
     headers?.forEach((receivedHeader) => {
       // check if it matches any of our expected headers
       expectedHeaders.forEach((expectedHeader) => {
         if (receivedHeader.startsWith(`${expectedHeader.headerName}=`)) {
-          this.turnInfo[expectedHeader.field] = receivedHeader.substring(
-            expectedHeader.headerName.length + 1
-          );
-          foundHeaders += 1;
+          foundHeaders[expectedHeader.headerName] = true;
+
+          const headerValue = receivedHeader.substring(expectedHeader.headerName.length + 1);
+
+          if (expectedHeader.multipleAllowed) {
+            this.turnInfo[expectedHeader.field].push(headerValue);
+          } else {
+            // just store the last one we find
+            this.turnInfo[expectedHeader.field] = headerValue;
+          }
         }
       });
     });
@@ -156,7 +149,7 @@ export default class TurnDiscovery {
     clearTimeout(this.responseTimer);
     this.responseTimer = undefined;
 
-    if (foundHeaders !== expectedHeaders.length) {
+    if (expectedHeaders.some((header) => !foundHeaders[header.headerName])) {
       LoggerProxy.logger.warn(
         `Roap:turnDiscovery#handleTurnDiscoveryResponse --> missing some headers, received ${from}: ${JSON.stringify(
           headers
@@ -169,9 +162,11 @@ export default class TurnDiscovery {
       );
     } else {
       LoggerProxy.logger.info(
-        `Roap:turnDiscovery#handleTurnDiscoveryResponse --> received a valid response ${from}, url=${this.turnInfo.url}`
+        `Roap:turnDiscovery#handleTurnDiscoveryResponse --> received a valid response ${from}, urls=${this.turnInfo.urls}`
       );
 
+      this.turnInfo.urls = this.turnInfo.urls.filter((url) => url !== ''); // remove empty urls, we might get them if we land on video-mesh nodes (VMN)
+
       this.defer.resolve({isOkRequired: !headers?.includes('noOkInTransaction')});
     }
   }

package/src/roap/types.ts

@@ -0,0 +1,23 @@
+import {Enum} from '../constants';
+
+export const TurnDiscoverySkipReason = {
+  missingHttpResponse: 'missing http response', // when we asked for the TURN discovery response to be in the http response, but it wasn't there
+  reachability: 'reachability', // when udp reachability to public clusters is ok, so we don't need TURN (this doens't apply when joinWithMedia() is used)
+  alreadyInProgress: 'already in progress', // when we try to start TURN discovery while it's already in progress
+} as const;
+
+export type TurnDiscoverySkipReason =
+  | Enum<typeof TurnDiscoverySkipReason> // this is a kind of FYI, because in practice typescript will infer the type of TurnDiscoverySkipReason as a string
+  | string // used in case of errors, contains the error message
+  | undefined; // used when TURN discovery is not skipped
+
+export type TurnServerInfo = {
+  urls: string[];
+  username: string;
+  password: string;
+};
+
+export type TurnDiscoveryResult = {
+  turnServerInfo?: TurnServerInfo;
+  turnDiscoverySkippedReason: TurnDiscoverySkipReason;
+};