@stoprocent/bleno 0.7.0

package/lib/hci-socket/bindings.js

@@ -0,0 +1,219 @@
+const debug = require('debug')('bindings');
+
+const { EventEmitter } = require('events');
+const os = require('os');
+
+const AclStream = require('./acl-stream');
+const Hci = require('./hci');
+const Gap = require('./gap');
+const Gatt = require('./gatt');
+
+class BlenoBindings extends EventEmitter {
+  constructor (options) {
+    super();
+
+    this._state = null;
+
+    this._advertising = false;
+
+    this._hci = new Hci(options);
+    this._gap = new Gap(this._hci);
+    this._gatt = new Gatt(this._hci);
+
+    this._address = null;
+    this._handle = null;
+    this._aclStream = null;
+  }
+
+  setAddress (address) {
+    this._hci.setAddress(address);
+  }
+
+  startAdvertising (name, serviceUuids) {
+    this._advertising = true;
+
+    this._gap.startAdvertising(name, serviceUuids);
+  }
+
+  startAdvertisingIBeacon (data) {
+    this._advertising = true;
+
+    this._gap.startAdvertisingIBeacon(data);
+  }
+
+  startAdvertisingWithEIRData (advertisementData, scanData) {
+    this._advertising = true;
+
+    this._gap.startAdvertisingWithEIRData(advertisementData, scanData);
+  }
+
+  stopAdvertising () {
+    this._advertising = false;
+
+    this._gap.stopAdvertising();
+  }
+
+  setServices (services) {
+    this._gatt.setServices(services);
+
+    this.emit('servicesSet');
+  }
+
+  disconnect () {
+    if (this._handle) {
+      debug('disconnect by server');
+
+      this._hci.disconnect(this._handle);
+    }
+  }
+
+  updateRssi () {
+    if (this._handle) {
+      this._hci.readRssi(this._handle);
+    }
+  }
+
+  init () {
+    this.onSigIntBinded = this.onSigInt.bind(this);
+
+    process.on('SIGINT', this.onSigIntBinded);
+    process.on('exit', this.onExit.bind(this));
+
+    this._gap.on('advertisingStart', this.onAdvertisingStart.bind(this));
+    this._gap.on('advertisingStop', this.onAdvertisingStop.bind(this));
+
+    this._gatt.on('mtuChange', this.onMtuChange.bind(this));
+
+    this._hci.on('stateChange', this.onStateChange.bind(this));
+    this._hci.on('addressChange', this.onAddressChange.bind(this));
+    this._hci.on('readLocalVersion', this.onReadLocalVersion.bind(this));
+
+    this._hci.on('leConnComplete', this.onLeConnComplete.bind(this));
+    this._hci.on('leConnUpdateComplete', this.onLeConnUpdateComplete.bind(this));
+    this._hci.on('rssiRead', this.onRssiRead.bind(this));
+    this._hci.on('disconnComplete', this.onDisconnComplete.bind(this));
+    this._hci.on('encryptChange', this.onEncryptChange.bind(this));
+    this._hci.on('leLtkNegReply', this.onLeLtkNegReply.bind(this));
+    this._hci.on('aclDataPkt', this.onAclDataPkt.bind(this));
+
+    this.emit('platform', os.platform());
+
+    this._hci.init();
+  }
+
+  onStateChange (state) {
+    if (this._state === state) {
+      return;
+    }
+    this._state = state;
+
+    if (state === 'unauthorized') {
+      console.log('Bleno warning: adapter state unauthorized, please run as root or with sudo');
+      console.log('               or see README for information on running without root/sudo:');
+      console.log('               https://github.com/abandonware/bleno#running-on-linux');
+    } else if (state === 'unsupported') {
+      console.log('Bleno warning: adapter does not support Bluetooth Low Energy (BLE, Bluetooth Smart).');
+      console.log('               Try to run with environment variable:');
+      console.log('               [sudo] BLENO_HCI_DEVICE_ID=x node ...');
+    }
+
+    this.emit('stateChange', state);
+  }
+
+  onAddressChange (address) {
+    this.emit('addressChange', address);
+  }
+
+  onReadLocalVersion (hciVer, hciRev, lmpVer, manufacturer, lmpSubVer) {
+  }
+
+  onAdvertisingStart (error) {
+    this.emit('advertisingStart', error);
+  }
+
+  onAdvertisingStop () {
+    this.emit('advertisingStop');
+  }
+
+  onLeConnComplete (status, handle, role, addressType, address, interval, latency, supervisionTimeout, masterClockAccuracy) {
+    if (role !== 1) {
+      // not slave, ignore
+      return;
+    }
+
+    this._address = address;
+    this._handle = handle;
+    this._aclStream = new AclStream(this._hci, handle, this._hci.addressType, this._hci.address, addressType, address);
+    this._gatt.setAclStream(this._aclStream);
+
+    this.emit('accept', address);
+  }
+
+  onLeConnUpdateComplete (handle, interval, latency, supervisionTimeout) {
+    // no-op
+  }
+
+  onDisconnComplete (handle, reason) {
+    if (this._aclStream) {
+      this._aclStream.push(null, null);
+    }
+
+    const address = this._address;
+
+    this._address = null;
+    this._handle = null;
+    this._aclStream = null;
+
+    if (address) {
+      this.emit('disconnect', address); // TODO: use reason
+    }
+
+    if (this._advertising) {
+      this._gap.restartAdvertising();
+    }
+  }
+
+  onEncryptChange (handle, encrypt) {
+    if (this._handle === handle && this._aclStream) {
+      this._aclStream.pushEncrypt(encrypt);
+    }
+  }
+
+  onLeLtkNegReply (handle) {
+    if (this._handle === handle && this._aclStream) {
+      this._aclStream.pushLtkNegReply();
+    }
+  }
+
+  onMtuChange (mtu) {
+    this.emit('mtuChange', mtu);
+  }
+
+  onRssiRead (handle, rssi) {
+    this.emit('rssiUpdate', rssi);
+  }
+
+  onAclDataPkt (handle, cid, data) {
+    if (this._handle === handle && this._aclStream) {
+      this._aclStream.push(cid, data);
+    }
+  }
+
+  onSigInt () {
+    const sigIntListeners = process.listeners('SIGINT');
+
+    if (sigIntListeners[sigIntListeners.length - 1] === this.onSigIntBinded) {
+      // we are the last listener, so exit
+      // this will trigger onExit, and clean up
+      process.exit(1);
+    }
+  }
+
+  onExit () {
+    this._gap.stopAdvertising();
+
+    this.disconnect();
+  }
+}
+
+module.exports = BlenoBindings;

