nimble/host: add gatts method for async authorization

This method can be used for asynchronous authorization.
It can be used by application to trigger access callback of characteristic
and send ATT response, in case where ble_att_svr_rx_foo returns with
BLE_HS_EPENDING without triggering att response.
Move ble_att_svr_tx_rsp and ble_att_svr_build_write_rsp declaration to
ble_att_priv.h

Author: piotrnarajowski

nimble/host/include/host/ble_gatt.h

@@ -1214,6 +1214,24 @@ int ble_gatts_start(void);
  */
 int ble_gatts_peer_cl_sup_feat_get(uint16_t conn_handle, uint8_t *out_supported_feat, uint8_t len);
 
+/**
+ * Handles authorization of pending ATT request. If the specified attribute
+ * handle is found on pending_attr_list, the operation is performed by calling
+ * the registered access callback and ATT response is issued.
+ *
+ * @param conn_handle           The connection over which to authorize a
+ *                                  pending ATT procedure
+ * @param attr_handle           The Handle of characteristic to perform att
+ *                                   procedure on.
+ * @param authorize             Whether to authorize a procedure
+ *
+ * @return                      0 on success;
+ *                              BLE_HS_EAUTHOR if no matching attribute is
+ *                              found on pending_attr_list.
+ */
+int ble_gatts_pending_req_auth(uint16_t conn_handle, uint16_t attr_handle,
+                               int authorize);
+
 #ifdef __cplusplus
 }
 #endif

nimble/host/src/ble_att_priv.h

@@ -131,7 +131,8 @@ struct pending_attr {
     struct ble_att_svr_entry *entry;
     uint16_t offset;
     struct os_mbuf *om;
-    uint16_t opcode;
+    uint16_t access_opcode;
+    uint8_t att_opcode;
 };
 
 SLIST_HEAD(pending_attr_list_head, pending_attr);
@@ -238,6 +239,15 @@ void ble_att_svr_restore_range(uint16_t start_handle, uint16_t end_handle);
 int ble_att_svr_tx_error_rsp(uint16_t conn_handle, uint16_t cid, struct os_mbuf *txom,
                              uint8_t req_op, uint16_t handle,
                              uint8_t error_code);
+
+int ble_att_svr_tx_rsp(uint16_t conn_handle, uint16_t cid, int hs_status,
+                       struct os_mbuf *om, uint8_t att_op,
+                       uint8_t err_status, uint16_t err_handle);
+int ble_att_svr_build_write_rsp(struct os_mbuf **rxom,
+                                struct os_mbuf**out_txom, uint8_t *att_err);
+int ble_att_svr_insert_prep_entry(uint16_t conn_handle, uint16_t handle,
+                                  uint16_t offset, const struct os_mbuf *rxom,
+                                  uint8_t *out_att_err);
 /*** $clt */
 
 /** An information-data entry in a find information response. */

nimble/host/src/ble_gatts.c

@@ -2034,6 +2034,98 @@ ble_gatts_find_dsc(const ble_uuid_t *svc_uuid, const ble_uuid_t *chr_uuid,
     }
 }
 
+int ble_gatts_pending_req_auth(uint16_t conn_handle, uint16_t attr_handle,
+                               int authorize)
+{
+    struct pending_attr *attr;
+    struct pending_attr *pend_attr;
+    ble_att_svr_access_fn *access_cb;
+    int rc;
+    uint8_t att_err = 0;
+    struct os_mbuf *txom;
+    struct ble_att_prep_write_cmd *req;
+
+    /* Silence warnings */
+    rc = 0;
+    pend_attr = NULL;
+    txom = NULL;
+
+    ble_hs_lock();
+    SLIST_FOREACH(attr, &pending_attr_list, next) {
+        if (attr->conn_handle == conn_handle &&
+            attr->entry->ha_handle_id == attr_handle) {
+            pend_attr = attr;
+            SLIST_REMOVE(&pending_attr_list, attr, pending_attr, next);
+        }
+    }
+    ble_hs_unlock();
+
+    if (!pend_attr) {
+        /* No matching attribute was found on pending_attr_list */
+        return BLE_HS_ENOENT;
+    }
+
+    if (pend_attr->att_opcode == BLE_ATT_OP_WRITE_REQ) {
+        rc = ble_att_svr_build_write_rsp(&pend_attr->om, &txom, &att_err);
+        if (rc != 0) {
+            goto done;
+        }
+    }
+
+    if (!authorize) {
+        att_err = BLE_ATT_ERR_INSUFFICIENT_AUTHOR;
+        rc = BLE_HS_EAUTHOR;
+        goto done;
+    }
+
+   /* Prepare write request */
+   if (pend_attr->att_opcode == BLE_ATT_OP_PREP_WRITE_REQ) {
+       req = (struct ble_att_prep_write_cmd *)(pend_attr)->om->om_data;
+       ble_hs_lock();
+       rc = ble_att_svr_insert_prep_entry(conn_handle,
+                                          le16toh(req->bapc_handle),
+                                          le16toh(req->bapc_offset),
+                                          pend_attr->om, &att_err);
+       ble_hs_unlock();
+       if (rc != 0) {
+           goto done;
+       }
+//       txom = pend_attr->om;
+//       pend_attr->rxom = NULL;
+       os_mbuf_prepend(pend_attr->om, 1);
+       pend_attr->om->om_data[0] = BLE_ATT_OP_PREP_WRITE_RSP;
+       rc = 0;
+       goto done;
+   }
+
+    if (authorize) {
+        access_cb = pend_attr->entry->ha_cb;
+        rc = access_cb(pend_attr->conn_handle, pend_attr->entry->ha_handle_id,
+                       pend_attr->access_opcode, pend_attr->offset,
+                       &pend_attr->om, pend_attr->entry->ha_cb_arg);
+    }
+
+    if (rc != 0 ) {
+        att_err = rc;
+        rc = BLE_HS_EAPP;
+    }
+
+    if (pend_attr->att_opcode == BLE_ATT_OP_WRITE_REQ) {
+        /* read reuses the request buffer for the response */
+        ble_att_svr_tx_rsp(conn_handle, BLE_L2CAP_CID_ATT, rc, txom,
+                           pend_attr->att_opcode, att_err, attr_handle);
+        return 0;
+    }
+
+    /* TODO: don't use BLE_L2CAP_CID_ATT, find a way to get cid */
+done:
+    /* Write does not reuse request buffer for the response */
+    ble_att_svr_tx_rsp(conn_handle, BLE_L2CAP_CID_ATT, rc, pend_attr->om,
+                       pend_attr->att_opcode, att_err, attr_handle);
+
+    return 0;
+}
+
 int
 ble_gatts_add_svcs(const struct ble_gatt_svc_def *svcs)
 {