rwebtransport 0.1.1 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/native.d.ts CHANGED
@@ -1,4 +1,5 @@
1
- import type { WebTransportCloseInfo } from './types.js';
1
+ import { WebTransportError } from './errors.js';
2
+ import type { WebTransportCloseInfo, WebTransportConnectionStats } from './types.js';
2
3
  export type NativeHandle = {
3
4
  readonly __brand: 'rwt-session';
4
5
  };
@@ -7,6 +8,7 @@ export type NativeServerHandle = {
7
8
  };
8
9
  export declare enum NativeEventType {
9
10
  Ready = "ready",
11
+ Draining = "draining",
10
12
  ServerReady = "serverReady",
11
13
  Closed = "closed",
12
14
  Error = "error",
@@ -19,12 +21,19 @@ export declare enum NativeEventType {
19
21
  StreamOpened = "streamOpened",
20
22
  WriteAck = "writeAck",
21
23
  DatagramAck = "datagramAck",
24
+ Stats = "stats",
25
+ KeyingMaterial = "keyingMaterial",
22
26
  Listening = "listening",
23
27
  ServerError = "serverError",
24
28
  ServerClosed = "serverClosed"
25
29
  }
26
30
  export interface NativeReadyEvent {
27
31
  type: NativeEventType.Ready;
32
+ protocol: string | null;
33
+ responseHeaders: [string, string][];
34
+ }
35
+ export interface NativeDrainingEvent {
36
+ type: NativeEventType.Draining;
28
37
  }
29
38
  export interface NativeServerReadyEvent {
30
39
  type: NativeEventType.ServerReady;
@@ -32,6 +41,8 @@ export interface NativeServerReadyEvent {
32
41
  path: string;
33
42
  origin: string | null;
34
43
  headers: Record<string, string>;
44
+ requestedProtocols: string[];
45
+ protocol: string | null;
35
46
  remoteAddress: string;
36
47
  remotePort: number;
37
48
  }
@@ -87,9 +98,27 @@ export interface NativeDatagramAckEvent {
87
98
  requestId: number;
88
99
  sent: boolean;
89
100
  }
90
- export type NativeEvent = NativeReadyEvent | NativeServerReadyEvent | NativeClosedEvent | NativeErrorEvent | NativeDatagramEvent | NativeStreamEvent | NativeStreamDataEvent | NativeStreamFinEvent | NativeStreamResetEvent | NativeStreamStopSendingEvent | NativeStreamOpenedEvent | NativeWriteAckEvent | NativeDatagramAckEvent;
101
+ export interface NativeStatsEvent {
102
+ type: NativeEventType.Stats;
103
+ requestId: number;
104
+ bytesSent: number;
105
+ bytesReceived: number;
106
+ packetsSent: number;
107
+ packetsReceived: number;
108
+ packetsLost: number;
109
+ smoothedRtt: number;
110
+ rttVariation: number;
111
+ minRtt: number;
112
+ }
113
+ export interface NativeKeyingMaterialEvent {
114
+ type: NativeEventType.KeyingMaterial;
115
+ requestId: number;
116
+ ok: boolean;
117
+ data?: Uint8Array;
118
+ }
119
+ export type NativeEvent = NativeReadyEvent | NativeDrainingEvent | NativeServerReadyEvent | NativeClosedEvent | NativeErrorEvent | NativeDatagramEvent | NativeStreamEvent | NativeStreamDataEvent | NativeStreamFinEvent | NativeStreamResetEvent | NativeStreamStopSendingEvent | NativeStreamOpenedEvent | NativeWriteAckEvent | NativeDatagramAckEvent | NativeStatsEvent | NativeKeyingMaterialEvent;
91
120
  export interface NativeAddon {
92
- connect(url: string, hashes: Uint8Array[], insecure: boolean, origin: string | null, headerNames: string[], headerValues: string[], onEvent: (ev: NativeEvent) => void): NativeHandle;
121
+ connect(url: string, hashes: Uint8Array[], insecure: boolean, origin: string | null, headerNames: string[], headerValues: string[], protocols: string[], onEvent: (ev: NativeEvent) => void): NativeHandle;
93
122
  openStream(handle: NativeHandle, bidi: boolean, requestId: number): void;
94
123
  writeStream(handle: NativeHandle, streamId: number, bytes: Uint8Array, requestId: number): void;
95
124
  finStream(handle: NativeHandle, streamId: number): void;
@@ -101,8 +130,11 @@ export interface NativeAddon {
101
130
  isReady(handle: NativeHandle): boolean;
102
131
  isClosed(handle: NativeHandle): boolean;
103
132
  closeSession(handle: NativeHandle, code: number, reason: Uint8Array): void;
133
+ drain(handle: NativeHandle): void;
134
+ getStats(handle: NativeHandle, requestId: number): void;
135
+ exportKeyingMaterial(handle: NativeHandle, requestId: number, label: Uint8Array, context: Uint8Array, length: number): void;
104
136
  shutdown(handle: NativeHandle): void;
105
- serverListen(certPath: string, keyPath: string, host: string, port: number, reusePort: boolean, onEvent: (ev: ServerNativeEvent) => void): NativeServerHandle;
137
+ serverListen(certPath: string, keyPath: string, host: string, port: number, reusePort: boolean, supportedProtocols: string[], allowedOrigins: string[] | null, responseHeaderNames: string[], responseHeaderValues: string[], onEvent: (ev: ServerNativeEvent) => void): NativeServerHandle;
106
138
  serverOpenStream(handle: NativeServerHandle, session: number, bidi: boolean, requestId: number): void;
107
139
  serverWrite(handle: NativeServerHandle, session: number, streamId: number, bytes: Uint8Array, requestId: number): void;
108
140
  serverFin(handle: NativeServerHandle, session: number, streamId: number): void;
@@ -112,6 +144,9 @@ export interface NativeAddon {
112
144
  serverSendDatagram(handle: NativeServerHandle, session: number, bytes: Uint8Array, requestId: number): void;
113
145
  serverMaxDatagramSize(handle: NativeServerHandle): number;
114
146
  serverCloseSession(handle: NativeServerHandle, session: number, code: number, reason: Uint8Array): void;
147
+ serverDrain(handle: NativeServerHandle, session: number): void;
148
+ serverGetStats(handle: NativeServerHandle, session: number, requestId: number): void;
149
+ serverExportKeyingMaterial(handle: NativeServerHandle, session: number, requestId: number, label: Uint8Array, context: Uint8Array, length: number): void;
115
150
  serverShutdown(handle: NativeServerHandle): void;
116
151
  }
117
152
  export interface NativeListeningEvent {
@@ -135,14 +170,17 @@ export interface ConnectConfig {
135
170
  origin: string | null;
136
171
  headerNames: string[];
137
172
  headerValues: string[];
173
+ protocols: string[];
138
174
  }
139
175
  export interface ReceiveSink {
140
176
  onData(chunk: Uint8Array): void;
141
177
  onFin(): void;
142
178
  onReset(code: number): void;
179
+ onSessionClose(error: WebTransportError): void;
143
180
  }
144
181
  export interface SendSink {
145
182
  onStopSending(code: number): void;
183
+ onSessionClose(error: WebTransportError): void;
146
184
  }
147
185
  export interface IncomingHandler {
148
186
  onBidi(streamId: number): void;
@@ -164,6 +202,9 @@ export interface SessionTransport {
164
202
  sendDatagram(bytes: Uint8Array, requestId: number): void;
165
203
  maxDatagramSize(): number;
166
204
  closeSession(code: number, reason: Uint8Array): void;
205
+ drain(): void;
206
+ getStats(requestId: number): void;
207
+ exportKeyingMaterial(requestId: number, label: Uint8Array, context: Uint8Array, length: number): void;
167
208
  shutdown(): void;
168
209
  }
169
210
  export declare class SessionCore {
@@ -172,14 +213,22 @@ export declare class SessionCore {
172
213
  private readonly opens;
173
214
  private readonly writes;
174
215
  private readonly datagramAcks;
216
+ private readonly statsRequests;
217
+ private readonly keyingMaterialRequests;
175
218
  private readonly receives;
176
219
  private readonly sends;
177
220
  private incoming;
178
221
  private datagramSink;
222
+ private droppedIncomingDatagrams;
179
223
  private closedState;
180
224
  private readyState;
225
+ private failedState;
226
+ private lastStats;
227
+ private cachedProtocol;
228
+ private cachedResponseHeaders;
181
229
  readonly ready: Deferred<void>;
182
230
  readonly closed: Deferred<WebTransportCloseInfo>;
231
+ readonly draining: Deferred<void>;
183
232
  constructor();
184
233
  attach(transport: SessionTransport): void;
185
234
  failSetup(message: string): void;
@@ -193,6 +242,9 @@ export declare class SessionCore {
193
242
  sendDatagram(chunk: Uint8Array): Promise<boolean>;
194
243
  maxDatagramSize(): number;
195
244
  close(code: number, reason: string): void;
245
+ drain(): void;
246
+ getStats(): Promise<WebTransportConnectionStats>;
247
+ exportKeyingMaterial(label: Uint8Array, context: Uint8Array, length: number): Promise<Uint8Array>;
196
248
  shutdown(): void;
197
249
  private usable;
198
250
  private deadError;
@@ -202,9 +254,13 @@ export declare class SessionCore {
202
254
  unregisterSend(streamId: number): void;
203
255
  setIncomingHandler(handler: IncomingHandler): void;
204
256
  setDatagramSink(sink: DatagramSink): void;
257
+ recordDroppedIncomingDatagram(): void;
205
258
  dispatch(ev: NativeEvent): void;
206
259
  private finish;
207
260
  get isClosed(): boolean;
261
+ get isReady(): boolean;
262
+ get protocol(): string;
263
+ get responseHeaders(): [string, string][];
208
264
  }
209
265
  export declare function createClientSession(config: ConnectConfig): SessionCore;
210
266
  export declare class ServerTransport implements SessionTransport {
@@ -221,6 +277,9 @@ export declare class ServerTransport implements SessionTransport {
221
277
  sendDatagram(bytes: Uint8Array, requestId: number): void;
222
278
  maxDatagramSize(): number;
223
279
  closeSession(code: number, reason: Uint8Array): void;
280
+ drain(): void;
281
+ getStats(requestId: number): void;
282
+ exportKeyingMaterial(requestId: number, label: Uint8Array, context: Uint8Array, length: number): void;
224
283
  shutdown(): void;
225
284
  }
226
285
  export {};
package/dist/server.d.ts CHANGED
@@ -6,12 +6,17 @@ export interface WebTransportServerOptions {
6
6
  cert: string;
7
7
  key: string;
8
8
  reusePort?: boolean;
9
+ supportedProtocols?: string[];
10
+ allowedOrigins?: string[];
11
+ responseHeaders?: Record<string, string>;
9
12
  }
10
13
  export interface WebTransportSessionRequest {
11
14
  authority: string;
12
15
  path: string;
13
16
  origin: string | null;
14
17
  headers: Record<string, string>;
18
+ requestedProtocols: string[];
19
+ protocol: string | null;
15
20
  remoteAddress: string;
16
21
  remotePort: number;
17
22
  }
@@ -20,6 +25,7 @@ export declare class WebTransportServerSession extends WebTransportSession {
20
25
  readonly path: string;
21
26
  readonly origin: string | null;
22
27
  readonly headers: Record<string, string>;
28
+ readonly requestedProtocols: string[];
23
29
  readonly remoteAddress: string;
24
30
  readonly remotePort: number;
25
31
  constructor(core: SessionCore, request: WebTransportSessionRequest);
package/dist/streams.d.ts CHANGED
@@ -3,12 +3,21 @@ export declare class WebTransportReceiveStream extends ReadableStream<Uint8Array
3
3
  readonly streamId: number;
4
4
  constructor(session: SessionCore, streamId: number);
5
5
  }
6
+ export declare class WebTransportSendGroup {
7
+ }
8
+ export interface WebTransportSendStreamOptions {
9
+ sendGroup?: WebTransportSendGroup;
10
+ sendOrder?: number;
11
+ waitUntilAvailable?: boolean;
12
+ }
6
13
  export declare class WebTransportSendStream extends WritableStream<Uint8Array> {
7
14
  readonly streamId: number;
8
- constructor(session: SessionCore, streamId: number);
15
+ sendGroup: WebTransportSendGroup | null;
16
+ sendOrder: number;
17
+ constructor(session: SessionCore, streamId: number, options?: WebTransportSendStreamOptions);
9
18
  }
10
19
  export declare class WebTransportBidirectionalStream {
11
20
  readonly readable: WebTransportReceiveStream;
12
21
  readonly writable: WebTransportSendStream;
13
- constructor(session: SessionCore, streamId: number);
22
+ constructor(session: SessionCore, streamId: number, options?: WebTransportSendStreamOptions);
14
23
  }
package/dist/types.d.ts CHANGED
@@ -4,11 +4,32 @@ export interface WebTransportHash {
4
4
  value: BinarySource;
5
5
  }
6
6
  export type WebTransportCongestionControl = 'default' | 'throughput' | 'low-latency';
7
+ export type WebTransportReliabilityMode = 'pending' | 'reliable-only' | 'supports-unreliable';
8
+ export interface WebTransportDatagramStats {
9
+ expiredOutgoing: number;
10
+ droppedIncoming: number;
11
+ lostOutgoing: number;
12
+ expiredIncoming: number;
13
+ }
14
+ export interface WebTransportConnectionStats {
15
+ bytesSent: number;
16
+ bytesReceived: number;
17
+ packetsSent: number;
18
+ packetsReceived: number;
19
+ packetsLost: number;
20
+ smoothedRtt: number;
21
+ rttVariation: number;
22
+ minRtt: number;
23
+ datagrams: WebTransportDatagramStats;
24
+ }
7
25
  export interface WebTransportOptions {
8
26
  serverCertificateHashes?: WebTransportHash[];
27
+ protocols?: string[];
9
28
  allowPooling?: boolean;
10
29
  requireUnreliable?: boolean;
11
30
  congestionControl?: WebTransportCongestionControl;
31
+ anticipatedConcurrentIncomingUnidirectionalStreams?: number | null;
32
+ anticipatedConcurrentIncomingBidirectionalStreams?: number | null;
12
33
  insecure?: boolean;
13
34
  headers?: Record<string, string>;
14
35
  origin?: string;
@@ -21,4 +42,3 @@ export interface WebTransportCloseOptions {
21
42
  closeCode?: number;
22
43
  reason?: string;
23
44
  }
24
- export type WebTransportSendGroup = unknown;
@@ -1,7 +1,7 @@
1
1
  import { SessionCore } from './native.js';
2
2
  import { WebTransportDatagramDuplexStream } from './datagrams.js';
3
- import { WebTransportBidirectionalStream, WebTransportReceiveStream, WebTransportSendStream } from './streams.js';
4
- import type { WebTransportCloseInfo, WebTransportCloseOptions, WebTransportOptions } from './types.js';
3
+ import { WebTransportBidirectionalStream, WebTransportReceiveStream, WebTransportSendStream, WebTransportSendGroup, type WebTransportSendStreamOptions } from './streams.js';
4
+ import type { BinarySource, WebTransportCloseInfo, WebTransportCloseOptions, WebTransportOptions, WebTransportReliabilityMode, WebTransportConnectionStats } from './types.js';
5
5
  export declare class WebTransportSession {
6
6
  protected readonly core: SessionCore;
7
7
  readonly datagrams: WebTransportDatagramDuplexStream;
@@ -11,10 +11,18 @@ export declare class WebTransportSession {
11
11
  constructor(core: SessionCore);
12
12
  get ready(): Promise<void>;
13
13
  get closed(): Promise<WebTransportCloseInfo>;
14
- createBidirectionalStream(): Promise<WebTransportBidirectionalStream>;
15
- createUnidirectionalStream(): Promise<WebTransportSendStream>;
14
+ get draining(): Promise<void>;
15
+ get reliability(): WebTransportReliabilityMode;
16
+ get protocol(): string;
17
+ createBidirectionalStream(options?: WebTransportSendStreamOptions): Promise<WebTransportBidirectionalStream>;
18
+ createUnidirectionalStream(options?: WebTransportSendStreamOptions): Promise<WebTransportSendStream>;
19
+ createSendGroup(): WebTransportSendGroup;
16
20
  close(closeInfo?: WebTransportCloseOptions): void;
21
+ drain(): void;
22
+ getStats(): Promise<WebTransportConnectionStats>;
23
+ exportKeyingMaterial(label: BinarySource, context: BinarySource, outputLength: number): Promise<Uint8Array>;
17
24
  }
18
25
  export declare class WebTransport extends WebTransportSession {
19
26
  constructor(url: string, options?: WebTransportOptions);
27
+ get responseHeaders(): Headers;
20
28
  }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "rwebtransport",
3
- "version": "0.1.1",
3
+ "version": "0.2.0",
4
4
  "description": "A fully-compatible WebTransport client and server for Node.js, powered by Cloudflare quiche + BoringSSL via neon.",
5
5
  "author": "Dacely Cloud",
6
6
  "homepage": "https://github.com/dacely-cloud/rwebtransport#readme",
@@ -7595,6 +7595,17 @@ impl<F: BufFactory> Connection<F> {
7595
7595
  self.alpn.as_ref()
7596
7596
  }
7597
7597
 
7598
+ /// Exports keying material from the TLS session (RFC 5705).
7599
+ ///
7600
+ /// Writes `out.len()` bytes of keying material, derived from `label` and the
7601
+ /// optional `context`, into `out`. Only available once the handshake has
7602
+ /// completed; calling it earlier returns [`Error::TlsFail`].
7603
+ pub fn export_keying_material(
7604
+ &mut self, out: &mut [u8], label: &[u8], context: Option<&[u8]>,
7605
+ ) -> Result<()> {
7606
+ self.handshake.export_keying_material(out, label, context)
7607
+ }
7608
+
7598
7609
  /// Returns the server name requested by the client.
7599
7610
  #[inline]
7600
7611
  pub fn server_name(&self) -> Option<&str> {
@@ -666,6 +666,38 @@ impl Handshake {
666
666
  }
667
667
  }
668
668
 
669
+ /// Export keying material from the completed TLS handshake (RFC 5705).
670
+ ///
671
+ /// Fills `out` with `out.len()` bytes derived from `label` and the optional
672
+ /// `context`. Fails if the handshake has not completed.
673
+ pub fn export_keying_material(
674
+ &mut self, out: &mut [u8], label: &[u8], context: Option<&[u8]>,
675
+ ) -> Result<()> {
676
+ let (context, context_len, use_context) = match context {
677
+ Some(c) => (c.as_ptr(), c.len(), 1),
678
+ None => (ptr::null(), 0, 0),
679
+ };
680
+
681
+ let rc = unsafe {
682
+ SSL_export_keying_material(
683
+ self.as_mut_ptr(),
684
+ out.as_mut_ptr(),
685
+ out.len(),
686
+ label.as_ptr() as *const c_char,
687
+ label.len(),
688
+ context,
689
+ context_len,
690
+ use_context,
691
+ )
692
+ };
693
+
694
+ if rc == 1 {
695
+ Ok(())
696
+ } else {
697
+ Err(Error::TlsFail)
698
+ }
699
+ }
700
+
669
701
  #[cfg(feature = "boringssl-boring-crate")]
670
702
  pub(crate) fn ssl_mut(&mut self) -> &mut boring::ssl::SslRef {
671
703
  use foreign_types_shared::ForeignTypeRef;
@@ -1206,6 +1238,12 @@ extern "C" {
1206
1238
 
1207
1239
  fn SSL_clear(ssl: *mut SSL) -> c_int;
1208
1240
 
1241
+ fn SSL_export_keying_material(
1242
+ ssl: *mut SSL, out: *mut u8, out_len: usize, label: *const c_char,
1243
+ label_len: usize, context: *const u8, context_len: usize,
1244
+ use_context: c_int,
1245
+ ) -> c_int;
1246
+
1209
1247
  fn SSL_free(ssl: *mut SSL);
1210
1248
 
1211
1249
  // SSL_CIPHER