fix: Host and Port types are only used internally now

When creating or getting the host and port information, they are now used as a string and number. Internally they are the Opaque types `Host` and `Port`.

Author: tegefaulkes

package-lock.json

@@ -3,8 +3,6 @@ import type { ContextTimed } from '@matrixai/contexts';
 import type {
   ClientCrypto,
   Host,
-  Hostname,
-  Port,
   VerifyCallback,
 } from './types';
 import type { Config } from './native/types';
@@ -76,16 +74,16 @@ class QUICClient extends EventTarget {
    */
   public static createQUICClient(
     opts: {
-      host: Host | Hostname;
-      port: Port;
-      localHost?: Host | Hostname;
-      localPort?: Port;
+      host: string;
+      port: number;
+      localHost?: string;
+      localPort?: number;
       crypto: {
         ops: ClientCrypto;
       };
       config?: Partial<QUICConfig>;
       socket?: QUICSocket;
-      resolveHostname?: (hostname: Hostname) => Host | PromiseLike<Host>;
+      resolveHostname?: (hostname: string) => Host | PromiseLike<Host>;
       reasonToCode?: StreamReasonToCode;
       codeToReason?: StreamCodeToReason;
       verifyCallback?: VerifyCallback;
@@ -98,8 +96,8 @@ class QUICClient extends EventTarget {
     {
       host,
       port,
-      localHost = '::' as Host,
-      localPort = 0 as Port,
+      localHost = '::',
+      localPort = 0,
       crypto,
       config = {},
       socket,
@@ -109,18 +107,18 @@ class QUICClient extends EventTarget {
       verifyCallback,
       logger = new Logger(`${this.name}`),
     }: {
-      host: Host | Hostname;
-      port: Port;
-      localHost?: Host | Hostname;
-      localPort?: Port;
+      host: string;
+      port: number;
+      localHost?: string;
+      localPort?: number;
       crypto: {
         ops: {
           randomBytes(data: ArrayBuffer): Promise<void>;
         };
       };
       config?: Partial<QUICConfig>;
       socket?: QUICSocket;
-      resolveHostname?: (hostname: Hostname) => Host | PromiseLike<Host>;
+      resolveHostname?: (hostname: string) => Host | PromiseLike<Host>;
       reasonToCode?: StreamReasonToCode;
       codeToReason?: StreamCodeToReason;
       verifyCallback?: VerifyCallback;
@@ -139,7 +137,12 @@ class QUICClient extends EventTarget {
     const scidBuffer = new ArrayBuffer(quiche.MAX_CONN_ID_LEN);
     await crypto.ops.randomBytes(scidBuffer);
     const scid = new QUICConnectionId(scidBuffer);
+    // validating host and port types
     let [host_] = await utils.resolveHost(host, resolveHostname);
+    let [localHost_] = await utils.resolveHost(host, resolveHostname);
+    if (!utils.isPort(port) || !utils.isPort(localPort)) {
+      throw Error('TMP Not a valid port number');
+    }
     // If the target host is in fact a zero IP, it cannot be used
     // as a target host, so we need to resolve it to a non-zero IP
     // in this case, 0.0.0.0 is resolved to 127.0.0.1 and :: and ::0 is
@@ -159,7 +162,7 @@ class QUICClient extends EventTarget {
       });
       isSocketShared = false;
       await socket.start({
-        host: localHost,
+        host: localHost_,
         port: localPort,
       });
     } else {
@@ -388,12 +391,12 @@ class QUICClient extends EventTarget {
   }
 
   @ready(new errors.ErrorQUICClientDestroyed())
-  public get host() {
+  public get host(): string {
     return this.socket.host;
   }
 
   @ready(new errors.ErrorQUICClientDestroyed())
-  public get port() {
+  public get port(): number {
     return this.socket.port;
   }
 

src/QUICClient.ts

@@ -453,19 +453,19 @@ class QUICConnection extends EventTarget {
     this.rejectClosedP = rejectClosedP;
   }
 
-  public get remoteHost() {
+  public get remoteHost(): string {
     return this._remoteHost;
   }
 
-  public get remotePort() {
+  public get remotePort(): number {
     return this._remotePort;
   }
 
-  public get localHost() {
+  public get localHost(): string {
     return this.socket.host;
   }
 
-  public get localPort() {
+  public get localPort(): number {
     return this.socket.port;
   }
 

src/QUICConnection.ts

@@ -122,7 +122,7 @@ class QUICServer extends EventTarget {
       cert: string | Array<string> | Uint8Array | Array<Uint8Array>;
     };
     socket?: QUICSocket;
-    resolveHostname?: (hostname: Hostname) => Host | PromiseLike<Host>;
+    resolveHostname?: (hostname: string) => Host | PromiseLike<Host>;
     reasonToCode?: StreamReasonToCode;
     codeToReason?: StreamCodeToReason;
     verifyCallback?: VerifyCallback;
@@ -156,12 +156,12 @@ class QUICServer extends EventTarget {
   }
 
   @ready(new errors.ErrorQUICServerNotRunning())
-  public get host() {
+  public get host(): string {
     return this.socket.host;
   }
 
   @ready(new errors.ErrorQUICServerNotRunning())
-  public get port() {
+  public get port(): number {
     return this.socket.port;
   }
 
@@ -172,12 +172,12 @@ class QUICServer extends EventTarget {
    * In which case, the `host` and `port` parameters here are ignored.
    */
   public async start({
-    host = '::' as Host,
-    port = 0 as Port,
+    host = '::',
+    port = 0,
     reuseAddr,
   }: {
-    host?: Host | Hostname;
-    port?: Port;
+    host?: string;
+    port?: number;
     reuseAddr?: boolean;
   } = {}) {
     let address: string;

src/QUICServer.ts

@@ -33,7 +33,7 @@ class QUICSocket extends EventTarget {
   protected logger: Logger;
   protected server?: QUICServer;
 
-  protected resolveHostname: (hostname: Hostname) => Host | PromiseLike<Host>;
+  protected resolveHostname: (hostname: string) => Host | PromiseLike<Host>;
 
   protected socketBind: (port: number, host: string) => Promise<void>;
   protected socketClose: () => Promise<void>;
@@ -138,7 +138,7 @@ class QUICSocket extends EventTarget {
     resolveHostname = utils.resolveHostname,
     logger,
   }: {
-    resolveHostname?: (hostname: Hostname) => Host | PromiseLike<Host>;
+    resolveHostname?: (hostname: string) => Host | PromiseLike<Host>;
     logger?: Logger;
   }) {
     super();
@@ -184,13 +184,13 @@ class QUICSocket extends EventTarget {
    * If the host is a hostname such as `localhost`, this will perform do local resolution.
    */
   public async start({
-    host = '::' as Host,
-    port = 0 as Port,
+    host = '::',
+    port = 0,
     reuseAddr = false,
     ipv6Only = false,
   }: {
-    host?: Host | Hostname;
-    port?: Port;
+    host?: string;
+    port?: number;
     reuseAddr?: boolean;
     ipv6Only?: boolean;
   } = {}): Promise<void> {
@@ -202,6 +202,7 @@ class QUICSocket extends EventTarget {
       host,
       this.resolveHostname,
     );
+    if (!utils.isPort(port)) throw Error('TMP invalid port');
     this.socket = dgram.createSocket({
       type: udpType,
       reuseAddr,

src/QUICSocket.ts

@@ -106,10 +106,10 @@ type StreamCodeToReason = (
 
 type ConnectionMetadata = {
   remoteCertificates: Array<string> | null;
-  localHost: Host;
-  localPort: Port;
-  remoteHost: Host;
-  remotePort: Port;
+  localHost: string;
+  localPort: number;
+  remoteHost: string;
+  remotePort: number;
 };
 
 type QUICConfig = {

src/types.ts

@@ -5,6 +5,7 @@ import type {
   ConnectionIdString,
   Host,
   Hostname,
+  Port,
   ServerCrypto,
 } from './types';
 import type { Connection } from './native';
@@ -146,7 +147,7 @@ function toCanonicalIp(host: string) {
  * It could be an IPv6 address or IPv4 address.
  * This uses the OS's DNS resolution system.
  */
-async function resolveHostname(hostname: Hostname): Promise<Host> {
+async function resolveHostname(hostname: string): Promise<Host> {
   const result = await dns.promises.lookup(hostname, {
     family: 0,
     all: false,
@@ -160,19 +161,27 @@ async function resolveHostname(hostname: Hostname): Promise<Host> {
  * The `resolveHostname` can be overridden.
  */
 async function resolveHost(
-  host: Host | Hostname,
-  resolveHostname: (hostname: Hostname) => Host | PromiseLike<Host>,
+  host: string,
+  resolveHostname: (hostname: string) => Host | PromiseLike<Host>,
 ): Promise<[Host, 'udp4' | 'udp6']> {
   if (isIPv4(host)) {
     return [host as Host, 'udp4'];
   } else if (isIPv6(host)) {
     return [host as Host, 'udp6'];
   } else {
-    host = await resolveHostname(host as Hostname);
+    host = await resolveHostname(host);
     return resolveHost(host, resolveHostname);
   }
 }
 
+/**
+ * Is it a valid Port?
+ */
+function isPort(port: any): port is Port {
+  if (typeof port !== 'number') return false;
+  return port >= 0 && port <= 65535;
+}
+
 /**
  * Convert callback-style to promise-style
  * If this is applied to overloaded function
@@ -455,6 +464,7 @@ export {
   toCanonicalIp,
   resolveHostname,
   resolveHost,
+  isPort,
   promisify,
   promise,
   bufferWrap,