quic: add getters for local and remote transport parameters

Signed-off-by: James M Snell <jasnell@gmail.com>

Author: jasnell

doc/api/quic.md

@@ -851,6 +851,17 @@ added: v23.8.0
 
 True if `session.destroy()` has been called. Read only.
 
+### `session.localTransportParams`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {quic.TransportParams|null}
+
+The transport parameters advertised by the local endpoint during the handshake.
+Returns `null` if the session has been destroyed. Read only.
+
 ### `session.endpoint`
 
 <!-- YAML
@@ -1144,6 +1155,19 @@ added: v23.8.0
 
 The local and remote socket addresses associated with the session. Read only.
 
+### `session.remoteTransportParams`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {quic.TransportParams|null|undefined}
+
+The transport parameters advertised by the remote peer during the handshake.
+Returns `null` if the session has been destroyed, `undefined` if the handshake
+has not yet completed and the remote parameters are not yet available. Read
+only.
+
 ### `session.sendDatagram(datagram[, encoding])`
 
 <!-- YAML
@@ -2947,6 +2971,37 @@ won't have need to specify.
 added: v23.8.0
 -->
 
+The `TransportParams` type represents the QUIC transport parameters that are
+negotiated during session establishment. These parameters are used when
+creating a session. The negotiated values can be observed via the
+`session.localTransportParams` and `session.remoteTransportParams` properties.
+
+#### `transportParams.initialSCID`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {string}
+
+The initial source connection ID (SCID) specified. This field is ignored on
+creation of the session and is provided for informational purposes only when
+available in the `session.localTransportParams` and
+`session.remoteTransportParams` properties.
+
+#### `transportParams.originalDCID`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {string}
+
+The original destination connection ID (DCID) specified. This field is
+ignored on creation of the session and is provided for informational
+purposes only when available in the `session.localTransportParams` and
+`session.remoteTransportParams` properties.
+
 #### `transportParams.preferredAddressIpv4`
 
 <!-- YAML
@@ -3060,6 +3115,19 @@ will not send datagrams larger than this value. The actual maximum size of
 a datagram that can be _sent_ is determined by the peer's
 `maxDatagramFrameSize`, not this endpoint's value.
 
+#### `transportParams.retrySCID`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {string}
+
+The retry connection ID specified. This field is ignored on creation
+of the session and is provided for informational purposes only when
+available in the `session.localTransportParams` and
+`session.remoteTransportParams` properties.
+
 ## Callbacks
 
 ### Callback error handling

lib/internal/quic/quic.js

