scan_beacon 0.5.2 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a5db65d671cd5e9211413474964dec5c321db9b9
-  data.tar.gz: c216b5ca742bf2c66802ac4d85e7d09d60d9c9ce
+  metadata.gz: f4548af4b44814857639f741b16b0b350d30ebd0
+  data.tar.gz: 42ca418ee1c526ea7286906ecd62e454cb1b6c63
 SHA512:
-  metadata.gz: af95dc0840d42696f139b48321a7cd972f472ea8964bd4953dca498c9219bf90d8c1bd8f510ba1118b5cf9b230b43564eeadc8c706010eba9dee1b3fb8911267
-  data.tar.gz: a456aa87b04087fbbae387ba5a7463aba1f57a49c26f98a1649bead49f25728ff9bfa5fc45445f3833468f53ee87c88f554abb9901e625590add68f050e18287
+  metadata.gz: da7aa4e68e45f42a7ec38b7502bc3ec955e8503ad22d62f97fe5d5c2797f59375a8c2c8825f3274091ed0deb5b305f86ee5a7a4b71e7aff47dfeb970f80c383f
+  data.tar.gz: 06b74ba91b756f475503143049b205d897ad785358811ea8878863e764b6110fc361dee6a7c7e35a125cf4dbe1cc464b131221ceed45341b5659c4f950b8c095

data/ext/bluez/addr_rotation.c

