@homebridge/dbus-native 0.4.0

package/lib/marshallers.js

@@ -0,0 +1,336 @@
+const Buffer = require('safe-buffer').Buffer;
+const align = require('./align').align;
+const parseSignature = require('../lib/signature');
+const Long = require('long');
+/**
+ * MakeSimpleMarshaller
+ * @param signature - the signature of the data you want to check
+ * @returns a simple marshaller with the "check" method
+ *
+ * check returns nothing - it only raises errors if the data is
+ * invalid for the signature
+ */
+var MakeSimpleMarshaller = function(signature) {
+  var marshaller = {};
+  function checkValidString(data) {
+    if (typeof data !== 'string') {
+      throw new Error(`Data: ${data} was not of type string`);
+    } else if (data.indexOf('\0') !== -1) {
+      throw new Error('String contains null byte');
+    }
+  }
+
+  function checkValidSignature(data) {
+    if (data.length > 0xff) {
+      throw new Error(
+        `Data: ${data} is too long for signature type (${data.length} > 255)`
+      );
+    }
+
+    var parenCount = 0;
+    for (var ii = 0; ii < data.length; ++ii) {
+      if (parenCount > 32) {
+        throw new Error(
+          `Maximum container type nesting exceeded in signature type:${data}`
+        );
+      }
+      switch (data[ii]) {
+        case '(':
+          ++parenCount;
+          break;
+        case ')':
+          --parenCount;
+          break;
+        default:
+          /* no-op */
+          break;
+      }
+    }
+    parseSignature(data);
+  }
+
+  switch (signature) {
+    case 'o':
+    // object path
+    // TODO: verify object path here?
+    case 's': // eslint-disable-line no-fallthrough
+      //STRING
+      marshaller.check = function(data) {
+        checkValidString(data);
+      };
+      marshaller.marshall = function(ps, data) {
+        this.check(data);
+        // utf8 string
+        align(ps, 4);
+        const buff = Buffer.from(data, 'utf8');
+        ps
+          .word32le(buff.length)
+          .put(buff)
+          .word8(0);
+        ps._offset += 5 + buff.length;
+      };
+      break;
+    case 'g':
+      //SIGNATURE
+      marshaller.check = function(data) {
+        checkValidString(data);
+        checkValidSignature(data);
+      };
+      marshaller.marshall = function(ps, data) {
+        this.check(data);
+        // signature
+        const buff = Buffer.from(data, 'ascii');
+        ps
+          .word8(data.length)
+          .put(buff)
+          .word8(0);
+        ps._offset += 2 + buff.length;
+      };
+      break;
+    case 'y':
+      //BYTE
+      marshaller.check = function(data) {
+        checkInteger(data);
+        checkRange(0x00, 0xff, data);
+      };
+      marshaller.marshall = function(ps, data) {
+        this.check(data);
+        ps.word8(data);
+        ps._offset++;
+      };
+      break;
+    case 'b':
+      //BOOLEAN
+      marshaller.check = function(data) {
+        checkBoolean(data);
+      };
+      marshaller.marshall = function(ps, data) {
+        this.check(data);
+        // booleans serialised as 0/1 unsigned 32 bit int
+        data = data ? 1 : 0;
+        align(ps, 4);
+        ps.word32le(data);
+        ps._offset += 4;
+      };
+      break;
+    case 'n':
+      //INT16
+      marshaller.check = function(data) {
+        checkInteger(data);
+        checkRange(-0x7fff - 1, 0x7fff, data);
+      };
+      marshaller.marshall = function(ps, data) {
+        this.check(data);
+        align(ps, 2);
+        const buff = Buffer.alloc(2);
+        buff.writeInt16LE(parseInt(data), 0);
+        ps.put(buff);
+        ps._offset += 2;
+      };
+      break;
+    case 'q':
+      //UINT16
+      marshaller.check = function(data) {
+        checkInteger(data);
+        checkRange(0, 0xffff, data);
+      };
+      marshaller.marshall = function(ps, data) {
+        this.check(data);
+        align(ps, 2);
+        ps.word16le(data);
+        ps._offset += 2;
+      };
+      break;
+    case 'i':
+      //INT32
+      marshaller.check = function(data) {
+        checkInteger(data);
+        checkRange(-0x7fffffff - 1, 0x7fffffff, data);
+      };
+      marshaller.marshall = function(ps, data) {
+        this.check(data);
+        align(ps, 4);
+        const buff = Buffer.alloc(4);
+        buff.writeInt32LE(parseInt(data), 0);
+        ps.put(buff);
+        ps._offset += 4;
+      };
+      break;
+    case 'u':
+      //UINT32
+      marshaller.check = function(data) {
+        checkInteger(data);
+        checkRange(0, 0xffffffff, data);
+      };
+      marshaller.marshall = function(ps, data) {
+        this.check(data);
+        // 32 t unsigned int
+        align(ps, 4);
+        ps.word32le(data);
+        ps._offset += 4;
+      };
+      break;
+    case 't':
+      //UINT64
+      marshaller.check = function(data) {
+        return checkLong(data, false);
+      };
+      marshaller.marshall = function(ps, data) {
+        data = this.check(data);
+        align(ps, 8);
+        ps.word32le(data.low);
+        ps.word32le(data.high);
+        ps._offset += 8;
+      };
+      break;
+    case 'x':
+      //INT64
+      marshaller.check = function(data) {
+        return checkLong(data, true);
+      };
+      marshaller.marshall = function(ps, data) {
+        data = this.check(data);
+        align(ps, 8);
+        ps.word32le(data.low);
+        ps.word32le(data.high);
+        ps._offset += 8;
+      };
+      break;
+    case 'd':
+      //DOUBLE
+      marshaller.check = function(data) {
+        if (typeof data !== 'number') {
+          throw new Error(`Data: ${data} was not of type number`);
+        } else if (Number.isNaN(data)) {
+          throw new Error(`Data: ${data} was not a number`);
+        } else if (!Number.isFinite(data)) {
+          throw new Error('Number outside range');
+        }
+      };
+      marshaller.marshall = function(ps, data) {
+        this.check(data);
+        align(ps, 8);
+        const buff = Buffer.alloc(8);
+        buff.writeDoubleLE(parseFloat(data), 0);
+        ps.put(buff);
+        ps._offset += 8;
+      };
+      break;
+    default:
+      throw new Error(`Unknown data type format: ${signature}`);
+  }
+  return marshaller;
+};
+exports.MakeSimpleMarshaller = MakeSimpleMarshaller;
+
+var checkRange = function(minValue, maxValue, data) {
+  if (data > maxValue || data < minValue) {
+    throw new Error('Number outside range');
+  }
+};
+
+var checkInteger = function(data) {
+  if (typeof data !== 'number') {
+    throw new Error(`Data: ${data} was not of type number`);
+  }
+  if (Math.floor(data) !== data) {
+    throw new Error(`Data: ${data} was not an integer`);
+  }
+};
+
+var checkBoolean = function(data) {
+  if (!(typeof data === 'boolean' || data === 0 || data === 1))
+    throw new Error(`Data: ${data} was not of type boolean`);
+};
+
+// This is essentially a tweaked version of 'fromValue' from Long.js with error checking.
+// This can take number or string of decimal characters or 'Long' instance (or Long-style object with props low,high,unsigned).
+var makeLong = function(val, signed) {
+  if (val instanceof Long) return val;
+  if (val instanceof Number) val = val.valueOf();
+  if (typeof val === 'number') {
+    try {
+      // Long.js won't alert you to precision loss in passing more than 53 bit ints through a double number, so we check here
+      checkInteger(val);
+      if (signed) {
+        checkRange(-0x1fffffffffffff, 0x1fffffffffffff, val);
+      } else {
+        checkRange(0, 0x1fffffffffffff, val);
+      }
+    } catch (e) {
+      e.message += ' (Number type can only carry 53 bit integer)';
+      throw e;
+    }
+    try {
+      return Long.fromNumber(val, !signed);
+    } catch (e) {
+      e.message = `Error converting number to 64bit integer "${e.message}"`;
+      throw e;
+    }
+  }
+  if (typeof val === 'string' || val instanceof String) {
+    var radix = 10;
+    val = val.trim().toUpperCase(); // remove extra whitespace and make uppercase (for hex)
+    if (val.substring(0, 2) === '0X') {
+      radix = 16;
+      val = val.substring(2);
+    } else if (val.substring(0, 3) === '-0X') {
+      // unusual, but just in case?
+      radix = 16;
+      val = `-${val.substring(3)}`;
+    }
+    val = val.replace(/^0+(?=\d)/, ''); // dump leading zeroes
+    var data;
+    try {
+      data = Long.fromString(val, !signed, radix);
+    } catch (e) {
+      e.message = `Error converting string to 64bit integer '${e.message}'`;
+      throw e;
+    }
+    // If string represents a number outside of 64 bit range, it can quietly overflow.
+    // We assume if things converted correctly the string coming out of Long should match what went into it.
+    if (data.toString(radix).toUpperCase() !== val)
+      throw new Error(
+        `Data: '${val}' did not convert correctly to ${
+          signed ? 'signed' : 'unsigned'
+        } 64 bit`
+      );
+    return data;
+  }
+  // Throws for non-objects, converts non-instanceof Long:
+  try {
+    return Long.fromBits(val.low, val.high, val.unsigned);
+  } catch (e) {
+    e.message = `Error converting object to 64bit integer '${e.message}'`;
+    throw e;
+  }
+};
+
+var checkLong = function(data, signed) {
+  if (!Long.isLong(data)) {
+    data = makeLong(data, signed);
+  }
+
+  // Do we enforce that Long.js object unsigned/signed match the field even if it is still in range?
+  // Probably, might help users avoid unintended bugs?
+  if (signed) {
+    if (data.unsigned)
+      throw new Error(
+        'Longjs object is unsigned, but marshalling into signed 64 bit field'
+      );
+    if (data.gt(Long.MAX_VALUE) || data.lt(Long.MIN_VALUE)) {
+      throw new Error(`Data: ${data} was out of range (64-bit signed)`);
+    }
+  } else {
+    if (!data.unsigned)
+      throw new Error(
+        'Longjs object is signed, but marshalling into unsigned 64 bit field'
+      );
+    // NOTE: data.gt(Long.MAX_UNSIGNED_VALUE) will catch if Long.js object is a signed value but is still within unsigned range!
+    //  Since we are enforcing signed type matching between Long.js object and field, this note should not matter.
+    if (data.gt(Long.MAX_UNSIGNED_VALUE) || data.lt(0)) {
+      throw new Error(`Data: ${data} was out of range (64-bit unsigned)`);
+    }
+  }
+  return data;
+};

