diodejs 0.0.5 → 0.1.1

package/README.md

@@ -87,13 +87,22 @@ async function main() {
   const connection = new DiodeConnection(host, port, certPath);
   await connection.connect();
 
-  const publishedPorts = [8080]; // Ports you want to publish
-  const publishPort = new PublishPort(connection, publishedPorts, certPath);
-
+  // Option 1: Simple array of ports (all public)
+  const publishedPorts = [8080, 3000]; 
+  
+  // Option 2: Object with port configurations for public/private access control
+  const publishedPortsWithConfig = {
+    8080: { mode: 'public' },  // Public port, accessible by any device
+    3000: { 
+      mode: 'private',  
+      whitelist: ['0x1234abcd5678...', '0x9876fedc5432...'] // Only these devices can connect
+    }
+  };
+  
+  const publishPort = new PublishPort(connection, publishedPortsWithConfig, certPath);
 }
 
 main();
-
 ```
 
 ## Reference
@@ -149,7 +158,9 @@ main();
 
 - **Constructor**: `new PublishPort(connection, publishedPorts, certPath)`
   - `connection` (DiodeConnection): An instance of `DiodeConnection`.
-  - `publishedPorts` (array): An array of ports to publish.
+  - `publishedPorts` (array|object): Either:
+    - An array of ports to publish (all public mode)
+    - An object mapping ports to their configuration: `{ port: { mode: 'public'|'private', whitelist: ['0x123...'] } }`
   - `certPath` (string): The path to the device certificate.
 
 - **Methods**:

package/bindPort.js

@@ -13,8 +13,7 @@ class BindPort {
 
   bind () {
     const deviceId = Buffer.from(this.deviceIdHex, 'hex');
-    const clientSockets = new Map();
-
+    // Remove local clientSockets map and use the one from connection
     const rpc = new DiodeRPC(this.connection);
 
     // Listen for data events from the device
@@ -31,12 +30,17 @@ class BindPort {
         const dataRef = Buffer.from(refRaw);
         const data = Buffer.from(dataRaw);
 
-        // Find the associated client socket
-        const clientSocket = clientSockets.get(dataRef.toString('hex'));
+        // Find the associated client socket from connection
+        const clientSocket = this.connection.getClientSocket(dataRef);
         if (clientSocket) {
           clientSocket.write(data);
         } else {
-          logger.warn(`No client socket found for ref: ${dataRef.toString('hex')}`);
+          const connectionInfo = this.connection.getConnection(dataRef);
+          if (connectionInfo) {
+            logger.debug(`No client socket found for ref: ${dataRef.toString('hex')}, but connection exists for ${connectionInfo.host}:${connectionInfo.port}`);
+          } else {
+            logger.warn(`No client socket found for ref: ${dataRef.toString('hex')}`);
+          }
         }
       } else if (messageType === 'portclose') {
         const refRaw = messageContent[1];
@@ -44,14 +48,16 @@ class BindPort {
         const dataRef = Buffer.from(refRaw);
 
         // Close the associated client socket
-        const clientSocket = clientSockets.get(dataRef.toString('hex'));
+        const clientSocket = this.connection.getClientSocket(dataRef);
         if (clientSocket) {
           clientSocket.end();
-          clientSockets.delete(dataRef.toString('hex'));
+          this.connection.deleteClientSocket(dataRef);
           logger.info(`Port closed for ref: ${dataRef.toString('hex')}`);
         }
       } else {
-        logger.warn(`Unknown unsolicited message type: ${messageType}`);
+        if (messageType != 'portopen') {
+          logger.warn(`Unknown unsolicited message type: ${messageType}`);
+        }
       }
     });
 
@@ -76,8 +82,8 @@ class BindPort {
         return;
       }
 
-      // Store the client socket with the ref (using hex string as key)
-      clientSockets.set(ref.toString('hex'), clientSocket);
+      // Store the client socket with the ref using connection's method
+      this.connection.addClientSocket(ref, clientSocket);
 
       // When data is received from the client, send it to the device
       clientSocket.on('data', async (data) => {
@@ -92,11 +98,11 @@ class BindPort {
       // Handle client socket closure
       clientSocket.on('end', async () => {
         logger.info('Client disconnected');
-        if (ref && clientSockets.has(ref.toString('hex'))) {
+        if (ref && this.connection.hasClientSocket(ref)) {
           try {
             await rpc.portClose(ref);
             logger.info(`Port closed on device for ref: ${ref.toString('hex')}`);
-            clientSockets.delete(ref.toString('hex'));
+            this.connection.deleteClientSocket(ref);
           } catch (error) {
             logger.error(`Error closing port on device: ${error}`);
           }

package/connection.js

@@ -28,6 +28,10 @@ class DiodeConnection extends EventEmitter {
     this.RPC = new DiodeRPC(this);
     this.isReconnecting = false;
     this.connectPromise = null;
+    
+    // Add maps for storing client sockets and connections
+    this.clientSockets = new Map(); // For BindPort
+    this.connections = new Map(); // For PublishPort
 
     // Check if certPath exists, if not generate the certificate
     if (!fs.existsSync(this.certPath)) {
@@ -562,6 +566,40 @@ class DiodeConnection extends EventEmitter {
   close() {
     this.socket.end();
   }
+
+  // Client sockets management methods (for BindPort)
+  addClientSocket(ref, socket) {
+    this.clientSockets.set(ref.toString('hex'), socket);
+  }
+
+  getClientSocket(ref) {
+    return this.clientSockets.get(ref.toString('hex'));
+  }
+
+  deleteClientSocket(ref) {
+    return this.clientSockets.delete(ref.toString('hex'));
+  }
+
+  hasClientSocket(ref) {
+    return this.clientSockets.has(ref.toString('hex'));
+  }
+
+  // Connections management methods (for PublishPort)
+  addConnection(ref, connectionInfo) {
+    this.connections.set(ref.toString('hex'), connectionInfo);
+  }
+
+  getConnection(ref) {
+    return this.connections.get(ref.toString('hex'));
+  }
+
+  deleteConnection(ref) {
+    return this.connections.delete(ref.toString('hex'));
+  }
+
+  hasConnection(ref) {
+    return this.connections.has(ref.toString('hex'));
+  }
 }
 
 

package/examples/publishAndBind.js

@@ -0,0 +1,23 @@
+const DiodeConnection = require('../connection')
+const PublishPort = require('../publishPort')
+const BindPort = require('../bindPort')
+
+const host = 'us2.prenet.diode.io';
+const port = 41046;
+const certPath = 'device_certificate.pem';
+
+const connection = new DiodeConnection(host, port, certPath);
+
+async function main() {
+    await connection.connect();
+    const publishedPorts = [8080]; // Ports you want to publish
+    const publishPort = new PublishPort(connection, publishedPorts, certPath);
+
+    const portForward = new BindPort(connection, 3002, 8080, "5365baf29cb7ab58de588dfc448913cb609283e2");
+    portForward.bind();
+
+}
+
+main();
+
+    

package/examples/publishPortTest.js

@@ -11,7 +11,7 @@ async function startPublishing() {
   const connection = new DiodeConnection(host, port, certPath);
   await connection.connect();
 
-  const publishedPorts = [8080]; // Ports you want to publish
+  const publishedPorts = {8080: {mode: 'private', whitelist: ['0xca1e71d8105a598810578fb6042fa8cbc1e7f039']}}
   const publishPort = new PublishPort(connection, publishedPorts, certPath);
 
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diodejs",
-  "version": "0.0.5",
+  "version": "0.1.1",
   "description": "A JavaScript client for interacting with the Diode network. It provides functionalities to bind and publish ports, send RPC commands, and handle responses.",
   "main": "index.js",
   "scripts": {

package/publishPort.js

@@ -39,9 +39,34 @@ class PublishPort extends EventEmitter {
   constructor(connection, publishedPorts, certPath) {
     super();
     this.connection = connection;
-    this.publishedPorts = new Set(publishedPorts); // Convert array to a Set
-    this.connections = new Map(); // Map to store active connections
+    
+    // Convert publishedPorts to a Map with configurations
+    this.publishedPorts = new Map();
+    
+    // Handle both array format and object format
+    if (Array.isArray(publishedPorts)) {
+      // Legacy array format - treat all ports as public
+      publishedPorts.forEach(port => {
+        this.publishedPorts.set(port, { mode: 'public', whitelist: [] });
+      });
+    } else if (typeof publishedPorts === 'object' && publishedPorts !== null) {
+      // New object format with configurations
+      Object.entries(publishedPorts).forEach(([port, config]) => {
+        const portNum = parseInt(port, 10);
+        // Ensure config is properly structured
+        const portConfig = typeof config === 'object' && config !== null
+          ? { 
+              mode: config.mode || 'public', 
+              whitelist: Array.isArray(config.whitelist) ? config.whitelist : [] 
+            }
+          : { mode: 'public', whitelist: [] };
+        
+        this.publishedPorts.set(portNum, portConfig);
+      });
+    }
+    
     this.startListening();
+    logger.info(`Publishing ports: ${Array.from(this.publishedPorts.keys())}`);
     this.rpc = new DiodeRPC(connection);
     this.certPath = certPath;
   }
@@ -60,7 +85,9 @@ class PublishPort extends EventEmitter {
       } else if (messageType === 'portclose') {
         this.handlePortClose(sessionIdRaw, messageContent);
       } else {
-        logger.warn(`Unknown unsolicited message type: ${messageType}`);
+        if (messageType != 'data') {
+          logger.warn(`Unknown unsolicited message type: ${messageType}`);
+        }
       }
     });
   }
@@ -74,7 +101,7 @@ class PublishPort extends EventEmitter {
     const sessionId = Buffer.from(sessionIdRaw);
     const portString = makeReadable(portStringRaw);
     const ref = Buffer.from(refRaw);
-    const deviceId = Buffer.from(deviceIdRaw).toString('hex');
+    const deviceId = `0x${Buffer.from(deviceIdRaw).toString('hex')}`;
 
     logger.info(`Received portopen request for portString ${portString} with ref ${ref.toString('hex')} from device ${deviceId}`);
 
@@ -94,13 +121,24 @@ class PublishPort extends EventEmitter {
     }
 
     // Check if the port is published
-    if (!this.publishedPorts.has(port)) { // Use .has() instead of .includes()
+    if (!this.publishedPorts.has(port)) {
       logger.warn(`Port ${port} is not published. Rejecting request.`);
       // Send error response
       this.rpc.sendError(sessionId, ref, 'Port is not published');
       return;
     }
 
+    // Get port configuration and check whitelist if in private mode
+    const portConfig = this.publishedPorts.get(port);
+    if (portConfig.mode === 'private' && Array.isArray(portConfig.whitelist)) {
+      if (!portConfig.whitelist.includes(deviceId)) {
+        logger.warn(`Device ${deviceId} is not whitelisted for port ${port}. Rejecting request.`);
+        this.rpc.sendError(sessionId, ref, 'Device not whitelisted');
+        return;
+      }
+      logger.info(`Device ${deviceId} is whitelisted for port ${port}. Accepting request.`);
+    }
+
     // Handle based on protocol
     if (protocol === 'tcp') {
       this.handleTCPConnection(sessionId, ref, port);
@@ -127,14 +165,14 @@ class PublishPort extends EventEmitter {
         logger.info(`Local service disconnected`);
         // Send portclose message to Diode
         this.rpc.portClose(ref);
-        this.connections.delete(ref.toString('hex'));
+        this.connection.deleteConnection(ref);
       });
 
       localSocket.on('error', (err) => {
         logger.error(`Error with local service: ${err}`);
         // Send portclose message to Diode
         this.rpc.portClose(ref);
-        this.connections.delete(ref.toString('hex'));
+        this.connection.deleteConnection(ref);
       });
     }
   }
@@ -150,8 +188,8 @@ class PublishPort extends EventEmitter {
     // Handle data, end, and error events
     this.setupLocalSocketHandlers(localSocket, ref, 'tcp');
 
-    // Store the local socket with the ref
-    this.connections.set(ref.toString('hex'), { socket: localSocket, protocol: 'tcp' });
+    // Store the local socket with the ref using connection's method
+    this.connection.addConnection(ref, { socket: localSocket, protocol: 'tcp' });
   }
 
   handleTLSConnection(sessionId, ref, port) {
@@ -189,16 +227,16 @@ class PublishPort extends EventEmitter {
     tlsSocket.on('error', (err) => {
       logger.error(`TLS Socket error: ${err}`);
       this.rpc.portClose(ref);
-      this.connections.delete(ref.toString('hex'));
+      this.connection.deleteConnection(ref);
     });
 
     tlsSocket.on('close', () => {
       console.log('TLS Socket closed');
-      this.connections.delete(ref.toString('hex'));
+      this.connection.deleteConnection(ref);
     });
 
-    // Store the connection info
-    this.connections.set(ref.toString('hex'), {
+    // Store the connection info using connection's method
+    this.connection.addConnection(ref, {
       diodeSocket,
       tlsSocket,
       localSocket,
@@ -216,8 +254,8 @@ class PublishPort extends EventEmitter {
     // Send success response
     this.rpc.sendResponse(sessionId, ref, 'ok');
 
-    // Store the connection info
-    this.connections.set(ref.toString('hex'), {
+    // Store the connection info using connection's method
+    this.connection.addConnection(ref, {
       socket: localSocket,
       protocol: 'udp',
       remoteInfo,
@@ -238,7 +276,7 @@ class PublishPort extends EventEmitter {
     localSocket.on('error', (err) => {
       logger.error(`UDP Socket error: ${err}`);
       this.rpc.portClose(ref);
-      this.connections.delete(ref.toString('hex'));
+      this.connection.deleteConnection(ref);
     });
   }
 
@@ -250,7 +288,7 @@ class PublishPort extends EventEmitter {
     const ref = Buffer.from(refRaw);
     const data = Buffer.from(dataRaw)//.slice(4);
 
-    const connectionInfo = this.connections.get(ref.toString('hex'));
+    const connectionInfo = this.connection.getConnection(ref);
     if (connectionInfo) {
       const { socket: localSocket, protocol, remoteInfo } = connectionInfo;
 
@@ -277,8 +315,13 @@ class PublishPort extends EventEmitter {
         diodeSocket.pushData(data);
       }
     } else {
-      logger.warn(`No local connection found for ref ${ref.toString('hex')}. Sending portclose.`);
-      this.rpc.sendError(sessionId, ref, 'No local connection found');
+      const clientSocket = this.connection.getClientSocket(ref);
+      if (clientSocket) {
+        logger.debug(`No local connection found for ref: ${ref.toString('hex')}, but client socket exists`);
+      } else {
+        logger.warn(`No local connection found for ref ${ref.toString('hex')}. Sending portclose.`);
+        this.rpc.sendError(sessionId, ref, 'No local connection found');
+      }
     }
   }
 
@@ -289,7 +332,7 @@ class PublishPort extends EventEmitter {
 
     logger.info(`Received portclose for ref ${ref.toString('hex')}`);
 
-    const connectionInfo = this.connections.get(ref.toString('hex'));
+    const connectionInfo = this.connection.getConnection(ref);
     if (connectionInfo) {
       const { diodeSocket, tlsSocket, socket: localSocket } = connectionInfo;
       // End all sockets
@@ -302,7 +345,7 @@ class PublishPort extends EventEmitter {
           localSocket.end();
         }
       }
-      this.connections.delete(ref.toString('hex'));
+      this.connection.deleteConnection(ref);
     }
   }
 }