@@ -0,0 +1,387 @@
+// code modified from bluez/tools/bdaddr.c, so including the below notice.
+/*
+ *
+ *  BlueZ - Bluetooth protocol stack for Linux
+ *
+ *  Copyright (C) 2004-2010  Marcel Holtmann <marcel@holtmann.org>
+ *
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifdef linux
+#include "ruby.h"
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/hci.h>
+#include <bluetooth/hci_lib.h>
+
+#include "utils.h"
+
+VALUE method_device_up(VALUE self, VALUE device_id);
+VALUE method_device_down(VALUE self, VALUE device_id);
+
+
+static int transient = 0;
+
+static int generic_reset_device(int dd)
+{
+        bdaddr_t bdaddr;
+        int err;
+
+        err = hci_send_cmd(dd, 0x03, 0x0003, 0, NULL);
+        if (err < 0)
+                return err;
+
+        return hci_read_bd_addr(dd, &bdaddr, 10000);
+}
+
+#define OCF_ERICSSON_WRITE_BD_ADDR      0x000d
+typedef struct {
+        bdaddr_t        bdaddr;
+} __attribute__ ((packed)) ericsson_write_bd_addr_cp;
+
+static int ericsson_write_bd_addr(int dd, bdaddr_t *bdaddr)
+{
+        struct hci_request rq;
+        ericsson_write_bd_addr_cp cp;
+
+        memset(&cp, 0, sizeof(cp));
+        bacpy(&cp.bdaddr, bdaddr);
+
+        memset(&rq, 0, sizeof(rq));
+        rq.ogf    = OGF_VENDOR_CMD;
+        rq.ocf    = OCF_ERICSSON_WRITE_BD_ADDR;
+        rq.cparam = &cp;
+        rq.clen   = sizeof(cp);
+        rq.rparam = NULL;
+        rq.rlen   = 0;
+
+        if (hci_send_req(dd, &rq, 1000) < 0)
+                return -1;
+
+        return 0;
+}
+
+#define OCF_ERICSSON_STORE_IN_FLASH     0x0022
+typedef struct {
+        uint8_t         user_id;
+        uint8_t         flash_length;
+        uint8_t         flash_data[253];
+} __attribute__ ((packed)) ericsson_store_in_flash_cp;
+
+static int ericsson_store_in_flash(int dd, uint8_t user_id, uint8_t flash_length, uint8_t *flash_data)
+{
+        struct hci_request rq;
+        ericsson_store_in_flash_cp cp;
+
+        memset(&cp, 0, sizeof(cp));
+        cp.user_id = user_id;
+        cp.flash_length = flash_length;
+        if (flash_length > 0)
+                memcpy(cp.flash_data, flash_data, flash_length);
+
+        memset(&rq, 0, sizeof(rq));
+        rq.ogf    = OGF_VENDOR_CMD;
+        rq.ocf    = OCF_ERICSSON_STORE_IN_FLASH;
+        rq.cparam = &cp;
+        rq.clen   = sizeof(cp);
+        rq.rparam = NULL;
+        rq.rlen   = 0;
+
+        if (hci_send_req(dd, &rq, 1000) < 0)
+                return -1;
+
+        return 0;
+}
+
+static int csr_write_bd_addr(int dd, bdaddr_t *bdaddr)
+{
+        unsigned char cmd[] = { 0x02, 0x00, 0x0c, 0x00, 0x11, 0x47, 0x03, 0x70,
+                                0x00, 0x00, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00,
+                                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+        unsigned char cp[254], rp[254];
+        struct hci_request rq;
+
+        if (transient)
+                cmd[14] = 0x08;
+
+        cmd[16] = bdaddr->b[2];
+        cmd[17] = 0x00;
+        cmd[18] = bdaddr->b[0];
+        cmd[19] = bdaddr->b[1];
+        cmd[20] = bdaddr->b[3];
+        cmd[21] = 0x00;
+        cmd[22] = bdaddr->b[4];
+        cmd[23] = bdaddr->b[5];
+
+        memset(&cp, 0, sizeof(cp));
+        cp[0] = 0xc2;
+        memcpy(cp + 1, cmd, sizeof(cmd));
+
+        memset(&rq, 0, sizeof(rq));
+        rq.ogf    = OGF_VENDOR_CMD;
+        rq.ocf    = 0x00;
+        rq.event  = EVT_VENDOR;
+        rq.cparam = cp;
+        rq.clen   = sizeof(cmd) + 1;
+        rq.rparam = rp;
+        rq.rlen   = sizeof(rp);
+
+        if (hci_send_req(dd, &rq, 2000) < 0)
+                return -1;
+
+        if (rp[0] != 0xc2) {
+                errno = EIO;
+                return -1;
+        }
+
+        if ((rp[9] + (rp[10] << 8)) != 0) {
+                errno = ENXIO;
+                return -1;
+        }
+
+        return 0;
+}
+
+static int csr_reset_device(int dd)
+{
+        unsigned char cmd[] = { 0x02, 0x00, 0x09, 0x00,
+                                0x00, 0x00, 0x01, 0x40, 0x00, 0x00,
+                                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+        unsigned char cp[254], rp[254];
+        struct hci_request rq;
+
+        if (transient)
+                cmd[6] = 0x02;
+
+        memset(&cp, 0, sizeof(cp));
+        cp[0] = 0xc2;
+        memcpy(cp + 1, cmd, sizeof(cmd));
+
+        memset(&rq, 0, sizeof(rq));
+        rq.ogf    = OGF_VENDOR_CMD;
+        rq.ocf    = 0x00;
+        rq.event  = EVT_VENDOR;
+        rq.cparam = cp;
+        rq.clen   = sizeof(cmd) + 1;
+        rq.rparam = rp;
+        rq.rlen   = sizeof(rp);
+
+        if (hci_send_req(dd, &rq, 2000) < 0)
+                return -1;
+
+        return 0;
+}
+
+#define OCF_TI_WRITE_BD_ADDR            0x0006
+typedef struct {
+        bdaddr_t        bdaddr;
+} __attribute__ ((packed)) ti_write_bd_addr_cp;
+
+static int ti_write_bd_addr(int dd, bdaddr_t *bdaddr)
+{
+        struct hci_request rq;
+        ti_write_bd_addr_cp cp;
+
+        memset(&cp, 0, sizeof(cp));
+        bacpy(&cp.bdaddr, bdaddr);
+
+        memset(&rq, 0, sizeof(rq));
+        rq.ogf    = OGF_VENDOR_CMD;
+        rq.ocf    = OCF_TI_WRITE_BD_ADDR;
+        rq.cparam = &cp;
+        rq.clen   = sizeof(cp);
+        rq.rparam = NULL;
+        rq.rlen   = 0;
+
+        if (hci_send_req(dd, &rq, 1000) < 0)
+                return -1;
+
+        return 0;
+}
+
+#define OCF_BCM_WRITE_BD_ADDR           0x0001
+typedef struct {
+        bdaddr_t        bdaddr;
+} __attribute__ ((packed)) bcm_write_bd_addr_cp;
+
+static int bcm_write_bd_addr(int dd, bdaddr_t *bdaddr)
+{
+        struct hci_request rq;
+        bcm_write_bd_addr_cp cp;
+
+        memset(&cp, 0, sizeof(cp));
+        bacpy(&cp.bdaddr, bdaddr);
+
+        memset(&rq, 0, sizeof(rq));
+        rq.ogf    = OGF_VENDOR_CMD;
+        rq.ocf    = OCF_BCM_WRITE_BD_ADDR;
+        rq.cparam = &cp;
+        rq.clen   = sizeof(cp);
+        rq.rparam = NULL;
+        rq.rlen   = 0;
+
+        if (hci_send_req(dd, &rq, 1000) < 0)
+                return -1;
+
+        return 0;
+}
+
+#define OCF_ZEEVO_WRITE_BD_ADDR         0x0001
+typedef struct {
+        bdaddr_t        bdaddr;
+} __attribute__ ((packed)) zeevo_write_bd_addr_cp;
+
+static int zeevo_write_bd_addr(int dd, bdaddr_t *bdaddr)
+{
+        struct hci_request rq;
+        zeevo_write_bd_addr_cp cp;
+
+        memset(&cp, 0, sizeof(cp));
+        bacpy(&cp.bdaddr, bdaddr);
+
+        memset(&rq, 0, sizeof(rq));
+        rq.ogf    = OGF_VENDOR_CMD;
+        rq.ocf    = OCF_ZEEVO_WRITE_BD_ADDR;
+        rq.cparam = &cp;
+        rq.clen   = sizeof(cp);
+        rq.rparam = NULL;
+        rq.rlen   = 0;
+
+        if (hci_send_req(dd, &rq, 1000) < 0)
+                return -1;
+
+        return 0;
+}
+
+#define OCF_MRVL_WRITE_BD_ADDR          0x0022
+typedef struct {
+        uint8_t         parameter_id;
+        uint8_t         bdaddr_len;
+        bdaddr_t        bdaddr;
+} __attribute__ ((packed)) mrvl_write_bd_addr_cp;
+
+static int mrvl_write_bd_addr(int dd, bdaddr_t *bdaddr)
+{
+        mrvl_write_bd_addr_cp cp;
+
+        memset(&cp, 0, sizeof(cp));
+        cp.parameter_id = 0xFE;
+        cp.bdaddr_len = 6;
+        bacpy(&cp.bdaddr, bdaddr);
+
+        if (hci_send_cmd(dd, OGF_VENDOR_CMD, OCF_MRVL_WRITE_BD_ADDR,
+                                                        sizeof(cp), &cp) < 0)
+                return -1;
+
+        sleep(1);
+        return 0;
+}
+
+static int st_write_bd_addr(int dd, bdaddr_t *bdaddr)
+{
+        return ericsson_store_in_flash(dd, 0xfe, 6, (uint8_t *) bdaddr);
+}
+
+static struct {
+        uint16_t compid;
+        int (*write_bd_addr)(int dd, bdaddr_t *bdaddr);
+        int (*reset_device)(int dd);
+} vendor[] = {
+        { 0,            ericsson_write_bd_addr, NULL                    },
+        { 10,           csr_write_bd_addr,      csr_reset_device        },
+        { 13,           ti_write_bd_addr,       NULL                    },
+        { 15,           bcm_write_bd_addr,      generic_reset_device    },
+        { 18,           zeevo_write_bd_addr,    NULL                    },
+        { 48,           st_write_bd_addr,       generic_reset_device    },
+        { 57,           ericsson_write_bd_addr, generic_reset_device    },
+        { 72,           mrvl_write_bd_addr,     generic_reset_device    },
+        { 65535,        NULL,                   NULL                    },
+};
+
+
+VALUE method_set_addr(VALUE klass, VALUE rb_device_id, VALUE rb_str_addr)
+{
+  struct hci_dev_info di;
+  struct hci_version ver;
+  bdaddr_t bdaddr;
+  int i, dd, dev = 0, reset = 0;
+
+  dev = FIX2INT(rb_device_id);
+  bacpy(&bdaddr, BDADDR_ANY);
+
+  dd = hci_open_dev(dev);
+  if (dd < 0) {
+    rb_raise(rb_eException, "Can't open device");
+  }
+
+  if (hci_devinfo(dev, &di) < 0) {
+    hci_close_dev(dd);
+    rb_raise(rb_eException, "Can't get device info");
+  }
+
+  if (hci_read_local_version(dd, &ver, 1000) < 0) {
+    hci_close_dev(dd);
+    rb_raise(rb_eException, "Can't read version info for device");
+  }
+
+  if (!bacmp(&di.bdaddr, BDADDR_ANY)) {
+    if (hci_read_bd_addr(dd, &bdaddr, 1000) < 0) {
+      hci_close_dev(dd);
+      rb_raise(rb_eException, "Can't read address for device");
+    }
+  } else {
+    bacpy(&bdaddr, &di.bdaddr);
+  }
+
+  str2ba(RSTRING_PTR(rb_str_addr), &bdaddr);
+
+  for (i = 0; vendor[i].compid != 65535; i++)
+  {
+    if (ver.manufacturer == vendor[i].compid) {
+
+      if (vendor[i].write_bd_addr(dd, &bdaddr) < 0) {
+        hci_close_dev(dd);
+        rb_raise(rb_eException, "Can't write new address");
+      }
+
+      if (reset && vendor[i].reset_device) {
+        if (vendor[i].reset_device(dd) < 0) {
+          rb_raise(rb_eException, "Can't reset device");
+        } else {
+          ioctl(dd, HCIDEVRESET, dev);
+        }
+      } else {
+        method_device_down(Qnil, rb_device_id);
+        method_device_up(Qnil, rb_device_id);
+      }
+
+      hci_close_dev(dd);
+      return rb_str_addr;
+    }
+  }
+  hci_close_dev(dd);
+  rb_raise(rb_eException, "Unsupported manufacturer");
+}
+
+#endif // linux

data/ext/bluez/advertising.c

@@ -24,20 +24,23 @@ typedef struct {
   uint8_t ad_data[28];
 } Advertisement;
 
-Advertisement advertisement;
-int advertising;
+Advertisement advertisements[10];
 
 VALUE method_start_advertising();
 
 void init_advertisement()
 {
-  memset(&advertisement, 0, sizeof(advertisement));
-  advertisement.flags.len = 2;
-  advertisement.flags.type = 1;
-  advertisement.flags.data = FLAGS_NOT_CONNECTABLE;
-  advertising = 0;
 }
 
+void set_advertisement_flags(Advertisement *advertisement)
+{
+  memset(advertisement, 0, sizeof(Advertisement));
+  advertisement->flags.len = 2;
+  advertisement->flags.type = 1;
+  advertisement->flags.data = FLAGS_NOT_CONNECTABLE;
+}
+
+/*
 VALUE method_set_connectable(VALUE self, VALUE connectable)
 {
   if ( RTEST(connectable) )
@@ -51,29 +54,30 @@ VALUE method_set_connectable(VALUE self, VALUE connectable)
   }
   return connectable;
 }
+*/
 
