hsync 0.23.0 → 0.25.0

package/lib/peers.js

@@ -18,7 +18,6 @@ function createPacket(topic, payload) {
     topic,
     payload: payloadStr,
   });
-  // console.log('packet', packet);
   return packet;
 }
 
@@ -46,6 +45,7 @@ function initPeers(hsyncClient) {
     if (!peer) {
       debug('CREATING peer', hostName);
       peer = createRPCPeer({hostName, hsyncClient, timeout});
+      hsyncClient.emit('peerCreated', peer);
       peer.myAuth = b64id.generateId();
       if (temporary) {
         peer.rpcTemporary = true;
@@ -66,6 +66,8 @@ function initPeers(hsyncClient) {
     const myAuth = b64id.generateId();
     const transport = new EventEmitter();
     const peer = rawr({transport, methods: Object.assign({}, hsyncClient.peerMethods), timeout, idGenerator: b64id.generateId});
+    debug('createRPCPeer rawr', peer);
+    
     peer.hostName = hostName;
     peer.rtcEvents = new EventEmitter();
     peer.localMethods = Object.assign({}, hsyncClient.peerMethods);

package/lib/socket-listeners.js

@@ -31,9 +31,23 @@ function initListeners(hsyncClient) {
 
   function addSocketListener(options = {}) {
     const { port, targetPort, targetHost } = options;
-    debug('creating handler', port, targetHost);
+    if (!targetHost) {
+      throw new Error('no targetHost');
+    }
+    let cleanHost = targetHost.trim();
+    if (cleanHost.endsWith('/')) {
+      cleanHost = cleanHost.substring(0, cleanHost.length - 1);
+    }
+    const url = new URL(cleanHost);
+    if (url.hostname.toLowerCase() === hsyncClient.myHostName.toLowerCase()) {
+      throw new Error('targetHost must be a different host');
+    }
+    debug('creating handler', port, cleanHost);
+    if (cleanHost !== targetHost) {
+      debug('targetHost cleaned UP', targetHost, cleanHost);
+    }
     
-    const rpcPeer = hsyncClient.getRPCPeer({ hostName: targetHost });
+    const rpcPeer = hsyncClient.getRPCPeer({ hostName: cleanHost });
 
     const socketServer = net.createServer(async (socket) => {
 
@@ -118,7 +132,7 @@ function initListeners(hsyncClient) {
         debug('connecting remotely', socket.socketId, targetPort, rpcPeer.hostName, targetHost);
         const result = await rpcPeer.methods.connectSocket({
           socketId: socket.socketId,
-          port: targetPort,
+          port: targetPort || port,
           hostName: rpcPeer.hostName,
         });
         debug('connect result', result);
@@ -154,8 +168,8 @@ function initListeners(hsyncClient) {
       socketServer,
       sockets,
       end,
-      targetHost,
-      targetPort,
+      targetHost: cleanHost,
+      targetPort: targetPort || port,
       port,
     };
 

package/lib/socket-relays.js

@@ -24,14 +24,16 @@ function initRelays(hsyncClient) {
         targetPort: l.targetPort,
         whitelist: l.whitelist || '',
         blacklist: l.blacklist || '',
+        hostName: l.targetHost,
       };
     });
     return retVal;
   }
 
-  function connectSocket(remotePeer, { port, socketId }) {
+  function connectSocket(peer, { port, socketId, hostName }) {
+    debug('connectSocket', port, socketId, hostName);
 
-    remotePeer.notifications.oncloseRelaySocket((remotePeer, { socketId }) => {
+    peer.notifications.oncloseRelaySocket((peer, { socketId }) => {
       debug('closeRelaySocket', socketId);
       if (sockets[socketId]) {
         sockets[socketId].end();
@@ -42,12 +44,12 @@ function initRelays(hsyncClient) {
     });
 
     const relay = cachedRelays['p' + port];
-    debug('connect relay', port, socketId, remotePeer.hostName);
+    debug('connect relay', port, socketId, peer.hostName);
     if (!relay) {
       throw new Error('no relay found for port: ' + port);
     }
 
-    //  TODO: check white and black lists on remotePeer
+    //  TODO: check white and black lists on peer
 
     // const relayDataTopic = `msg/${hostName}/${hsyncClient.myHostName}/relayData/${socketId}`;
     return new Promise((resolve, reject) => {
@@ -61,10 +63,10 @@ function initRelays(hsyncClient) {
 
       socket.on('data', async (data) => {
         debug(`data in ${socket.socketId}`, relay.targetPort, relay.targetHost, data.length);
-        // TODO: queue data if remotePeer is not ready
-        if (remotePeer.packAndSend) {
+        // TODO: queue data if peer is not ready
+        if (peer.packAndSend) {
           debug('sending relay data via rtc', socket.socketId, data.length);
-          remotePeer.packAndSend(`socketData/${socket.socketId}`, Buffer.from(data));
+          peer.packAndSend(`socketData/${socket.socketId}`, Buffer.from(data));
           return;
         }
       });
@@ -72,7 +74,7 @@ function initRelays(hsyncClient) {
         debug(`LOCAL CONNECTION CLOSED`, socket.socketId);
         if (sockets[socket.socketId]) {
           try {
-            await remotePeer.notifiers.closeListenerSocket({socketId});
+            await peer.notifiers.closeListenerSocket({socketId});
           } catch (e) {
             debug('error closing socket', e);
           }
@@ -90,8 +92,9 @@ function initRelays(hsyncClient) {
 
   }
 
-  function addSocketRelay({whitelist, blacklist, port, targetPort, targetHost = 'localhost'}) {
+  function addSocketRelay({whitelist, blacklist, port, targetPort, targetHost}) {
     targetPort = targetPort || port;
+    targetHost = targetHost || 'localhost';
     debug('creating relay', whitelist, blacklist, port, targetPort, targetHost);
     const newRelay = {
       whitelist,
@@ -99,6 +102,7 @@ function initRelays(hsyncClient) {
       port,
       targetPort,
       targetHost,
+      hostName: targetHost,
     };
     cachedRelays['p' + port] = newRelay;
     return newRelay;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hsync",
-  "version": "0.23.0",
+  "version": "0.25.0",
   "description": "client for hsync-server",
   "main": "hsync.js",
   "scripts": {
@@ -18,7 +18,11 @@
     "json-rpc",
     "ngrok",
     "websocket",
-    "mqtt"
+    "mqtt",
+    "proxy",
+    "reverse-proxy",
+    "vpn",
+    "tunnel"
   ],
   "browser": {
     "./hsync": "./hsync-web"