implement connect outbound, fix connection close handling, and add finger command

Author: obfuscatedgenerated

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "ollieos",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "",
   "main": "server.js",
   "scripts": {

package.json

@@ -105,15 +105,15 @@ export abstract class AbstractClientSocket {
         await this._handle_send_internal(uint8_data);
     }
 
-    protected abstract _handle_close_internal(): Promise<void>;
+    protected abstract _handle_close_internal(passive: boolean): Promise<void>;
 
-    async close(): Promise<void> {
+    async close(passive = false): Promise<void> {
         if (this.ready_state === SocketReadyState.CLOSING || this.ready_state === SocketReadyState.CLOSED) {
             return;
         }
 
         this.ready_state = SocketReadyState.CLOSING;
-        await this._handle_close_internal();
+        await this._handle_close_internal(passive);
 
         // invoke close listeners
         for (const listener of this.#close_listeners) {

src/kernel/network.ts

@@ -25,7 +25,14 @@ interface CloseConnectionMessage extends BaseMessage {
     sock_id: string;
 }
 
-type OutboundMessage = BindMessage | UnbindMessage | DataMessage | CloseConnectionMessage;
+interface ConnectMessage extends BaseMessage {
+    type: "connect_req";
+    host: string;
+    port: number;
+    force_sock_id?: string;
+}
+
+type OutboundMessage = BindMessage | UnbindMessage | DataMessage | CloseConnectionMessage | ConnectMessage;
 
 interface IncomingConnectionMessage extends BaseMessage {
     type: "incoming_connection";
@@ -35,32 +42,36 @@ interface IncomingConnectionMessage extends BaseMessage {
 
 interface ConnectionClosingMessage extends BaseMessage {
     type: "connection_closing";
-    port: number;
+    port?: number;
     sock_id: string;
 }
 
-interface AckBindMessage extends BaseMessage {
-    type: "ack_bind";
-    port: number;
+interface AckMessage extends BaseMessage {
     success: boolean;
     error?: string;
 }
 
-interface AckUnbindMessage extends BaseMessage {
+interface AckBindMessage extends AckMessage {
+    type: "ack_bind";
+    port: number;
+}
+
+interface AckUnbindMessage extends AckMessage {
     type: "ack_unbind";
     port: number;
-    success: boolean;
-    error?: string;
 }
 
-interface AckCloseConnectionMessage extends BaseMessage {
+interface AckCloseConnectionMessage extends AckMessage {
     type: "ack_close_connection";
     sock_id: string;
-    success: boolean;
-    error?: string;
 }
 
-type InboundMessage = IncomingConnectionMessage | ConnectionClosingMessage | AckBindMessage | AckUnbindMessage | DataMessage | AckCloseConnectionMessage;
+interface AckConnectMessage extends AckMessage {
+    type: "ack_connect";
+    sock_id: string;
+}
+
+type InboundMessage = IncomingConnectionMessage | ConnectionClosingMessage | AckBindMessage | AckUnbindMessage | DataMessage | AckCloseConnectionMessage | AckConnectMessage;
 
 const uint8_to_base64 = (data: Uint8Array): string => {
     let binary = "";
@@ -79,7 +90,12 @@ export class PorterBridgeClientSocket extends AbstractClientSocket {
         this.ready_state = SocketReadyState.OPEN;
     }
 
-    protected async _handle_close_internal(): Promise<void> {
+    protected async _handle_close_internal(passive: boolean): Promise<void> {
+        if (passive) {
+            // nothing to do
+            return;
+        }
+
         const msg: CloseConnectionMessage = {
             type: "close_connection",
             sock_id: this.id,
@@ -187,7 +203,7 @@ export class PorterBridgeNetworkManager extends AbstractNetworkManager {
 
     constructor() {
         super();
-        this.#connect();
+        this.#connect_to_ws();
     }
 
     #ws: WebSocket;
@@ -256,7 +272,7 @@ export class PorterBridgeNetworkManager extends AbstractNetworkManager {
         });
     }
 
-    #connect() {
+    #connect_to_ws() {
         // open websocket connection on port 9000, handling all routing (rather than making a separate listener/connection for each socket)
         this.#ws = new WebSocket("ws://127.0.0.1:9000");
 
@@ -285,7 +301,8 @@ export class PorterBridgeNetworkManager extends AbstractNetworkManager {
                 case "connection_closing": {
                     const client = this.#client_map.get(data.sock_id);
                     if (client) {
-                        client.close().catch(err => {
+                        // emit passive close event
+                        client.close(true).catch(err => {
                             console.error(`Error closing client socket ${data.sock_id}:`, err);
                         });
                     } else {
@@ -325,7 +342,7 @@ export class PorterBridgeNetworkManager extends AbstractNetworkManager {
 
             // attempt to reconnect with exponential backoff
             setTimeout(() => {
-                this.#connect();
+                this.#connect_to_ws();
             }, Math.min(50 * 2 ** this.#reconnect_attempts, 3000));
             this.#reconnect_attempts++;
         });
@@ -384,6 +401,45 @@ export class PorterBridgeNetworkManager extends AbstractNetworkManager {
     }
 
     async connect(host: string, port: number): Promise<AbstractClientSocket> {
-        throw new Error("Outbound connections are not supported in porter networking yet");
+        // generate a sock id that we will provide to immediately reserve in the map without waiting for a reply
+        const sock_id = crypto.randomUUID();
+
+        const msg: ConnectMessage = {
+            type: "connect_req",
+            host,
+            port,
+            force_sock_id: sock_id,
+        };
+
+        await this.wait_for_ws_ready();
+        this.#ws.send(JSON.stringify(msg));
+
+        return new Promise<PorterBridgeClientSocket>((resolve, reject) => {
+            const handler = (event: MessageEvent) => {
+                const data = JSON.parse(event.data) as InboundMessage;
+
+                // TODO: move this routing logic to the manager instead of having each connect call add its own listener for efficiency
+                if (data.type === "ack_connect" && data.sock_id === sock_id) {
+                    this.#ws.removeEventListener("message", handler);
+
+                    if (data.success) {
+                        // create the client and add to map
+                        const client = new PorterBridgeClientSocket(sock_id, this);
+                        this.#client_map.set(sock_id, client);
+
+                        // cleanup on close
+                        client.add_event_listener("close", () => {
+                            this.#client_map.delete(sock_id);
+                        });
+
+                        resolve(client);
+                    } else {
+                        reject(new Error(data.error || `Failed to connect to ${host}:${port}`));
+                    }
+                }
+            };
+
+            this.#ws.addEventListener("message", handler);
+        });
     }
 }

src/network_impl/porter.ts

@@ -38,8 +38,9 @@ export { default as unalias } from "./unalias";
 export { default as ps } from "./ps";
 export { default as kill } from "./kill";
 export { default as spark } from "./spark";
-
 export { default as hello_http } from "./hello_http";
+export { default as finger } from "./finger";
+
 export { default as telnetd } from "./services/telnetd";
 
 // shhhhh!

src/programs/@ALL.ts

@@ -0,0 +1,54 @@
+import type {Program} from "../types";
+
+export default {
+    name: "finger",
+    description: "Displays information about a user on a remote system.",
+    usage_suffix: "<username>@<hostname>",
+    arg_descriptions: {
+        "<username>@<hostname>": "The username and hostname of the user to query. For example, ollieg@happynetbox.com"
+    },
+    compat: "2.0.0",
+    completion: async () => [],
+    main: async (data) => {
+        // extract from data to make code less verbose
+        const {term, process, kernel, args} = data;
+
+        if (args.length !== 1) {
+            term.writeln(`${term.ansi.PREFABS.error}Invalid number of arguments. Usage: finger <username>@<hostname>${term.ansi.STYLE.reset_all}`);
+            return 1;
+        }
+
+        const [user, host] = args[0].split("@");
+        if (!user || !host) {
+            term.writeln(`${term.ansi.PREFABS.error}Invalid argument format. Usage: finger <username>@<hostname>${term.ansi.STYLE.reset_all}`);
+            return 1;
+        }
+
+        if (!kernel.has_network_manager()) {
+            term.writeln(`${term.ansi.PREFABS.error}No network manager found. This program requires a network manager to function.${term.ansi.STYLE.reset_all}`);
+            return 1;
+        }
+
+        const net_manager = kernel.get_network_manager();
+        if (!await net_manager.is_up(true)) {
+            term.writeln(`${term.ansi.PREFABS.error}Network is down!${term.ansi.STYLE.reset_all}`);
+            return 1;
+        }
+
+        const socket = await process.network_connect(host, 79);
+        if (!socket) {
+            term.writeln(`${term.ansi.PREFABS.error}Failed to connect to ${host}:79${term.ansi.STYLE.reset_all}`);
+            return 1;
+        }
+
+        socket.add_event_listener("data", term.write.bind(term));
+        socket.send(`${user}\r\n`);
+
+        // wait until connection is closed
+        await new Promise<void>((resolve) => {
+            socket.add_event_listener("close", resolve);
+        });
+
+        return 0;
+    }
+} as Program;

src/programs/finger.ts

@@ -49,7 +49,9 @@ export default {
         }
 
         if (args[0] === "-h") {
-            await kernel.spawn("help", ["hex"], shell).completion;
+            const spawn_result = kernel.spawn("help", ["hex"], shell);
+            spawn_result.process.kill(await spawn_result.completion);
+            return 0;
         }
 
         // get filepath