Identifying unprovisioned mesh device

[jnicklas]

I'm struggling with how to properly identify an unprovisioned mesh device. Basically when i scan for unprovisioned devices from my iOS app, I'd like for only our devices to show up, not any random mesh device. I'm still struggling to understand all the terminology, but if I understand everything correctly, I should be checking the `p_device_uri` set in `mesh_provisionee_prov_start` against the advertised data, or something. According to the mesh spec, it seems like this data is hashed using the salt function `s1`, which I think corresponds to `OpenSSLHelper.calculateSalt` in the iOS SDK. However, what I'm not understanding is which data to actually check against and how. So far, when I discover unprovisioned proxy nodes, I can do this:

func centralManager(_ central: CBCentralManager,
                        didDiscover peripheral: CBPeripheral,
                        advertisementData: [String: Any],
                        rssi RSSI: NSNumber) {

  if let serviceData = advertisementData[CBAdvertisementDataServiceDataKey] as! [CBUUID: NSData]? {
    let provisioningData = serviceData[MeshServiceProvisioningUUID]
    print("service data: \(provisioningData)")
  }

}

`provisioningData` contains some bytes of data, for me it returned `E754E3DAAFFDEE419AC6AD32896107A80000`, Which is 18bytes. The mesh spec seems to define the beacon format as follows:

But this comes out to 23 bytes, so it can't really match the format of the data I received.

It seems that the nRF Connect application is able to decipher at least some of this data, since it shows the device UUID in its scan view, but since the source of this app is not available I can't check against it.

Any help would be appreciated!

[jnicklas]

I've finally understood why and how this works. What I'm receiving is in fact not the GAP advertising data, but rather the GATT scan response. As per the mesh spec (Table 7.3) the service data in the GATT information only contains the Device UUID (first 16 bytes) and the OOB information (last 2 bytes), which matches exactly what I receive. I've been unable to find any reference to reading GAP data in iOS, I wonder if it's even supported at all. Looking at the CoreBluetooth API, it seems there is no other way of searching for devices.

So by looking into GATT, I found out that the application can override `mesh_adv_data_set` and that this allows me to hook into the advertised data. I've added some manufacture data in the scan response which allows me to identify the device.

Something like this:

typedef struct __attribute((packed))
{
    uint16_t product_id;
    uint16_t app_version;
} lc_mesh_manuf_data_t;

void mesh_adv_data_set(uint16_t service_uuid, const uint8_t * p_service_data, uint8_t length)
{
    // [...]

    /* The application may freely set anything into the scan response data. */
    ble_advdata_t srdata;
    memset(&srdata, 0, sizeof(srdata));
    srdata.name_type = BLE_ADVDATA_FULL_NAME;

    ble_advdata_manuf_data_t manuf_data;

    lc_mesh_manuf_data_t manuf_data_data;

    manuf_data_data.product_id = APP_PRODUCT_ID;
    manuf_data_data.app_version = APP_VERSION;

    manuf_data.company_identifier = APP_COMPANY_ID;
    manuf_data.data.p_data = (uint8_t *) &manuf_data_data;
    manuf_data.data.size = sizeof(manuf_data_data);

    srdata.p_manuf_specific_data = &manuf_data;

    // [...]
}

This seems to work quite well. And I can read out this information in iOS like this:

extension MeshNetworkScanner: CBCentralManagerDelegate {
    func centralManagerDidUpdateState(_ central: CBCentralManager) {
        // FIXME: handle central manager being unavailable
    }

    func centralManager(_ central: CBCentralManager,
                        didDiscover peripheral: CBPeripheral,
                        advertisementData: [String: Any],
                        rssi RSSI: NSNumber) {
        
        if let serviceData = advertisementData[CBAdvertisementDataManufacturerDataKey] as! Data? {
            if serviceData.count >= 6 {
                let manufacturerId = UInt16(littleEndian: serviceData[0...1].withUnsafeBytes { $0.pointee })
                let productId = UInt16(littleEndian: serviceData[2...3].withUnsafeBytes { $0.pointee })
                
                // we'll check that this is an actual LightCore device
                if manufacturerId == MeshNetwork.companyId && productId == MeshNetwork.productId {
                    let newNode = UnprovisionedMeshNode(withPeripheral: peripheral, andAdvertisementDictionary: advertisementData, RSSI: RSSI)
                    delegate?.nodeDiscovered(newNode)
                }
            }
        }
    }
}

[bjorn-spockeli]

Hi Nicklas, 

Advertising it exclusivly related to the Generic Access Profile, hence the sd_ble_gap_-  prefix to all SoftDevice functions related to advertisment.  

A node, i.e. an unprovisioned device, can be provisioned through the Advertisment bearer or the GATT bearer using the Mesh Provisioning Service. I assumed that you would be able to receive both the PB-ADV and PB-GATT advertisement data with iOS devices as the nRF device will interleave these, see quote below:

If PB-ADV is supported, an unprovisioned Provisioning Server that supports PB-GATT has to interleave the connectable advertising for PB-GATT with the Unprovisioned Device beacon (see Section 3.9.2).

However, it could be that iOS devices filter out advertisment packets with the ADV type used by the Unprovisioned Device beacon. So adding a custom ID to the scan response data for the PB-GATT advertisment data is the way to go. 

Best regards

Bjørn