@homebridge/dbus-native 0.4.0

package/LICENSE

@@ -0,0 +1,18 @@
+This software is released under the MIT license:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,124 @@
+node-dbus
+===========
+
+[![Greenkeeper badge](https://badges.greenkeeper.io/sidorares/dbus-native.svg)](https://greenkeeper.io/)
+D-bus protocol client and server for node.js
+
+[![Build Status](https://secure.travis-ci.org/sidorares/dbus-native.png)](http://travis-ci.org/sidorares/dbus-native)
+
+Installation
+------------
+
+```shell
+npm install dbus-native
+```
+or
+
+```shell
+git clone https://github.com/sidorares/node-dbus # clone the repo
+cd node-dbus
+npm install # install dependencies
+sudo cp examples/com.github.sidorares.dbus.Example.conf /etc/dbus-1/system.d/ # if you want to test examples/service.js
+```
+
+Usage
+------
+
+Short example using desktop notifications service
+
+```js
+var dbus = require('dbus-native');
+var sessionBus = dbus.sessionBus();
+sessionBus.getService('org.freedesktop.Notifications').getInterface(
+    '/org/freedesktop/Notifications',
+    'org.freedesktop.Notifications', function(err, notifications) {
+
+    // dbus signals are EventEmitter events
+    notifications.on('ActionInvoked', function() {
+        console.log('ActionInvoked', arguments);
+    });
+    notifications.on('NotificationClosed', function() {
+        console.log('NotificationClosed', arguments);
+    });
+    notifications.Notify('exampl', 0, '', 'summary 3', 'new message text', ['xxx yyy', 'test2', 'test3', 'test4'], [],  5, function(err, id) {
+       //setTimeout(function() { n.CloseNotification(id, console.log); }, 4000);
+    });
+});
+```
+
+API
+---
+
+### Low level messaging: bus connection
+
+`connection = dbus.createClient(options)`
+
+options:
+   - socket - unix socket path
+   - port - TCP port
+   - host - TCP host
+   - busAddress - encoded bus address. Default is `DBUS_SESSION_BUS_ADDRESS` environment variable. See http://dbus.freedesktop.org/doc/dbus-specification.html#addresses
+   - authMethods - array of authentication methods, which are attempted in the order provided (default:['EXTERNAL', 'DBUS_COOKIE_SHA1', 'ANONYMOUS'])
+   - ayBuffer - boolean (default:true): if true 'ay' dbus fields are returned as buffers
+   - ReturnLongjs - boolean (default:false): if true 64 bit dbus fields (x/t) are read out as Long.js objects, otherwise they are converted to numbers (which should be good up to 53 bits)
+   - ( TODO: add/document option to use adress from X11 session )
+
+connection has only one method, `message(msg)`
+
+message fields:
+   - type - methodCall, methodReturn, error or signal
+   - path - object path
+   - interface
+   - destination
+   - sender
+   - member
+   - serial
+   - signature
+   - body
+   - errorName
+   - replySerial
+
+connection signals:
+   - connect - emitted after successful authentication
+   - message
+   - error
+
+example:
+
+```js
+var dbus = require('dbus-native');
+var conn = dbus.createConnection();
+conn.message({
+    path:'/org/freedesktop/DBus',
+    destination: 'org.freedesktop.DBus',
+    'interface': 'org.freedesktop.DBus',
+    member: 'Hello',
+    type: dbus.messageType.methodCall
+});
+conn.on('message', function(msg) { console.log(msg); });
+```
+
+### Note on INT64 'x' and UINT64 't'
+Long.js is used for 64 Bit support. https://github.com/dcodeIO/long.js
+The following javascript types can be marshalled into 64 bit dbus fields:
+   - typeof 'number' up to 53bits
+   - typeof 'string' (consisting of decimal digits with no separators or '0x' prefixed hexadecimal) up to full 64bit range
+   - Long.js objects (or object with compatible properties)
+
+By default 64 bit dbus fields are unmarshalled into a 'number' (with precision loss beyond 53 bits). Use {ReturnLongjs:true} option to return the actual Long.js object and preserve the entire 64 bits.
+
+### Links
+   - http://cgit.freedesktop.org/dbus - freedesktop reference C library
+   - https://github.com/guelfey/go.dbus
+   - https://github.com/Shouqun/node-dbus - libdbus
+   - https://github.com/Motorola-Mobility/node-dbus - libdbus
+   - https://github.com/izaakschroeder/node-dbus - libdbus
+   - https://github.com/agnat/node_libdbus
+   - https://github.com/agnat/node_dbus - native js
+   - https://github.com/cocagne/txdbus - native python + twisted
+   - http://search.cpan.org/~danberr/Net-DBus-1.0.0/ (seems to be native, but requires libdbus?)
+   - https://github.com/mvidner/ruby-dbus (native, sync)
+   - http://www.ndesk.org/DBusSharp (C#/Mono)
+   - https://github.com/lizenn/erlang-dbus/ - erlang
+   - https://github.com/mspanc/dbux/ - elixir
+   - http://0pointer.net/blog/the-new-sd-bus-api-of-systemd.html - Blog post about sb-bus and D-Bus in general

package/bin/dbus2js.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const xml2js = require('xml2js');
+const xml2js_opts = Object.assign({}, xml2js.defaults["0.1"], { explicitArray: true });
+const dbus = require('../index');
+const optimist = require('optimist');
+
+var argv = optimist.boolean(['server', 'dump']).argv;
+
+function die(err) {
+  console.log(err);
+  process.exit(-1);
+}
+
+var bus = argv.bus === 'system' ? dbus.systemBus() : dbus.sessionBus();
+
+function getXML(callback) {
+  if (argv.xml) {
+    fs.readFile(argv.xml, 'ascii', callback);
+  } else {
+    bus.invoke(
+      {
+        destination: argv.service,
+        path: argv.path,
+        interface: 'org.freedesktop.DBus.Introspectable',
+        member: 'Introspect'
+      },
+      callback
+    );
+  }
+}
+
+if (argv.dump) {
+  getXML(function(err, xml) {
+    console.log(xml);
+    bus.connection.end();
+  });
+}
+
+if (!argv.server) {
+  getXML(function(err, xml) {
+    if (err) die(err);
+
+    var output = [];
+
+    var parser = new xml2js.Parser(xml2js_opts);
+    parser.parseString(xml, function(err, result) {
+      if (err) die(err);
+
+      var ifaceName, method, property, iface, arg, signature;
+      var ifaces = result['interface'];
+      for (var i = 0; i < ifaces.length; ++i) {
+        iface = ifaces[i];
+        ifaceName = iface['@'].name;
+
+        output.push(`module.exports['${ifaceName}'] = function(bus) {`);
+        output.push(
+          '    this.addListener = this.on = function(signame, callback) {'
+        );
+        //TODO: add path and interface to path
+        output.push(
+          "        bus.addMatch('type=\\'signal\\',member=\\'' + signame + '\\'', function(err, result) {"
+        );
+        output.push('            if (err) throw new Error(err);');
+        output.push('        });');
+        output.push(
+          `        var signalFullName = bus.mangle('${argv.path}', '${
+            ifaceName
+          }', signame);`
+        );
+        output.push(
+          '        bus.signals.on(signalFullName, function(messageBody) {'
+        );
+        output.push('             callback.apply(null, messageBody);');
+        output.push('        });');
+        output.push('    };');
+
+        for (var m = 0; iface.method && m < iface.method.length; ++m) {
+          method = iface.method[m];
+          signature = '';
+          const methodName = method['@'].name;
+
+          var decl = `    this.${methodName} = function(`;
+          var params = [];
+          for (var a = 0; method.arg && a < method.arg.length; ++a) {
+            arg = method.arg[a]['@'];
+            if (arg.direction === 'in') {
+              decl += `${arg.name}, `;
+              params.push(arg.name);
+              signature += arg.type;
+            }
+          }
+          decl += 'callback) {';
+          output.push(decl);
+          output.push('        bus.invoke({');
+          output.push(`            destination: '${argv.service}',`);
+          output.push(`            path: '${argv.path}',`);
+          output.push(`            interface: '${ifaceName}',`);
+          output.push(`            member: '${methodName}',`);
+          if (params.length > 0) {
+            output.push(`            body: [${params.join(', ')}], `);
+            output.push(`            signature: '${signature}',`);
+          }
+          output.push('        }, callback);');
+          output.push('    };');
+        }
+        for (var p = 0; iface.property && p < iface.property.length; ++p) {
+          property = iface.property[p];
+          console.log('    property: \n', property);
+        }
+        output.push('}');
+      }
+      console.log(output.join('\n'));
+      bus.connection.end();
+    });
+  });
+}

package/index.js

@@ -0,0 +1,155 @@
+// dbus.freedesktop.org/doc/dbus-specification.html
+
+const EventEmitter = require('events').EventEmitter;
+const net = require('net');
+
+const constants = require('./lib/constants');
+const message = require('./lib/message');
+const clientHandshake = require('./lib/handshake');
+const serverHandshake = require('./lib/server-handshake');
+const MessageBus = require('./lib/bus');
+const server = require('./lib/server');
+
+function createStream(opts) {
+  if (opts.stream) return opts.stream;
+  var host = opts.host;
+  var port = opts.port;
+  var socket = opts.socket;
+  if (socket) return net.createConnection(socket);
+  if (port) return net.createConnection(port, host);
+
+  var busAddress = opts.busAddress || process.env.DBUS_SESSION_BUS_ADDRESS;
+  if (!busAddress) throw new Error('unknown bus address');
+
+  var addresses = busAddress.split(';');
+  for (var i = 0; i < addresses.length; ++i) {
+    var address = addresses[i];
+    var familyParams = address.split(':');
+    var family = familyParams[0];
+    var params = {};
+    familyParams[1].split(',').map(function(p) {
+      var keyVal = p.split('=');
+      params[keyVal[0]] = keyVal[1];
+    });
+
+    try {
+      switch (family.toLowerCase()) {
+        case 'tcp':
+          host = params.host || 'localhost';
+          port = params.port;
+          return net.createConnection(port, host);
+        case 'unix':
+          if (params.socket) return net.createConnection(params.socket);
+          if (params.abstract) {
+            var abs = require('abstract-socket');
+            return abs.connect('\u0000' + params.abstract);
+          }
+          if (params.path) return net.createConnection(params.path);
+          throw new Error(
+            "not enough parameters for 'unix' connection - you need to specify 'socket' or 'abstract' or 'path' parameter"
+          );
+        case 'unixexec':
+          var eventStream = require('event-stream');
+          var spawn = require('child_process').spawn;
+          var args = [];
+          for (var n = 1; params['arg' + n]; n++) args.push(params['arg' + n]);
+          var child = spawn(params.path, args);
+
+          return eventStream.duplex(child.stdin, child.stdout);
+        default:
+          throw new Error('unknown address type:' + family);
+      }
+    } catch (e) {
+      if (i < addresses.length - 1) {
+        console.warn(e.message);
+        continue;
+      } else {
+        throw e;
+      }
+    }
+  }
+}
+
+function createConnection(opts) {
+  var self = new EventEmitter();
+  if (!opts) opts = {};
+  var stream = (self.stream = createStream(opts));
+  stream.setNoDelay();
+
+  stream.on('error', function(err) {
+    // forward network and stream errors
+    self.emit('error', err);
+  });
+
+  stream.on('end', function() {
+    self.emit('end');
+    self.message = function() {
+      console.warn("Didn't write bytes to closed stream");
+    };
+  });
+
+  self.end = function() {
+    stream.end();
+    return self;
+  };
+
+  var handshake = opts.server ? serverHandshake : clientHandshake;
+  handshake(stream, opts, function(error, guid) {
+    if (error) {
+      return self.emit('error', error);
+    }
+    self.guid = guid;
+    self.emit('connect');
+    message.unmarshalMessages(
+      stream,
+      function(message) {
+        self.emit('message', message);
+      },
+      opts
+    );
+  });
+
+  self._messages = [];
+
+  // pre-connect version, buffers all messages. replaced after connect
+  self.message = function(msg) {
+    self._messages.push(msg);
+  };
+
+  self.once('connect', function() {
+    self.state = 'connected';
+    for (var i = 0; i < self._messages.length; ++i) {
+      stream.write(message.marshall(self._messages[i]));
+    }
+    self._messages.length = 0;
+
+    // no need to buffer once connected
+    self.message = function(msg) {
+      stream.write(message.marshall(msg));
+    };
+  });
+
+  return self;
+}
+
+module.exports.createClient = function(params) {
+  var connection = createConnection(params || {});
+  return new MessageBus(connection, params || {});
+};
+
+module.exports.systemBus = function() {
+  return module.exports.createClient({
+    busAddress:
+      process.env.DBUS_SYSTEM_BUS_ADDRESS ||
+      'unix:path=/var/run/dbus/system_bus_socket'
+  });
+};
+
+module.exports.sessionBus = function(opts) {
+  return module.exports.createClient(opts);
+};
+
+module.exports.messageType = constants.messageType;
+module.exports.createConnection = createConnection;
+
+module.exports.createServer = server.createServer;

package/lib/address-x11.js

@@ -0,0 +1,38 @@
+// read dbus adress from window selection
+
+const x11 = require('x11');
+const fs = require('fs');
+const os = require('os');
+
+function getDbusAddress(callback) {
+  // read machine uuid
+  fs.readFile('/var/lib/dbus/machine-id', 'ascii', function(err, uuid) {
+    if (err) return callback(err);
+    var hostname = os.hostname().split('-')[0];
+    x11.createClient(function(err, display) {
+      var X = display.client;
+      var selectionName = `_DBUS_SESSION_BUS_SELECTION_${
+        hostname
+      }_${uuid.trim()}`;
+      X.InternAtom(false, selectionName, function(err, id) {
+        if (err) return callback(err);
+        X.GetSelectionOwner(id, function(err, win) {
+          if (err) return callback(err);
+          X.InternAtom(false, '_DBUS_SESSION_BUS_ADDRESS', function(
+            err,
+            propId
+          ) {
+            if (err) return callback(err);
+            win = display.screen[0].root;
+            X.GetProperty(0, win, propId, 0, 0, 10000000, function(err, val) {
+              if (err) return callback(err);
+              callback(null, val.data.toString());
+            });
+          });
+        });
+      });
+    });
+  });
+}
+
+module.exports = getDbusAddress;

package/lib/align.js

@@ -0,0 +1,12 @@
+const Buffer = require('safe-buffer').Buffer;
+
+function align(ps, n) {
+  var pad = n - ps._offset % n;
+  if (pad === 0 || pad === n) return;
+  // TODO: write8(0) in a loop (3 to 7 times here) could be more efficient
+  var padBuff = Buffer.alloc(pad);
+  ps.put(Buffer.from(padBuff));
+  ps._offset += pad;
+}
+
+exports.align = align;