コード例 #1
0
static void
prphtest_register_cb(uint8_t op, union ble_gatt_register_ctxt *ctxt, void *arg)
{
    uint16_t uuid16;

    switch (op) {
    case BLE_GATT_REGISTER_OP_SVC:
        uuid16 = ble_uuid_128_to_16(ctxt->svc_reg.svc->uuid128);
        assert(uuid16 != 0);
        console_printf("registered service 0x%04x with handle=%d\n",
                       uuid16, ctxt->svc_reg.handle);
        break;

    case BLE_GATT_REGISTER_OP_CHR:
        uuid16 = ble_uuid_128_to_16(ctxt->chr_reg.chr->uuid128);
        assert(uuid16 != 0);
        console_printf("registering characteristic 0x%04x with def_handle=%d "
                       "val_handle=%d\n",
                       uuid16, ctxt->chr_reg.def_handle,
                       ctxt->chr_reg.val_handle);
        break;

    default:
        assert(0);
        break;
    }
}
コード例 #2
0
static void
ble_gatt_disc_c_test_misc_verify_chars(struct ble_gatt_disc_c_test_char *chars,
                                       int stop_after)
{
    uint16_t uuid16;
    int i;

    if (stop_after == 0) {
        stop_after = INT_MAX;
    }

    for (i = 0; i < stop_after && chars[i].decl_handle != 0; i++) {
        TEST_ASSERT(chars[i].decl_handle ==
                    ble_gatt_disc_c_test_chars[i].decl_handle);
        TEST_ASSERT(chars[i].value_handle ==
                    ble_gatt_disc_c_test_chars[i].value_handle);
        if (chars[i].uuid16 != 0) {
            uuid16 = ble_uuid_128_to_16(ble_gatt_disc_c_test_chars[i].uuid128);
            TEST_ASSERT(chars[i].uuid16 == uuid16);
        } else {
            TEST_ASSERT(memcmp(chars[i].uuid128,
                               ble_gatt_disc_c_test_chars[i].uuid128,
                               16) == 0);
        }
    }

    TEST_ASSERT(i == ble_gatt_disc_c_test_num_chars);
    TEST_ASSERT(ble_gatt_disc_c_test_rx_complete);
}
コード例 #3
0
static int
ble_gatt_find_s_test_misc_rx_read_type(
    uint16_t conn_handle, struct ble_gatt_find_s_test_entry *entries)
{
    struct ble_att_read_type_rsp rsp;
    uint16_t uuid16;
    uint8_t buf[1024];
    int off;
    int rc;
    int i;

    memset(&rsp, 0, sizeof rsp);

    off = BLE_ATT_READ_TYPE_RSP_BASE_SZ;
    for (i = 0; entries[i].inc_handle != 0; i++) {
        if (rsp.batp_length == BLE_GATTS_INC_SVC_LEN_NO_UUID + 2) {
            break;
        }

        uuid16 = ble_uuid_128_to_16(entries[i].uuid128);
        if (uuid16 == 0) {
            if (rsp.batp_length != 0) {
                break;
            }
            rsp.batp_length = BLE_GATTS_INC_SVC_LEN_NO_UUID + 2;
        } else {
            rsp.batp_length = BLE_GATTS_INC_SVC_LEN_UUID + 2;
        }

        TEST_ASSERT_FATAL(off + rsp.batp_length <= sizeof buf);

        htole16(buf + off, entries[i].inc_handle);
        off += 2;

        htole16(buf + off, entries[i].start_handle);
        off += 2;

        htole16(buf + off, entries[i].end_handle);
        off += 2;

        if (uuid16 != 0) {
            htole16(buf + off, uuid16);
            off += 2;
        }
    }

    if (i == 0) {
        ble_hs_test_util_rx_att_err_rsp(conn_handle, BLE_ATT_OP_READ_TYPE_REQ,
                                        BLE_ATT_ERR_ATTR_NOT_FOUND, 0);
        return 0;
    }

    ble_att_read_type_rsp_write(buf + 0, BLE_ATT_READ_TYPE_RSP_BASE_SZ, &rsp);

    rc = ble_hs_test_util_l2cap_rx_payload_flat(conn_handle, BLE_L2CAP_CID_ATT,
                                                buf, off);
    TEST_ASSERT(rc == 0);

    return i;
}
コード例 #4
0
static int
ble_svc_gap_access(uint16_t conn_handle, uint16_t attr_handle,
                   struct ble_gatt_access_ctxt *ctxt, void *arg)
{
    uint16_t uuid16;
    int rc;

    uuid16 = ble_uuid_128_to_16(ctxt->chr->uuid128);
    assert(uuid16 != 0);