@@ -2626,6 +2626,8 @@ class QuicSession {
     certificate: undefined,
     peerCertificate: undefined,
     ephemeralKeyInfo: undefined,
+    localTransportParams: undefined,
+    remoteTransportParams: undefined,
   };
 
   static {
@@ -2676,6 +2678,45 @@ class QuicSession {
     debug('session created');
   }
 
+  get localTransportParams() {
+    if (this.#inner.localTransportParams !== undefined) {
+      return this.#inner.localTransportParams;
+    }
+    // If the handle is already gone, we cannot retrieve the transport params.
+    if (this.destroyed) return null;
+    const params = this.#handle.localTransportParams();
+    if (params.preferredAddressIpv4 !== undefined) {
+      params.preferredAddressIpv4 = new InternalSocketAddress(params.preferredAddressIpv4);
+    }
+    if (params.preferredAddressIpv6 !== undefined) {
+      params.preferredAddressIpv6 = new InternalSocketAddress(params.preferredAddressIpv6);
+    }
+    return this.#inner.localTransportParams = params;
+  }
+
+  get remoteTransportParams() {
+    if (this.#inner.remoteTransportParams !== undefined) {
+      return this.#inner.remoteTransportParams;
+    }
+    // If the handle is already gone, we cannot retrieve the transport params.
+    if (this.destroyed) return null;
+    const params = this.#handle.remoteTransportParams();
+    // If params is undefined, the transport parameters have not yet been received.
+    // Note the distinction between this and the case where the handle is gone.
+    // If the handle is gone, we return null because we know the transport
+    // parameters will be unavailable. If the transport parameters have not yet
+    // been received, we return undefined to indicate that they may still become
+    // available in the future.
+    if (params === undefined) return undefined;
+    if (params.preferredAddressIpv4 !== undefined) {
+      params.preferredAddressIpv4 = new InternalSocketAddress(params.preferredAddressIpv4);
+    }
+    if (params.preferredAddressIpv6 !== undefined) {
+      params.preferredAddressIpv6 = new InternalSocketAddress(params.preferredAddressIpv6);
+    }
+    return this.#inner.remoteTransportParams = params;
+  }
+
   /** @type {boolean} */
   get #isClosedOrClosing() {
     return this.#handle === undefined || this.#inner.isPendingClose;

src/quic/bindingdata.cc

@@ -20,6 +20,7 @@
 namespace node {
 
 using mem::kReserveSizeAndAlign;
+using v8::DictionaryTemplate;
 using v8::Function;
 using v8::FunctionTemplate;
 using v8::HandleScope;
@@ -377,6 +378,16 @@ QUIC_CONSTRUCTORS(V)
 
 #undef V
 
+void BindingData::set_transport_params_template(
+    Local<DictionaryTemplate> tmpl) {
+  transport_params_template_.Reset(env()->isolate(), tmpl);
+}
+
+Local<DictionaryTemplate> BindingData::transport_params_template() const {
+  return PersistentToLocal::Default(env()->isolate(),
+    transport_params_template_);
+}
+
 #define V(name, _)                                                             \
   void BindingData::set_##name##_callback(Local<Function> fn) {                \
     name##_callback_.Reset(env()->isolate(), fn);                              \

src/quic/bindingdata.h

@@ -303,6 +303,9 @@ class BindingData final
   QUIC_CONSTRUCTORS(V)
 #undef V
 
+  void set_transport_params_template(v8::Local<v8::DictionaryTemplate> tmpl);
+  v8::Local<v8::DictionaryTemplate> transport_params_template() const;
+
 #define V(name, _)                                                             \
   void set_##name##_callback(v8::Local<v8::Function> fn);                      \
   v8::Local<v8::Function> name##_callback() const;
@@ -321,6 +324,8 @@ class BindingData final
   QUIC_CONSTRUCTORS(V)
 #undef V
 
+  v8::Global<v8::DictionaryTemplate> transport_params_template_;
+
 #define V(name, _) v8::Global<v8::Function> name##_callback_;
   QUIC_JS_CALLBACKS(V)
 #undef V

src/quic/session.cc

@@ -190,7 +190,9 @@ uint64_t MaxDatagramPayload(uint64_t max_frame_size) {
   V(SilentClose, silentClose, SIDE_EFFECT)                                     \
   V(UpdateKey, updateKey, SIDE_EFFECT)                                         \
   V(OpenStream, openStream, SIDE_EFFECT)                                       \
-  V(SendDatagram, sendDatagram, SIDE_EFFECT)
+  V(SendDatagram, sendDatagram, SIDE_EFFECT)                                   \
+  V(LocalTransportParams, localTransportParams, NO_SIDE_EFFECT)                \
+  V(RemoteTransportParams, remoteTransportParams, NO_SIDE_EFFECT)              \
 
 struct Session::State final {
 #define V(_, name, type) type name;
@@ -1163,6 +1165,36 @@ struct Session::Impl final : public MemoryRetainer {
         BigInt::New(env->isolate(), session->SendDatagram(std::move(store))));
   }
 
+  JS_METHOD(LocalTransportParams) {
+    auto env = Environment::GetCurrent(args);
+    Session* session;
+    ASSIGN_OR_RETURN_UNWRAP(&session, args.This());
+
+    ngtcp2_conn* conn = *session;
+    TransportParams params(ngtcp2_conn_get_local_transport_params(conn));
+    Local<Object> obj;
+    if (params.ToObject(env).ToLocal(&obj)) {
+      args.GetReturnValue().Set(obj);
+    }
+  }
+
+  JS_METHOD(RemoteTransportParams) {
+    auto env = Environment::GetCurrent(args);
+    Session* session;
+    ASSIGN_OR_RETURN_UNWRAP(&session, args.This());
+
+    ngtcp2_conn* conn = *session;
+    auto params = ngtcp2_conn_get_remote_transport_params(conn);
+    if (params == nullptr) {
+      // Remote transport parameters are not yet available.
+      return args.GetReturnValue().SetUndefined();
+    }
+    TransportParams tp(params);
+    Local<Object> obj;
+    if (tp.ToObject(env).ToLocal(&obj)) {
+      args.GetReturnValue().Set(obj);
+    }
+  }
   // Internal ngtcp2 callbacks
 
   static int on_acknowledge_stream_data_offset(ngtcp2_conn* conn,