-VALUE method_set_advertisement_bytes(VALUE self, VALUE bytes)
+VALUE method_set_advertisement_bytes(VALUE self, VALUE rb_device_id, VALUE bytes)
 {
+  int device_id = FIX2INT(rb_device_id);
+  Advertisement *advertisement = &advertisements[device_id];
   uint8_t len = RSTRING_LEN(bytes);
   if (len > 28) {
     len = 28;
   }
-  advertisement.len = len + advertisement.flags.len + 1; // + 1 is to account for the flags length field
-  memcpy(advertisement.ad_data, RSTRING_PTR(bytes), len);
-  if (advertising) {
-    method_start_advertising();
-  }
+  set_advertisement_flags(advertisement);
+  advertisement->len = len + advertisement->flags.len + 1; // + 1 is to account for the flags length field
+  memcpy(advertisement->ad_data, RSTRING_PTR(bytes), len);
   return bytes;
 }
 
-VALUE method_start_advertising()
+VALUE method_start_advertising(VALUE klass, VALUE rb_device_id, VALUE random_address)
 {
   struct hci_request rq;
   le_set_advertising_parameters_cp adv_params_cp;
   uint8_t status;
-  
+
   // open connection to the device
-  int device_id = hci_get_route(NULL);
+  int device_id = FIX2INT(rb_device_id);
   if (device_id < 0) {
     rb_raise(rb_eException, "Could not find device");
   }
@@ -85,8 +89,8 @@ VALUE method_start_advertising()
   memset(&rq, 0, sizeof(rq));
   rq.ogf = OGF_LE_CTL;
   rq.ocf = OCF_LE_SET_ADVERTISING_DATA;
-  rq.cparam = &advertisement;
-  rq.clen = sizeof(advertisement);
+  rq.cparam = &advertisements[device_id];
+  rq.clen = sizeof(Advertisement);
   rq.rparam = &status;
   rq.rlen = 1;
   hci_send_req(device_handle, &rq, 1000);
@@ -98,6 +102,9 @@ VALUE method_start_advertising()
   adv_params_cp.max_interval = interval_100ms;
   adv_params_cp.advtype = 0x03; // non-connectable undirected advertising
   adv_params_cp.chan_map = 0x07;// all 3 channels
+  if (random_address != Qnil) {
+    adv_params_cp.own_bdaddr_type = LE_RANDOM_ADDRESS;
+  }
   memset(&rq, 0, sizeof(rq));
   rq.ogf = OGF_LE_CTL;
   rq.ocf = OCF_LE_SET_ADVERTISING_PARAMETERS;
@@ -107,22 +114,35 @@ VALUE method_start_advertising()
   rq.rlen = 1;
   hci_send_req(device_handle, &rq, 1000);
 
+  if (random_address != Qnil)
+  {
+    // set random address
+    le_set_random_address_cp random_addr_cp;
+    str2ba(StringValuePtr(random_address), &random_addr_cp.bdaddr);
+    memset(&rq, 0, sizeof(rq));
+    rq.ogf = OGF_LE_CTL;
+    rq.ocf = OCF_LE_SET_RANDOM_ADDRESS;
+    rq.cparam = &random_addr_cp;
+    rq.clen = LE_SET_RANDOM_ADDRESS_CP_SIZE;
+    rq.rparam = &status;
+    rq.rlen = 1;
+    hci_send_req(device_handle, &rq, 1000);
+  }
+
   // turn on advertising
   hci_le_set_advertise_enable(device_handle, 0x01, 1000);
 
   // and close the connection
   hci_close_dev(device_handle);
-  advertising = 1;
   return Qnil;
 }
 