package/lib/hci-socket/crypto.js

@@ -0,0 +1,74 @@
+const crypto = require('crypto');
+
+function r () {
+  return crypto.randomBytes(16);
+}
+
+function c1 (k, r, pres, preq, iat, ia, rat, ra) {
+  const p1 = Buffer.concat([
+    iat,
+    rat,
+    preq,
+    pres
+  ]);
+
+  const p2 = Buffer.concat([
+    ra,
+    ia,
+    Buffer.from('00000000', 'hex')
+  ]);
+
+  let res = xor(r, p1);
+  res = e(k, res);
+  res = xor(res, p2);
+  res = e(k, res);
+
+  return res;
+}
+
+function s1 (k, r1, r2) {
+  return e(k, Buffer.concat([
+    r2.slice(0, 8),
+    r1.slice(0, 8)
+  ]));
+}
+
+function e (key, data) {
+  key = swap(key);
+  data = swap(data);
+
+  const cipher = crypto.createCipheriv('aes-128-ecb', key, '');
+  cipher.setAutoPadding(false);
+
+  return swap(Buffer.concat([
+    cipher.update(data),
+    cipher.final()
+  ]));
+}
+
+function xor (b1, b2) {
+  const result = Buffer.alloc(b1.length);
+
+  for (let i = 0; i < b1.length; i++) {
+    result[i] = b1[i] ^ b2[i];
+  }
+
+  return result;
+}
+
+function swap (input) {
+  const output = Buffer.alloc(input.length);
+
+  for (let i = 0; i < output.length; i++) {
+    output[i] = input[input.length - i - 1];
+  }
+
+  return output;
+}
+
+module.exports = {
+  r,
+  c1,
+  s1,
+  e
+};

