| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| #include <assert.h> |
| #include <string.h> |
| #include <stdint.h> |
| |
| #include "os/mynewt.h" |
| |
| #if (MYNEWT_VAL(OC_TRANSPORT_GATT) == 1) |
| |
| #include <stats/stats.h> |
| #include "oic/oc_gatt.h" |
| #include "oic/oc_log.h" |
| #include "oic/oc_ri.h" |
| #include "oic/messaging/coap/coap.h" |
| #include "oic/port/oc_connectivity.h" |
| #include "oic/port/mynewt/ble.h" |
| #include "host/ble_hs.h" |
| #include "services/gap/ble_svc_gap.h" |
| #include "services/gatt/ble_svc_gatt.h" |
| |
| static uint8_t oc_ep_gatt_size(const struct oc_endpoint *oe); |
| static void oc_send_buffer_gatt(struct os_mbuf *m); |
| static char *oc_log_ep_gatt(char *ptr, int maxlen, const struct oc_endpoint *); |
| enum oc_resource_properties |
| oc_get_trans_security_gatt(const struct oc_endpoint *oe_ble); |
| static int oc_connectivity_init_gatt(void); |
| void oc_connectivity_shutdown_gatt(void); |
| |
| static const struct oc_transport oc_gatt_transport = { |
| .ot_flags = OC_TRANSPORT_USE_TCP, |
| .ot_ep_size = oc_ep_gatt_size, |
| .ot_tx_ucast = oc_send_buffer_gatt, |
| .ot_tx_mcast = oc_send_buffer_gatt, |
| .ot_get_trans_security = oc_get_trans_security_gatt, |
| .ot_ep_str = oc_log_ep_gatt, |
| .ot_init = oc_connectivity_init_gatt, |
| .ot_shutdown = oc_connectivity_shutdown_gatt |
| }; |
| |
| static uint8_t oc_gatt_transport_id; |
| |
| /* OIC Transport Profile GATT */ |
| |
| /* unsecure service UUID */ |
| /* ADE3D529-C784-4F63-A987-EB69F70EE816 */ |
| static const ble_uuid128_t oc_gatt_unsec_svc_uuid = |
| BLE_UUID128_INIT(OC_GATT_UNSEC_SVC_UUID); |
| |
| /* unsecure request characteristic UUID */ |
| /* AD7B334F-4637-4B86-90B6-9D787F03D218 */ |
| static const ble_uuid128_t oc_gatt_unsec_req_chr_uuid = |
| BLE_UUID128_INIT(OC_GATT_UNSEC_REQ_CHR_UUID); |
| |
| /* response characteristic UUID */ |
| /* E9241982-4580-42C4-8831-95048216B256 */ |
| static const ble_uuid128_t oc_gatt_unsec_rsp_chr_uuid = |
| BLE_UUID128_INIT(OC_GATT_UNSEC_RSP_CHR_UUID); |
| |
| /* secure service UUID. */ |
| /* 0xfe18 */ |
| static const ble_uuid16_t oc_gatt_sec_svc_uuid = |
| BLE_UUID16_INIT(OC_GATT_SEC_SVC_UUID); |
| |
| /* secure request characteristic UUID. */ |
| /* 0x1000 */ |
| static const ble_uuid16_t oc_gatt_sec_req_chr_uuid = |
| BLE_UUID16_INIT(OC_GATT_SEC_REQ_CHR_UUID); |
| |
| /* secure response characteristic UUID. */ |
| /* 0x1001 */ |
| static const ble_uuid16_t oc_gatt_sec_rsp_chr_uuid = |
| BLE_UUID16_INIT(OC_GATT_SEC_RSP_CHR_UUID); |
| |
| STATS_SECT_START(oc_ble_stats) |
| STATS_SECT_ENTRY(iframe) |
| STATS_SECT_ENTRY(iseg) |
| STATS_SECT_ENTRY(ibytes) |
| STATS_SECT_ENTRY(ierr) |
| STATS_SECT_ENTRY(oframe) |
| STATS_SECT_ENTRY(oseg) |
| STATS_SECT_ENTRY(obytes) |
| STATS_SECT_ENTRY(oerr) |
| STATS_SECT_END |
| STATS_SECT_DECL(oc_ble_stats) oc_ble_stats; |
| STATS_NAME_START(oc_ble_stats) |
| STATS_NAME(oc_ble_stats, iframe) |
| STATS_NAME(oc_ble_stats, iseg) |
| STATS_NAME(oc_ble_stats, ibytes) |
| STATS_NAME(oc_ble_stats, ierr) |
| STATS_NAME(oc_ble_stats, oframe) |
| STATS_NAME(oc_ble_stats, oseg) |
| STATS_NAME(oc_ble_stats, obytes) |
| STATS_NAME(oc_ble_stats, oerr) |
| STATS_NAME_END(oc_ble_stats) |
| |
| static STAILQ_HEAD(, os_mbuf_pkthdr) oc_ble_reass_q; |
| |
| #if (MYNEWT_VAL(OC_SERVER) == 1) |
| /* |
| * BLE nmgr attribute handles for service |
| */ |
| #define OC_BLE_SRV_CNT 2 |
| static struct { |
| uint16_t req; |
| uint16_t rsp; |
| } oc_ble_srv_handles[OC_BLE_SRV_CNT]; |
| |
| static int oc_gatt_chr_access(uint16_t conn_handle, uint16_t attr_handle, |
| struct ble_gatt_access_ctxt *ctxt, void *arg); |
| |
| static const struct ble_gatt_svc_def oc_gatt_svr_svcs[] = { { |
| /* Service: iotivity */ |
| .type = BLE_GATT_SVC_TYPE_PRIMARY, |
| .uuid = &oc_gatt_unsec_svc_uuid.u, |
| .characteristics = (struct ble_gatt_chr_def[]) { |
| { |
| /* Characteristic: Request */ |
| .uuid = &oc_gatt_unsec_req_chr_uuid.u, |
| .access_cb = oc_gatt_chr_access, |
| .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_WRITE_NO_RSP, |
| .val_handle = &oc_ble_srv_handles[0].req, |
| },{ |
| /* Characteristic: Response */ |
| .uuid = &oc_gatt_unsec_rsp_chr_uuid.u, |
| .access_cb = oc_gatt_chr_access, |
| .flags = BLE_GATT_CHR_F_NOTIFY, |
| .val_handle = &oc_ble_srv_handles[0].rsp, |
| },{ |
| 0, /* No more characteristics in this service */ |
| } |
| }, |
| },{ |
| /* Service: CoAP-over-BLE */ |
| .type = BLE_GATT_SVC_TYPE_PRIMARY, |
| .uuid = &oc_gatt_sec_svc_uuid.u, |
| .characteristics = (struct ble_gatt_chr_def[]) { |
| { |
| /* Characteristic: Request */ |
| .uuid = &oc_gatt_sec_req_chr_uuid.u, |
| .access_cb = oc_gatt_chr_access, |
| .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_WRITE_NO_RSP, |
| .val_handle = &oc_ble_srv_handles[1].req, |
| },{ |
| /* Characteristic: Response */ |
| .uuid = &oc_gatt_sec_rsp_chr_uuid.u, |
| .access_cb = oc_gatt_chr_access, |
| .flags = BLE_GATT_CHR_F_NOTIFY, |
| .val_handle = &oc_ble_srv_handles[1].rsp, |
| },{ |
| 0, /* No more characteristics in this service */ |
| } |
| }, |
| }, |
| { |
| 0, /* No more services */ |
| }, |
| }; |
| |
| /* |
| * Look up service index based on characteristic handle from request. |
| */ |
| static int |
| oc_ble_req_attr_to_idx(uint16_t attr_handle) |
| { |
| int i; |
| |
| for (i = 0; i < OC_BLE_SRV_CNT; i++) { |
| if (oc_ble_srv_handles[i].req == attr_handle) { |
| return i; |
| } |
| } |
| return -1; |
| } |
| |
| static uint8_t |
| oc_ep_gatt_size(const struct oc_endpoint *oe) |
| { |
| return sizeof(struct oc_endpoint_ble); |
| } |
| |
| static char * |
| oc_log_ep_gatt(char *ptr, int maxlen, const struct oc_endpoint *oe) |
| { |
| struct oc_endpoint_ble *oe_ble = (struct oc_endpoint_ble *)oe; |
| |
| snprintf(ptr, maxlen, "ble %u", oe_ble->conn_handle); |
| return ptr; |
| } |
| |
| int |
| oc_ble_reass(struct os_mbuf *om1, uint16_t conn_handle, uint8_t srv_idx) |
| { |
| struct os_mbuf_pkthdr *pkt1; |
| struct oc_endpoint_ble *oe_ble; |
| struct os_mbuf *om2; |
| struct os_mbuf_pkthdr *pkt2; |
| uint8_t hdr[6]; /* sizeof(coap_tcp_hdr32) */ |
| |
| pkt1 = OS_MBUF_PKTHDR(om1); |
| assert(pkt1); |
| |
| STATS_INC(oc_ble_stats, iseg); |
| STATS_INCN(oc_ble_stats, ibytes, pkt1->omp_len); |
| |
| OC_LOG(DEBUG, "oc_gatt rx seg %u-%x-%u\n", conn_handle, |
| (unsigned)pkt1, pkt1->omp_len); |
| |
| STAILQ_FOREACH(pkt2, &oc_ble_reass_q, omp_next) { |
| om2 = OS_MBUF_PKTHDR_TO_MBUF(pkt2); |
| oe_ble = (struct oc_endpoint_ble *)OC_MBUF_ENDPOINT(om2); |
| if (conn_handle == oe_ble->conn_handle && srv_idx == oe_ble->srv_idx) { |
| /* |
| * Data from same connection. Append. |
| */ |
| os_mbuf_concat(om2, om1); |
| os_mbuf_copydata(om2, 0, sizeof(hdr), hdr); |
| |
| if (coap_tcp_msg_size(hdr, sizeof(hdr)) <= pkt2->omp_len) { |
| STAILQ_REMOVE(&oc_ble_reass_q, pkt2, os_mbuf_pkthdr, omp_next); |
| STATS_INC(oc_ble_stats, iframe); |
| oc_recv_message(om2); |
| } |
| pkt1 = NULL; |
| break; |
| } |
| } |
| if (pkt1) { |
| /* |
| * New frame, need to add oc_endpoint_ble in the front. |
| * Check if there is enough space available. If not, allocate a |
| * new pkthdr. |
| */ |
| if (OS_MBUF_USRHDR_LEN(om1) < sizeof(struct oc_endpoint_ble)) { |
| om2 = os_msys_get_pkthdr(0, sizeof(struct oc_endpoint_ble)); |
| if (!om2) { |
| OC_LOG(ERROR, "oc_gatt_rx: Could not allocate mbuf\n"); |
| STATS_INC(oc_ble_stats, ierr); |
| return -1; |
| } |
| OS_MBUF_PKTHDR(om2)->omp_len = pkt1->omp_len; |
| SLIST_NEXT(om2, om_next) = om1; |
| } else { |
| om2 = om1; |
| } |
| oe_ble = (struct oc_endpoint_ble *)OC_MBUF_ENDPOINT(om2); |
| oe_ble->ep.oe_type = oc_gatt_transport_id; |
| oe_ble->ep.oe_flags = 0; |
| oe_ble->srv_idx = srv_idx; |
| oe_ble->conn_handle = conn_handle; |
| pkt2 = OS_MBUF_PKTHDR(om2); |
| |
| os_mbuf_copydata(om2, 0, sizeof(hdr), hdr); |
| if (coap_tcp_msg_size(hdr, sizeof(hdr)) > pkt2->omp_len) { |
| STAILQ_INSERT_TAIL(&oc_ble_reass_q, pkt2, omp_next); |
| } else { |
| STATS_INC(oc_ble_stats, iframe); |
| oc_recv_message(om2); |
| } |
| } |
| return 0; |
| } |
| |
| static int |
| oc_gatt_chr_access(uint16_t conn_handle, uint16_t attr_handle, |
| struct ble_gatt_access_ctxt *ctxt, void *arg) |
| { |
| struct os_mbuf *m; |
| int rc; |
| int srv_idx; |
| |
| switch (ctxt->op) { |
| case BLE_GATT_ACCESS_OP_WRITE_CHR: |
| m = ctxt->om; |
| |
| srv_idx = oc_ble_req_attr_to_idx(attr_handle); |
| assert(srv_idx >= 0); |
| rc = oc_ble_reass(m, conn_handle, srv_idx); |
| if (rc) { |
| return BLE_ATT_ERR_INSUFFICIENT_RES; |
| } |
| |
| /* tell nimble we are keeping the mbuf */ |
| ctxt->om = NULL; |
| |
| break; |
| default: |
| assert(0); |
| return BLE_ATT_ERR_UNLIKELY; |
| } |
| return 0; |
| } |
| #endif |
| |
| int |
| oc_ble_coap_gatt_srv_init(void) |
| { |
| #if (MYNEWT_VAL(OC_SERVER) == 1) |
| int rc; |
| |
| rc = ble_gatts_count_cfg(oc_gatt_svr_svcs); |
| assert(rc == 0); |
| |
| rc = ble_gatts_add_svcs(oc_gatt_svr_svcs); |
| assert(rc == 0); |
| #endif |
| (void)stats_init_and_reg(STATS_HDR(oc_ble_stats), |
| STATS_SIZE_INIT_PARMS(oc_ble_stats, STATS_SIZE_32), |
| STATS_NAME_INIT_PARMS(oc_ble_stats), "oc_ble"); |
| return 0; |
| } |
| |
| void |
| oc_ble_coap_conn_new(uint16_t conn_handle) |
| { |
| OC_LOG(DEBUG, "oc_gatt newconn %x\n", conn_handle); |
| } |
| |
| void |
| oc_ble_coap_conn_del(uint16_t conn_handle) |
| { |
| struct os_mbuf_pkthdr *pkt; |
| struct os_mbuf *m; |
| struct oc_endpoint_ble *oe_ble; |
| |
| OC_LOG(DEBUG, "oc_gatt endconn %x\n", conn_handle); |
| STAILQ_FOREACH(pkt, &oc_ble_reass_q, omp_next) { |
| m = OS_MBUF_PKTHDR_TO_MBUF(pkt); |
| oe_ble = (struct oc_endpoint_ble *)OC_MBUF_ENDPOINT(m); |
| if (oe_ble->conn_handle == conn_handle) { |
| STAILQ_REMOVE(&oc_ble_reass_q, pkt, os_mbuf_pkthdr, omp_next); |
| os_mbuf_free_chain(m); |
| break; |
| } |
| } |
| } |
| |
| int |
| oc_connectivity_init_gatt(void) |
| { |
| STAILQ_INIT(&oc_ble_reass_q); |
| return 0; |
| } |
| |
| void |
| oc_connectivity_shutdown_gatt(void) |
| { |
| /* there is not unregister for BLE */ |
| } |
| |
| #if (MYNEWT_VAL(OC_SERVER) == 1) |
| static int |
| oc_ble_frag(struct os_mbuf *m, uint16_t mtu) |
| { |
| struct os_mbuf_pkthdr *pkt; |
| struct os_mbuf *n; |
| uint16_t off, blk; |
| |
| pkt = OS_MBUF_PKTHDR(m); |
| if (pkt->omp_len <= mtu) { |
| STAILQ_NEXT(pkt, omp_next) = NULL; |
| return 0; |
| } |
| |
| off = pkt->omp_len - (pkt->omp_len % mtu); |
| while (off >= mtu) { |
| n = os_msys_get_pkthdr(mtu, 0); |
| if (!n) { |
| goto err; |
| } |
| STAILQ_NEXT(OS_MBUF_PKTHDR(n), omp_next) = STAILQ_NEXT(pkt, omp_next); |
| STAILQ_NEXT(pkt, omp_next) = OS_MBUF_PKTHDR(n); |
| |
| blk = pkt->omp_len - off; |
| if (os_mbuf_appendfrom(n, m, off, blk)) { |
| goto err; |
| } |
| off -= mtu; |
| os_mbuf_adj(m, -blk); |
| } |
| return 0; |
| err: |
| pkt = OS_MBUF_PKTHDR(m); |
| while (1) { |
| pkt = STAILQ_NEXT(pkt, omp_next); |
| os_mbuf_free_chain(m); |
| if (!pkt) { |
| break; |
| } |
| m = OS_MBUF_PKTHDR_TO_MBUF(pkt); |
| }; |
| return -1; |
| } |
| #endif |
| |
| void |
| oc_send_buffer_gatt(struct os_mbuf *m) |
| { |
| #if (MYNEWT_VAL(OC_SERVER) == 1) |
| struct oc_endpoint_ble *oe_ble; |
| struct os_mbuf_pkthdr *pkt; |
| uint16_t mtu; |
| uint16_t conn_handle; |
| uint16_t attr_handle; |
| #endif |
| |
| #if (MYNEWT_VAL(OC_SERVER) == 1) |
| |
| assert(OS_MBUF_USRHDR_LEN(m) >= sizeof(struct oc_endpoint_ble)); |
| oe_ble = (struct oc_endpoint_ble *)OC_MBUF_ENDPOINT(m); |
| conn_handle = oe_ble->conn_handle; |
| |
| STATS_INC(oc_ble_stats, oframe); |
| STATS_INCN(oc_ble_stats, obytes, OS_MBUF_PKTLEN(m)); |
| |
| if (oe_ble->srv_idx >= OC_BLE_SRV_CNT) { |
| goto err; |
| } |
| attr_handle = oc_ble_srv_handles[oe_ble->srv_idx].rsp; |
| |
| mtu = ble_att_mtu(conn_handle); |
| if (mtu < 4) { |
| oc_ble_coap_conn_del(conn_handle); |
| goto err; |
| } |
| mtu -= 3; /* # of bytes for ATT notification base */ |
| |
| if (oc_ble_frag(m, mtu)) { |
| STATS_INC(oc_ble_stats, oerr); |
| return; |
| } |
| while (1) { |
| STATS_INC(oc_ble_stats, oseg); |
| pkt = STAILQ_NEXT(OS_MBUF_PKTHDR(m), omp_next); |
| |
| ble_gattc_notify_custom(conn_handle, attr_handle, m); |
| if (pkt) { |
| m = OS_MBUF_PKTHDR_TO_MBUF(pkt); |
| } else { |
| break; |
| } |
| } |
| return; |
| |
| err: |
| os_mbuf_free_chain(m); |
| STATS_INC(oc_ble_stats, oerr); |
| #endif |
| } |
| |
| /** |
| * Retrieves the specified BLE endpoint's transport layer security properties. |
| */ |
| oc_resource_properties_t |
| oc_get_trans_security_gatt(const struct oc_endpoint *oe) |
| { |
| const struct oc_endpoint_ble *oe_ble; |
| oc_resource_properties_t props; |
| struct ble_gap_conn_desc desc; |
| int rc; |
| |
| oe_ble = (const struct oc_endpoint_ble *)oe; |
| rc = ble_gap_conn_find(oe_ble->conn_handle, &desc); |
| if (rc != 0) { |
| return 0; |
| } |
| |
| props = 0; |
| if (desc.sec_state.encrypted) { |
| props |= OC_TRANS_ENC; |
| } |
| if (desc.sec_state.authenticated) { |
| props |= OC_TRANS_AUTH; |
| } |
| |
| return props; |
| } |
| |
| #endif |
| |
| void |
| oc_register_gatt(void) |
| { |
| #if (MYNEWT_VAL(OC_TRANSPORT_GATT) == 1) |
| oc_gatt_transport_id = oc_transport_register(&oc_gatt_transport); |
| #endif |
| } |
