werift 0.20.1 → 0.21.0

package/src/peerConnection.ts

@@ -81,7 +81,6 @@ const log = debug("werift:packages/webrtc/src/peerConnection.ts");
 export class RTCPeerConnection extends EventTarget {
   readonly cname = uuid.v4();
   sctpTransport?: RTCSctpTransport;
-  transportEstablished = false;
   config: Required<PeerConfig> = cloneDeep<PeerConfig>(defaultPeerConfig);
   connectionState: ConnectionState = "new";
   iceConnectionState: RTCIceConnectionState = "new";
@@ -95,8 +94,7 @@ export class RTCPeerConnection extends EventTarget {
   private replaceTransceiver(t: RTCRtpTransceiver, index: number) {
     this.transceivers[index] = t;
   }
-
-  candidatesSent = new Set<string>();
+  needRestart = false;
 
   readonly iceGatheringStateChange = new Event<[IceGathererState]>();
   readonly iceConnectionStateChange = new Event<[RTCIceConnectionState]>();
@@ -117,7 +115,7 @@ export class RTCPeerConnection extends EventTarget {
   onconnectionstatechange?: Callback;
 
   private readonly router = new RtpRouter();
-  private readonly certificates: RTCCertificate[] = [];
+  private certificate?: RTCCertificate;
   sctpRemotePort?: number;
   private seenMid = new Set<string>();
   private currentLocalDescription?: SessionDescription;
@@ -147,9 +145,28 @@ export class RTCPeerConnection extends EventTarget {
     return this.router.extIdUriMap;
   }
 
+  get iceGeneration() {
+    return this.iceTransports[0].connection.generation;
+  }
+
   constructor(config: Partial<PeerConfig> = {}) {
     super();
 
+    this.setConfiguration(config);
+
+    this.iceConnectionStateChange.subscribe((state) => {
+      switch (state) {
+        case "disconnected":
+          this.setConnectionState("disconnected");
+          break;
+        case "closed":
+          this.close();
+          break;
+      }
+    });
+  }
+
+  setConfiguration(config: Partial<PeerConfig>) {
     deepMerge(this.config, config);
 
     if (this.config.icePortRange) {
@@ -194,23 +211,15 @@ export class RTCPeerConnection extends EventTarget {
 
     if (this.config.dtls) {
       const { keys } = this.config.dtls;
+
       if (keys) {
-        this.certificates.push(
-          new RTCCertificate(keys.keyPem, keys.certPem, keys.signatureHash),
+        this.certificate = new RTCCertificate(
+          keys.keyPem,
+          keys.certPem,
+          keys.signatureHash,
         );
       }
     }
-
-    this.iceConnectionStateChange.subscribe((state) => {
-      switch (state) {
-        case "disconnected":
-          this.setConnectionState("disconnected");
-          break;
-        case "closed":
-          this.close();
-          break;
-      }
-    });
   }
 
   get localDescription() {
@@ -251,8 +260,16 @@ export class RTCPeerConnection extends EventTarget {
     return this.config;
   }
 
-  async createOffer() {
+  async createOffer({ iceRestart }: { iceRestart?: boolean } = {}) {
+    if (iceRestart || this.needRestart) {
+      this.needRestart = false;
+      for (const t of this.iceTransports) {
+        t.restart();
+      }
+    }
+
     await this.ensureCerts();
+
     const description = this.buildOfferSdp();
     return description.toJSON();
   }
@@ -465,7 +482,9 @@ export class RTCPeerConnection extends EventTarget {
 
   private needNegotiation = async () => {
     this.shouldNegotiationneeded = true;
-    if (this.negotiationneeded || this.signalingState !== "stable") return;
+    if (this.negotiationneeded || this.signalingState !== "stable") {
+      return;
+    }
     this.shouldNegotiationneeded = false;
     setImmediate(() => {
       this.negotiationneeded = true;
@@ -493,12 +512,13 @@ export class RTCPeerConnection extends EventTarget {
       additionalHostAddresses: this.config.iceAdditionalHostAddresses,
       filterStunResponse: this.config.iceFilterStunResponse,
       filterCandidatePair: this.config.iceFilterCandidatePair,
+      localPasswordPrefix: this.config.icePasswordPrefix,
       useIpv4: this.config.iceUseIpv4,
       useIpv6: this.config.iceUseIpv6,
       turnTransport: this.config.forceTurnTCP === true ? "tcp" : "udp",
     });
     if (existing) {
-      iceGatherer.connection.localUserName = existing.connection.localUserName;
+      iceGatherer.connection.localUsername = existing.connection.localUsername;
       iceGatherer.connection.localPassword = existing.connection.localPassword;
     }
     iceGatherer.onGatheringStateChange.subscribe(() => {
@@ -509,8 +529,10 @@ export class RTCPeerConnection extends EventTarget {
     iceTransport.onStateChange.subscribe(() => {
       this.updateIceConnectionState();
     });
-
-    iceTransport.iceGather.onIceCandidate = (candidate) => {
+    iceTransport.onNegotiationNeeded.subscribe(() => {
+      this.needNegotiation();
+    });
+    iceTransport.onIceCandidate.subscribe((candidate) => {
       if (!this.localDescription) {
         log("localDescription not found when ice candidate was gathered");
         return;
@@ -549,28 +571,18 @@ export class RTCPeerConnection extends EventTarget {
 
       candidate.foundation = "candidate:" + candidate.foundation;
 
-      // prevent ice candidates that have already been sent from being being resent
-      // when the connection is renegotiated during a later setLocalDescription call.
-      if (candidate.sdpMid) {
-        const candidateKey = `${candidate.foundation}:${candidate.sdpMid}`;
-        if (this.candidatesSent.has(candidateKey)) {
-          return;
-        }
-        this.candidatesSent.add(candidateKey);
-      }
-
       this.onIceCandidate.execute(candidate.toJSON());
       if (this.onicecandidate) {
         this.onicecandidate({ candidate: candidate.toJSON() });
       }
       this.emit("icecandidate", { candidate });
-    };
+    });
 
     const dtlsTransport = new RTCDtlsTransport(
       this.config,
       iceTransport,
       this.router,
-      this.certificates,
+      this.certificate,
       srtpProfiles,
     );
 
@@ -617,7 +629,7 @@ export class RTCPeerConnection extends EventTarget {
     }
 
     // # assign MID
-    description.media.forEach((media, i) => {
+    for (const [i, media] of enumerate(description.media)) {
       const mid = media.rtp.muxId!;
       this.seenMid.add(mid);
       if (["audio", "video"].includes(media.kind)) {
@@ -629,9 +641,10 @@ export class RTCPeerConnection extends EventTarget {
       if (media.kind === "application" && this.sctpTransport) {
         this.sctpTransport.mid = mid;
       }
-    });
+    }
 
-    const setupRole = (dtlsTransport: RTCDtlsTransport) => {
+    // setup ice,dtls role
+    for (const dtlsTransport of this.dtlsTransports) {
       const iceTransport = dtlsTransport.iceTransport;
 
       // # set ICE role
@@ -654,34 +667,22 @@ export class RTCPeerConnection extends EventTarget {
           dtlsTransport.role = role;
         }
       }
-    };
-    this.dtlsTransports.forEach((d) => setupRole(d));
+    }
 
     // # configure direction
     if (["answer", "pranswer"].includes(description.type)) {
-      this.transceivers.forEach((t) => {
+      for (const t of this.transceivers) {
         const direction = andDirection(t.direction, t.offerDirection);
         t.setCurrentDirection(direction);
-      });
+      }
     }
 
     // for trickle ice
     this.setLocal(description);
 
-    // # gather candidates
-    const connected = this.iceTransports.find(
-      (transport) => transport.state === "connected",
-    );
-    if (this.remoteIsBundled && connected) {
-      // no need to gather ice candidates on an existing bundled connection
-      await connected.iceGather.gather();
-    } else {
-      await Promise.allSettled(
-        this.iceTransports.map((iceTransport) =>
-          iceTransport.iceGather.gather(),
-        ),
-      );
-    }
+    await this.gatherCandidates().catch((e) => {
+      log("gatherCandidates failed", e);
+    });
 
     // connect transports
     if (description.type === "answer") {
@@ -700,6 +701,20 @@ export class RTCPeerConnection extends EventTarget {
     return description;
   }
 
+  private async gatherCandidates() {
+    // # gather candidates
+    const connected = this.iceTransports.find(
+      (transport) => transport.state === "connected",
+    );
+    if (this.remoteIsBundled && connected) {
+      // no need to gather ice candidates on an existing bundled connection
+    } else {
+      await Promise.allSettled(
+        this.iceTransports.map((iceTransport) => iceTransport.gather()),
+      );
+    }
+  }
+
   private setLocal(description: SessionDescription) {
     description.media
       .filter((m) => ["audio", "video"].includes(m.kind))
@@ -771,20 +786,25 @@ export class RTCPeerConnection extends EventTarget {
   }
 
   private async connect() {
-    if (this.transportEstablished) {
-      return;
-    }
     log("start connect");
 
-    this.setConnectionState("connecting");
-
     await Promise.allSettled(
       this.dtlsTransports.map(async (dtlsTransport) => {
         const { iceTransport } = dtlsTransport;
+        if (iceTransport.state === "connected") {
+          return;
+        }
+
+        this.setConnectionState("connecting");
+
         await iceTransport.start().catch((err) => {
           log("iceTransport.start failed", err);
           throw err;
         });
+
+        if (dtlsTransport.state === "connected") {
+          return;
+        }
         await dtlsTransport.start().catch((err) => {
           log("dtlsTransport.start failed", err);
           throw err;
@@ -801,7 +821,6 @@ export class RTCPeerConnection extends EventTarget {
       }),
     );
 
-    this.transportEstablished = true;
     this.setConnectionState("connected");
   }
 
@@ -851,7 +870,7 @@ export class RTCPeerConnection extends EventTarget {
     return receiveParameters;
   }
 
-  get remoteIsBundled() {
+  private get remoteIsBundled() {
     const remoteSdp = this._remoteDescription;
     if (!remoteSdp) {
       return undefined;
@@ -862,6 +881,11 @@ export class RTCPeerConnection extends EventTarget {
     return bundle;
   }
 
+  restartIce() {
+    this.needRestart = true;
+    this.needNegotiation();
+  }
+
   async setRemoteDescription(sessionDescription: RTCSessionDescriptionInit) {
     if (
       !sessionDescription.sdp ||
@@ -954,9 +978,11 @@ export class RTCPeerConnection extends EventTarget {
 
       const iceTransport = dtlsTransport.iceTransport;
 
-      if (remoteMedia.iceParams && remoteMedia.dtlsParams) {
-        iceTransport.setRemoteParams(remoteMedia.iceParams);
-        dtlsTransport.setRemoteParams(remoteMedia.dtlsParams);
+      if (remoteMedia.iceParams) {
+        const renomination = !!remoteSdp.media.find(
+          (m) => m.direction === "inactive",
+        );
+        iceTransport.setRemoteParams(remoteMedia.iceParams, renomination);
 
         // One agent full, one lite:  The full agent MUST take the controlling role, and the lite agent MUST take the controlled role
         // RFC 8445 S6.1.1
@@ -964,6 +990,9 @@ export class RTCPeerConnection extends EventTarget {
           iceTransport.connection.iceControlling = true;
         }
       }
+      if (remoteMedia.dtlsParams) {
+        dtlsTransport.setRemoteParams(remoteMedia.dtlsParams);
+      }
 
       // # add ICE candidates
       remoteMedia.iceCandidates.forEach(iceTransport.addRemoteCandidate);
@@ -1035,13 +1064,17 @@ export class RTCPeerConnection extends EventTarget {
       const localCodecs = this.config.codecs[remoteMedia.kind] || [];
 
       const existCodec = findCodecByMimeType(localCodecs, remoteCodec);
-      if (!existCodec) return false;
+      if (!existCodec) {
+        return false;
+      }
 
       if (existCodec?.name.toLowerCase() === "rtx") {
         const params = codecParametersFromString(existCodec.parameters ?? "");
         const pt = params["apt"];
         const origin = remoteMedia.rtp.codecs.find((c) => c.payloadType === pt);
-        if (!origin) return false;
+        if (!origin) {
+          return false;
+        }
         return !!findCodecByMimeType(localCodecs, origin);
       }
 
@@ -1315,22 +1348,18 @@ export class RTCPeerConnection extends EventTarget {
   }
 
   private async ensureCerts() {
-    const ensureCert = async (dtlsTransport: RTCDtlsTransport) => {
-      if (this.certificates.length === 0) {
-        const localCertificate = await dtlsTransport.setupCertificate();
-        this.certificates.push(localCertificate);
-      } else {
-        dtlsTransport.localCertificate = this.certificates[0];
-      }
-    };
+    if (!this.certificate) {
+      this.certificate = await RTCDtlsTransport.SetupCertificate();
+    }
 
     for (const dtlsTransport of this.dtlsTransports) {
-      await ensureCert(dtlsTransport);
+      dtlsTransport.localCertificate = this.certificate;
     }
   }
 
   async createAnswer() {
     await this.ensureCerts();
+
     const description = this.buildAnswer();
     return description.toJSON();
   }
@@ -1393,11 +1422,11 @@ export class RTCPeerConnection extends EventTarget {
 
     if (this.config.bundlePolicy !== "disable") {
       const bundle = new GroupDescription("BUNDLE", []);
-      description.media.forEach((media) => {
+      for (const media of description.media) {
         if (media.direction !== "inactive") {
           bundle.items.push(media.rtp.muxId!);
         }
-      });
+      }
       description.group.push(bundle);
     }
 
@@ -1440,8 +1469,8 @@ export class RTCPeerConnection extends EventTarget {
 
     function allMatch(...state: IceGathererState[]) {
       return (
-        all.filter((check) => state.includes(check.iceGather.gatheringState))
-          .length === all.length
+        all.filter((check) => state.includes(check.gatheringState)).length ===
+        all.length
       );
     }
 
@@ -1451,9 +1480,7 @@ export class RTCPeerConnection extends EventTarget {
       newState = "complete";
     } else if (!all.length || allMatch("new", "complete")) {
       newState = "new";
-    } else if (
-      all.map((check) => check.iceGather.gatheringState).includes("gathering")
-    ) {
+    } else if (all.map((check) => check.gatheringState).includes("gathering")) {
       newState = "gathering";
     } else {
       newState = "new";
@@ -1520,7 +1547,9 @@ export class RTCPeerConnection extends EventTarget {
     log("connectionStateChange", state);
     this.connectionState = state;
     this.connectionStateChange.execute(state);
-    if (this.onconnectionstatechange) this.onconnectionstatechange();
+    if (this.onconnectionstatechange) {
+      this.onconnectionstatechange();
+    }
     this.emit("connectionstatechange");
   }
 
@@ -1600,11 +1629,10 @@ export function addTransportDescription(
   dtlsTransport: RTCDtlsTransport,
 ) {
   const iceTransport = dtlsTransport.iceTransport;
-  const iceGatherer = iceTransport.iceGather;
 
-  media.iceCandidates = iceGatherer.localCandidates;
-  media.iceCandidatesComplete = iceGatherer.gatheringState === "complete";
-  media.iceParams = iceGatherer.localParameters;
+  media.iceCandidates = iceTransport.localCandidates;
+  media.iceCandidatesComplete = iceTransport.gatheringState === "complete";
+  media.iceParams = iceTransport.localParameters;
   media.iceOptions = "trickle";
 
   media.host = DISCARD_HOST;
@@ -1672,6 +1700,7 @@ export interface PeerConfig {
   dtls: Partial<{
     keys: DtlsKeys;
   }>;
+  icePasswordPrefix: string | undefined;
   bundlePolicy: BundlePolicy;
   debug: Partial<{
     /**% */
@@ -1739,6 +1768,7 @@ export const defaultPeerConfig: PeerConfig = {
   iceUseIpv6: true,
   iceFilterStunResponse: undefined,
   iceFilterCandidatePair: undefined,
+  icePasswordPrefix: undefined,
   dtls: {},
   bundlePolicy: "max-compat",
   debug: {},

package/src/sdp.ts

@@ -563,15 +563,22 @@ function ipAddressToSdp(addr: string) {
 
 export function candidateToSdp(c: IceCandidate) {
   let sdp = `${c.foundation} ${c.component} ${c.protocol} ${c.priority} ${c.ip} ${c.port} typ ${c.type}`;
-  if (c.relatedAddress) {
+  if (c.relatedAddress != undefined) {
     sdp += ` raddr ${c.relatedAddress}`;
   }
-  if (c.relatedPort) {
+  if (c.relatedPort != undefined) {
     sdp += ` rport ${c.relatedPort}`;
   }
-  if (c.tcpType) {
+  if (c.tcpType != undefined) {
     sdp += ` tcptype ${c.tcpType}`;
   }
+  if (c.generation != undefined) {
+    sdp += ` generation ${c.generation}`;
+  }
+  if (c.ufrag != undefined) {
+    sdp += ` ufrag ${c.ufrag}`;
+  }
+
   return sdp;
 }
 
@@ -644,6 +651,12 @@ export function candidateFromSdp(sdp: string) {
       case "tcptype":
         candidate.tcpType = bits[i + 1];
         break;
+      case "generation":
+        candidate.generation = Number.parseInt(bits[i + 1]);
+        break;
+      case "ufrag":
+        candidate.ufrag = bits[i + 1];
+        break;
     }
   });
 

package/src/transport/dtls.ts

@@ -18,7 +18,7 @@ import {
 } from "../../../dtls/src/cipher/const";
 import { CipherContext } from "../../../dtls/src/context/cipher";
 import type { Profile } from "../../../dtls/src/context/srtp";
-import type { Connection } from "../../../ice/src";
+import type { IceConnection } from "../../../ice/src";
 import {
   type RtcpPacket,
   RtcpPacketConverter,
@@ -51,18 +51,18 @@ export class RTCDtlsTransport {
 
   readonly onStateChange = new Event<[DtlsState]>();
 
-  localCertificate?: RTCCertificate;
-  localCertificatePromise?: Promise<RTCCertificate>;
+  static localCertificate?: RTCCertificate;
+  static localCertificatePromise?: Promise<RTCCertificate>;
   private remoteParameters?: RTCDtlsParameters;
 
   constructor(
     readonly config: PeerConfig,
     readonly iceTransport: RTCIceTransport,
     readonly router: RtpRouter,
-    readonly certificates: RTCCertificate[],
+    public localCertificate?: RTCCertificate,
     private readonly srtpProfiles: Profile[] = [],
   ) {
-    this.localCertificate = this.certificates[0];
+    this.localCertificate ??= RTCDtlsTransport.localCertificate;
   }
 
   get localParameters() {
@@ -72,7 +72,7 @@ export class RTCDtlsTransport {
     );
   }
 
-  async setupCertificate() {
+  static async SetupCertificate() {
     if (this.localCertificate) {
       return this.localCertificate;
     }
@@ -360,10 +360,12 @@ export class RTCDtlsParameters {
 }
 
 class IceTransport implements Transport {
-  constructor(private ice: Connection) {
+  constructor(private ice: IceConnection) {
     ice.onData.subscribe((buf) => {
       if (isDtls(buf)) {
-        if (this.onData) this.onData(buf);
+        if (this.onData) {
+          this.onData(buf);
+        }
       }
     });
   }
@@ -378,4 +380,4 @@ class IceTransport implements Transport {
   }
 }
 
-const createIceTransport = (ice: Connection) => new IceTransport(ice);
+const createIceTransport = (ice: IceConnection) => new IceTransport(ice);