@homebridge/dbus-native 0.4.0

package/lib/handshake.js

@@ -0,0 +1,137 @@
+const Buffer = require('safe-buffer').Buffer;
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const constants = require('./constants');
+const readLine = require('./readline');
+
+function sha1(input) {
+  var shasum = crypto.createHash('sha1');
+  shasum.update(input);
+  return shasum.digest('hex');
+}
+
+function getUserHome() {
+  return process.env[process.platform.match(/$win/) ? 'USERPROFILE' : 'HOME'];
+}
+
+function getCookie(context, id, cb) {
+  // http://dbus.freedesktop.org/doc/dbus-specification.html#auth-mechanisms-sha
+  var dirname = path.join(getUserHome(), '.dbus-keyrings');
+  // > There is a default context, "org_freedesktop_general" that's used by servers that do not specify otherwise.
+  if (context.length === 0) context = 'org_freedesktop_general';
+
+  var filename = path.join(dirname, context);
+  // check it's not writable by others and readable by user
+  fs.stat(dirname, function(err, stat) {
+    if (err) return cb(err);
+    if (stat.mode & 0o22)
+      return cb(
+        new Error(
+          'User keyrings directory is writeable by other users. Aborting authentication'
+        )
+      );
+    if (process.hasOwnProperty('getuid') && stat.uid !== process.getuid())
+      return cb(
+        new Error(
+          'Keyrings directory is not owned by the current user. Aborting authentication!'
+        )
+      );
+    fs.readFile(filename, 'ascii', function(err, keyrings) {
+      if (err) return cb(err);
+      var lines = keyrings.split('\n');
+      for (var l = 0; l < lines.length; ++l) {
+        var data = lines[l].split(' ');
+        if (id === data[0]) return cb(null, data[2]);
+      }
+      return cb(new Error('cookie not found'));
+    });
+  });
+}
+
+function hexlify(input) {
+  return Buffer.from(input.toString(), 'ascii').toString('hex');
+}
+
+module.exports = function auth(stream, opts, cb) {
+  // filter used to make a copy so we don't accidently change opts data
+  var authMethods;
+  if (opts.authMethods) {
+    authMethods = opts.authMethods;
+  } else {
+    authMethods = constants.defaultAuthMethods;
+  }
+  stream.write('\0');
+  tryAuth(stream, authMethods.slice(), cb);
+};
+
+function tryAuth(stream, methods, cb) {
+  if (methods.length === 0) {
+    return cb(new Error('No authentication methods left to try'));
+  }
+
+  var authMethod = methods.shift();
+  var uid = process.hasOwnProperty('getuid') ? process.getuid() : 0;
+  var id = hexlify(uid);
+
+  function beginOrNextAuth() {
+    readLine(stream, function(line) {
+      var ok = line.toString('ascii').match(/^([A-Za-z]+) (.*)/);
+      if (ok && ok[1] === 'OK') {
+        stream.write('BEGIN\r\n');
+        return cb(null, ok[2]); // ok[2] = guid. Do we need it?
+      } else {
+        // TODO: parse error!
+        if (!methods.empty) {
+          tryAuth(stream, methods, cb);
+        } else {
+          return cb(line);
+        }
+      }
+    });
+  }
+
+  switch (authMethod) {
+    case 'EXTERNAL':
+      stream.write(`AUTH ${authMethod} ${id}\r\n`);
+      beginOrNextAuth();
+      break;
+    case 'DBUS_COOKIE_SHA1':
+      stream.write(`AUTH ${authMethod} ${id}\r\n`);
+      readLine(stream, function(line) {
+        var data = Buffer.from(
+          line
+            .toString()
+            .split(' ')[1]
+            .trim(),
+          'hex'
+        )
+          .toString()
+          .split(' ');
+        var cookieContext = data[0];
+        var cookieId = data[1];
+        var serverChallenge = data[2];
+        // any random 16 bytes should work, sha1(rnd) to make it simplier
+        var clientChallenge = crypto.randomBytes(16).toString('hex');
+        getCookie(cookieContext, cookieId, function(err, cookie) {
+          if (err) return cb(err);
+          var response = sha1(
+            [serverChallenge, clientChallenge, cookie].join(':')
+          );
+          var reply = hexlify(clientChallenge + response);
+          stream.write(`DATA ${reply}\r\n`);
+          beginOrNextAuth();
+        });
+      });
+      break;
+    case 'ANONYMOUS':
+      stream.write('AUTH ANONYMOUS \r\n');
+      beginOrNextAuth();
+      break;
+    default:
+      console.error(`Unsupported auth method: ${authMethod}`);
+      beginOrNextAuth();
+      break;
+  }
+}