package/lib/message.js

@@ -0,0 +1,118 @@
+const Buffer = require('safe-buffer').Buffer;
+const marshall = require('./marshall');
+const constants = require('./constants');
+const DBusBuffer = require('./dbus-buffer');
+
+const headerSignature = require('./header-signature.json');
+
+module.exports.unmarshalMessages = function messageParser(
+  stream,
+  onMessage,
+  opts
+) {
+  var state = 0; // 0: header, 1: fields + body
+  var header, fieldsAndBody;
+  var fieldsLength, fieldsLengthPadded;
+  var fieldsAndBodyLength = 0;
+  var bodyLength = 0;
+  stream.on('readable', function() {
+    while (1) {
+      if (state === 0) {
+        header = stream.read(16);
+        if (!header) break;
+        state = 1;
+
+        fieldsLength = header.readUInt32LE(12);
+        fieldsLengthPadded = ((fieldsLength + 7) >> 3) << 3;
+        bodyLength = header.readUInt32LE(4);
+        fieldsAndBodyLength = fieldsLengthPadded + bodyLength;
+      } else {
+        fieldsAndBody = stream.read(fieldsAndBodyLength);
+        if (!fieldsAndBody) break;
+        state = 0;
+
+        var messageBuffer = new DBusBuffer(fieldsAndBody, undefined, opts);
+        var unmarshalledHeader = messageBuffer.readArray(
+          headerSignature[0].child[0],
+          fieldsLength
+        );
+        messageBuffer.align(3);
+        var headerName;
+        var message = {};
+        message.serial = header.readUInt32LE(8);
+
+        for (var i = 0; i < unmarshalledHeader.length; ++i) {
+          headerName = constants.headerTypeName[unmarshalledHeader[i][0]];
+          message[headerName] = unmarshalledHeader[i][1][1][0];
+        }
+
+        message.type = header[1];
+        message.flags = header[2];
+
+        if (bodyLength > 0 && message.signature) {
+          message.body = messageBuffer.read(message.signature);
+        }
+        onMessage(message);
+      }
+    }
+  });
+};
+
+// given buffer which contains entire message deserialise it
+// TODO: factor out common code
+module.exports.unmarshall = function unmarshall(buff, opts) {
+  var msgBuf = new DBusBuffer(buff, undefined, opts);
+  var headers = msgBuf.read('yyyyuua(yv)');
+  var message = {};
+  for (var i = 0; i < headers[6].length; ++i) {
+    var headerName = constants.headerTypeName[headers[6][i][0]];
+    message[headerName] = headers[6][i][1][1][0];
+  }
+  message.type = headers[1];
+  message.flags = headers[2];
+  message.serial = headers[5];
+  msgBuf.align(3);
+  message.body = msgBuf.read(message.signature);
+  return message;
+};
+
+module.exports.marshall = function marshallMessage(message) {
+  if (!message.serial) throw new Error('Missing or invalid serial');
+  var flags = message.flags || 0;
+  var type = message.type || constants.messageType.methodCall;
+  var bodyLength = 0;
+  var bodyBuff;
+  if (message.signature && message.body) {
+    bodyBuff = marshall(message.signature, message.body);
+    bodyLength = bodyBuff.length;
+  }
+  var header = [
+    constants.endianness.le,
+    type,
+    flags,
+    constants.protocolVersion,
+    bodyLength,
+    message.serial
+  ];
+  var headerBuff = marshall('yyyyuu', header);
+  var fields = [];
+  constants.headerTypeName.forEach(function(fieldName) {
+    var fieldVal = message[fieldName];
+    if (fieldVal) {
+      fields.push([
+        constants.headerTypeId[fieldName],
+        [constants.fieldSignature[fieldName], fieldVal]
+      ]);
+    }
+  });
+  var fieldsBuff = marshall('a(yv)', [fields], 12);
+  var headerLenAligned =
+    ((headerBuff.length + fieldsBuff.length + 7) >> 3) << 3;
+  var messageLen = headerLenAligned + bodyLength;
+  var messageBuff = Buffer.alloc(messageLen);
+  headerBuff.copy(messageBuff);
+  fieldsBuff.copy(messageBuff, headerBuff.length);
+  if (bodyLength > 0) bodyBuff.copy(messageBuff, headerLenAligned);
+
+  return messageBuff;
+};