-VALUE method_stop_advertising()
+VALUE method_stop_advertising(VALUE klass, VALUE rb_device_id)
 {
-  int device_id = hci_get_route(NULL);
+  int device_id = FIX2INT(rb_device_id);
   int device_handle = hci_open_dev(device_id);
   hci_le_set_advertise_enable(device_handle, 0x00, 1000);
   hci_close_dev(device_handle);
-  advertising = 0;
   return Qnil;
 }
 

data/ext/bluez/bluez.c

@@ -14,12 +14,13 @@ VALUE bluez_module = Qnil;
 void Init_bluez();
 VALUE method_device_up(VALUE self, VALUE device_id);
 VALUE method_device_down(VALUE self, VALUE device_id);
-VALUE method_set_connectable(VALUE self, VALUE connectable);
-VALUE method_set_advertisement_bytes(VALUE self, VALUE bytes);
-VALUE method_start_advertising();
-VALUE method_stop_advertising();
+//VALUE method_set_connectable(VALUE self, VALUE connectable);
+VALUE method_set_advertisement_bytes(VALUE self, VALUE rb_device_id, VALUE bytes);
+VALUE method_start_advertising(VALUE klass, VALUE rb_device_id, VALUE random_address);
+VALUE method_stop_advertising(VALUE klass, VALUE rb_device_id);
 VALUE method_scan(int argc, VALUE *argv, VALUE klass);
 VALUE method_devices();
