/* * 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 #include #include //#include "os/mynewt.h" #include "host/ble_hs.h" //#include "mgmt/mgmt.h" #include "smp/smp.h" #include "app_smp/smp.h" extern struct ble_npl_eventq * smp_get_dflt_eventq(void); /** * \addtogroup SMP * @{ */ /* smp ble mqueue */ struct os_mqueue g_smp_ble_mq; /* ble smp transport */ struct smp_transport g_smp_ble_transport; /* ble smp attr handle */ uint16_t g_ble_smp_attr_handle; /** * The vendor specific "smp" service consists of one write no-rsp * characteristic for smp requests: a single-byte characteristic that can * only accepts write-without-response commands. The contents of each write * command contains an NMP request. NMP responses are sent back in the form of * unsolicited notifications from the same characteristic. */ /* {8D53DC1D-1DB7-4CD3-868B-8A527460AA84} */ static const ble_uuid128_t gatt_svr_svc_smp = BLE_UUID128_INIT(0x84, 0xaa, 0x60, 0x74, 0x52, 0x8a, 0x8b, 0x86, 0xd3, 0x4c, 0xb7, 0x1d, 0x1d, 0xdc, 0x53, 0x8d); /* {DA2E7828-FBCE-4E01-AE9E-261174997C48} */ static const ble_uuid128_t gatt_svr_chr_smp = BLE_UUID128_INIT(0x48, 0x7c, 0x99, 0x74, 0x11, 0x26, 0x9e, 0xae, 0x01, 0x4e, 0xce, 0xfb, 0x28, 0x78, 0x2e, 0xda); static int gatt_svr_chr_access_smp(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg); static const struct ble_gatt_svc_def gatt_svr_svcs[] = { { /* Service: smp */ .type = BLE_GATT_SVC_TYPE_PRIMARY, .uuid = &gatt_svr_svc_smp.u, .characteristics = (struct ble_gatt_chr_def[]) { { /* Characteristic: Write No Rsp */ .uuid = &gatt_svr_chr_smp.u, .access_cb = gatt_svr_chr_access_smp, .flags = BLE_GATT_CHR_F_WRITE_NO_RSP | BLE_GATT_CHR_F_NOTIFY, .val_handle = &g_ble_smp_attr_handle, }, { 0, /* No more characteristics in this service */ } }, }, { 0, /* No more services */ }, }; static int gatt_svr_chr_access_smp(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg) { int rc; struct os_mbuf *m_req; switch (ctxt->op) { case BLE_GATT_ACCESS_OP_WRITE_CHR: /* Try to reuse the BLE packet mbuf as the smp request. This * requires a two-byte usrhdr to hold the BLE connection handle so * that the smp response can be sent to the correct peer. If * it is not possible to reuse the mbuf, then allocate a new one * and copy the request contents. */ if (OS_MBUF_USRHDR_LEN(ctxt->om) >= sizeof (conn_handle)) { /* Sufficient usrhdr space already present. */ m_req = ctxt->om; ctxt->om = NULL; } else if (OS_MBUF_LEADINGSPACE(ctxt->om) >= sizeof (conn_handle)) { /* Usrhdr isn't present, but there is enough leading space to * add one. */ m_req = ctxt->om; ctxt->om = NULL; m_req->om_pkthdr_len += sizeof (conn_handle); } else { /* The mbuf can't be reused. Allocate a new one and perform a * copy. Don't set ctxt->om to NULL; let the NimBLE host free * it. */ m_req = os_msys_get_pkthdr(OS_MBUF_PKTLEN(ctxt->om), sizeof (conn_handle)); if (!m_req) { return BLE_ATT_ERR_INSUFFICIENT_RES; } rc = os_mbuf_appendfrom(m_req, ctxt->om, 0, OS_MBUF_PKTLEN(ctxt->om)); if (rc) { return BLE_ATT_ERR_INSUFFICIENT_RES; } } /* Write the connection handle to the smp request usrhdr. This * is necessary so that we later know who to send the smp * response to. */ memcpy(OS_MBUF_USRHDR(m_req), &conn_handle, sizeof(conn_handle)); rc = smp_rx_req(&g_smp_ble_transport, m_req); if (rc) { return BLE_ATT_ERR_UNLIKELY; } return 0; default: assert(0); return BLE_ATT_ERR_UNLIKELY; } } uint16_t smp_ble_get_mtu(struct os_mbuf *req) { uint16_t conn_handle; uint16_t mtu; memcpy(&conn_handle, OS_MBUF_USRHDR(req), sizeof (conn_handle)); mtu = ble_att_mtu(conn_handle); if (!mtu) { /* No longer connected. */ return 0; } /* 3 is the number of bytes for ATT notification base */ mtu = mtu - 3; return (mtu); } /** * SMP ble process mqueue event * Gets an event from the smp mqueue and does a notify with the response * * @param eventq * @return 0 on success; non-zero on failure */ static void smp_ble_event_data_in(struct ble_npl_event *ev) { struct os_mbuf *m_resp; uint16_t conn_handle; while ((m_resp = os_mqueue_get(&g_smp_ble_mq)) != NULL) { assert(OS_MBUF_USRHDR_LEN(m_resp) >= sizeof (conn_handle)); memcpy(&conn_handle, OS_MBUF_USRHDR(m_resp), sizeof (conn_handle)); ble_gattc_notify_custom(conn_handle, g_ble_smp_attr_handle, m_resp); } } static int smp_ble_out(struct os_mbuf *om) { int rc; rc = os_mqueue_put(&g_smp_ble_mq, smp_get_dflt_eventq(), om); if (rc != 0) { goto err; } return 0; err: os_mbuf_free_chain(om); return rc; } /** * SMP ble GATT server initialization * * @param eventq * @return 0 on success; non-zero on failure */ int smp_ble_gatt_svr_init(void) { int rc; rc = ble_gatts_count_cfg(gatt_svr_svcs); if (rc != 0) { goto err; } rc = ble_gatts_add_svcs(gatt_svr_svcs); if (rc != 0) { return rc; } os_mqueue_init(&g_smp_ble_mq, &smp_ble_event_data_in, NULL); rc = smp_transport_init(&g_smp_ble_transport, smp_ble_out, smp_ble_get_mtu); err: return rc; } void smp_ble_pkg_init(void) { int rc; rc = smp_ble_gatt_svr_init(); assert(rc == 0); } /** * @} SMP */