iosignal 4.10.0 → 5.0.0

package/dist/types/client/IOCore.d.ts

@@ -77,6 +77,7 @@ export class IOCore extends EventEmitter<string | symbol, any> {
      * @type {Boho}
      */
     boho: Boho;
+    serverTimeNonce: any;
     /**
      * Indicates if the connection is TLS (wss).
      * @type {boolean}

package/dist/types/client/browser/IOWebSocket.d.ts

@@ -74,6 +74,6 @@ export default class IO extends IOCore {
     socket_send(data: BufferSource): void;
 }
 export type Boho = import("boho").Boho;
-export type MBP = any;
+export type MBP = typeof import("meta-buffer-pack");
 export type Buffer = import("boho").Buffer;
 import { IOCore } from "../IOCore.js";

package/dist/types/common/constants.d.ts

@@ -2,11 +2,14 @@ export type STATE = {
     CONNECTING: number;
     OPEN: number;
     SERVER_READY: number;
-    AUTH_ACK: number;
-    CLOSING: number;
-    READY: number;
+    AUTH_REQ: number;
+    AUTH_RES: number;
     AUTH_FAIL: number;
     AUTH_CLEAR: number;
+    CID_REQ: number;
+    CID_RES: number;
+    READY: number;
+    CLOSING: number;
     CLOSED: number;
     STOP: number;
     REDIRECTING: number;
@@ -16,9 +19,7 @@ export namespace STATE {
     let OPEN: number;
     let SERVER_READY: number;
     let AUTH_REQ: number;
-    let AUTH_NONCE: number;
-    let AUTH_HMAC: number;
-    let AUTH_ACK: number;
+    let AUTH_RES: number;
     let AUTH_FAIL: number;
     let AUTH_CLEAR: number;
     let CID_REQ: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iosignal",
-  "version": "4.10.0",
+  "version": "5.0.0",
   "description": "iosignal",
   "type": "module",
   "exports": {
@@ -37,7 +37,7 @@
     "typescript": "^5.8.3"
   },
   "dependencies": {
-    "boho": "^1.1.1",
+    "boho": "^2.0.0",
     "eventemitter3": "^5.0.1",
     "meta-buffer-pack": "^2.1.0",
     "ws": "^8.18.3"

package/src/auth/BohoAuth.js

@@ -34,10 +34,10 @@ export class BohoAuth {
   }
 
 
-  async verify_auth_hmac(auth_hmac, peer) {
+  async verify_auth_req(auth_req, peer) {
     try {
       //1. unpack 
-      let infoPack = MBP.unpack(auth_hmac, Boho.Meta.AUTH_HMAC)
+      let infoPack = MBP.unpack(auth_req, Boho.Meta.AUTH_REQ)
       if (!infoPack) {
         this.send_auth_fail(peer, 'unpack auth_pack fail');
         return
@@ -75,8 +75,8 @@ export class BohoAuth {
       }
 
       //3. check hmac
-      let auth_ack = peer.boho.check_auth_hmac(infoPack)
-      if (!auth_ack) {
+      let auth_res = peer.boho.verify_auth_req(infoPack)
+      if (!auth_res) {
         this.send_auth_fail(peer, 'hmac dismatched');
         return
       }
@@ -99,8 +99,12 @@ export class BohoAuth {
         )
         if (this.keepOldConnection) { // default true
           // keep old connection. reject new connection by sending auth_fail signal.
-          this.send_auth_fail(peer, 'duplicate login')
           // peer.send(authClearSignal)
+          if( peer.socketType == 'websocket'){
+            this.send_auth_fail(peer, 'duplicate login')
+          }else{
+            peer.close(); //arduino 
+          }
         } else {
           // accept new connection. stop the old connection by sending auth_clear signal.
           old.send(authClearSignal)
@@ -145,8 +149,8 @@ export class BohoAuth {
       //9. set cid2remote
       peer.manager.cid2remote.set(peer.cid, peer)
       //10. send ack.
-      peer.send(auth_ack)
-      peer.setState(STATE.AUTH_ACK)
+      peer.send(auth_res)
+      peer.setState(STATE.AUTH_RES)
       if (this.authLogger) {
         let peerInfo = `OK #${peer.ssid} cid: ${peer.cid} did:${peer.did}`
         if (peer.isAdmin) peerInfo = "#ADMIN# " + peerInfo
@@ -154,7 +158,7 @@ export class BohoAuth {
       }
       return authInfo
     } catch (error) {
-      console.log('verify_auth_hmac error', error)
+      console.log('verify_auth_req error', error)
       this.send_auth_fail(peer, '[BohoAuth]caught: unknown error:' + error);
     }
   }

package/src/client/IOCore.js

@@ -114,6 +114,8 @@ export class IOCore extends EventEmitter {
      * @type {Boho}
      */
     this.boho = new Boho()
+
+    this.serverTimeNonce = Buffer.alloc( Boho.MetaSize.SERVER_TIME_NONCE  );
     /**
      * Indicates if the connection is TLS (wss).
      * @type {boolean}
@@ -345,10 +347,13 @@ export class IOCore extends EventEmitter {
    * @returns {this} 
    */
   login(id, key) {
-    this.auth(id, key)
-    this.useAuth = true
-    let auth_pack = this.boho.auth_req()
-    this.send(auth_pack)
+    if( this.serverTimeNonce ){
+      console.log('iosignal.login serverTimeNonce', this.serverTimeNonce)
+      this.auth(id, key)
+      this.useAuth = true
+      let auth_pack = this.boho.auth_req(this.serverTimeNonce )
+      this.send(auth_pack)
+    }
     return this
   }
 
@@ -497,12 +502,15 @@ export class IOCore extends EventEmitter {
         this.redirect(url)
         break;
 
-      case IOMsg.SERVER_READY:
+      case Boho.BohoMsg.SERVER_TIME_NONCE: // SERVER_READY
         this.stateChange('server_ready', 'server_ready')
         if (this.useAuth) {
-          this.send(this.boho.auth_req())
-          // CID_REQ will be called, after auth_ack.
+          this.send(this.boho.auth_req(buffer))
+          this.stateChange('auth_req','auth_req')
+          // CID_REQ will be called, after auth_res.
         } else {
+          // keep server_time_nonce for manual login()
+          buffer.copy( this.serverTimeNonce);
           // CID_REQ here, if not using auth.
           this.send(Buffer.from([IOMsg.CID_REQ]))
         }
@@ -549,6 +557,7 @@ export class IOCore extends EventEmitter {
             > cid_sub message:  tag includes cid and @ both : 'cid@*'
             > ch_sub message:  else.
           */
+        //  console.log('payloadType', payloadType )
           switch (payloadType) {
 
             case PAYLOAD_TYPE.EMPTY:
@@ -625,26 +634,16 @@ export class IOCore extends EventEmitter {
         this.testPromise(buffer)
         break;
 
-      case Boho.BohoMsg.AUTH_NONCE:
-        this.stateChange('auth_nonce','server sent auth_nonce.')
-        let auth_hmac = this.boho.auth_hmac(buffer)
-        if (auth_hmac) {
-          this.send(auth_hmac)
-        } else {
-          this.stateChange('auth_fail', 'boho.auth_hmac() invalid auth_nonce.')
-        }
-        break;
-
       case Boho.BohoMsg.AUTH_FAIL:
         this.stateChange('auth_fail', 'auth_fail from server.')
         break;
 
-      case Boho.BohoMsg.AUTH_ACK:
-        if (this.boho.check_auth_ack_hmac(buffer)) {
-          this.stateChange('auth_ack', 'server sent auth_ack')
+      case Boho.BohoMsg.AUTH_RES:
+        if (this.boho.verify_auth_res(buffer)) {
+          this.stateChange('auth_res', 'server sent auth_res')
           this.send(Buffer.from([IOMsg.CID_REQ]))
         } else {
-          this.stateChange('auth_fail', 'check_auth_ack_hmac() invalid server_hmac')
+          this.stateChange('auth_fail', 'verify_auth_res() invalid server_hmac')
         }
         break;
 
@@ -872,6 +871,7 @@ export class IOCore extends EventEmitter {
    */
   signal_e2e(tag, data, key) {
 
+    if( !this.boho.isAuthorized ) return;
     if (typeof tag !== 'string') throw TypeError('tag should be string.')
     let tagEncoded = encoder.encode(tag)
     let dataPack = MBP.B8(data)

package/src/common/constants.js

@@ -4,11 +4,13 @@
  * @property {number} CONNECTING
  * @property {number} OPEN
  * @property {number} SERVER_READY
- * @property {number} AUTH_ACK
- * @property {number} CLOSING
- * @property {number} READY
+ * @property {number} AUTH_REQ
+ * @property {number} AUTH_RES
  * @property {number} AUTH_FAIL
  * @property {number} AUTH_CLEAR
+ * @property {number} CID_REQ
+ * @property {number} CID_RES
+ * @property {number} READY
  * @property {number} CLOSING
  * @property {number} CLOSED
  * @property {number} STOP
@@ -20,11 +22,10 @@ export const STATE = {
   OPEN:          1,
   SERVER_READY: 10,
   AUTH_REQ:     11,
-  AUTH_NONCE:   12,
-  AUTH_HMAC:    13,
-  AUTH_ACK:     14,
-  AUTH_FAIL:    15,
-  AUTH_CLEAR:   16,
+  AUTH_RES:     12,
+  AUTH_FAIL:    13,
+  AUTH_CLEAR:   14,
+
   CID_REQ:      17,
   CID_RES:      18,
   READY:        19,
@@ -139,15 +140,7 @@ export let IOMsg = {
 
   // DO NOT USE: 0xB0~ 0xBF
   // Boho module using this numbers.
-  // AUTH_REQ : 0xB0,  
-  // AUTH_NONCE: 0xB1,
-  // AUTH_HMAC: 0xB2,
-  // AUTH_ACK: 0xB3,
-  // AUTH_FAIL: 0xB4,
-  // AUTH_EXT: 0xB5,
-  // ENC_PACK : 0xB6,  
-  // ENC_E2E : 0xB7,  
-  // ENC_488 : 0xB8
+
   // reserved ~0xBF
 
   // C. IO status contorl.

package/src/server/Manager.js

@@ -4,7 +4,7 @@ import { serverOption } from './serverOption.js'
 import { IOMsg, STATE } from '../common/constants.js'
 import { getSignalPack } from '../common/payload.js';
 import { FileLogger } from './FileLogger.js'
-import { Metric } from './Metric.js'
+import { Metrics } from './Metrics.js'
 
 const encoder = new TextEncoder()
 const decoder = new TextDecoder()
@@ -36,7 +36,7 @@ export class Manager {
     this.channel_map = new Map()      // key: channelName -> value: < remote : Set >
     this.CHANNEL_PREFIX = 'CH:'
     this.CID_PREFIX = 'CID:'
-    this.metric = new Metric(this)
+    this.metrics = new Metrics(this)
     this.lastSSID = 0;
 
     this.pingIntervalID = setInterval(e => {
@@ -72,7 +72,7 @@ export class Manager {
     socket.isAlive = true;
     let remote = new Remote(socket, req, this)
     this.remotes.add(remote)
-    remote.send(Buffer.from([IOMsg.SERVER_READY]))
+    remote.send( remote.boho.server_time_nonce() )
     remote.setState(STATE.SERVER_READY)
     this.lastSSID = remote.ssid;
     let connectionInfo = `+ IP:${remote.ip} #${remote.ssid} ${socket.socketType === 'websocket' ? "WS" : "CS"} `;
@@ -402,18 +402,18 @@ export class Manager {
     }
 
     if (serverOption.showChannel > 0) {
-      this.metric.channels(serverOption.showChannel);
+      this.metrics.channels(serverOption.showChannel);
     }
     let mode = parseInt(serverOption.showMetric)
     switch (mode) {
       case 1:
-        this.metric.oneline(true);
+        this.metrics.oneline(true);
         break;
       case 2:
-        this.metric.getRemotes(true);
+        this.metrics.getRemotes(true);
         break;
       case 3:
-        this.metric.getChannelList(true);
+        this.metrics.getChannelList(true);
         break;
       default:
     }

package/src/server/Metrics.js

@@ -0,0 +1,155 @@
+import { memoryUsage } from 'process';
+import { ENC_MODE } from '../common/constants.js'
+
+const MAX = 10
+let period = 10000
+
+export class Metrics {
+  constructor(manager) {
+    this.manager = manager;
+
+    this.metricsPack = {
+      remotes: [0],
+      channels: [0],
+      txBytes: [0],
+      rxBytes: [0],
+      unixTime: [Math.floor(Date.now() / 1000)],
+      period: 0
+    }
+
+    this.tickId = setInterval(e => {
+
+      this.metricsPack.remotes.push(this.manager.remotes.size)
+      if (this.metricsPack.remotes.length > MAX) this.metricsPack.remotes.shift()
+
+      this.metricsPack.channels.push(this.manager.channel_map.size)
+      if (this.metricsPack.channels.length > MAX) this.metricsPack.channels.shift()
+
+
+      this.metricsPack.txBytes.push(this.manager.txBytes)
+      if (this.metricsPack.txBytes.length > MAX) this.metricsPack.txBytes.shift()
+
+      this.metricsPack.rxBytes.push(this.manager.rxBytes)
+      if (this.metricsPack.rxBytes.length > MAX) this.metricsPack.rxBytes.shift()
+
+      this.metricsPack.unixTime = Math.floor(Date.now() / 1000)
+      this.metricsPack.period = period;
+      this.manager.txBytes = 0
+      this.manager.rxBytes = 0
+
+
+    }, 10000)
+  }
+
+
+
+  oneline(prn) {
+    let memoryUse = memoryUsage();
+    let memoryInfo = [{
+      ...memoryUse
+    }]
+
+    if (prn) console.table(memoryInfo, ['rss', 'heapTotal', 'heapUsed', 'external', 'arrayBuffers']);
+
+    let metric = [{
+      lastSSID: this.manager.lastSSID,
+      remotes: this.manager.remotes.size,
+      channels: this.manager.channel_map.size,
+      txBytes: this.manager.txBytes,
+      rxBytes: this.manager.rxBytes,
+    }]
+
+    if (prn) console.table(metric, ['lastSSID', 'remotes', 'channels', 'txBytes', 'rxBytes']);
+
+    return metric[0]
+  }
+
+  getRemotes(prn) {
+    let remoteList = Array.from(this.manager.remotes.values())
+    let remoteStates = remoteList.map(v => {
+      return "#" + v.ssid + ":" + v.cid + "(" + v.state + ")"
+    })
+    if (prn) console.table(remoteStates)
+    return remoteStates
+  }
+
+  getCIdList(prn) {
+    let CIdList = Array.from(this.manager.cid2remote.keys())
+    if (prn) console.table(CIdList)
+    return CIdList
+  }
+
+  getChannelList(prn) {
+    let chList = Array.from(this.manager.channel_map.keys())
+    if (prn) console.table(chList)
+    return chList
+  }
+
+  getSubscribers(ch) {
+    let list = [];
+    if (this.manager.channel_map.has(ch)) {
+      let subscribers = this.manager.channel_map.get(ch) //set
+      subscribers.forEach(c => {
+        list.push(c.cid)
+      })
+    }
+    // console.log(list)
+    return list
+  }
+
+  getRemoteByCId(cid, mode = 1) {
+
+    if (this.manager.cid2remote.has(cid)) {
+      let remote = this.manager.cid2remote.get(cid)
+      if (mode == 1) {
+        return {
+          ip: remote.ip,
+          id: remote.cid,
+          ssid: remote.ssid,
+          cid: remote.cid,
+          uid: remote.uid,
+          uptime: Math.trunc((Date.now() - remote.socket.openTime) / 1000),
+          tx: remote.socket.txCounter,
+          rx: remote.socket.rxCounter,
+          txBytes: remote.socket.bytesWritten || remote.socket._socket?.bytesWritten,
+          rxBytes: remote.socket.bytesRead || remote.socket._socket?.bytesRead
+        }
+      } else if (mode == 2) {
+        return {
+          ip: remote.ip,
+          uptime: Math.trunc((Date.now() - remote.socket.openTime) / 1000),
+          nick: remote.nick,
+          ssid: remote.ssid
+        }
+      } else if (mode == 3) {
+        return {
+          ip: remote.ip,
+          uptime: Math.trunc((Date.now() - remote.socket.openTime) / 1000),
+          nick: remote.nick,
+          ssid: remote.ssid,
+          isSecure: remote.TLS,
+          isAuth: remote.boho.isAuthorized,
+          encMode: ENC_MODE[remote.encMode]
+        }
+      } else if (mode == 4) {
+        let channels = Array.from(remote.channels.keys())
+        let set_memory = Array.from(remote.memory.keys())
+        let retain_signal = Array.from(remote.retain_signal.keys())
+        return {
+          ip: remote.ip,
+          uptime: Math.trunc((Date.now() - remote.socket.openTime) / 1000),
+          channels: channels,
+          set: set_memory,
+          retain: retain_signal
+        }
+      }
+
+    } else {
+      return { result: "nop" }
+    }
+
+  }
+
+
+}
+

package/src/server/RemoteCore.js

@@ -27,7 +27,7 @@ export class RemoteCore {
     this.ssid = RemoteCore.ssid++;  // ordered index number
     this.manager = manager;
 
-    this.cid = ''; // Communication Id
+    this.cid = ''; // Client Id
     this.did = ''; // Device Id
     this.uid = ''; // User Id
     this.nick = ''
@@ -50,7 +50,7 @@ export class RemoteCore {
     this.state = state
     if (serverOption.debug.showAuthInfo) {
       this.stateLog.push(  state + ":" + STATE[ state]   )
-      if( state == STATE.AUTH_ACK){
+      if( state == STATE.AUTH_RES){
         console.log('[auth success]', this.cid, this.stateLog.join('>'))
       }else if( state == STATE.AUTH_FAIL){
         console.log('[auth_fail]',this.stateLog.join('>'))
@@ -291,29 +291,16 @@ export class RemoteCore {
           break;
 
 
-        // Auth
+        // client's auth requst
         case Boho.BohoMsg.AUTH_REQ:
           if (!this.manager.authManager) return
           if (this.state < STATE.SERVER_READY) {
-            console.log('protocol error. auth_req before server_ready')
+            console.log('protocol error. must called auth_req after server_ready')
             this.close();
           }
           this.setState(STATE.AUTH_REQ)
-          let auth_nonce_pack = this.boho.auth_nonce()
-          // console.log('## auth_nonce_pack', auth_nonce_pack )
-          this.send(auth_nonce_pack)
-          this.setState(STATE.AUTH_NONCE)
-          break;
-
-        case Boho.BohoMsg.AUTH_HMAC:
-          if (!this.manager.authManager) return
-          if (this.state < STATE.AUTH_NONCE) {
-            console.log('protocol error. auth_hmac before server_nonce')
-            this.close();
-          }
-          this.setState(STATE.AUTH_HMAC)
           //async
-          this.manager.authManager.verify_auth_hmac(message, this)
+          this.manager.authManager.verify_auth_req(message, this)
             .then(authInfo => {
               if (authInfo?.name) {
                 this.manager.deligateSignal(this, '@$name', authInfo.name)
@@ -321,7 +308,7 @@ export class RemoteCore {
                 // this.manager.sender('@$name', authInfo.name )
               }
 
-              // console.log('[VERIFY AUTH_HMAC] SubClass of BohoAuth return authInfo:', authInfo )
+              // console.log('[VERIFY AUTH_REQ] SubClass of BohoAuth return authInfo:', authInfo )
             })
             .catch(e => {
               console.log('authInfo return fail.', e )

package/src/server/Server.js

@@ -131,25 +131,25 @@ export class Server extends EventEmitter {
 
 /**
  * RPC service register.
- * target:  service_name <string>
- * service: service_module <function module|class instance>
+ * service: service_name <string>
+ * service_module <function module|class instance>
  * return this
  */
-  attach(target, service_module) {
+  attach(service, service_module) {
 
-    if( typeof target !== 'string'){
-      throw new Error(`service( target ,service ) target name is not a string.`)
+    if( typeof service !== 'string'){
+      throw new Error(`attach service name is not a string.`)
     }
     if (!service_module.checkPermission || typeof service_module.checkPermission != 'function') {
-      throw new Error(`Service ${target} : no checkPermission or not a function.`)
+      throw new Error(`Service ${service} : no checkPermission or not a function.`)
     }
     if(!service_module.commands || !Array.isArray(service_module.commands) ){
-      throw new Error(`Service ${target} : no commands or !Array.`)
+      throw new Error(`Service ${service} : no commands or !Array.`)
     }
     
     // Service TYPE 1. single call() function.
     if ( service_module.call && typeof service_module.call == 'function' ) {
-      this.on(target, (remote, req) => {
+      this.on(service, (remote, req) => {
         try {
           if (!service_module.checkPermission(remote, req)) {
             remote.response(req.mid, STATUS.ERROR, "NO_PERMISSION.")
@@ -162,13 +162,13 @@ export class Server extends EventEmitter {
             remote.response(req.mid, STATUS.ERROR, "UNKNOWN_COMMAND");
           }
         } catch (error) {
-          console.error(`Unhandled Service Error in target [${target}]:`, error);
+          console.error(`Unhandled Service Error in service [${service}]:`, error);
           remote.response(req.mid, STATUS.ERROR, "INTERNAL_SERVER_ERROR");
         }
       })
     } else {
       // Service TYPE 2. multiple functions.
-      this.on(target, (remote, req) => {
+      this.on(service, (remote, req) => {
         try {
           if (!service_module.checkPermission(remote, req)) {
             remote.response(req.mid, STATUS.ERROR, "NO_PERMISSION.")
@@ -180,13 +180,13 @@ export class Server extends EventEmitter {
             remote.response(req.mid, STATUS.ERROR, "UNKNOWN_COMMAND");
           }
         } catch (error) {
-          console.error(`Unhandled Service Error in target [${target}]:`, error);
+          console.error(`Unhandled Service Error in service [${service}]:`, error);
           remote.response(req.mid, STATUS.ERROR, "INTERNAL_SERVER_ERROR");
         }
       })
     }
-    this.serviceNames.add(target)
-    // console.log(`[Service attached: ${target} ] accept commands: ${service_module.commands}`)
+    this.serviceNames.add(service)
+    // console.log(`[Service attached: ${service} ] accept commands: ${service_module.commands}`)
     return this
   }
 

package/src/services/sudoService.js

@@ -21,18 +21,18 @@ export async function call(remote, req) {
     let cmd = req.topic;
     cmd = cmd.toLowerCase()
     if (cmd == 'cid') {
-      result = remote.manager.metric.getCIdList()
+      result = remote.manager.metrics.getCIdList()
     } else if (cmd == 'remotes' || cmd == 'clients') {
-      result = remote.manager.metric.getRemotes()
+      result = remote.manager.metrics.getRemotes()
     } else if (cmd == 'channels') {
-      result = remote.manager.metric.getChannelList()
+      result = remote.manager.metrics.getChannelList()
     } else if (cmd == 'subscribers') {
       let ch = req.$[0]
-      if (ch) result = remote.manager.metric.getSubscribers(ch)
+      if (ch) result = remote.manager.metrics.getSubscribers(ch)
     } else if (cmd == 'remote' || cmd == 'client') {
       let cid = req.$[0]
       let mode = req.$[1]
-      if (cid) result = remote.manager.metric.getRemoteByCId(cid, mode)
+      if (cid) result = remote.manager.metrics.getRemoteByCId(cid, mode)
 
     } else if (cmd == 'close') {
       if (req.$[0]) result = remote.manager.closeRemoteByCId(req.$[0])