+VALUE method_set_addr(VALUE klass, VALUE rb_device_id, VALUE rb_str_addr);
 void init_advertisement();
 
 void Init_bluez()
@@ -28,12 +29,13 @@ void Init_bluez()
   bluez_module = rb_define_module_under(scan_beacon_module, "BlueZ");
   rb_define_singleton_method(bluez_module, "device_up", method_device_up, 1);
   rb_define_singleton_method(bluez_module, "device_down", method_device_down, 1);
-  rb_define_singleton_method(bluez_module, "start_advertising", method_start_advertising, 0);
-  rb_define_singleton_method(bluez_module, "stop_advertising", method_stop_advertising, 0);
-  rb_define_singleton_method(bluez_module, "advertisement_bytes=", method_set_advertisement_bytes, 1);
-  rb_define_singleton_method(bluez_module, "connectable=", method_set_connectable, 1);
+  rb_define_singleton_method(bluez_module, "start_advertising", method_start_advertising, 2);
+  rb_define_singleton_method(bluez_module, "stop_advertising", method_stop_advertising, 1);
+  rb_define_singleton_method(bluez_module, "set_advertisement_bytes", method_set_advertisement_bytes, 2);
+  //rb_define_singleton_method(bluez_module, "connectable=", method_set_connectable, 1);
   rb_define_singleton_method(bluez_module, "scan", method_scan, -1);
   rb_define_singleton_method(bluez_module, "devices", method_devices, 0);
+  rb_define_singleton_method(bluez_module, "set_addr", method_set_addr, 2);
 
   // initialize the advertisement
   init_advertisement();

data/lib/scan_beacon/beacon/field.rb

@@ -0,0 +1,93 @@
+module ScanBeacon
+  class Beacon
+    class Field
+      include Comparable
+      ENCODING = "ASCII-8BIT".freeze
+      NULL_BYTE = "\x00".force_encoding(ENCODING).freeze
+
+      def initialize(opts = {})
+        self.set_data(opts)
+      end
+
+      def self.field_with_length(id, length)
+        return id if id.is_a? self
+        if id.is_a? String
+          self.new hex: id, length: length
+        elsif id.is_a? Integer
+          self.new number: id, length: length
+        end
+      end
+
+      def set_data(opts = {})
+        bytes = opts[:bytes]
+        hex = opts[:hex]
+        number = opts[:number]
+        length = opts[:length]
+        if bytes
+          @data = bytes.force_encoding(ENCODING)
+        elsif hex
+          # zero pad hex if needed
+          hex = "0"*(length*2-hex.size) + hex if length and hex.size < length*2
+          @data = [hex].pack("H*")
+        elsif number
+          raise ArgumentError.new("Must also give a field length when you give a number") if length.nil?
+          set_data(hex: number.to_s(16), length: length)
+        end
+      end
+
+      def value
+        if @data.size < 6
+          self.to_i
+        else
+          self.to_hex
+        end
+      end
+
+      def to_s
+        value.to_s
+      end
+
+      def inspect
+        "<Beacon::Field value=#{self.value.inspect}>"
+      end
+
+      def bytes
+        @data
+      end
+
+      def to_i
+        size = @data.size
+        case size
+        when 0
+          nil
+        when 1
+          @data.unpack("C")[0]
+        when 2
+          @data.unpack("S>")[0]
+        when 3
+          (NULL_BYTE + @data).unpack("L>")[0]
+        when 4
+          @data.unpack("L>")[0]
+        when 5,6,7
+          (NULL_BYTE*(8-size) + @data).unpack("Q>")[0]
+        when 8
+          @data.unpack("Q>")[0]
+        else
+          @data[-8..-1].unpack("Q>")[0]
+        end
+      end
+
+      def to_hex
+        @data.unpack("H*")[0]
+      end
+
+      def <=> (other)
+        if other.is_a? self.class
+          self.bytes <=> other.bytes
+        else
+          self.value <=> other
+        end
+      end
+    end
+  end
+end

data/lib/scan_beacon/beacon.rb

@@ -32,15 +32,16 @@ module ScanBeacon
     end
 
     def uuid
-      "#{ids[0][0..7]}-#{ids[0][8..11]}-#{ids[0][12..15]}-#{ids[0][16..19]}-#{ids[0][20..-1]}".upcase
+      id0 = ids[0].to_s
+      "#{id0[0..7]}-#{id0[8..11]}-#{id0[12..15]}-#{id0[16..19]}-#{id0[20..-1]}".upcase
     end
 
     def major
-      ids[1]
+      ids[1].to_i
     end
 
     def minor
-      ids[2]
+      ids[2].to_i
     end
 
     def ad_count

data/lib/scan_beacon/beacon_parser.rb

@@ -2,11 +2,11 @@ module ScanBeacon
   class BeaconParser
     DEFAULT_LAYOUTS = {
       altbeacon: "m:2-3=beac,i:4-19,i:20-21,i:22-23,p:24-24,d:25-25",
-      eddystone_uid: "s:0-1=aafe,m:2-2=00,p:3-3:-41,i:4-13,i:14-19;d:20-21"
+      eddystone_uid: "s:0-1=feaa,m:2-2=00,p:3-3:-41,i:4-13,i:14-19;d:20-21"
     }
     AD_TYPE_MFG = 0xff
     AD_TYPE_SERVICE = 0x03