package/lib/portforward.js

@@ -0,0 +1,38 @@
+const net = require('net');
+const abs = require('abstract-socket');
+const hexy = require('hexy').hexy;
+
+var address = process.env.DBUS_SESSION_BUS_ADDRESS;
+var m = address.match(/abstract=([^,]+)/);
+
+net
+  .createServer(function(s) {
+    var buff = '';
+    var connected = false;
+    var cli = abs.createConnection(`\0${m[1]}`);
+    s.on('data', function(d) {
+      if (connected) {
+        cli.write(d);
+      } else {
+        buff += d.toString();
+      }
+    });
+    setTimeout(function() {
+      console.log('CONNECTED!');
+      connected = true;
+      cli.write(buff);
+    }, 100);
+    cli.pipe(s);
+
+    cli.on('data', function(b) {
+      console.log(hexy(b, { prefix: 'from client ' }));
+    });
+    s.on('data', function(b) {
+      console.log(hexy(b, { prefix: 'from server ' }));
+    });
+  })
+  .listen(3334, function() {
+    console.log(
+      'Server started. connect with DBUS_SESSION_BUS_ADDRESS=tcp:host=127.0.0.1,port=3334'
+    );
+  });

package/lib/readline.js

@@ -0,0 +1,23 @@
+const Buffer = require('safe-buffer').Buffer;
+
+module.exports = function readOneLine(stream, cb) {
+  var bytes = [];
+  function readable() {
+    while (1) {
+      var buf = stream.read(1);
+      if (!buf) return;
+      var b = buf[0];
+      if (b === 0x0a) {
+        try {
+          cb(Buffer.from(bytes));
+        } catch (error) {
+          stream.emit('error', error);
+        }
+        stream.removeListener('readable', readable);
+        return;
+      }
+      bytes.push(b);
+    }
+  }
+  stream.on('readable', readable);
+};

