hsync 0.21.0 → 0.24.0

package/lib/peers.js

@@ -18,7 +18,6 @@ function createPacket(topic, payload) {
     topic,
     payload: payloadStr,
   });
-  // console.log('packet', packet);
   return packet;
 }
 
@@ -66,6 +65,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);
@@ -73,12 +74,13 @@ function initPeers(hsyncClient) {
   
     peer.localMethods.rtcSignal = (peerInfo, signal) => {
       debug('rtcSignal', signal.type);
-      if (signal.type === 'offer' && !peer.rtcCon && !signal.alreadySent) {
+      if (signal.type === 'offer') { // && !peer.rtcCon && !signal.alreadySent) {
+        peer.rtcStatus = 'connecting';
         rtc.answerPeer(peer, signal);
       } else if (signal.type === 'answer') {
         peer.handleRtcAnswer(signal);
       }
-      return 'rtcSignal ok';
+      return `rtcSignal ${signal.type} handled ok`;
     }
   
     peer.rtcEvents.on('packet', async (packet) => {
@@ -97,6 +99,13 @@ function initPeers(hsyncClient) {
           transport.receiveData(rpcMsg);
           //   return;
           // }
+        } else if (p1 === 'jsonMsg') {
+          try {
+            const jsonMsg = JSON.parse(msg.payload.toString());
+            peer.rtcEvents.emit('jsonMsg', jsonMsg);
+          } catch (e) {
+            debug('error parsing jsonMsg', e);
+          }
         } else if (p1 === 'socketData') {
           handleSocketPacket(msg);
         } else if (p1 === 'test') {
@@ -110,7 +119,7 @@ function initPeers(hsyncClient) {
     });
   
     peer.rtcEvents.on('dcOpen', () => {
-      debug('dcOpen');
+      debug(peer.answerer ? 'answerer' : 'offerer', 'dcOpen');
       peer.packAndSend = (topic, payload) => {
         const packet = createPacket(topic, payload);
         if (topic === 'test') {
@@ -154,20 +163,35 @@ function initPeers(hsyncClient) {
   
     peer.connectRTC = async () => {
       debug('connectRTC');
+      peer.rtcStatus = 'connecting';
+      peer.rtcEvents.emit('connecting');
       return new Promise(async (resolve, reject) => {
         try {
           const offer = await rtc.offerPeer(peer);
           debug('offer', offer);
           peer.rtcEvents.once('dcOpen', () => {
-            debug('dcOpen!');
+            peer.rtcStatus = 'connected';
+            debug('offerer dcOpen!');
             resolve(offer);
           });
         } catch (e) {
           debug('error connecting to rtc', e);
+          peer.rtcStatus = 'error';
           reject(e);
         }
       });
     };
+
+    peer.sendJSONMsg = (msg) => {
+      if (typeof msg !== 'object') {
+        throw new Error('sendJSONMsg requires an object');
+      }
+      if (!peer.packAndSend) {
+        throw new Error('peer not connected');
+      }
+      const payload = JSON.stringify(msg);
+      peer.packAndSend('jsonMsg', payload);
+    };
   
     transport.send = async (msg) => {
       const fullMsg = {

package/lib/rtc-node.js

@@ -32,6 +32,12 @@ function offerPeer(peer) {
     let gatheringComplete = false;
     let offerSent = false;
     const start = Date.now();
+
+    peer.handleRtcAnswer = (answer) => {
+      debug('node handle RtcAnswer', answer.sdp.length);
+      peer.rtcCon.setRemoteDescription(answer.sdp, answer.type);
+      return 'node handle RtcAnswer ok';
+    }
   
     async function sendOffer() {
       const desc = con.localDescription();
@@ -86,10 +92,6 @@ function offerPeer(peer) {
         dc.sendMessageBinary(packet);
       };
       peer.rtcEvents.emit('dcOpen', dc);
-      // dc.sendMessage("Hello from node from offerer");
-      // peer.dc.onStateChange((state) => {
-      //   debug('dc state change', state);
-      // });
       debug('keys', Object.keys(dc));
     });
   
@@ -107,12 +109,6 @@ function offerPeer(peer) {
         offerSent = true;
       }
     }, GATHERING_TIMEOUT);
-  
-    peer.handleRtcAnswer = (answer) => {
-      debug('node handleRtcAnswer', answer.sdp.length);
-      con.setRemoteDescription(answer.sdp, answer.type);
-      return 'node handleRtcAnswer ok';
-    }
 
   });
 }
@@ -124,6 +120,7 @@ async function answerPeer(peer, offer) {
 
   const con = new rtc.PeerConnection('pc', defaultOptions);
   peer.rtcCon = con;
+  peer.answerer = true;
   
   function sendAnswer() {
     const desc = con.localDescription();
@@ -135,6 +132,16 @@ async function answerPeer(peer, offer) {
     if (state === 'connected') {
       peer.connected = true;
       peer.rtcEvents.emit('connected', con);
+    } else if (state === 'disconnected') {
+      peer.connected = false;
+      peer.rtcEvents.emit('disconnected', con);
+      peer.rtcCon = null;
+      peer.dc = null;
+    } else if (state === 'closed') {
+      peer.connected = false;
+      peer.rtcEvents.emit('closed', con);
+      peer.rtcCon = null;
+      peer.dc = null;
     }
   });
 
@@ -163,10 +170,6 @@ async function answerPeer(peer, offer) {
       dc.sendMessageBinary(packet);
     };
     peer.rtcEvents.emit('dcOpen', dc);
-
-    // peer.dc.onStateChange((state) => {
-    //   debug('dc state change', state);
-    // });
   });
 
 }

package/lib/rtc-web.js

@@ -53,10 +53,20 @@ async function offerPeer(peer) {
     };
 
     con.onconnectionstatechange = (event) => {
-      debug('connection state', con.connectionState, event);
+      debug('offerer connection state', con.connectionState, event);
       if(con.connectionState === 'connected') {
         peer.connected = true;
         peer.rtcEvents.emit('connected', con);
+      } else if (con.connectionState === 'disconnected') {
+        peer.connected = false;
+        peer.rtcEvents.emit('disconnected', con);
+        peer.rtcCon = null;
+        peer.dc = null;
+      } else if (con.connectionState === 'closed') {
+        peer.connected = false;
+        peer.rtcEvents.emit('closed', con);
+        peer.rtcCon = null;
+        peer.dc = null;
       }
     };
 
@@ -94,9 +104,9 @@ async function offerPeer(peer) {
     }, GATHERING_TIMEOUT);
 
     peer.handleRtcAnswer = (answer) => {
-      debug('node handleRtcAnswer', answer.sdp.length);
+      debug('web handle RtcAnswer', answer.sdp.length);
       con.setRemoteDescription(answer);
-      return 'web handleRtcAnswer ok';
+      return 'web handle RtcAnswer ok';
     }
   });
 }
@@ -107,6 +117,7 @@ async function answerPeer(peer, offer) {
   // window.rtc = rtc;
 
   peer.rtcCon = con;
+  peer.answerer = true;
   
   let gatheringComplete = false;
   const start = Date.now();
@@ -133,7 +144,7 @@ async function answerPeer(peer, offer) {
   };
 
   con.onconnectionstatechange = (event) => {
-    debug('connection state', con.connectionState, event);
+    debug('answerer connection state', con.connectionState, event);
     if(con.connectionState === 'connected') {
       peer.connected = true;
       peer.rtcEvents.emit('connected', con);

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.21.0",
+  "version": "0.24.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"