-    BT_EIR_SERVICE_DATA = "\x16"
+    BT_EIR_SERVICE_DATA = "\x16".force_encoding("ASCII-8BIT")
     attr_accessor :beacon_type
 
     def self.default_parsers
@@ -15,31 +15,49 @@ module ScanBeacon
 
     def initialize(beacon_type, layout)
       @beacon_type = beacon_type
-      @layout = layout.split(",")
       if layout.include?("s")
         @ad_type = AD_TYPE_SERVICE
       else
         @ad_type = AD_TYPE_MFG
       end
-      @matchers = @layout.find_all {|item| ["m", "s"].include? item[0]}.map {|matcher|
-        _, range_start, range_end, expected = matcher.split(/:|=|-/)
-        {start: range_start.to_i, end: range_end.to_i, expected: expected}
-      }
-      @ids = @layout.find_all {|item| item[0] == "i"}.map {|id|
-        _, range_start, range_end = id.split(/:|-/)
-        {start: range_start.to_i, end: range_end.to_i}
-      }
-      @data_fields = @layout.find_all {|item| item[0] == "d"}.map {|field|
-        _, range_start, range_end = field.split(/:|-/)
-        {start: range_start.to_i, end: range_end.to_i}
-      }
-      _, power_start, power_end = @layout.find {|item| item[0] == "p"}.split(/:|-/)
-      @power = {start: power_start.to_i, end: power_end.to_i}
+      @layout = layout
+      parse_layout
+    end
+
+    def parse_layout
+      @matchers = []
+      @ids = []
+      @data_fields = []
+      @power = nil
+      @layout.split(",").each do |field|
+        field_type, range_start, range_end, expected = field.split(/:|=|-/)
+        field_params = {
+          start: range_start.to_i,
+          end: range_end.to_i,
+          length: range_end.to_i - range_start.to_i + 1,
+        }
+        field_params[:expected] = [expected].pack("H*") unless expected.nil?
+        case field_type
+        when 'm'
+          @matchers << field_params
+        when 's'
+          # swap byte order of service uuid
+          expected = field_params[:expected]
+          field_params[:expected] = expected[1] + expected[0]
+          @matchers << field_params
+        when 'i'
+          @ids << field_params
+        when 'd'
+          @data_fields << field_params
+        when 'p'
+          @power = field_params
+        end
+      end
     end
 
     def matches?(data)
       @matchers.each do |matcher|
-        return false unless data[matcher[:start]..matcher[:end]].unpack("H*").join == matcher[:expected]
+        return false unless data[matcher[:start]..matcher[:end]] == matcher[:expected]
       end
       return true
     end
@@ -66,20 +84,7 @@ module ScanBeacon
     def parse_elems(elems, data)
       elems.map {|elem|
         elem_str = data[elem[:start]..elem[:end]]
-        elem_length = elem_str.size
-        case elem_length
-        when 1
-          elem_str.unpack('C')[0]
-        when 2 
-          # two bytes, so treat it as a short (big endian)
-          elem_str.unpack('S>')[0]
-        when 6
-          # 6 bytes, treat it is an eddystone instance id
-          ("\x00\x00"+elem_str).unpack('Q>')[0]
-        else
-          # not two bytes, so treat it as a hex string
-          elem_str.unpack('H*').join
-        end
+        Beacon::Field.new(bytes: elem_str)
       }
     end
 
@@ -88,46 +93,37 @@ module ScanBeacon
     end
 
     def parse_power(data)
+      return nil if @power.nil?
       data[@power[:start]..@power[:end]].unpack('c')[0]
     end
 
     def generate_ad(beacon)
       length = [@matchers, @ids, @power, @data_fields].flatten.map {|elem| elem[:end] }.max + 1
-      ad = "\x00" * length
+      ad = ("\x00" * length).force_encoding("ASCII-8BIT")
       @matchers.each do |matcher|
-        ad[matcher[:start]..matcher[:end]] = [matcher[:expected]].pack("H*")
+        ad[matcher[:start]..matcher[:end]] = matcher[:expected]
       end
       @ids.each_with_index do |id, index|
-        ad[id[:start]..id[:end]] = generate_field(id, beacon.ids[index])
+        id_bytes = Beacon::Field.field_with_length(beacon.ids[index], id[:length]).bytes
+        ad[id[:start]..id[:end]] = id_bytes
       end
       @data_fields.each_with_index do |field, index|
-        ad[field[:start]..field[:end]] = generate_field(field, beacon.data[index]) unless beacon.data[index].nil?
+        unless beacon.data[index].nil?
+          field_bytes = Beacon::Field.field_with_length(beacon.data[index], field[:length]).bytes
+          ad[field[:start]..field[:end]] = field_bytes
+        end
       end
       ad[@power[:start]..@power[:end]] = [beacon.power].pack('c')
       if @ad_type == AD_TYPE_SERVICE