package/lib/server-handshake.js

@@ -0,0 +1,37 @@
+const Buffer = require('safe-buffer').Buffer;
+const readLine = require('./readline');
+
+module.exports = function serverHandshake(stream, opts, cb) {
+  stream.name = 'SERVER SERVER';
+  readLine(stream, function(hello) {
+    console.log(['hello string: ', hello.toString(), hello]);
+    stream.write('REJECTED EXTERNAL DBUS_COOKIE_SHA1 ANONYMOUS\r\n');
+    readLine(stream, function() {
+      stream.write(
+        `DATA ${Buffer.from(
+          'org_freedesktop_general 642038150 b9ce247a275f427c8586e4c9de9bb951'
+        ).toString('hex')}\r\n`
+      );
+      readLine(stream, function() {
+        stream.write(
+          'OK 6f72675f667265656465736b746f705f67656e6572616c20353631303331333937206239636532343761323735663432376338353836653463396465396262393531\r\n'
+        );
+        readLine(stream, function(begin) {
+          console.log(['AFTER begin: ', begin.toString()]);
+          cb(null);
+        });
+      });
+    });
+  });
+};
+
+// cookie: 561031397 1410749774 3a83c8200f930e7af4de135e8abd299b681a1f44dbb85399
+
+// 1539856202
+
+// server: org_freedesktop_general 561031397 b9ce247a275f427c8586e4c9de9bb951
+// client: bwFSDjS0TJerqb0l 82986a987194788803d7da2a4b00e801cff9bdfd
+//                          82986a987194788803d7da2a4b00e801cff9bdfd = sha1(b9ce247a275f427c8586e4c9de9bb951:bwFSDjS0TJerqb0l:3a83c8200f930e7af4de135e8abd299b681a1f44dbb85399)
+// server: OK e12a29dd7ffe3effac5eb95054123f80
+
+//dbus.write('DATA 6f72675f667265656465736b746f705f67656e6572616c203636383430 31303032 203733653733313762383630356537323937623438303233376336353234343533\r\n');