package/lib/header-signature.json

@@ -0,0 +1,20 @@
+[
+    {
+        "type": "a",
+        "child": [
+            {
+                "type": "(",
+                "child": [
+                    {
+                        "type": "y",
+                        "child": []
+                    },
+                    {
+                        "type": "v",
+                        "child": []
+                    }
+                ]
+            }
+        ]
+    }
+]

package/lib/hello-message.js

@@ -0,0 +1,16 @@
+const Buffer = require('safe-buffer').Buffer;
+
+// Pre-serialised hello message. serial = 1
+module.exports = function() {
+  return Buffer.from(
+    `6c01 0001 0000 0000 0100 0000 6d00 0000
+     0101 6f00 1500 0000 2f6f 7267 2f66 7265
+     6564 6573 6b74 6f70 2f44 4275 7300 0000
+     0301 7300 0500 0000 4865 6c6c 6f00 0000
+     0201 7300 1400 0000 6f72 672e 6672 6565
+     6465 736b 746f 702e 4442 7573 0000 0000
+     0601 7300 1400 0000 6f72 672e 6672 6565
+     6465 736b 746f 702e 4442 7573 0000 0000`.replace(/ |\n/g, ''),
+    'hex'
+  );
+};

package/lib/introspect.js

@@ -0,0 +1,201 @@
+const xml2js = require('xml2js');
+
+module.exports.introspectBus = function(obj, callback) {
+  var bus = obj.service.bus;
+  bus.invoke(
+    {
+      destination: obj.service.name,
+      path: obj.name,
+      interface: 'org.freedesktop.DBus.Introspectable',
+      member: 'Introspect'
+    },
+    function(err, xml) { module.exports.processXML(err, xml, obj, callback); }
+  );
+};
+
+module.exports.processXML = function(err, xml, obj, callback) {
+  if (err) return callback(err);
+  var parser = new xml2js.Parser();
+  parser.parseString(xml, function(err, result) {
+    if (err) return callback(err);
+    if (!result.node) throw new Error('No root XML node');
+    result = result.node; // unwrap the root node
+    // If no interface, try first sub node?
+    if (!result.interface) {
+      if (result.node && result.node.length > 0 && result.node[0]['$']) {
+        var subObj = Object.assign(obj, {});
+        if (subObj.name.slice(-1) !== '/') subObj.name += '/';
+        subObj.name += result.node[0]['$'].name;
+        return module.exports.introspectBus(subObj, callback);
+      }
+      return callback(new Error('No such interface found'));
+    }
+    var proxy = {};
+    var nodes = [];
+    var ifaceName, method, property, iface, arg, signature, currentIface;
+    var ifaces = result['interface'];
+    var xmlnodes = result['node'] || [];
+
+    for (var n = 1; n < xmlnodes.length; ++n) {
+      // Start at 1 because we want to skip the root node
+      nodes.push(xmlnodes[n]['$']['name']);
+    }
+
+    for (var i = 0; i < ifaces.length; ++i) {
+      iface = ifaces[i];
+      ifaceName = iface['$'].name;
+      currentIface = proxy[ifaceName] = new DBusInterface(obj, ifaceName);
+
+      for (var m = 0; iface.method && m < iface.method.length; ++m) {
+        method = iface.method[m];
+        signature = '';
+        var methodName = method['$'].name;
+        for (var a = 0; method.arg && a < method.arg.length; ++a) {
+          arg = method.arg[a]['$'];
+          if (arg.direction === 'in') signature += arg.type;
+        }
+        // add method
+        currentIface.$createMethod(methodName, signature);
+      }
+      for (var p = 0; iface.property && p < iface.property.length; ++p) {
+        property = iface.property[p];
+        currentIface.$createProp(property['$'].name, property['$'].type, property['$'].access)
+      }
+      // TODO: introspect signals
+    }
+    callback(null, proxy, nodes);
+  });
+}
+
+
+function DBusInterface(parent_obj, ifname)
+{
+  // Since methods and props presently get added directly to the object, to avoid collision with existing names we must use $ naming convention as $ is invalid for dbus member names
+  // https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names
+  this.$parent = parent_obj; // parent DbusObject
+  this.$name = ifname; // string interface name
+  this.$methods = {}; // dictionary of methods (exposed for test), should we just store signature or use object to store more info?
+  //this.$signals = {};
+  this.$properties = {};
+  this.$callbacks = [];
+  this.$sigHandlers = [];
+}
+DBusInterface.prototype.$getSigHandler = function(callback) {
+  var index;
+  if ((index = this.$callbacks.indexOf(callback)) === -1) {
+    index = this.$callbacks.push(callback) - 1;
+    this.$sigHandlers[index] = function(messageBody) {
+      callback.apply(null, messageBody);
+    };
+  }
+  return this.$sigHandlers[index];
+}
+DBusInterface.prototype.addListener = DBusInterface.prototype.on = function(signame, callback) {
+  // http://dbus.freedesktop.org/doc/api/html/group__DBusBus.html#ga4eb6401ba014da3dbe3dc4e2a8e5b3ef
+  // An example is "type='signal',sender='org.freedesktop.DBus', interface='org.freedesktop.DBus',member='Foo', path='/bar/foo',destination=':452345.34'" ...
+  var bus = this.$parent.service.bus;
+  var signalFullName = bus.mangle(this.$parent.name, this.$name, signame);
+  if (!bus.signals.listeners(signalFullName).length) {
+    // This is the first time, so call addMatch
+    var match = getMatchRule(this.$parent.name, this.$name, signame);
+    bus.addMatch(match, function(err) {
+      if (err) throw new Error(err);
+      bus.signals.on(signalFullName, this.$getSigHandler(callback));
+    }.bind(this));
+  } else {
+    // The match is already there, just add event listener
+    bus.signals.on(signalFullName, this.$getSigHandler(callback));
+  }
+}
+DBusInterface.prototype.removeListener = DBusInterface.prototype.off = function(signame, callback) {
+  var bus = this.$parent.service.bus;
+  var signalFullName = bus.mangle(this.$parent.name, this.$name, signame);
+  bus.signals.removeListener( signalFullName, this.$getSigHandler(callback) );
+  if (!bus.signals.listeners(signalFullName).length) {
+    // There is no event handlers for this match
+    var match = getMatchRule(this.$parent.name, this.$name, signame);
+    bus.removeMatch(match, function(err) {
+      if (err) throw new Error(err);
+      // Now it is safe to empty these arrays
+      this.$callbacks.length = 0;
+      this.$sigHandlers.length = 0;
+    }.bind(this));
+  }
+}
+DBusInterface.prototype.$createMethod = function(mName, signature)
+{
+  this.$methods[mName] = signature;
+  this[mName] = function() { this.$callMethod(mName, arguments); }
+}
+DBusInterface.prototype.$callMethod = function(mName, args)
+{
+  var bus = this.$parent.service.bus;
+  if (!Array.isArray(args)) args = Array.from(args); // Array.prototype.slice.apply(args)
+  var callback =
+    typeof args[args.length - 1] === 'function'
+      ? args.pop()
+      : function() {};
+  var msg = {
+    destination: this.$parent.service.name,
+    path: this.$parent.name,
+    interface: this.$name,
+    member: mName
+  };
+  if (this.$methods[mName] !== '') {
+    msg.signature = this.$methods[mName];
+    msg.body = args;
+  }
+  bus.invoke(msg, callback);
+}
+DBusInterface.prototype.$createProp = function(propName, propType, propAccess)
+{
+  this.$properties[propName] = { type: propType, access: propAccess };
+  Object.defineProperty(this, propName, {
+    enumerable: true,
+    get: () => callback => this.$readProp(propName, callback),
+    set: function(val) { this.$writeProp(propName, val) }
+  });
+}
+DBusInterface.prototype.$readProp = function(propName, callback)
+{
+  var bus = this.$parent.service.bus;
+  bus.invoke(
+    {
+      destination: this.$parent.service.name,
+      path: this.$parent.name,
+      interface: 'org.freedesktop.DBus.Properties',
+      member: 'Get',
+      signature: 'ss',
+      body: [this.$name, propName]
+    },
+    function(err, val) {
+      if (err) {
+        callback(err);
+      } else {
+        var signature = val[0];
+        if (signature.length === 1) {
+          callback(err, val[1][0]);
+        } else {
+          callback(err, val[1]);
+        }
+      }
+    }
+  );
+}
+DBusInterface.prototype.$writeProp = function(propName, val)
+{
+  var bus = this.$parent.service.bus;
+  bus.invoke({
+    destination: this.$parent.service.name,
+    path: this.$parent.name,
+    interface: 'org.freedesktop.DBus.Properties',
+    member: 'Set',
+    signature: 'ssv',
+    body: [this.$name, propName, [this.$properties[propName].type, val]]
+  });
+}
+
+
+function getMatchRule(objName, ifName, signame) {
+  return `type='signal',path='${objName}',interface='${ifName}',member='${signame}'`;
+}