-        "\x03\x03" + [beacon.service_uuid].pack("S<") + [length+1].pack('C') + BT_EIR_SERVICE_DATA + ad
+        "\x03\x03".force_encoding("ASCII-8BIT") + [beacon.service_uuid].pack("S<") + [length+1].pack('C') + BT_EIR_SERVICE_DATA + ad
       elsif @ad_type == AD_TYPE_MFG
         ad[0..1] = [beacon.mfg_id].pack("S<")
         [length+1].pack('C') + [AD_TYPE_MFG].pack('C') +  ad
       end
     end
 
-    def generate_field(field, value)
-      field_length = field[:end] - field[:start] + 1
-      case field_length
-      when 1
-        [value].pack("c")
-      when 2
-        [value].pack("S>")
-      when 6
-        [value].pack("Q>")[2..-1]
-      else
-        [value].pack("H*")[0..field_length-1]
-      end
-    end 
-
     def inspect
-      "<BeaconParser type=\"#{@beacon_type}\", layout=\"#{@layout.join(",")}\">"
+      "<BeaconParser type=\"#{@beacon_type}\", layout=\"#{@layout}\">"
     end
   end
 end

data/lib/scan_beacon/ble112_advertiser.rb

@@ -0,0 +1,63 @@
+module ScanBeacon
+  class BLE112Advertiser
+
+    attr_accessor :beacon, :parser, :ad
+
+    def initialize(opts = {})
+      @device = BLE112Device.new opts[:port]
+      self.beacon = opts[:beacon]
+      self.parser = opts[:parser]
+      self.parser ||= BeaconParser.default_parsers.find {|parser| parser.beacon_type == beacon.beacon_types.first}
+      @advertising = false
+    end
+
+    def beacon=(value)
+      @beacon = value
+      update_ad
+    end
+
+    def parser=(value)
+      @parser = value
+      update_ad
+    end
+
+    def ad=(value)
+      @ad = value
+    end
+
+    def start(with_rotation = false)
+      @device.open do
+        @device.start_advertising(@ad, with_rotation)
+        @advertising = true
+      end
+    end
+
+    def stop
+      @device.open do
+        @device.stop_advertising
+        @advertising = false
+      end
+    end
+
+    def inspect
+      "<BLE112Advertiser ad=#{@ad.inspect}>"
+    end
+
+    def update_ad
+      self.ad = @parser.generate_ad(@beacon) if @parser && @beacon
+      self.start if @advertising
+    end
+
+    def rotate_addr
+      @device.open do
+        @device.rotate_addr
+      end
+    end
+
+    def rotate_addr_and_update_ad
+      self.update_ad
+      self.start(true)
+    end
+
+  end
+end

data/lib/scan_beacon/ble112_device.rb

@@ -12,6 +12,10 @@ module ScanBeacon
     BG_RESET = 0
     BG_DISCONNECT = 0
     BG_SET_MODE = 1
+    BG_GAP_SET_PRIVACY_FLAGS = 0
+    BG_GAP_SET_ADV_PARAM = 8
+    BG_GAP_SET_ADV_DATA = 9
+
     BG_DISCOVER = 2
     BG_DISCOVER_STOP = 4
     BG_SCAN_PARAMS = 7
@@ -19,6 +23,8 @@ module ScanBeacon
     BG_GAP_DISCOVER_ALL = 2
     BG_GAP_NON_DISCOVERABLE = 0
     BG_GAP_NON_CONNECTABLE = 0
+    BG_GAP_USER_DATA = 4
+    BG_GAP_CONNECTABLE = 2
 
     def initialize(port=nil)
       @port = port || Dir.glob("/dev/{cu.usbmodem,ttyACM}*")[0]
@@ -56,6 +62,39 @@ module ScanBeacon
       bg_command(@file, BG_MSG_CLASS_GAP, BG_DISCOVER_STOP)
     end
 
+    def start_advertising(ad_data, privacy = false)
+      # disconnect any connections
+      bg_command(@file, BG_MSG_CLASS_CONNECTION, BG_DISCONNECT,0)
+
+      # set advertising interval 0x00A0 = 100 ms interval, 7 = all channels
+      bg_command(@file, BG_MSG_CLASS_GAP, BG_GAP_SET_ADV_PARAM, [0xA0, 0x00, 0xA0, 0x00, 7])
+
+      # set privacy mode (rotate bluetooth address)
+      if privacy
+        bg_command(@file, BG_MSG_CLASS_GAP, BG_GAP_SET_PRIVACY_FLAGS, [1, 0])
+      end
+
+      # add flags header
+      ad_data = "\x02\x01\x06" + ad_data
+      ad_data = [0,ad_data.size].pack("C*") + ad_data
+
+      stop_advertising
+      bg_command(@file, BG_MSG_CLASS_GAP, BG_GAP_SET_ADV_DATA, ad_data.unpack("C*"))
+      bg_command(@file, BG_MSG_CLASS_GAP, BG_SET_MODE, [BG_GAP_USER_DATA, BG_GAP_CONNECTABLE])
+    end
+
+    def rotate_addr
+      # set peripheral into private mode is not needed, as the mac is rotated every time gap_set_mode is called
+      bg_command(@file, BG_MSG_CLASS_GAP, BG_GAP_SET_PRIVACY_FLAGS, [1, 0])
+
+      # set gap mode
+      bg_command(@file, BG_MSG_CLASS_GAP, BG_SET_MODE, [BG_GAP_USER_DATA, BG_GAP_CONNECTABLE])
+    end
+
+    def stop_advertising
+      bg_command(@file, BG_MSG_CLASS_GAP, BG_SET_MODE, [BG_GAP_NON_DISCOVERABLE, BG_GAP_NON_CONNECTABLE])
+    end
+
     def read
       BLE112Response.new( bg_read(@file) )
     end