package/lib/server.js

@@ -0,0 +1,18 @@
+const dbus = require('../index');
+const net = require('net');
+
+module.exports.createServer = function(handler) {
+  function Server() {
+    var id = 123;
+    this.server = net.createServer(function(socket) {
+      socket.idd = id;
+      id++;
+
+      var dbusConn = dbus.createConnection({ stream: socket, server: true });
+      if (handler) handler(dbusConn);
+      // TODO: inherit from EE this.emit('connect', dbusConn);
+    });
+    this.listen = this.server.listen.bind(this.server);
+  }
+  return new Server();
+};

package/lib/signature.js

@@ -0,0 +1,61 @@
+// parse signature from string to tree
+
+var match = {
+  '{': '}',
+  '(': ')'
+};
+
+var knownTypes = {};
+'(){}ybnqiuxtdsogarvehm*?@&^'.split('').forEach(function(c) {
+  knownTypes[c] = true;
+});
+
+module.exports = function parseSignature(signature) {
+  var index = 0;
+  function next() {
+    if (index < signature.length) {
+      var c = signature[index];
+      ++index;
+      return c;
+    }
+    return null;
+  }
+
+  function parseOne(c) {
+    function checkNotEnd(c) {
+      if (!c) throw new Error('Bad signature: unexpected end');
+      return c;
+    }
+
+    if (!knownTypes[c])
+      throw new Error(`Unknown type: "${c}" in signature "${signature}"`);
+
+    var ele;
+    var res = { type: c, child: [] };
+    switch (c) {
+      case 'a': // array
+        ele = next();
+        checkNotEnd(ele);
+        res.child.push(parseOne(ele));
+        return res;
+      case '{': // dict entry
+      case '(': // struct
+        while ((ele = next()) !== null && ele !== match[c])
+          res.child.push(parseOne(ele));
+        checkNotEnd(ele);
+        return res;
+    }
+    return res;
+  }
+
+  var ret = [];
+  var c;
+  while ((c = next()) !== null) ret.push(parseOne(c));
+  return ret;
+};
+
+// command-line test
+//console.log(JSON.stringify(module.exports(process.argv[2]), null, 4));
+//var tree = module.exports('a(ssssbbbbbbbbuasa{ss}sa{sv})a(ssssssbbssa{ss}sa{sv})a(ssssssbsassa{sv})');
+//console.log(tree);
+//console.log(fromTree(tree))