package/lib/hci-socket/gap.js

@@ -0,0 +1,212 @@
+const debug = require('debug')('gap');
+
+const { EventEmitter } = require('events');
+const os = require('os');
+
+const Hci = require('./hci');
+
+const isLinux = (os.platform() === 'linux');
+const isIntelEdison = isLinux && (os.release().includes('edison'));
+const isYocto = isLinux && (os.release().includes('yocto'));
+
+class Gap extends EventEmitter {
+  constructor (hci) {
+    super();
+
+    this._hci = hci;
+
+    this._advertiseState = null;
+
+    this._hci.on('error', this.onHciError.bind(this));
+
+    this._hci.on('leAdvertisingParametersSet', this.onHciLeAdvertisingParametersSet.bind(this));
+    this._hci.on('leAdvertisingDataSet', this.onHciLeAdvertisingDataSet.bind(this));
+    this._hci.on('leScanResponseDataSet', this.onHciLeScanResponseDataSet.bind(this));
+    this._hci.on('leAdvertiseEnableSet', this.onHciLeAdvertiseEnableSet.bind(this));
+  }
+
+  startAdvertising (name, serviceUuids) {
+    debug('startAdvertising: name = ' + name + ', serviceUuids = ' + JSON.stringify(serviceUuids, null, 2));
+
+    let advertisementDataLength = 3;
+    let scanDataLength = 0;
+
+    const serviceUuids16bit = [];
+    const serviceUuids128bit = [];
+
+    if (name && name.length) {
+      scanDataLength += 2 + name.length;
+    }
+
+    if (serviceUuids && serviceUuids.length) {
+      for (let i = 0; i < serviceUuids.length; i++) {
+        const serviceUuid = Buffer.from(serviceUuids[i].match(/.{1,2}/g).reverse().join(''), 'hex');
+
+        if (serviceUuid.length === 2) {
+          serviceUuids16bit.push(serviceUuid);
+        } else if (serviceUuid.length === 16) {
+          serviceUuids128bit.push(serviceUuid);
+        }
+      }
+    }
+
+    if (serviceUuids16bit.length) {
+      advertisementDataLength += 2 + 2 * serviceUuids16bit.length;
+    }
+
+    if (serviceUuids128bit.length) {
+      advertisementDataLength += 2 + 16 * serviceUuids128bit.length;
+    }
+
+    const advertisementData = Buffer.alloc(advertisementDataLength);
+    const scanData = Buffer.alloc(scanDataLength);
+
+    // flags
+    advertisementData.writeUInt8(2, 0);
+    advertisementData.writeUInt8(0x01, 1);
+    advertisementData.writeUInt8(0x06, 2);
+
+    let advertisementDataOffset = 3;
+
+    if (serviceUuids16bit.length) {
+      advertisementData.writeUInt8(1 + 2 * serviceUuids16bit.length, advertisementDataOffset);
+      advertisementDataOffset++;
+
+      advertisementData.writeUInt8(0x03, advertisementDataOffset);
+      advertisementDataOffset++;
+
+      for (let i = 0; i < serviceUuids16bit.length; i++) {
+        serviceUuids16bit[i].copy(advertisementData, advertisementDataOffset);
+        advertisementDataOffset += serviceUuids16bit[i].length;
+      }
+    }
+
+    if (serviceUuids128bit.length) {
+      advertisementData.writeUInt8(1 + 16 * serviceUuids128bit.length, advertisementDataOffset);
+      advertisementDataOffset++;
+
+      advertisementData.writeUInt8(0x06, advertisementDataOffset);
+      advertisementDataOffset++;
+
+      for (let i = 0; i < serviceUuids128bit.length; i++) {
+        serviceUuids128bit[i].copy(advertisementData, advertisementDataOffset);
+        advertisementDataOffset += serviceUuids128bit[i].length;
+      }
+    }
+
+    // name
+    if (name && name.length) {
+      const nameBuffer = Buffer.from(name);
+
+      scanData.writeUInt8(1 + nameBuffer.length, 0);
+      scanData.writeUInt8(0x08, 1);
+      nameBuffer.copy(scanData, 2);
+    }
+
+    this.startAdvertisingWithEIRData(advertisementData, scanData);
+  }
+
+  startAdvertisingIBeacon (data) {
+    debug('startAdvertisingIBeacon: data = ' + data.toString('hex'));
+
+    const dataLength = data.length;
+    const manufacturerDataLength = 4 + dataLength;
+    const advertisementDataLength = 5 + manufacturerDataLength;
+    // const scanDataLength = 0;
+
+    const advertisementData = Buffer.alloc(advertisementDataLength);
+    const scanData = Buffer.alloc(0);
+
+    // flags
+    advertisementData.writeUInt8(2, 0);
+    advertisementData.writeUInt8(0x01, 1);
+    advertisementData.writeUInt8(0x06, 2);
+
+    advertisementData.writeUInt8(manufacturerDataLength + 1, 3);
+    advertisementData.writeUInt8(0xff, 4);
+    advertisementData.writeUInt16LE(0x004c, 5); // Apple Company Identifier LE (16 bit)
+    advertisementData.writeUInt8(0x02, 7); // type, 2 => iBeacon
+    advertisementData.writeUInt8(dataLength, 8);
+
+    data.copy(advertisementData, 9);
+
+    this.startAdvertisingWithEIRData(advertisementData, scanData);
+  }
+
+  startAdvertisingWithEIRData (advertisementData, scanData) {
+    advertisementData = advertisementData || Buffer.alloc(0);
+    scanData = scanData || Buffer.alloc(0);
+
+    debug('startAdvertisingWithEIRData: advertisement data = ' + advertisementData.toString('hex') + ', scan data = ' + scanData.toString('hex'));
+
+    let error = null;
+
+    if (advertisementData.length > 31) {
+      error = new Error('Advertisement data is over maximum limit of 31 bytes');
+    } else if (scanData.length > 31) {
+      error = new Error('Scan data is over maximum limit of 31 bytes');
+    }
+
+    if (error) {
+      this.emit('advertisingStart', error);
+    } else {
+      this._advertiseState = 'starting';
+
+      if (isIntelEdison || isYocto) {
+        // work around for Intel Edison
+        debug('skipping first set of scan response and advertisement data');
+      } else {
+        this._hci.setScanResponseData(scanData);
+        this._hci.setAdvertisingData(advertisementData);
+      }
+      this._hci.setAdvertiseEnable(true);
+      this._hci.setScanResponseData(scanData);
+      this._hci.setAdvertisingData(advertisementData);
+    }
+  }
+
+  restartAdvertising () {
+    this._advertiseState = 'restarting';
+
+    this._hci.setAdvertiseEnable(true);
+  }
+
+  stopAdvertising () {
+    this._advertiseState = 'stopping';
+
+    this._hci.setAdvertiseEnable(false);
+  }
+
+  onHciError (error) {
+    this.emit('error', error);
+  }
+
+  onHciLeAdvertisingParametersSet (status) {
+  }
+
+  onHciLeAdvertisingDataSet (status) {
+  }
+
+  onHciLeScanResponseDataSet (status) {
+  }
+
+  onHciLeAdvertiseEnableSet (status) {
+    if (this._advertiseState === 'starting') {
+      this._advertiseState = 'started';
+
+      let error = null;
+
+      if (status) {
+        error = new Error(Hci.STATUS_MAPPER[status] || ('Unknown (' + status + ')'));
+      }
+
+      this.emit('advertisingStart', error);
+    } else if (this._advertiseState === 'stopping') {
+      this._advertiseState = 'stopped';
+
+      this.emit('advertisingStop');
+    }
+  }
+}
+
+module.exports = Gap;