    switch (uuid16) {
    case BLE_SVC_GAP_CHR_UUID16_DEVICE_NAME:
        assert(ctxt->op == BLE_GATT_ACCESS_OP_READ_CHR);
        rc = os_mbuf_append(ctxt->om, ble_svc_gap_name,
                            strlen(ble_svc_gap_name));
        return rc == 0 ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES;

    case BLE_SVC_GAP_CHR_UUID16_APPEARANCE:
        assert(ctxt->op == BLE_GATT_ACCESS_OP_READ_CHR);
        rc = os_mbuf_append(ctxt->om, &ble_svc_gap_appearance,
                            sizeof ble_svc_gap_appearance);
        return rc == 0 ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES;

    case BLE_SVC_GAP_CHR_UUID16_PERIPH_PRIV_FLAG:
        assert(ctxt->op == BLE_GATT_ACCESS_OP_READ_CHR);
        rc = os_mbuf_append(ctxt->om, &ble_svc_gap_privacy_flag,
                            sizeof ble_svc_gap_privacy_flag);
        return rc == 0 ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES;

    case BLE_SVC_GAP_CHR_UUID16_RECONNECT_ADDR:
        assert(ctxt->op == BLE_GATT_ACCESS_OP_WRITE_CHR);
        if (OS_MBUF_PKTLEN(ctxt->om) != sizeof ble_svc_gap_reconnect_addr) {
            return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
        }
        ble_hs_mbuf_to_flat(ctxt->om, ble_svc_gap_reconnect_addr,
                            sizeof ble_svc_gap_reconnect_addr, NULL);
        return 0;

    case BLE_SVC_GAP_CHR_UUID16_PERIPH_PREF_CONN_PARAMS:
        assert(ctxt->op == BLE_GATT_ACCESS_OP_READ_CHR);
        rc = os_mbuf_append(ctxt->om, &ble_svc_gap_pref_conn_params,
                            sizeof ble_svc_gap_pref_conn_params);
        return rc == 0 ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES;

    default:
        assert(0);
        return BLE_ATT_ERR_UNLIKELY;
    }
}
コード例 #5
0
static void
ble_gatt_find_s_test_misc_find_inc(uint16_t conn_handle,
                                   uint16_t start_handle, uint16_t end_handle,
                                   struct ble_gatt_find_s_test_entry *entries)
{
    struct ble_gatt_service service;
    int cur_start;
    int num_found;
    int idx;
    int rc;
    int i;

    rc = ble_gattc_find_inc_svcs(conn_handle, start_handle, end_handle,
                                 ble_gatt_find_s_test_misc_cb, &service);
    TEST_ASSERT(rc == 0);

    cur_start = start_handle;
    idx = 0;
    while (1) {
        ble_gatt_find_s_test_misc_verify_tx_read_type(cur_start, end_handle);
        num_found = ble_gatt_find_s_test_misc_rx_read_type(conn_handle,
                                                           entries + idx);
        if (num_found == 0) {
            break;
        }

        if (ble_uuid_128_to_16(entries[idx].uuid128) == 0) {
            TEST_ASSERT(num_found == 1);
            ble_gatt_find_s_test_misc_verify_tx_read(
                entries[idx].start_handle);
            ble_gatt_find_s_test_misc_rx_read(conn_handle,
                                              entries[idx].uuid128);
        }

        idx += num_found;
        cur_start = entries[idx - 1].inc_handle + 1;
    }
    TEST_ASSERT(idx == ble_gatt_find_s_test_num_svcs);
    TEST_ASSERT(ble_gatt_find_s_test_proc_complete);

    for (i = 0; i < ble_gatt_find_s_test_num_svcs; i++) {
        TEST_ASSERT(ble_gatt_find_s_test_svcs[i].start_handle ==
                    entries[i].start_handle);
        TEST_ASSERT(ble_gatt_find_s_test_svcs[i].end_handle ==
                    entries[i].end_handle);
        TEST_ASSERT(memcmp(ble_gatt_find_s_test_svcs[i].uuid128,
                           entries[i].uuid128, 16) == 0);
    }
}
コード例 #6
0
static char *
gatt_svr_uuid_to_s(const void *uuid128, char *dst)
{
    const uint8_t *u8p;
    uint16_t uuid16;

    uuid16 = ble_uuid_128_to_16(uuid128);
    if (uuid16 != 0) {
        sprintf(dst, "0x%04x", uuid16);
        return dst;
    }

    u8p = uuid128;

    sprintf(dst,      "%02x%02x%02x%02x-", u8p[15], u8p[14], u8p[13], u8p[12]);
    sprintf(dst + 9,  "%02x%02x-%02x%02x-", u8p[11], u8p[10], u8p[9], u8p[8]);
    sprintf(dst + 19, "%02x%02x%02x%02x%02x%02x%02x%02x",
            u8p[7], u8p[6], u8p[5], u8p[4], u8p[3], u8p[2], u8p[1], u8p[0]);

    return dst;
}
コード例 #7
0
ファイル: misc.c プロジェクト: mikeryan/incubator-mynewt-core
void
print_uuid(void *uuid128)
{
    uint16_t uuid16;
    uint8_t *u8p;

    uuid16 = ble_uuid_128_to_16(uuid128);
    if (uuid16 != 0) {
        console_printf("0x%04x", uuid16);
        return;
    }

    u8p = uuid128;

    /* 00001101-0000-1000-8000-00805f9b34fb */
    console_printf("%02x%02x%02x%02x-", u8p[15], u8p[14], u8p[13], u8p[12]);
    console_printf("%02x%02x-%02x%02x-", u8p[11], u8p[10], u8p[9], u8p[8]);
    console_printf("%02x%02x%02x%02x%02x%02x%02x%02x",
                   u8p[7], u8p[6], u8p[5], u8p[4],
                   u8p[3], u8p[2], u8p[1], u8p[0]);
}
コード例 #8
0
static int
prphtest_gatt_cb(uint16_t conn_handle, uint16_t attr_handle, uint8_t op,
                 union ble_gatt_access_ctxt *ctxt, void *arg)
{
    static uint8_t buf[128];
    uint16_t uuid16;

