This document defines a set of ECMAScript APIs in WebIDL to allow data to be sent 13 | and received from another browser or device implementing the QUIC protocol. 14 | The specification for multiplexing of QUIC with STUN/TURN/ZRTP/DTLS/RTP/RTCP 15 | [[RFC9443]] was developed within the IETF AVTCORE Working Group.
16 |22 | This specification extends the WebRTC [[WEBRTC]], ORTC [[ORTC]] and WebTransport 23 | [[WEBTRANSPORT]] APIs to enable peer-to-peer operation using QUIC [[RFC9000]]. 24 | This specification supports the exchange of arbitrary data with remote peers using 25 | NAT-traversal technologies such as ICE, STUN, and TURN. As specified in [[RFC9443]], 26 | QUIC can be multiplexed on the same port as RTP, RTCP, DTLS, STUN and TURN, allowing 27 | the API defined in this specification to be utilized along with the functionality 28 | defined in [[WEBRTC]] and [[ORTC]] including communication using audio/video media 29 | and SCTP data channels. 30 |
31 |32 | This specification defines an interface to QUIC streams [[RFC9000]] as well as 33 | datagrams [[RFC9221]]. By utilizing a QUIC stream per message, it is possible 34 | to implement support for message-based communications (such as {{RTCDataChannel}}) 35 | on top. 36 |
37 |This specification extends the WebTransport API [[WEBTRANSPORT]] 38 | under development within the W3C WebTransport WG.
39 |42 | Conformance requirements phrased as algorithms or specific steps may be 43 | implemented in any manner, so long as the end result is equivalent. (In 44 | particular, the algorithms defined in this specification are intended 45 | to be easy to follow, and not intended to be performant.) 46 |
47 |48 | Implementations that use ECMAScript to implement the APIs defined in 49 | this specification MUST implement them in a manner consistent with the 50 | ECMAScript Bindings defined in the Web IDL specification [[!WEBIDL]], 51 | as this specification uses that specification and terminology. 52 |
53 |57 | The {{EventHandler}} interface, representing a callback used for event 58 | handlers, is defined in [[!HTML]]. 59 |
60 |61 | The concepts [= queue a task =] and [= networking task source =] are 62 | defined in [[!HTML]]. 63 |
64 |65 | The concept [= fire an event =] is defined in [[!DOM]]. 66 |
67 |68 | The terms [= event =], [= event handlers =] and [= event handler event 69 | types =] are defined in [[!HTML]]. 70 |
71 |72 | {{Performance.timeOrigin}} and {{Performance.now()}} are defined in 73 | [[!hr-time]]. 74 |
75 |76 | The terms serializable objects, 77 | [= serialization steps =], and [= deserialization steps =] are defined in [[!HTML]]. 78 |
79 |80 | When referring to exceptions, the terms [= exception/throw =] and 81 | [= exception/created =] are defined in [[!WEBIDL]]. 82 |
83 |84 | The callback {{VoidFunction}} is defined in [[!WEBIDL]]. 85 |
86 |87 | The term "throw" is used as specified in [[!INFRA]]: it terminates the 88 | current processing steps. 89 |
90 |91 | The terms fulfilled, 92 | rejected, resolved, and 94 | settled used in the context of Promises are defined in 95 | [[!ECMASCRIPT-6.0]]. 96 |
97 |98 | WebTransport is defined in [[!WEBTRANSPORT]] Section 5. 99 |
100 |101 | RTCIceTransport is defined in [[!WEBRTC]] Section 5.6 and [[!ORTC]] Section 3. 102 |
103 |104 | RTCCertificate is defined in [[!WEBRTC]] Section 4.9 and [[!ORTC]] Section 15. 105 |
106 |107 | RTCDtlsFingerprint is defined in [[!WEBRTC]] Section 5.5.2 and [[!ORTC]] Section 4.5. 108 |
109 |110 | [[\State]] is defined in [[!WEBTRANSPORT]] Section 5.1. 111 |
112 |
116 | The RTCQuicTransport interface extends the WebTransport interface
117 | to support peer-to-peer use cases, by adding information relating to use of a
118 | QUIC transport with an ICE transport.
119 |
123 | A RTCQuicTransport instance is constructed
124 | using an RTCIceTransport and an optional sequence of
125 | RTCCertificate objects. A
126 | RTCQuicTransport object whose {{RTCQuicTransport/[[State]]}} internal
127 | slot is "closed" or "failed" can be
128 | garbage-collected when it is no longer referenced.
129 |
131 | The QUIC negotiation occurs between transport endpoints determined via ICE. 132 | Multiplexing of QUIC with STUN, TURN, DTLS, RTP and RTCP is defined in [[RFC9443]]. 133 |
134 |
135 | A newly constructed RTCQuicTransport MUST listen and respond to incoming QUIC packets before
137 | start() is called. However, to complete the negotiation it is
138 | necessary to verify the remote fingerprint by computing fingerprints for
139 | the selected remote certificate using the digest algorithms provided
140 | in remoteParameters.fingerprints[].algorithm. If a
141 | calculated fingerprint and algorithm matches a fingerprint and algorithm
142 | included in remoteParameters.fingerprints[],
143 | the remote fingerprint is verified. After the QUIC handshake exchange
144 | completes (but before the remote fingerprint is verified) incoming media packets
145 | may be received. A modest buffer MUST be
146 | provided to avoid loss of media prior to remote fingerprint validation (which can
147 | begin after start() is called).
148 |
154 | [Exposed=Window]
155 | interface RTCQuicTransport : WebTransport {
156 | constructor(RTCIceTransport transport, optional sequence<RTCCertificate> certificates);
157 | readonly attribute RTCIceTransport transport;
158 | RTCQuicParameters getLocalParameters ();
159 | RTCQuicParameters? getRemoteParameters ();
160 | sequence<RTCCertificate> getCertificates ();
161 | sequence<ArrayBuffer> getRemoteCertificates ();
162 | undefined start (RTCQuicParameters remoteParameters);
163 | };
164 |
167 | When RTCQuicTransport.constructor() is invoked,
168 | the user agent MUST run the
169 | following steps:
170 |
state attribute has the
177 | value "closed" [= exception/throw =] an
178 | InvalidStateError and abort these steps.
179 | RTCQuicTransport whose {{RTCQuicTransport/[[State]]}} internal
182 | slot is not "closed", [= exception/throw =] an
183 | InvalidStateError and abort these steps.
184 | null otherwise.
188 | expires attribute of each RTCCertificate
192 | object is in the future. If a certificate has expired, [= exception/throw =]
193 | an InvalidAccessError and abort these steps.
194 | RTCQuicTransport object.
198 | "connecting".
202 | null or is empty,
215 | generate a certificate using the default key generation algorithm
216 | and store it in the {{RTCQuicTransport/[[Certificates]]}} internal slot.
217 | RTCQuicTransport| Parameter | 230 |Type | 231 |Nullable | 232 |Optional | 233 |Description | 234 |
|---|---|---|---|---|
| transport | 237 |RTCIceTransport |
238 | ✘ | 240 |✘ | 242 |243 | |
| certificates | 246 |
247 | sequence<RTCCertificate> |
248 | ✘ | 250 |✔ | 252 |253 | |
transport of type RTCIceTransport, readonlyThe associated RTCIceTransport instance.
267 | When the RTCIceTransport's state
268 | attribute changes values, the user agent MUST
269 | run the following steps:
state attribute is not
277 | "closed", abort these steps.
278 | RTCQuicTransport.
281 | "closed".
285 | getLocalParameters
297 | getLocalParameters() obtains the QUIC parameters of
298 | the local RTCQuicTransport upon construction.
299 | If multiple certificates were provided in the constructor, then
300 | multiple fingerprints will be returned, one for each certificate.
301 | getLocalParameters().role always returns the default
302 | role of a newly constructed RTCQuicTransport;
303 | for a browser this will be auto.
304 |
RTCQuicParameters
310 | getRemoteParameters
315 | getRemoteParameters() obtains
316 | the remote QUIC parameters passed in the
317 | start() method. Prior to calling
318 | start(), null is returned.
319 |
RTCQuicParameters, nullable
325 | getCertificatesgetCertificates() returns the value of the RTCQuicTransport's
330 | {{RTCQuicTransport/[[Certificates]]}} internal slot.
sequence<RTCCertificate>
336 | getRemoteCertificates
341 | getRemoteCertificates() returns the certificate chain in use by the remote side, with each
342 | certificate encoded in binary Distinguished Encoding Rules (DER) [[!X690]].
343 | getRemoteCertificates() returns an empty list prior to
344 | selection of the remote certificate, which is completed once quictransport's
345 | {{RTCQuicTransport/[[State]]}} internal slot transitions to "connected".
346 |
sequence<ArrayBuffer>
352 | start357 | Start QUIC transport negotiation with the parameters of the remote QUIC 358 | transport, including verification of the remote fingerprint. 359 | During connection establishment, use of this API must be indicated 360 | by selecting the ALPN token "q2q" in the crypto handshake. 361 | 362 |
363 |
364 | Only a single QUIC transport can be multiplexed over an ICE transport.
365 | Therefore if a RTCQuicTransport object
366 | quicTransportB is constructed with an
367 | {{RTCIceTransport}} object iceTransport
368 | previously used to construct another RTCQuicTransport
369 | object quicTransportA, then if
370 | quicTransportB.start() is called prior to having called
371 | quicTransportA.stop(), then [= exception/throw =] an
372 | InvalidStateError.
374 | If start is called after a previous start
375 | call, or if quictransport's {{RTCQuicTransport/[[State]]}} internal slot is
376 | "closed", [= exception/throw = ] an InvalidStateError.
377 |
379 | If all of the values of
380 | remoteParameters.fingerprints[j].algorithm
381 | are unsupported, where j goes from 0 to the number of fingerprints,
382 | [= exception/throw =] a NotSupportedError.
383 |
| Parameter | 388 |Type | 389 |Nullable | 390 |Optional | 391 |Description | 392 |
|---|---|---|---|---|
| remoteParameters | 395 |RTCQuicParameters |
396 | ✘ | 398 |✘ | 400 |401 | |
void
406 | The RTCQuicParameters dictionary includes information
415 | relating to QUIC configuration.
dictionary RTCQuicParameters {
418 | RTCQuicRole role = "auto";
419 | required sequence<RTCDtlsFingerprint> fingerprints;
420 | };
421 | role of type RTCQuicRole, defaulting to
427 | "auto"The QUIC role, with a default of auto.
fingerprints of type sequence<{{RTCDtlsFingerprint}}>Sequence of fingerprints, at least one fingerprint for each certificate 435 | (with one computed with the digest algorithm used in the certificate 436 | signature).
437 |RTCQuicRole indicates the role of the QUIC
445 | transport.
enum RTCQuicRole {
448 | "auto",
449 | "client",
450 | "server"
451 | };
452 | | Enumeration description | 456 ||
|---|---|
auto |
459 |
460 | The QUIC role is determined based on the resolved ICE role:
461 | the ICE |
464 |
client |
467 |
468 | The QUIC client role. 469 | |
470 |
server |
473 |
474 | The QUIC server role. 475 | |
476 |
484 | To diagnose QUIC role issues, an application may wish to determine
485 | the desired and actual QUIC role of an RTCQuicTransport.
486 | For a browser implementing ORTC, a RTCQuicTransport
487 | object assumes a QUIC role of auto upon construction.
488 | This implies that the QUIC role is determined by the ICE role. Since
489 | getLocalParameters().role always returns the role assigned
490 | to an RTCQuicTransport object upon construction
491 | (auto for a browser), the getLocalParameters
492 | method cannot be used to determine the desired or actual role of an
493 | RTCQuicTransport.
494 |
496 | An application can determine the desired role of an
497 | RTCQuicTransport from the value of
498 | remoteParameters.role passed to
499 | RTCQuicTransport.start(remoteParameters).
500 | If remoteParameters.role is server
501 | then the desired role of the RTCQuicTransport
502 | is client. If remoteParameters.role
503 | is client then the desired role of the
504 | RTCQuicTransport is server.
505 |
507 | The RTCQuicTransport.transport.onstatechange EventHandler
508 | can be used to determine whether an RTCQuicTransport
509 | transitions to the desired role. When
510 | RTCQuicTransport.transport.state transitions to
511 | connected, if RTCQuicTransport.transport.role
512 | is controlled then the role of the
513 | RTCQuicTransport is client.
514 | If RTCQuicTransport.transport.role
515 | is controlling then the role of the
516 | RTCQuicTransport is server.
517 |
523 | function initiate(mySignaller) {
524 | // Prepare the ICE gatherer
525 | var gatherOptions = {
526 | gatherPolicy: "all",
527 | iceServers: [
528 | { urls: "stun:stun1.example.net" },
529 | { urls: "turn:turn.example.org", username: "user", credential: "myPassword",
530 | credentialType: "password" }
531 | ]
532 | };
533 | var iceGatherer = new RTCIceGatherer(gatherOptions);
534 | // Handle state changes
535 | iceGatherer.onstatechange = function(event) {
536 | myIceGathererStateChange("iceGatherer", event.state);
537 | };
538 | // Handle errors
539 | iceGatherer.onerror = errorHandler;
540 | // Prepare to signal local candidates
541 | iceGatherer.onlocalcandidate = function(event) {
542 | mySignaller.mySendLocalCandidate(event.candidate);
543 | };
544 |
545 | // Start gathering
546 | iceGatherer.gather();
547 | // Create ICE transport
548 | var ice = new RTCIceTransport(iceGatherer);
549 | // Prepare to handle remote ICE candidates
550 | mySignaller.onRemoteCandidate = function(remote) {
551 | ice.addRemoteCandidate(remote.candidate);
552 | };
553 |
554 | // Create the DTLS certificate
555 | var certs;
556 | var keygenAlgorithm = { name: "ECDSA", namedCurve: "P-256" };
557 | RTCCertificate.generateCertificate(keygenAlgorithm).then(function(certificate){
558 | certs[0] = certificate;
559 | }, function(){
560 | trace('Certificate could not be created');
561 | });
562 |
563 | // Create DTLS and QUIC transport
564 | var dtls = new RTCDtlsTransport(ice, certs);
565 | var quic = new RTCQuicTransport(ice, certs);
566 |
567 | mySignaller.sendInitiate({
568 | ice: iceGatherer.getLocalParameters(),
569 | dtls: dtls.getLocalParameters(),
570 | quic: quic.getLocalParameters(),
571 | // ... marshall RtpSender/RtpReceiver capabilities as illustrated in Section 6.5 Example 9.
572 | }, function(remote) {
573 | // Start the ICE, DTLS and QUIC transports
574 | ice.start(iceGatherer, remote.ice, RTCIceRole.controlling);
575 | dtls.start(remote.dtls);
576 | quic.start(remote.quic);
577 | // ... configure RtpSender/RtpReceiver objects as illustrated in Section 6.5 Example 9.
578 | });
579 | }
580 |
581 |
582 | // This is an example of how to answer
583 | // Include some helper functions
584 | import {trace, errorHandler, mySendLocalCandidate, myIceGathererStateChange,
585 | myIceTransportStateChange, myDtlsTransportStateChange} from 'helper';
586 |
587 | function accept(mySignaller, remote) {
588 | var gatherOptions = {
589 | gatherPolicy: "all",
590 | iceServers: [
591 | { urls: "stun:stun1.example.net" },
592 | { urls: "turn:turn.example.org", username: "user", credential: "myPassword",
593 | credentialType: "password" }
594 | ]
595 | };
596 | var iceGatherer = new RTCIceGatherer(gatherOptions);
597 | // Handle state changes
598 | iceGatherer.onstatechange = function(event) {
599 | myIceGathererStateChange("iceGatherer", event.state);
600 | };
601 | // Handle errors
602 | iceGatherer.onerror = errorHandler;
603 | // Prepare to signal local candidates
604 | iceGatherer.onlocalcandidate = function(event) {
605 | mySignaller.mySendLocalCandidate(event.candidate);
606 | };
607 |
608 | // Start gathering
609 | iceGatherer.gather();
610 | // Create ICE transport
611 | var ice = new RTCIceTransport(iceGatherer);
612 | // Prepare to handle remote ICE candidates
613 | mySignaller.onRemoteCandidate = function(remote) {
614 | ice.addRemoteCandidate(remote.candidate);
615 | };
616 |
617 | // Create the DTLS certificate
618 | var certs;
619 | var keygenAlgorithm = { name: "ECDSA", namedCurve: "P-256" };
620 | RTCCertificate.generateCertificate(keygenAlgorithm).then(function(certificate){
621 | certs[0] = certificate;
622 | }, function(){
623 | trace('Certificate could not be created');
624 | });
625 |
626 | // Create DTLS and SCTP transport
627 | var dtls = new RTCDtlsTransport(ice, certs);
628 | var quic = new RTCQuicTransport(ice, certs);
629 |
630 | mySignaller.sendAccept({
631 | ice: iceGatherer.getLocalParameters(),
632 | dtls: dtls.getLocalParameters(),
633 | quic: quic.getLocalParameters(),
634 | // ... marshall RtpSender/RtpReceiver capabilities as illustrated in Section 6.5 Example 9.
635 | });
636 |
637 | // Start the ICE, DTLS and SCTP transports
638 | ice.start(iceGatherer, remote.ice, RTCIceRole.controlled);
639 | dtls.start(remote.dtls);
640 | // Start the QuicTransport
641 | quic.start(remote.quic);
642 |
643 | // ... configure RtpSender/RtpReceiver objects as illustrated in Section 6.5 Example 9.
644 |
645 | }
646 |
647 | 651 | This section is non-normative; it specifies no new behaviour, but 652 | instead summarizes information already present in other parts of the 653 | specification. The overall security considerations of the 654 | APIs and protocols used in WebRTC are described in [[RFC8827]]. 655 |
656 |659 | The QUIC API enables data to be communicated between 660 | browsers and other devices, including other browsers. 661 |
662 |663 | This means that data can be shared between applications 664 | running in different browsers, or between an application running in the 665 | same browser and something that is not a browser. This is an extension 666 | to the Web model which has had barriers against sending data 667 | between entities with different origins. 668 |
669 |670 | This specification provides no user prompts or chrome indicators 671 | for communication; it assumes that once the Web page has been allowed to 672 | access data, it is free to share that data with other entities as it 673 | chooses. Peer-to-peer exchanges of data via QUIC can therefore 674 | occur without any user explicit consent or involvement. 675 |
676 |Since the browser is an active platform executing in a trusted network 680 | environment (inside the firewall), it is important to limit the damage 681 | that the browser can do to other elements on the local network, and it is 682 | important to protect data from interception, manipulation and 683 | modification by untrusted participants.
684 |Mitigations include:
685 |These measures are specified in the relevant IETF documents.
697 |Utilizing the generateCertificate() API in [[!WEBRTC]], it is possible to
701 | generate and store certificates that can subsequently be reused in constructing
702 | RTCQuicTransport objects. These persistent certificates
703 | can therefore be used to identify a user.
This document defines a set of ECMAScript APIs in WebIDL to allow data to be sent 13 | and received between a browser and server implementing the QUIC 14 | protocol. This specification is being developed in conjunction with a protocol 15 | specification developed by the IETF QUIC Working Group.
16 |This specification uses QUIC [[!QUIC-TRANSPORT]] to send data 22 | to and receive data from servers. It can be used like WebSockets 23 | but with support for multiple streams, unidirectional streams, 24 | out-or-order deliver, and unreliable delivery.
25 |The QUIC API presented in this specification 26 | represents a preliminary proposal based on work-in-progress 27 | within the IETF QUIC WG. Since the QUIC transport specification is 28 | a work-in-progress, both the protocol and API are likely to 29 | change significantly going forward.
30 |This specification defines conformance criteria that apply to a single 33 | product: the user agent that implements the interfaces that it 34 | contains.
35 |Conformance requirements phrased as algorithms or specific steps may be 36 | implemented in any manner, so long as the end result is equivalent. (In 37 | particular, the algorithms defined in this specification are intended to be 38 | easy to follow, and not intended to be performant.)
39 |Implementations that use ECMAScript to implement the APIs defined in 40 | this specification MUST implement them 41 | in a manner consistent with the ECMAScript Bindings defined in the Web IDL 42 | specification [[!WEBIDL-1]], as this specification uses that specification 43 | and terminology.
44 |The EventHandler
49 | interface, representing a callback used for event handlers, and the ErrorEvent
51 | interface are defined in [[!HTML51]].
The concepts queue a task, 54 | fires a simple 56 | event and networking 58 | task source are defined in [[!HTML51]].
59 |The term finished reading means that the application has read all
60 | available data up to the STREAM frame with the FIN bit set, which causes
61 | the [[\Readable]] slot to be set to false.
The terms event, event 64 | handlers and event 66 | handler event types are defined in [[!HTML51]].
67 |When referring to exceptions, the terms throw and 69 | create are 71 | defined in [[!WEBIDL-1]].
72 |The terms fulfilled, rejected, 74 | resolved, pending and 75 | settled used in the context of Promises are defined in 76 | [[!ECMASCRIPT-6.0]].
77 |The QuicTransportBase is the base interface
81 | for QuicTransport. Most of the functionality of a
82 | QuicTransport is in the base class to allow for other
83 | subclasses (such as a p2p variant) to share the same interface.
84 |
An QuicTransportBase instance can be associated to
88 | one or more QuicBidirectionalStream,
89 | QuicSendStream, or QuicReceiveStream
90 | instances.
96 | interface QuicTransportBase {
97 | readonly attribute QuicTransportState state;
98 | readonly attribute unsigned short maxDatagramSize;
99 | void stop (QuicTransportStopInfo stopInfo);
100 | Promise<QuicBidirectionalStream> createBidirectionalStream ();
101 | Promise<QuicSendStream> createSendStream (optional QuicStreamParameters parameters);
102 | Promise<void> readyToSendDatagram ();
103 | Promise<boolean> sendDatagram (Uint8Array data);
104 | Promise<sequence<Uint8Array>> receiveDatagrams ();
105 | attribute EventHandler onstatechange;
106 | attribute EventHandler onerror;
107 | attribute EventHandler onreceivestream;
108 | attribute EventHandler onbidirectionalstream;
109 | };
110 | state of type QuicTransportState, readonlyThe current state of the QUIC transport. On getting, it 118 | MUST return the value 119 | of the [[\QuicTransportState]] internal slot.
120 |maxDatagramSize of type unsigned short, readonlyThe maximum size data that may be passed to sendDatagram.
125 |onstatechange of type EventHandlerThis event handler, of event handler event type
130 | statechange, MUST
131 | be fired any time the [[\QuicTransportState]] slot changes, unless
132 | the state changes due to calling stop.
onerror of type EventHandlerThis event handler, of event handler event type error,
138 | MUST be fired on reception of a QUIC
139 | error; an implementation SHOULD include QUIC error information in
141 | error.message (defined in [[!HTML51]] Section 7.1.3.8.2). This
142 | event MUST be fired before the
143 | onstatechange event.
onreceivestream of type EventHandlerThis event handler, of event handler event type
149 | receivestream,
150 | MUST be fired on when data is received
151 | from a newly created remote QuicReceiveStream for the
152 | first time.
153 |
onbidirectionalstream of type EventHandlerThis event handler, of event handler event type
159 | bidirectionalstream,
160 | MUST be fired when data is received
161 | from a newly created remote QuicBidirectionalStream for the
162 | first time.
163 |
stopStops and closes the QuicTransportBase object.
174 | This triggers an Immediate Close as described in [[QUIC-TRANSPORT]] section 10.3.
175 |
When stop is called, the user agent MUST
176 | run the following steps:
QuicTransportBase
179 | on which stop is invoked."closed"
181 | then abort these steps."closed".stopInfo be the first argument.void
194 | | Parameter | 199 |Type | 200 |Nullable | 201 |Optional | 202 |Description | 203 |
|---|---|---|---|---|
| stopInfo | 206 |QuicTransportStopInfo |
207 | ✘ | 209 |✘ | 211 |212 | |
createBidirectionalStreamCreates an QuicBidirectionalStream object.
When createBidectionalStream is called, the user agent
221 | MUST run the following
222 | steps:
Let transport be the QuicTransportBase
226 | on which createBidectionalStream is invoked.
If transport's state is "closed" or
230 | "failed", immediately return a new rejected promise with a
231 | newly created InvalidStateError and abort these steps.
If transport's state is "connected",
235 | immediately return a new resolved promise with a newly created
236 | QuicBidirectionalStream object,
237 | add the QuicBidirectionalStream to the transport
238 | and abort these steps.
Let p be a new promise.
242 |Return p and continue the following steps in 245 | the background.
246 |Resolve p with a newly created
250 | QuicBidirectionalStream object,
251 | add the QuicBidirectionalStream to the transport
252 | when all of the following conditions are met:
transport's state has transitioned to
255 | "connected"Reject p with a newly created
265 | InvalidStateError when all of the following conditions are met:
266 |
transport's state transitions to
268 | "closed" or "failed"Promise<QuicBidirectionalStream>
279 | createSendStreamCreates an QuicSendStream object.
When createSendStream is called, the user agent
285 | MUST run the following
286 | steps:
Let transport be the QuicTransportBase
290 | on which createSendStream is invoked.
If transport's state is "closed" or
294 | "failed", immediately return a new rejected promise with a
295 | newly created InvalidStateError and abort these steps.
If transport's state is "connected",
299 | immediately return a new resolved promise with a newly created
300 | QuicSendStream object,
301 | add the QuicSendStream to the transport
302 | and abort these steps.
Let p be a new promise.
306 |Return p and continue the following steps in 309 | the background.
310 |Resolve p with a newly created
314 | QuicSendStream object,
315 | add the QuicSendStream to the transport
316 | when all of the following conditions are met:
transport's state has transitioned to
319 | "connected"Reject p with a newly created
329 | InvalidStateError when all of the following conditions are met:
330 |
transport's state transitions to
332 | "closed" or "failed"Promise<QuicSendStream>
343 | readyToSendDatagramReturns a promise that will be resolved when the QuicTransport can send 348 | a datagram as defined by [[QUIC-DATAGRAM]].
349 |When readyToSendDatagram is called, the user agent
350 | MUST run the following
351 | steps:
Let p be a new promise.
355 |Let transport be the
358 | QuicTransportBase on which
359 | readyToSendDatagram is invoked.
Return p and continue the following steps in 363 | the background.
364 |If transport can send a datagram, imediately resolve 368 | p and abort these steps.
369 |If transport's state is "failed"
372 | or "closed" immediately reject p with a newly
373 | created InvalidStateError and abort these steps.
If transport is blocked from sending a datagram due to
377 | congestion control, resolve p when transport
378 | is no longer blocked.
reject p with a newly created
382 | InvalidStateError if the transport's
383 | state transitions to "failed" or "closed".
Promise<void>
392 | sendDatagramSends a datagram as defined by [[QUIC-DATAGRAM]].
397 |When sendDatagram is called, the user agent
398 | MUST run the following
399 | steps:
Let transport be
404 | the QuicTransportBase on
405 | which sendDatagram is invoked.
If transport's state is not connected return
409 | a promise rejected with a newly created
410 | InvalidStateError and abort these steps.
If data is too large to fit into a
414 | datagram, return a promise rejected with a newly created
415 | InvalidArgumentError and abort these steps.
If transport is unable to send the datagram due
419 | to congestion control, return a promise rejected with
420 | a newly created InvalidStateError and abort
421 | these steps.
Let p be a new promise.
425 |Return p and continue the following steps in 428 | the background.
429 || Parameter | 448 |Type | 449 |Nullable | 450 |Optional | 451 |Description | 452 |
|---|---|---|---|---|
| data | 455 |Uint8Array |
456 | ✘ | 458 |✘ | 460 |461 | |
Promise<boolean>
466 | receiveDatagramsIf datagrams have been received since the last call to receiveDatagrams(), 471 | return a new promise resolved with all of the received datagrams.
472 |If not, return a new promise that will resolve when more datagrams are received, 473 | resolved with all datagrams received.
474 |If too many datagrams are queued between calls to receiveDatagrams(), 475 | the implementation may drop datagrams and replace them with a null value 476 | in the sequence of datagrams returned in the next call to receiveDatagrams(). 477 | One null value may represent many dropped datagrams.
478 |
receiveDatagrams() may only be called once at a time. 479 | If a promised returned from a previous call is still unresolved, 480 | the user agent MUST return a new promise rejected with an InvalidStateError.
481 |Promise<sequence<Uint8Array>>
483 | To add the QuicBidirectionalStream to the QuicTransportBase
495 | run the following steps:
Let stream be the newly created
499 | QuicBidirectionalStream object.
Add stream to transport's [[\QuicTransportReadableStreams]] 503 | internal slot.
504 |Add stream to transport's [[\QuicTransportWritableStreams]] 507 | internal slot.
508 |Continue the following steps in the background.
511 |Create stream's associated underlying data 514 | transport.
515 |To add the QuicSendStream to the QuicTransportBase
521 | run the following steps:
Let stream be the newly created
525 | QuicSendStream object.
Add stream to transport's [[\QuicTransportWritableStreams]] 529 | internal slot.
530 |Continue the following steps in the background.
533 |Create stream's associated underlying data 536 | transport.
537 |The QuicStreamParameters dictionary includes information
544 | relating to QUIC stream configuration.
dictionary QuicStreamParameters {
547 | bool disableRetransmissions = false;
548 | };
549 | disableRetransmissions of type bool, defaulting to
555 | falsedisableRetransmissions, with a default of false. If
558 | true, the stream will be sent without retransmissions. If false, the
559 | stream will be sent with retransmissions.
The receivestream event uses the
568 | ReceiveStreamEvent interface.
571 | [ Constructor (DOMString type, ReceiveStreamEventInit eventInitDict), Exposed=Window]
572 | interface ReceiveStreamEvent : Event {
573 | readonly attribute QuicReceiveStream stream;
574 | };
575 | ReceiveStreamEvent| Parameter | 585 |Type | 586 |Nullable | 587 |Optional | 588 |Description | 589 |
|---|---|---|---|---|
| type | 592 |DOMString |
593 | ✘ | 595 |✘ | 597 |598 | |
| eventInitDict | 601 |ReceiveStreamEventInit |
602 | ✘ | 604 |✘ | 606 |607 | |
stream of type QuicReceiveStream, readonlyThe stream
621 | attribute represents the QuicReceiveStream object
622 | associated with the event.
The ReceiveStreamEventInit dictionary includes
629 | information on the configuration of the QUIC stream.
dictionary ReceiveStreamEventInit : EventInit {
631 | QuicReceiveStream stream;
632 | };
633 | stream of type QuicReceiveStreamThe QuicReceiveStream object associated with the
641 | event.
The bidirectionalstream event uses the
650 | BidirectionalStreamEvent interface.
653 | [ Constructor (DOMString type, BidirectionalStreamEventInit eventInitDict), Exposed=Window]
654 | interface BidirectionalStreamEvent : Event {
655 | readonly attribute QuicBidirectionalStream stream;
656 | };
657 | BidirectionalStreamEvent| Parameter | 667 |Type | 668 |Nullable | 669 |Optional | 670 |Description | 671 |
|---|---|---|---|---|
| type | 674 |DOMString |
675 | ✘ | 677 |✘ | 679 |680 | |
| eventInitDict | 683 |BidirectionalStreamEventInit |
684 | ✘ | 686 |✘ | 688 |689 | |
stream of type QuicBidirectionalStream, readonlyThe stream
703 | attribute represents the QuicBidirectionalStream object
704 | associated with the event.
The BidirectionalStreamEventInit dictionary includes
711 | information on the configuration of the QUIC stream.
dictionary BidirectionalStreamEventInit : EventInit {
713 | QuicBidirectionalStream stream;
714 | };
715 | stream of type QuicBidirectionalStreamThe QuicBidirectionalStream object associated with the
723 | event.
QuicTransportState indicates the state of the QUIC
732 | transport.
enum QuicTransportState {
735 | "new",
736 | "connecting",
737 | "connected",
738 | "closed",
739 | "failed"
740 | };
741 | | Enumeration description | 746 ||
|---|---|
new |
749 |
750 | The |
753 |
connecting |
757 |
758 | QUIC is in the process of negotiating a secure connection.
759 | Once a secure connection is negotiated
760 | (but prior to verification of the remote fingerprint, enabled by calling
761 | |
763 |
connected |
767 |
768 | QUIC has completed negotiation of a secure connection. 769 | Outgoing data and media can now flow through. 770 | |
771 |
closed |
775 |
776 | The QUIC connection has been closed intentionally via a call to
777 |
|
808 |
failed |
812 |
813 | The QUIC connection has been closed as the result of an error (such as
814 | receipt of an error alert or a failure to validate the remote
815 | fingerprint). When the
|
844 |
The QuicTransportStopInfo dictionary includes information
852 | relating to the error code for stopping a QuicTransportBase.
853 | This information is used to set the error code and reason for an CONNECTION_CLOSE
854 | frame.
dictionary QuicTransportStopInfo {
857 | unsigned short errorCode = 0;
858 | DOMString reason = "";
859 | };
860 |
861 | errorCode of type unsigned short, defaulting to
867 | 0.The error code used in CONNECTION_CLOSE frame.
870 |reason of type DOMString, defaulting to ""The reason for stopping the QuicTransportBase
The QuicTransportBase is a subclass of
884 | QuicTransportBase focused on client/server use cases.
889 | [ Constructor (DOMString host, unsigned short port), Exposed=Window]
890 | interface QuicTransport : QuicTransportBase {
891 | };
892 | QuicTransport constructor is invoked,
895 | the user agent MUST run the
896 | following steps:
897 | NotSupportedError and abort these steps.
901 | QuicTransport object.
905 | QuicWritableStream
908 | objects, initialized to empty.
909 | QuicReadableStream
912 | objects, initialized to empty.
913 | "connecting".
917 | Uint8Array, initialized to empty.
920 | Promise<sequence<Uint8Array>>?,
923 | initialized to null.
924 | "failed" and abort these steps.
937 | "failed" and abort these steps.
942 |
943 | ",".
948 | "*",
957 | set quictransport's [[\QuicTransportState]]
958 | internal slot to "connected" and abort these steps.
959 | "failed".
963 | QuicTransport| Parameter | 978 |Type | 979 |Nullable | 980 |Optional | 981 |Description | 982 |
|---|---|---|---|---|
| host | 985 |DOMString |
986 | ✘ | 988 |✘ | 990 |The host to connect to. | 991 |
| port | 994 |unsigned short |
995 | ✘ | 997 |✘ | 999 |The port to connect to. | 1000 |
The QUIC Stream API includes information relating
1012 | to a QUIC stream.
QuicBidirectionalStream, QuicSendStream,
1016 | and QuicReceiveStream instances are associated to
1017 | a QuicTransportBase instance.
An QuicBidirectionalStream can be created in the following ways:
QuicTransportBase's createBidirectionalStream method.bidirectionalstream event on the
1025 | QuicTransportBase.An QuicSendStream can be created in the following ways:
QuicTransportBase's createSendStream method.An QuicReceiveStream can be created in the following
1032 | ways:
receivestream event on the
1035 | QuicTransportBase.
1042 | [ Exposed=Window ]
1043 | interface mixin QuicWritableStream {
1044 | readonly attribute boolean writable;
1045 | readonly attribute unsigned long writeBufferedAmount;
1046 | readonly attribute Promise<QuicStreamAbortInfo> writingAborted;
1047 | void write (QuicStreamWriteParameters data);
1048 | void abortWriting (QuicStreamAbortInfo abortInfo);
1049 | Promise<void> waitForWriteBufferedAmountBelow(unsigned long threshold);
1050 | };
1051 |
1052 | The QuicWritableStream will initialize with
1055 | the following:
QuicWritableStream.true.writable of type boolean
1069 | readonlyThe writable
1072 | attribute represents whether data can be written to the
1073 | QuicWritableStream. On getting it
1074 | MUST return the value of the
1075 | [[\Writable]] slot.
writeBufferedAmount of type unsigned
1078 | long, readonlyThe writeBufferedAmount
1081 | attribute represents the number of bytes of application data
1082 | that have been queued using write but that, as of the last
1083 | time the event loop started executing a task, had not yet been transmitted
1084 | to the network. This includes any data sent during the execution of the
1085 | current task, regardless of whether the user agent is able to
1086 | transmit text asynchronously with script execution. This does not
1087 | include framing overhead incurred by the protocol, or buffering done
1088 | by the operating system or network hardware. On getting, it
1089 | MUST return the value of the
1090 | QuicWritableStream's [[\WriteBufferedAmount]] internal slot.
1091 |
writingAborted of type QuicStreamAbortInfo
1093 | readonlyThe writingAborted
1096 | attribute represents a promise that resolves when the
1097 | STOP_SENDING frame is received from the QuicReadableStream.
1098 | When the stream receives a STOP_SENDING frame from its corresponding
1099 | QuicReadableStream, the user agent
1100 | MUST run the following:
1101 |
QuicWritableStream object.
1103 | false.QuicTransportBase,
1106 | which the stream was created from.
1107 | QuicStreamAbortInfo with the errorCode
1111 | set to the value from the STOP_SENDING frame.writeWrites data to the stream. When the remote QuicTransportBase
1123 | receives the STREAM frame from this stream for the first time, it will trigger the
1124 | creation of the corresponding remote stream. When the write method is
1125 | called, the user agent MUST
1126 | run the following steps:
QuicWritableStream
1130 | object on which data is to be sent.false, throw a NotSupportedError and abort
1133 | these steps.false,
1135 | throw an InvalidStateError and abort these steps.true, run the
1142 | following:false.QuicTransportBase,
1148 | which the stream was created from.QuicTransportBase's onerror
1156 | EventHandler.| Parameter | 1162 |Type | 1163 |Nullable | 1164 |Optional | 1165 |Description | 1166 |
|---|---|---|---|---|
| data | 1169 |QuicStreamWriteParameters |
1170 | ✘ | 1172 |✘ | 1174 |1175 | |
void
1180 | abortWritingA hard shutdown of the QuicWritableStream. It may be called
1185 | regardless of whether the QuicWritableStream
1186 | was created by the local or remote peer. When the abortWriting()
1187 | method is called, the user agent MUST
1188 | run the following steps:
QuicWritableStream object
1191 | which is about to abort writing.false,
1193 | throw an InvalidStateError and abort these steps.false.QuicTransportBase,
1197 | which the stream was created from.| Parameter | 1208 |Type | 1209 |Nullable | 1210 |Optional | 1211 |Description | 1212 |
|---|---|---|---|---|
| abortInfo | 1215 |QuicStreamAbortInfo |
1216 | ✘ | 1218 |✘ | 1220 |1221 | |
void
1226 | waitForWriteBufferedAmountBelowwaitForWriteBufferedAmountBelow resolves the promise when
1231 | the data queued in the write buffer falls below the given threshold.
1232 | If waitForWriteBufferedAmountBelow
1233 | is called multiple times, multiple promises could be resolved when the
1234 | write buffer falls below the threshold for each promise. The Promise will
1235 | be rejected with a newly created InvalidStateError if the
1236 | stream's [[\Writable]] slot transitions from true to false
1237 | and the promise isn't settled. When the waitForWriteBufferedAmountBelow method
1238 | is called, the user agent MUST run
1239 | the following steps:
QuicWritableStream
1242 | object on which waitForWriteBufferedAmountBelow was invoked.false, reject p with a
1246 | newly created InvalidStateError and abort
1247 | these steps.undefined.| Parameter | 1257 |Type | 1258 |Nullable | 1259 |Optional | 1260 |Description | 1261 |
|---|---|---|---|---|
| threshold | 1264 |unsigned long |
1265 | ✘ | 1267 |✘ | 1269 |1270 | |
Promise<void>
1275 |
1285 | [ Exposed=Window ]
1286 | interface mixin QuicReadableStream {
1287 | readonly attribute boolean readable;
1288 | readonly attribute unsigned long readableAmount;
1289 | readonly attribute Promise<QuicStreamAbortInfo> readingAborted;
1290 | QuicStreamReadResult readInto (Uint8Array data);
1291 | void abortReading (QuicStreamAbortInfo abortInfo);
1292 | Promise<void> waitForReadable(unsigned long amount);
1293 | };
1294 |
1295 | The QuicReadableStream will initialize with
1298 | the following:
QuicReadableStream.true.readable of type boolean,
1312 | readonlyThe readable
1315 | attribute represents whether data can be read from the QuicReadableStream.
1316 | On getting, it MUST return the value of the
1317 | QuicReadableStream's [[\Readable]] slot.
1318 |
readableAmount of type unsigned
1320 | long, readonlyThe readableAmount
1323 | attribute represents the number of bytes buffered for access by
1324 | readInto but that, as of the last time the event loop
1325 | started executing a task, had not yet been read. This does not include
1326 | framing overhead incurred by the protocol, or buffers associated with
1327 | the network hardware. On getting, it MUST
1328 | return the value of the QuicReadableStream's
1329 | [[\ReadableAmount]] internal slot.
readingAborted of type QuicStreamAbortInfo
1332 | readonlyThe readingAborted
1335 | attribute represents a promise that resolves when the
1336 | RST_STREAM frame is received from the QuicWritableStream.
1337 | When the stream receives a RST_STREAM frame from its corresponding
1338 | QuicWritableStream, the user agent
1339 | MUST run the following:
1340 |
QuicReadableStream
1342 | objectfalse.QuicTransportBase,
1346 | which the stream was created from.
1347 | QuicStreamAbortInfo with errorCode
1351 | set to the value of the errror code from the RST_STREAM frame.readIntoReads from the QuicReadableStream into the buffer specified
1363 | by the first argument and returns QuicStreamReadResult.
1364 | When the readInto method is called, the user agent
1365 | MUST run the following steps:
QuicReadableStream object
1368 | on which readInto is invoked.false,
1370 | throw an InvalidStateError, then abort these steps.QuicStreamReadResult
1373 | to be returned.amount set to 0 and finished set to
1376 | true and abort these steps.amount to the size of
1381 | data in bytes.finished to true.false.QuicTransportBase,
1389 | which the stream was created from.
1390 | finished to false.| Parameter | 1400 |Type | 1401 |Nullable | 1402 |Optional | 1403 |Description | 1404 |
|---|---|---|---|---|
| data | 1407 |Uint8Array |
1408 | ✘ | 1410 |✘ | 1412 |1413 | |
QuicStreamReadResult
1418 | abortReadingA hard shutdown of the QuicReadableStream. It may be called
1423 | regardless of whether the QuicReadableStream object
1424 | was created by the local or remote peer. When the abortReading()
1425 | method is called, the user agent MUST
1426 | run the following steps:
QuicReadableStream object
1429 | which is about to abort reading.false,
1431 | throw an InvalidStateError and abort these steps.false.QuicTransportBase,
1435 | which the stream was created from.
1436 | | Parameter | 1446 |Type | 1447 |Nullable | 1448 |Optional | 1449 |Description | 1450 |
|---|---|---|---|---|
| abortInfo | 1453 |QuicStreamAbortInfo |
1454 | ✘ | 1456 |✘ | 1458 |1459 | |
void
1464 | waitForReadablewaitForReadable waits for data to become available, or
1469 | for the QuicReadableStream to be finished reading. It
1470 | resolves the promise when the data queued in the read buffer
1471 | increases above the amount provided as an argument or when a STREAM frame
1472 | with the FIN bit set has been received. If waitForReadable
1473 | is called multiple times, multiple promises could be resolved.
1474 | The Promise will be rejected with a newly created
1475 | InvalidStateError if the stream's
1476 | [[\Readable]] slot transitions from true to false and the promise
1477 | isn't settled. When the waitForReadable method is
1478 | called, the user agent MUST
1479 | run the following steps:
QuicReadableStream
1482 | on which waitForReadable is invoked.false, reject p with a
1486 | newly created InvalidStateError and abort
1487 | these steps.undefined when
1490 | any of the following conditions are met:
1491 | | Parameter | 1505 |Type | 1506 |Nullable | 1507 |Optional | 1508 |Description | 1509 |
|---|---|---|---|---|
| amount | 1512 |unsigned long |
1513 | ✘ | 1515 |✘ | 1517 |1518 | |
Promise<void>
1523 |
1533 | [ Exposed=Window ]
1534 | interface QuicStream {
1535 | readonly attribute unsigned long long streamId;
1536 | readonly attribute QuicTransportBase transport;
1537 | };
1538 |
1539 | streamId of type unsigned long long, readonlyThe readonly attribute referring to the ID of the
1547 | QuicStream object.
transport of type QuicTransportBase, readonlyThe readonly attribute referring to the related QuicTransportBase object.
1562 | [ Exposed=Window ]
1563 | interface QuicBidirectionalStream : QuicStream {
1564 | };
1565 | QuicBidirectionalStream includes QuicWritableStream;
1566 | QuicBidirectionalStream includes QuicReadableStream;
1567 |
1568 |
1574 | [ Exposed=Window ]
1575 | interface QuicSendStream : QuicStream {
1576 | };
1577 | QuicSendStream includes QuicWritableStream;
1578 |
1579 |
1585 | [ Exposed=Window ]
1586 | interface QuicReceiveStream : QuicStream {
1587 | };
1588 | QuicReceiveStream includes QuicReadableStream;
1589 |
1590 | The QuicStreamWriteParameters dictionary includes information
1595 | relating to the data to be written with QuicWritableStream.write.
dictionary QuicStreamWriteParameters {
1598 | Uint8Array data;
1599 | boolean finished = false;
1600 | };
1601 |
1602 | data of type Uint8Array.The data to be written.
1610 |finished of type boolean.Set to true if this is the last data to be written.
1615 | This will result in a STREAM frame with the FIN bit set.
The QuicStreamReadResult dictionary includes information
1624 | relating to the result returned from readInto.
dictionary QuicStreamReadResult {
1627 | unsigned long amount;
1628 | boolean finished = false;
1629 | };
1630 |
1631 | amount of type unsigned long.The amount of data read in bytes.
1639 |finished of type boolean.Set to true if the QuicReadableStream has
1644 | finished reading.
The QuicStreamAbortInfo dictionary includes information
1653 | relating to the error code for aborting a QUIC stream. This could be used either
1654 | in a RST_STREAM frame or STOP_SENDING frame.
dictionary QuicStreamAbortInfo {
1657 | unsigned short errorCode = 0;
1658 | };
1659 |
1660 | errorCode of type unsigned short.The error code used in the RST_STREAM or STOP_SENDING frame. 1668 | The default value of 0 means "STOPPING."
1669 |This section is non-normative; it specifies no new behaviour, but 1678 | instead summarizes information already present in other parts of the 1679 | specification.
1680 | 1681 |The fact that communication is taking place cannot be hidden from 1684 | adversaries that can observe the network, so this has to be regarded as 1685 | public information.
1686 |Since the QUIC protocol utilizes a cryptographic negotiation based on 1687 | TLS 1.3 [[TLS13]] in order to encrypt communications, it provides confidentiality.
1688 |The following events fire on QuicTransportBase objects:
| Event name | 1697 |Interface | 1698 |Fired when... | 1699 |
|---|---|---|
error |
1704 | ErrorEvent |
1705 | The QuicTransportBase object has encountered an error. |
1706 |
statechange |
1709 | Event |
1710 | The QuicTransportState changed. |
1711 |
receivestream |
1714 | ReceiveStreamEvent |
1715 | A new QuicReceiveStream is dispatched to the
1716 | script in response to the remote peer creating a send only QUIC stream and
1717 | sending data on it. Prior to receivestream
1718 | firing, the QuicReceiveStream is added to
1719 | QuicTransportBase's [[\QuicTransportReadableStreams]]
1720 | internal slot. |
1721 |
bidirectionalstream |
1724 | BidirectionalStreamEvent |
1725 | A new QuicBidirectionalStream is dispatched to the
1726 | script in response to the remote peer creating a bidirectional QUIC stream and
1727 | sending data on it. Prior to bidirectionalstream
1728 | firing, the QuicBidirectionalStream is added to the
1729 | QuicTransportBase's [[\QuicTransportReadableStreams]]
1730 | and [[\QuicTransportWritableStreams]] internal slots. |
1731 |
Unreliable delivery can be achieved by creating many streams with retransmissions disabled, 1740 | each transporting a single small message.
1741 |
1742 | let quic = getQuicTransport();
1743 | let messages = getMessages();
1744 | for (msg in messages) {
1745 | quic.createSendStream({disableRetransmissions: true}).write({data: msg, finished: true});
1746 | }
1747 |
1748 | Sending a buffer of QUIC datagrams can be achieved by using the
1752 | sendDatagram and readyToSendDatagram methods. In
1753 | the following example datagrams are only sent if the
1754 | QuicTransport is ready to send, however the sending is not
1755 | blocked on the ACK promise returned from sendDatagram (these are
1756 | ignored in this example).
1758 | const quic = getQuicTransport();
1759 | const datagrams = getDatagramsToSend();
1760 | datagrams.forEach((datagram) => {
1761 | await quic.readyToSendDatagram();
1762 | quic.sendDatagram(datagram);
1763 | });
1764 |
1765 | Sending QUIC datagrams at a fixed rate regardless if the transport is ready to
1769 | send can be achieved by simply using sendDatagram and not using
1770 | the readyToSendDatagram method. More complex scenarios can utilize
1771 | the readyToSendDatagram method.
1773 | // Sends datagrams every 100 ms.
1774 | const quic = getQuicTransport();
1775 | setInterval(() => {
1776 | quic.sendDatagram(createDatagram());
1777 | }, 100);
1778 |
1779 | Receiving QUIC datagrams can be achieved by using the
1783 | receiveDatagrams method, remembering to check for null values
1784 | indicating that packets are not being processed quickly enough.
1785 |
1787 | const quic = getQuicTransport();
1788 | const datagrams = await quic.receiveDatagrams();
1789 | for (let data of datagrams) {
1790 | if (data == null) {
1791 | // Log that datagrams were lost. Look into making the event handler faster
1792 | // or reducing the send rate of the remote side.
1793 | } else {
1794 | // Process the data
1795 | }
1796 | };
1797 |
1798 | This section will be removed before publication.
1803 |The editors wish to thank the Working Group chairs and Team Contact, 1807 | Harald Alvestrand, Stefan Håkansson, Bernard Aboba and Dominique 1808 | Hazaël-Massieux, for their support. Contributions to this 1809 | specification were provided by Robin Raymond.
1810 |The QuicTransport and QuicStream objects
1811 | were initially described in the W3C ORTC CG,
1812 | and have been adapted for use in this specification.