fix: added validation errors

Author: tegefaulkes

src/QUICClient.ts

@@ -1,6 +1,6 @@
 import type { PromiseCancellable } from '@matrixai/async-cancellable';
 import type { ContextTimed } from '@matrixai/contexts';
-import type { ClientCrypto, Host, Port, VerifyCallback } from './types';
+import type { ClientCrypto, Host, VerifyCallback } from './types';
 import type { Config } from './native/types';
 import type QUICConnectionMap from './QUICConnectionMap';
 import type {
@@ -136,6 +136,8 @@ class QUICClient extends EventTarget {
     // Validating host and port types
     let [host_] = await utils.resolveHost(host, resolveHostname);
     const [localHost_] = await utils.resolveHost(localHost, resolveHostname);
+    const port_ = utils.toPort(port);
+    const localPort_ = utils.toPort(localPort);
     // 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
@@ -156,7 +158,7 @@ class QUICClient extends EventTarget {
       isSocketShared = false;
       await socket.start({
         host: localHost_,
-        port: localPort,
+        port: localPort_,
       });
     } else {
       if (!socket[running]) {
@@ -208,7 +210,7 @@ class QUICClient extends EventTarget {
         socket,
         remoteInfo: {
           host: host_,
-          port: port as Port,
+          port: port_,
         },
         config: quicConfig,
         reasonToCode,

src/QUICConnection.ts

@@ -454,11 +454,11 @@ class QUICConnection extends EventTarget {
   }
 
   public get remoteHost(): string {
-    return this._remoteHost;
+    return utils.fromHost(this._remoteHost);
   }
 
   public get remotePort(): number {
-    return this._remotePort;
+    return utils.fromPort(this._remotePort);
   }
 
   public get localHost(): string {

src/QUICSocket.ts

@@ -154,8 +154,8 @@ class QUICSocket extends EventTarget {
    * Whereas `0.0.0.0` means only all IPv4.
    */
   @ready(new errors.ErrorQUICSocketNotRunning())
-  public get host() {
-    return this._host;
+  public get host(): string {
+    return utils.fromHost(this._host);
   }
 
   /**
@@ -164,8 +164,8 @@ class QUICSocket extends EventTarget {
    * Because `0` is always resolved to a specific port.
    */
   @ready(new errors.ErrorQUICSocketNotRunning())
-  public get port() {
-    return this._port;
+  public get port(): number {
+    return utils.fromPort(this._port);
   }
 
   /**
@@ -202,6 +202,7 @@ class QUICSocket extends EventTarget {
       host,
       this.resolveHostname,
     );
+    const port_ = utils.toPort(port);
     this.socket = dgram.createSocket({
       type: udpType,
       reuseAddr,
@@ -215,7 +216,7 @@ class QUICSocket extends EventTarget {
     // This resolves DNS via `getaddrinfo` under the hood.
     // It which respects the hosts file.
     // This makes it equivalent to `dns.lookup`.
-    const socketBindP = this.socketBind(port, host_);
+    const socketBindP = this.socketBind(port_, host_);
     try {
       await Promise.race([socketBindP, errorP]);
     } catch (e) {

src/errors.ts

@@ -5,6 +5,14 @@ class ErrorQUIC<T> extends AbstractError<T> {
   static description = 'QUIC error';
 }
 
+class ErrorQUICHostInvalid<T> extends AbstractError<T> {
+  static description = 'Host provided was not valid';
+}
+
+class ErrorQUICPortInvalid<T> extends AbstractError<T> {
+  static description = 'Port provided was not valid';
+}
+
 class ErrorQUICConfig<T> extends ErrorQUIC<T> {
   static description = 'QUIC config error';
 }
@@ -141,6 +149,8 @@ class ErrorQUICUndefinedBehaviour<T> extends ErrorQUIC<T> {
 
 export {
   ErrorQUIC,
+  ErrorQUICHostInvalid,
+  ErrorQUICPortInvalid,
   ErrorQUICConfig,
   ErrorQUICSocket,
   ErrorQUICSocketNotRunning,

src/utils.ts

@@ -168,11 +168,22 @@ async function resolveHost(
   } else if (isIPv6(host)) {
     return [host as Host, 'udp6'];
   } else {
-    host = await resolveHostname(host);
-    return resolveHost(host, resolveHostname);
+    try {
+      host = await resolveHostname(host);
+      return resolveHost(host, resolveHostname);
+    } catch {
+      throw new errors.ErrorQUICHostInvalid();
+    }
   }
 }
 
+/**
+ * Converts a Host back to a string.
+ */
+function fromHost(host: Host): string {
+  return host;
+}
+
 /**
  * Is it a valid Port?
  */
@@ -181,6 +192,21 @@ function isPort(port: any): port is Port {
   return port >= 0 && port <= 65535;
 }
 
+/**
+ * Throws if port is invalid, otherwise returns port as Port.
+ */
+function toPort(port: any): Port {
+  if (!isPort(port)) throw new errors.ErrorQUICPortInvalid();
+  return port;
+}
+
+/**
+ * Converts a Port back to a number.
+ */
+function fromPort(port: Port): number {
+  return port;
+}
+
 /**
  * Convert callback-style to promise-style
  * If this is applied to overloaded function
@@ -463,7 +489,10 @@ export {
   toCanonicalIp,
   resolveHostname,
   resolveHost,
+  fromHost,
   isPort,
+  toPort,
+  fromPort,
   promisify,
   promise,
   bufferWrap,