    assert(op == BLE_GATT_ACCESS_OP_READ_CHR);

    uuid16 = ble_uuid_128_to_16(ctxt->chr_access.chr->uuid128);
    switch (uuid16) {
    case PRPHTEST_CHR1_UUID:
        console_printf("reading characteristic1 value");
        memcpy(buf, "char1", 5);
        ctxt->chr_access.len = 5;
        break;

    case PRPHTEST_CHR2_UUID:
        console_printf("reading characteristic2 value");
        memcpy(buf, "char2", 5);
        ctxt->chr_access.len = 5;
        break;

    case PRPHTEST_CHR3_UUID:
        console_printf("reading characteristic3 value");
        memcpy(buf, "char3", 5);
        ctxt->chr_access.len = 5;
        break;

    default:
        assert(0);
        break;
    }

    ctxt->chr_access.data = buf;

    return 0;
}
コード例 #9
0
int
ble_uuid_append(struct os_mbuf *om, void *uuid128)
{
    uint16_t uuid16;
    void *buf;
    int rc;

    uuid16 = ble_uuid_128_to_16(uuid128);
    if (uuid16 != 0) {
        buf = os_mbuf_extend(om, 2);
        if (buf == NULL) {
            return BLE_HS_ENOMEM;
        }

        htole16(buf, uuid16);
    } else {
        rc = os_mbuf_append(om, uuid128, 16);
        if (rc != 0) {
            return BLE_HS_ENOMEM;
        }
    }

    return 0;
}
コード例 #10
0
static int
gatt_svr_chr_access_alert(uint16_t conn_handle, uint16_t attr_handle,
                          struct ble_gatt_access_ctxt *ctxt,
                          void *arg)
{
    uint16_t uuid16;
    int rc;

    uuid16 = ble_uuid_128_to_16(ctxt->chr->uuid128);
    assert(uuid16 != 0);

    switch (uuid16) {
    case GATT_SVR_CHR_SUP_NEW_ALERT_CAT_UUID:
        assert(ctxt->op == BLE_GATT_ACCESS_OP_READ_CHR);
        rc = os_mbuf_append(ctxt->om, &gatt_svr_new_alert_cat,
                            sizeof gatt_svr_new_alert_cat);
        return rc == 0 ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES;

    case GATT_SVR_CHR_NEW_ALERT:
        if (ctxt->op == BLE_GATT_ACCESS_OP_WRITE_CHR) {
            rc = gatt_svr_chr_write(ctxt->om, 0,
                                    sizeof gatt_svr_new_alert_val,
                                    gatt_svr_new_alert_val,
                                    &gatt_svr_new_alert_val_len);
            return rc;
        } else if (ctxt->op == BLE_GATT_ACCESS_OP_READ_CHR) {
            rc = os_mbuf_append(ctxt->om, &gatt_svr_new_alert_val,
                                sizeof gatt_svr_new_alert_val);
            return rc == 0 ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES;
        }

    case GATT_SVR_CHR_SUP_UNR_ALERT_CAT_UUID:
        assert(ctxt->op == BLE_GATT_ACCESS_OP_READ_CHR);
        rc = os_mbuf_append(ctxt->om, &gatt_svr_unr_alert_cat,
                            sizeof gatt_svr_unr_alert_cat);
        return rc == 0 ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES;

    case GATT_SVR_CHR_UNR_ALERT_STAT_UUID:
        if (ctxt->op == BLE_GATT_ACCESS_OP_WRITE_CHR) {
            rc = gatt_svr_chr_write(ctxt->om, 2, 2, &gatt_svr_unr_alert_stat,
                                    NULL);
            return rc;
        } else {
            rc = os_mbuf_append(ctxt->om, &gatt_svr_unr_alert_stat,
                                sizeof gatt_svr_unr_alert_stat);
            return rc == 0 ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES;
        }

    case GATT_SVR_CHR_ALERT_NOT_CTRL_PT:
        if (ctxt->op == BLE_GATT_ACCESS_OP_WRITE_CHR) {
            rc = gatt_svr_chr_write(ctxt->om, 2, 2,
                                    &gatt_svr_alert_not_ctrl_pt, NULL);
        } else {
            rc = BLE_ATT_ERR_UNLIKELY;
        }
        return rc;

    default:
        assert(0);
        return BLE_ATT_ERR_UNLIKELY;
    }
}