/* * SPDX-FileCopyrightText: 2021-2023 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Unlicense OR CC0-1.0 */ #include #include #include #include "host/ble_hs.h" #include "host/ble_uuid.h" #include "services/gap/ble_svc_gap.h" #include "services/gatt/ble_svc_gatt.h" #include "ble_dynamic_service.h" #include "services/ans/ble_svc_ans.h" /*** Maximum number of characteristics with the notify flag ***/ #define MAX_NOTIFY 5 static const ble_uuid128_t gatt_svr_svc_uuid = BLE_UUID128_INIT(0x2d, 0x71, 0xa2, 0x59, 0xb4, 0x58, 0xc8, 0x12, 0x99, 0x99, 0x43, 0x95, 0x12, 0x2f, 0x46, 0x59); /* A characteristic that can be subscribed to */ static uint8_t gatt_svr_chr_val; static uint16_t gatt_svr_chr_val_handle; static const ble_uuid128_t gatt_svr_chr_uuid = BLE_UUID128_INIT(0x00, 0x00, 0x00, 0x00, 0x11, 0x11, 0x11, 0x11, 0x22, 0x22, 0x22, 0x22, 0x33, 0x33, 0x33, 0x33); /* A custom descriptor */ static uint8_t gatt_svr_dsc_val; static const ble_uuid128_t gatt_svr_dsc_uuid = BLE_UUID128_INIT(0x01, 0x01, 0x01, 0x01, 0x12, 0x12, 0x12, 0x12, 0x23, 0x23, 0x23, 0x23, 0x34, 0x34, 0x34, 0x34); static int gatt_svc_access(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg); const struct ble_gatt_svc_def gatt_svr_svcs[] = { { /*** Service ***/ .type = BLE_GATT_SVC_TYPE_PRIMARY, .uuid = &gatt_svr_svc_uuid.u, .characteristics = (struct ble_gatt_chr_def[]) { { /*** This characteristic can be subscribed to by writing 0x00 and 0x01 to the CCCD ***/ .uuid = &gatt_svr_chr_uuid.u, .access_cb = gatt_svc_access, .flags = BLE_GATT_CHR_F_READ | BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_NOTIFY | BLE_GATT_CHR_F_INDICATE, .val_handle = &gatt_svr_chr_val_handle, .descriptors = (struct ble_gatt_dsc_def[]) { { .uuid = &gatt_svr_dsc_uuid.u, .att_flags = BLE_ATT_F_READ, .access_cb = gatt_svc_access, }, { 0, /* No more descriptors in this characteristic */ } }, }, { 0, /* No more characteristics in this service. */ } }, }, { 0, /* No more services. */ }, }; static int gatt_svr_write(struct os_mbuf *om, uint16_t min_len, uint16_t max_len, void *dst, uint16_t *len) { uint16_t om_len; int rc; om_len = OS_MBUF_PKTLEN(om); if (om_len < min_len || om_len > max_len) { return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN; } rc = ble_hs_mbuf_to_flat(om, dst, max_len, len); if (rc != 0) { return BLE_ATT_ERR_UNLIKELY; } return 0; } /** * Access callback whenever a characteristic/descriptor is read or written to. * Here reads and writes need to be handled. * ctxt->op tells weather the operation is read or write and * weather it is on a characteristic or descriptor, * ctxt->dsc->uuid tells which characteristic/descriptor is accessed. * attr_handle give the value handle of the attribute being accessed. * Accordingly do: * Append the value to ctxt->om if the operation is READ * Write ctxt->om to the value if the operation is WRITE **/ static int gatt_svc_access(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg) { const ble_uuid_t *uuid; int rc; switch (ctxt->op) { case BLE_GATT_ACCESS_OP_READ_CHR: if (conn_handle != BLE_HS_CONN_HANDLE_NONE) { MODLOG_DFLT(INFO, "Characteristic read; conn_handle=%d attr_handle=%d\n", conn_handle, attr_handle); } else { MODLOG_DFLT(INFO, "Characteristic read by NimBLE stack; attr_handle=%d\n", attr_handle); } uuid = ctxt->chr->uuid; if (attr_handle == gatt_svr_chr_val_handle) { rc = os_mbuf_append(ctxt->om, &gatt_svr_chr_val, sizeof(gatt_svr_chr_val)); return rc == 0 ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES; } goto unknown; case BLE_GATT_ACCESS_OP_WRITE_CHR: if (conn_handle != BLE_HS_CONN_HANDLE_NONE) { MODLOG_DFLT(INFO, "Characteristic write; conn_handle=%d attr_handle=%d", conn_handle, attr_handle); } else { MODLOG_DFLT(INFO, "Characteristic write by NimBLE stack; attr_handle=%d", attr_handle); } uuid = ctxt->chr->uuid; if (attr_handle == gatt_svr_chr_val_handle) { rc = gatt_svr_write(ctxt->om, sizeof(gatt_svr_chr_val), sizeof(gatt_svr_chr_val), &gatt_svr_chr_val, NULL); ble_gatts_chr_updated(attr_handle); MODLOG_DFLT(INFO, "Notification/Indication scheduled for " "all subscribed peers.\n"); return rc; } goto unknown; case BLE_GATT_ACCESS_OP_READ_DSC: if (conn_handle != BLE_HS_CONN_HANDLE_NONE) { MODLOG_DFLT(INFO, "Descriptor read; conn_handle=%d attr_handle=%d\n", conn_handle, attr_handle); } else { MODLOG_DFLT(INFO, "Descriptor read by NimBLE stack; attr_handle=%d\n", attr_handle); } uuid = ctxt->dsc->uuid; if (ble_uuid_cmp(uuid, &gatt_svr_dsc_uuid.u) == 0) { rc = os_mbuf_append(ctxt->om, &gatt_svr_dsc_val, sizeof(gatt_svr_chr_val)); return rc == 0 ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES; } goto unknown; case BLE_GATT_ACCESS_OP_WRITE_DSC: goto unknown; default: goto unknown; } unknown: /* Unknown characteristic/descriptor; * The NimBLE host should not have called this function; */ assert(0); return BLE_ATT_ERR_UNLIKELY; } void gatt_svr_register_cb(struct ble_gatt_register_ctxt *ctxt, void *arg) { char buf[BLE_UUID_STR_LEN]; switch (ctxt->op) { case BLE_GATT_REGISTER_OP_SVC: MODLOG_DFLT(DEBUG, "registered service %s with handle=%d\n", ble_uuid_to_str(ctxt->svc.svc_def->uuid, buf), ctxt->svc.handle); break; case BLE_GATT_REGISTER_OP_CHR: MODLOG_DFLT(DEBUG, "registering characteristic %s with " "def_handle=%d val_handle=%d\n", ble_uuid_to_str(ctxt->chr.chr_def->uuid, buf), ctxt->chr.def_handle, ctxt->chr.val_handle); break; case BLE_GATT_REGISTER_OP_DSC: MODLOG_DFLT(DEBUG, "registering descriptor %s with handle=%d\n", ble_uuid_to_str(ctxt->dsc.dsc_def->uuid, buf), ctxt->dsc.handle); break; default: assert(0); break; } } /* Adds custom service *@params *operation : uint8_t (1 for add and 0 for delete) *gatt_svr_svcs : struct ble_gatt_svc_def (NULL if operation is delete, else pass the services) *uuid : const ble_uuid_t * (NULL if operation is add, else pass the uuid of the service to be deleted) */ int dynamic_service(const uint8_t operation, const struct ble_gatt_svc_def *svcs, const ble_uuid_t *uuid) { int rc = 0; int i = 0; switch(operation) { case 1: /* add services in gatt_svr_svcs */ if(svcs == NULL) { /* don't add anything gatt_svr_svcs is NULL */ MODLOG_DFLT(ERROR, "No services to add\n"); return ESP_FAIL; } rc = ble_gatts_add_dynamic_svcs(svcs); return rc; break; case 0: /* delete service by uuid*/ if(uuid == NULL) { MODLOG_DFLT(ERROR, "No service to delete\n"); return ESP_FAIL; } rc = ble_gatts_delete_svc(uuid); if(rc != 0) { /* not able to delete service return immidietely */ return rc; } i++; return rc; break; } return rc; } int gatt_svr_init(void) { ble_svc_gap_init(); ble_svc_gatt_init(); ble_svc_ans_init(); /* Setting a value for the read-only descriptor */ gatt_svr_dsc_val = 0x99; return 0; }