package/lib/marshall.js

@@ -0,0 +1,108 @@
+const assert = require('assert');
+
+const parseSignature = require('./signature');
+const put = require('put');
+const Marshallers = require('./marshallers');
+const align = require('./align').align;
+
+module.exports = function marshall(signature, data, offset) {
+  if (typeof offset === 'undefined') offset = 0;
+  var tree = parseSignature(signature);
+  if (!Array.isArray(data) || data.length !== tree.length) {
+    throw new Error(
+      `message body does not match message signature. Body:${JSON.stringify(
+        data
+      )}, signature:${signature}`
+    );
+  }
+  var putstream = put();
+  putstream._offset = offset;
+  var buf = writeStruct(putstream, tree, data).buffer();
+  return buf;
+};
+
+// TODO: serialise JS objects as a{sv}
+//function writeHash(ps, treeKey, treeVal, data) {
+//
+//}
+
+function writeStruct(ps, tree, data) {
+  if (tree.length !== data.length) {
+    throw new Error('Invalid struct data');
+  }
+  for (var i = 0; i < tree.length; ++i) {
+    write(ps, tree[i], data[i]);
+  }
+  return ps;
+}
+
+function write(ps, ele, data) {
+  switch (ele.type) {
+    case '(':
+    case '{':
+      align(ps, 8);
+      writeStruct(ps, ele.child, data);
+      break;
+    case 'a':
+      // array serialisation:
+      // length of array body aligned at 4 byte boundary
+      // (optional 4 bytes to align first body element on 8-byte boundary if element
+      // body
+      var arrPut = put();
+      arrPut._offset = ps._offset;
+      var _offset = arrPut._offset;
+      writeSimple(arrPut, 'u', 0); // array length placeholder
+      var lengthOffset = arrPut._offset - 4 - _offset;
+      // we need to alighn here because alignment is not included in array length
+      if (['x', 't', 'd', '{', '('].indexOf(ele.child[0].type) !== -1)
+        align(arrPut, 8);
+      var startOffset = arrPut._offset;
+      for (var i = 0; i < data.length; ++i)
+        write(arrPut, ele.child[0], data[i]);
+      var arrBuff = arrPut.buffer();
+      var length = arrPut._offset - startOffset;
+      // lengthOffset in the range 0 to 3 depending on number of align bytes padded _before_ arrayLength
+      arrBuff.writeUInt32LE(length, lengthOffset);
+      ps.put(arrBuff);
+      ps._offset += arrBuff.length;
+      break;
+    case 'v':
+      // TODO: allow serialisation of simple types as variants, e. g 123 -> ['u', 123], true -> ['b', 1], 'abc' -> ['s', 'abc']
+      assert.equal(data.length, 2, 'variant data should be [signature, data]');
+      var signatureEle = {
+        type: 'g',
+        child: []
+      };
+      write(ps, signatureEle, data[0]);
+      var tree = parseSignature(data[0]);
+      assert(tree.length === 1);
+      write(ps, tree[0], data[1]);
+      break;
+    default:
+      return writeSimple(ps, ele.type, data);
+  }
+}
+
+var stringTypes = ['g', 'o', 's'];
+
+function writeSimple(ps, type, data) {
+  if (typeof data === 'undefined')
+    throw new Error(
+      "Serialisation of JS 'undefined' type is not supported by d-bus"
+    );
+  if (data === null)
+    throw new Error('Serialisation of null value is not supported by d-bus');
+
+  if (Buffer.isBuffer(data)) data = data.toString(); // encoding?
+  if (stringTypes.indexOf(type) !== -1 && typeof data !== 'string') {
+    throw new Error(
+      `Expected string or buffer argument, got ${JSON.stringify(
+        data
+      )} of type '${type}'`
+    );
+  }
+
+  var simpleMarshaller = Marshallers.MakeSimpleMarshaller(type);
+  simpleMarshaller.marshall(ps, data);
+  return ps;
+}