support Multiple Handshake Message

Author: shinyoshiaki

package.json

@@ -23,6 +23,7 @@
     "ci": "run-s type:all build test doc",
     "clean": "rm -rf packages/*/node_modules",
     "datachannel": "ts-node-dev examples/datachannel/offer.ts",
+    "debug": "DEBUG=werift* tsx watch examples/mediachannel/sendrecv/answer.ts",
     "doc": "npm run doc --workspaces --if-present && rm -rf doc && cd packages/webrtc && mv doc ../..",
     "e2e": "cd e2e && npm run ci:silent",
     "e2e:verbose": "cd e2e && npm run ci",

packages/dtls/src/record/receive.ts

@@ -14,8 +14,10 @@ export const parsePacket = (data: Buffer) => {
   const packets: DtlsPlaintext[] = [];
   while (data.length > start) {
     const fragmentLength = data.readUInt16BE(start + 11);
-    if (data.length < start + (12 + fragmentLength)) break;
-    const packet = DtlsPlaintext.deSerialize(data.slice(start));
+    if (data.length < start + (12 + fragmentLength)) {
+      break;
+    }
+    const packet = DtlsPlaintext.deSerialize(data.subarray(start));
     packets.push(packet);
 
     start += 13 + fragmentLength;
@@ -25,16 +27,24 @@ export const parsePacket = (data: Buffer) => {
 };
 
 export const parsePlainText =
-  (dtls: DtlsContext, cipher: CipherContext) => (plain: DtlsPlaintext) => {
+  (dtls: DtlsContext, cipher: CipherContext) =>
+  (
+    plain: DtlsPlaintext,
+  ): {
+    type: ContentType;
+    data: any;
+  }[] => {
     const contentType = plain.recordLayerHeader.contentType;
 
     switch (contentType) {
       case ContentType.changeCipherSpec: {
         log(dtls.sessionId, "change cipher spec");
-        return {
-          type: ContentType.changeCipherSpec,
-          data: undefined,
-        };
+        return [
+          {
+            type: ContentType.changeCipherSpec,
+            data: undefined,
+          },
+        ];
       }
       case ContentType.handshake: {
         let raw = plain.fragment;
@@ -48,20 +58,29 @@ export const parsePlainText =
           throw error;
         }
         try {
-          return {
-            type: ContentType.handshake,
-            data: FragmentedHandshake.deSerialize(raw),
-          };
+          let start = 0;
+          const handshakes: { type: ContentType; data: any }[] = [];
+          while (raw.length > start) {
+            const handshake = FragmentedHandshake.deSerialize(
+              raw.subarray(start),
+            );
+            handshakes.push({ type: ContentType.handshake, data: handshake });
+            start += handshake.fragment_length + 12;
+          }
+
+          return handshakes;
         } catch (error) {
           err(dtls.sessionId, "decSerialize failed", error, raw);
           throw error;
         }
       }
       case ContentType.applicationData: {
-        return {
-          type: ContentType.applicationData,
-          data: cipher.decryptPacket(plain),
-        };
+        return [
+          {
+            type: ContentType.applicationData,
+            data: cipher.decryptPacket(plain),
+          },
+        ];
       }
       case ContentType.alert: {
         let alert = Alert.deSerialize(plain.fragment);
@@ -84,10 +103,10 @@ export const parsePlainText =
         if (alert.level > 1) {
           throw new Error("alert fatal error");
         }
-        return { type: ContentType.alert, data: undefined };
+        return [{ type: ContentType.alert, data: undefined }];
       }
       default: {
-        return { type: ContentType.alert, data: undefined };
+        return [{ type: ContentType.alert, data: undefined }];
       }
     }
   };

packages/dtls/src/socket.ts

@@ -81,39 +81,41 @@ export class DtlsSocket {
 
     for (const packet of packets) {
       try {
-        const message = parsePlainText(this.dtls, this.cipher)(packet);
-        switch (message.type) {
-          case ContentType.handshake:
-            {
-              const handshake = message.data as FragmentedHandshake;
-              const handshakes = this.handleFragmentHandshake([handshake]);
-              const assembled = Object.values(
-                handshakes.reduce(
-                  (acc: { [type: string]: FragmentedHandshake[] }, cur) => {
-                    if (!acc[cur.msg_type]) acc[cur.msg_type] = [];
-                    acc[cur.msg_type].push(cur);
-                    return acc;
-                  },
-                  {},
-                ),
-              )
-                .map((v) => FragmentedHandshake.assemble(v))
-                .sort((a, b) => a.msg_type - b.msg_type);
+        const messages = parsePlainText(this.dtls, this.cipher)(packet);
+        for (const message of messages) {
+          switch (message.type) {
+            case ContentType.handshake:
+              {
+                const handshake = message.data as FragmentedHandshake;
+                const handshakes = this.handleFragmentHandshake([handshake]);
+                const assembled = Object.values(
+                  handshakes.reduce(
+                    (acc: { [type: string]: FragmentedHandshake[] }, cur) => {
+                      if (!acc[cur.msg_type]) acc[cur.msg_type] = [];
+                      acc[cur.msg_type].push(cur);
+                      return acc;
+                    },
+                    {},
+                  ),
+                )
+                  .map((v) => FragmentedHandshake.assemble(v))
+                  .sort((a, b) => a.msg_type - b.msg_type);
 
-              this.onHandleHandshakes(assembled).catch((error) => {
-                err(this.dtls.sessionId, "onHandleHandshakes error", error);
-                this.onError.execute(error);
-              });
-            }
-            break;
-          case ContentType.applicationData:
-            {
-              this.onData.execute(message.data as Buffer);
-            }
-            break;
-          case ContentType.alert:
-            this.onClose.execute();
-            break;
+                this.onHandleHandshakes(assembled).catch((error) => {
+                  err(this.dtls.sessionId, "onHandleHandshakes error", error);
+                  this.onError.execute(error);
+                });
+              }
+              break;
+            case ContentType.applicationData:
+              {
+                this.onData.execute(message.data as Buffer);
+              }
+              break;
+            case ContentType.alert:
+              this.onClose.execute();
+              break;
+          }
         }
       } catch (error) {
         err(this.dtls.sessionId, "catch udpOnMessage error", error);