@@ -71,7 +110,7 @@ module ScanBeacon
 
     class BLE112Response
       def initialize(data)
-        @data = data
+        @data = data.force_encoding("ASCII-8BIT")
       end
 
       def size
@@ -90,8 +129,12 @@ module ScanBeacon
         size > 20 && advertisement_type == 0xFF
       end
 
+      def service_ad?
+        size > 20 && advertisement_type ==0x03
+      end
+
       def advertisement?
-        event? && gap_scan? && manufacturer_ad?
+        event? && gap_scan? && (manufacturer_ad? || service_ad?)
       end
 
       def advertisement_type

data/lib/scan_beacon/ble112_scanner.rb

@@ -14,7 +14,11 @@ module ScanBeacon
           while keep_scanning do
             response = device.read
             if response.advertisement?
-              keep_scanning = false if yield(response.advertisement_data, response.mac, response.rssi) == false
+              if response.manufacturer_ad?
+                keep_scanning = false if yield(response.advertisement_data, response.mac, response.rssi) == false
+              else
+                keep_scanning = false if yield(response.advertisement_data[4..-1], response.mac, response.rssi, 0x03) == false
+              end
             end
           end
         ensure

data/lib/scan_beacon/bluez_advertiser.rb

@@ -1,12 +1,13 @@
 module ScanBeacon
   class BlueZAdvertiser
  
-    attr_accessor :beacon, :parser, :ad
+    attr_accessor :beacon, :parser, :ad, :addr
 
     def initialize(opts = {})
       @device_id = opts[:device_id] || BlueZ.devices.map {|d| d[:device_id]}[0]
       raise "No available devices" if @device_id.nil?
       BlueZ.device_up @device_id
+      @addr = @initial_addr = BlueZ.devices.find {|d| d[:device_id] == @device_id}[:addr]
       self.beacon = opts[:beacon]
       self.parser = opts[:parser]
       self.parser ||= BeaconParser.default_parsers.find {|parser| parser.beacon_type == beacon.beacon_types.first}
@@ -24,15 +25,20 @@ module ScanBeacon
 
     def ad=(value)
       @ad = value
-      BlueZ.advertisement_bytes = @ad
+      BlueZ.set_advertisement_bytes @device_id, @ad
     end
 
     def start
-      BlueZ.start_advertising
+      BlueZ.start_advertising @device_id, nil
+    end
+
+    def start_with_random_addr
+      addr = random_addr
+      BlueZ.start_advertising @device_id, addr
     end
 
     def stop
-      BlueZ.stop_advertising
+      BlueZ.stop_advertising @device_id
     end
 
     def inspect
@@ -43,5 +49,16 @@ module ScanBeacon
       self.ad = @parser.generate_ad(@beacon) if @parser && @beacon
     end
 
+    def rotate_addr_and_update_ad
+      self.update_ad
+      self.stop
+      self.start_with_random_addr
+    end
+
+    def random_addr
+      data = @initial_addr + Time.now.to_s
+      Digest::SHA256.digest(data)[0..5].unpack("H2:H2:H2:H2:H2:H2").join(":")
+    end
+
   end
 end

data/lib/scan_beacon/version.rb

@@ -1,3 +1,3 @@
 module ScanBeacon
-  VERSION = "0.5.2"
+  VERSION = "0.5.3"
 end

data/lib/scan_beacon.rb

@@ -1,9 +1,11 @@
 require "scan_beacon/version"
 require "scan_beacon/beacon"
+require "scan_beacon/beacon/field"
 require "scan_beacon/beacon_parser"
 require "scan_beacon/generic_scanner"
 require "scan_beacon/ble112_device"
 require "scan_beacon/ble112_scanner"
+require "scan_beacon/ble112_advertiser"
 case RUBY_PLATFORM
 when /darwin/
   require "scan_beacon/core_bluetooth"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scan_beacon
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.5.3
 platform: ruby
 authors:
 - Radius Networks
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-08-24 00:00:00.000000000 Z
+date: 2015-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- ext/bluez/addr_rotation.c
 - ext/bluez/advertising.c
 - ext/bluez/bluez.c
 - ext/bluez/devices.c
@@ -91,7 +92,9 @@ files:
 - ext/core_bluetooth/extconf.rb
 - lib/scan_beacon.rb
 - lib/scan_beacon/beacon.rb
+- lib/scan_beacon/beacon/field.rb
 - lib/scan_beacon/beacon_parser.rb
+- lib/scan_beacon/ble112_advertiser.rb
 - lib/scan_beacon/ble112_device.rb
 - lib/scan_beacon/ble112_scanner.rb
 - lib/scan_beacon/bluez_advertiser.rb