nimble/host: Fix ATT Read By Type Response handling

andrzej-kaczmarek · andrzej-kaczmarek · commit 864cf7959e76 · 2025-10-07T11:02:48.000+02:00
ATT_READ_BY_TYPE_RSP handler will extract proc from the proc list and
then call the callback for each handle-value pair in the PDU. However,
this means each time proc is extracted it will be then added to the
tail of the proc list. If there are more than 1 matching procesures on
the list, subsequent extracts when handling *the same PDU* may extract
invalid proc from the list and break the procedure.

This fixes the problem by adding proc back to list at the head instead
of the tail of proc list. This way subsequent iterations of handle-value
pairs handling will extract proper proc as it will be the first matching
on the list.
diff --git a/nimble/host/src/ble_att_clt.c b/nimble/host/src/ble_att_clt.c
@@ -431,13 +431,20 @@ ble_att_clt_rx_read_type(uint16_t conn_handle, uint16_t cid, struct os_mbuf **rx
         adata.value_len = data_len - sizeof(*data);
         adata.value = data->value;
 
-        ble_gattc_rx_read_type_adata(conn_handle, cid, &adata);
+        rc = ble_gattc_rx_read_type_adata(conn_handle, cid, &adata);
+        if (rc != 0) {
+            /* We should not call complete callback if this returned an error
+             * since proc is not added to the proc list.
+             */
+            return rc;
+        }
         os_mbuf_adj(*rxom, data_len);
     }
 
 done:
     /* Notify GATT that the response is done being parsed. */
     ble_gattc_rx_read_type_complete(conn_handle, cid, rc);
+
     return rc;
 
 }
diff --git a/nimble/host/src/ble_gatt_priv.h b/nimble/host/src/ble_gatt_priv.h
@@ -119,8 +119,8 @@ void ble_gatts_indicate_fail_notconn(uint16_t conn_handle);
 
 void ble_gattc_rx_err(uint16_t conn_handle, uint16_t cid, uint16_t handle, uint16_t status);
 void ble_gattc_rx_mtu(uint16_t conn_handle, uint16_t cid, int status, uint16_t chan_mtu);
-void ble_gattc_rx_read_type_adata(uint16_t conn_handle, uint16_t cid,
-                                  struct ble_att_read_type_adata *adata);
+int ble_gattc_rx_read_type_adata(uint16_t conn_handle, uint16_t cid,
+                                 struct ble_att_read_type_adata *adata);
 void ble_gattc_rx_read_type_complete(uint16_t conn_handle, uint16_t cid, int status);
 void ble_gattc_rx_read_rsp(uint16_t conn_handle, uint16_t cid, int status,
                            struct os_mbuf **rxom);
diff --git a/nimble/host/src/ble_gattc.c b/nimble/host/src/ble_gattc.c
@@ -754,12 +754,16 @@ ble_gattc_proc_free(struct ble_gattc_proc *proc)
 }
 
 static void
-ble_gattc_proc_insert(struct ble_gattc_proc *proc)
+ble_gattc_proc_insert(struct ble_gattc_proc *proc, bool insert_head)
 {
     ble_gattc_dbg_assert_proc_not_inserted(proc);
 
     ble_hs_lock();
-    STAILQ_INSERT_TAIL(&ble_gattc_procs, proc, next);
+    if (insert_head) {
+        STAILQ_INSERT_HEAD(&ble_gattc_procs, proc, next);
+    } else {
+        STAILQ_INSERT_TAIL(&ble_gattc_procs, proc, next);
+    }
     ble_hs_unlock();
 }
 
@@ -790,15 +794,15 @@ ble_gattc_proc_set_resume_timer(struct ble_gattc_proc *proc)
 }
 
 static void
-ble_gattc_process_status(struct ble_gattc_proc *proc, int status)
+ble_gattc_process_status(struct ble_gattc_proc *proc, int status, bool insert_head)
 {
     switch (status) {
     case 0:
         if (!(proc->flags & BLE_GATTC_PROC_F_STALLED)) {
             ble_gattc_proc_set_exp_timer(proc);
         }
 
-        ble_gattc_proc_insert(proc);
+        ble_gattc_proc_insert(proc, insert_head);
         ble_hs_timer_resched();
         break;
 
@@ -1187,7 +1191,7 @@ ble_gattc_resume_procs(void)
 
         proc->flags &= ~BLE_GATTC_PROC_F_STALLED;
         rc = resume_cb(proc);
-        ble_gattc_process_status(proc, rc);
+        ble_gattc_process_status(proc, rc, false);
     }
 }
 
@@ -1398,7 +1402,7 @@ ble_gattc_exchange_mtu(uint16_t conn_handle, ble_gatt_mtu_fn *cb, void *cb_arg)
         STATS_INC(ble_gattc_stats, mtu_fail);
     }
 
-    ble_gattc_process_status(proc, rc);
+    ble_gattc_process_status(proc, rc, false);
     return rc;
 }
 
@@ -1623,7 +1627,7 @@ ble_gattc_disc_all_svcs(uint16_t conn_handle, ble_gatt_disc_svc_fn *cb,
         STATS_INC(ble_gattc_stats, disc_all_svcs_fail);
     }
 
-    ble_gattc_process_status(proc, rc);
+    ble_gattc_process_status(proc, rc, false);
     return rc;
 }
 
@@ -1837,7 +1841,7 @@ ble_gattc_disc_svc_by_uuid(uint16_t conn_handle, const ble_uuid_t *uuid,
         STATS_INC(ble_gattc_stats, disc_svc_uuid_fail);
     }
 
-    ble_gattc_process_status(proc, rc);
+    ble_gattc_process_status(proc, rc, false);
     return rc;
 }
 
@@ -2153,7 +2157,7 @@ ble_gattc_find_inc_svcs(uint16_t conn_handle, uint16_t start_handle,
         STATS_INC(ble_gattc_stats, find_inc_svcs_fail);
     }
 
-    ble_gattc_process_status(proc, rc);
+    ble_gattc_process_status(proc, rc, false);
     return rc;
 }
 
@@ -2386,7 +2390,7 @@ ble_gattc_disc_all_chrs(uint16_t conn_handle, uint16_t start_handle,
         STATS_INC(ble_gattc_stats, disc_all_chrs_fail);
     }
 
-    ble_gattc_process_status(proc, rc);
+    ble_gattc_process_status(proc, rc, false);
     return rc;
 }
 
@@ -2626,7 +2630,7 @@ ble_gattc_disc_chrs_by_uuid(uint16_t conn_handle, uint16_t start_handle,
         STATS_INC(ble_gattc_stats, disc_chrs_uuid_fail);
     }
 
-    ble_gattc_process_status(proc, rc);
+    ble_gattc_process_status(proc, rc, false);
     return rc;
 }
 
@@ -2836,7 +2840,7 @@ ble_gattc_disc_all_dscs(uint16_t conn_handle, uint16_t start_handle,
         STATS_INC(ble_gattc_stats, disc_all_dscs_fail);
     }
 
-    ble_gattc_process_status(proc, rc);
+    ble_gattc_process_status(proc, rc, false);
     return rc;
 }
 
@@ -2971,7 +2975,7 @@ ble_gattc_read(uint16_t conn_handle, uint16_t attr_handle,
         STATS_INC(ble_gattc_stats, read_fail);
     }
 
-    ble_gattc_process_status(proc, rc);
+    ble_gattc_process_status(proc, rc, false);
     return rc;
 }
 
@@ -3135,7 +3139,7 @@ ble_gattc_read_by_uuid(uint16_t conn_handle, uint16_t start_handle,
         STATS_INC(ble_gattc_stats, read_uuid_fail);
     }
 
-    ble_gattc_process_status(proc, rc);
+    ble_gattc_process_status(proc, rc, false);
     return rc;
 }
 
@@ -3331,7 +3335,7 @@ ble_gattc_read_long(uint16_t conn_handle, uint16_t handle, uint16_t offset,
         STATS_INC(ble_gattc_stats, read_long_fail);
     }
 
-    ble_gattc_process_status(proc, rc);
+    ble_gattc_process_status(proc, rc, false);
     return rc;
 }
 
@@ -3555,7 +3559,7 @@ ble_gattc_read_mult_internal(uint16_t conn_handle, const uint16_t *handles,
         STATS_INC(ble_gattc_stats, read_mult_fail);
     }
 
-    ble_gattc_process_status(proc, rc);
+    ble_gattc_process_status(proc, rc, false);
     return rc;
 }
 
@@ -3730,7 +3734,7 @@ ble_gattc_write(uint16_t conn_handle, uint16_t attr_handle,
     /* Free the mbuf in case the send failed. */
     os_mbuf_free_chain(txom);
 
-    ble_gattc_process_status(proc, rc);
+    ble_gattc_process_status(proc, rc, false);
     return rc;
 }
 
@@ -4048,7 +4052,7 @@ ble_gattc_write_long(uint16_t conn_handle, uint16_t attr_handle,
     /* Free the mbuf in case of failure. */
     os_mbuf_free_chain(txom);
 
-    ble_gattc_process_status(proc, rc);
+    ble_gattc_process_status(proc, rc, false);
     return rc;
 }
 
@@ -4337,7 +4341,7 @@ ble_gattc_write_reliable(uint16_t conn_handle,
         attrs[i].om = NULL;
     }
 
-    ble_gattc_process_status(proc, rc);
+    ble_gattc_process_status(proc, rc, false);
     return rc;
 }
 
@@ -4709,7 +4713,7 @@ ble_gatts_indicate_custom(uint16_t conn_handle, uint16_t chr_val_handle,
     /* Tell the application that an indication transmission was attempted. */
     ble_gap_notify_tx_event(rc, conn_handle, chr_val_handle, 1);
 
-    ble_gattc_process_status(proc, rc);
+    ble_gattc_process_status(proc, rc, false);
     os_mbuf_free_chain(txom);
     return rc;
 }
@@ -4777,7 +4781,7 @@ ble_gattc_rx_mtu(uint16_t conn_handle, uint16_t cid, int status, uint16_t chan_m
     proc = ble_gattc_extract_first_by_conn_cid_op(conn_handle, BLE_L2CAP_CID_ATT, BLE_GATT_OP_MTU);
     if (proc != NULL) {
         ble_gattc_mtu_cb(proc, status, 0, chan_mtu);
-        ble_gattc_process_status(proc, BLE_HS_EDONE);
+        ble_gattc_process_status(proc, BLE_HS_EDONE, false);
     }
 }
 
@@ -4800,7 +4804,7 @@ ble_gattc_rx_find_info_idata(uint16_t conn_handle, uint16_t cid,
                                               BLE_GATT_OP_DISC_ALL_DSCS);
     if (proc != NULL) {
         rc = ble_gattc_disc_all_dscs_rx_idata(proc, idata);
-        ble_gattc_process_status(proc, rc);
+        ble_gattc_process_status(proc, rc, false);
     }
 }
 
@@ -4822,7 +4826,7 @@ ble_gattc_rx_find_info_complete(uint16_t conn_handle, uint16_t cid, int status)
                                                   BLE_GATT_OP_DISC_ALL_DSCS);
     if (proc != NULL) {
         rc = ble_gattc_disc_all_dscs_rx_complete(proc, status);
-        ble_gattc_process_status(proc, rc);
+        ble_gattc_process_status(proc, rc, false);
     }
 }
 
@@ -4845,7 +4849,7 @@ ble_gattc_rx_find_type_value_hinfo(uint16_t conn_handle, uint16_t cid,
                                               BLE_GATT_OP_DISC_SVC_UUID);
     if (proc != NULL) {
         rc = ble_gattc_disc_svc_uuid_rx_hinfo(proc, hinfo);
-        ble_gattc_process_status(proc, rc);
+        ble_gattc_process_status(proc, rc, false);
     }
 }
 
@@ -4867,15 +4871,15 @@ ble_gattc_rx_find_type_value_complete(uint16_t conn_handle, uint16_t cid, int st
                                                   BLE_GATT_OP_DISC_SVC_UUID);
     if (proc != NULL) {
         rc = ble_gattc_disc_svc_uuid_rx_complete(proc, status);
-        ble_gattc_process_status(proc, rc);
+        ble_gattc_process_status(proc, rc, false);
     }
 }
 
 /**
  * Dispatches an incoming "attribute data" entry from a read-by-type-response
  * to the appropriate active GATT procedure.
  */
-void
+int
 ble_gattc_rx_read_type_adata(uint16_t conn_handle, uint16_t cid,
                              struct ble_att_read_type_adata *adata)
 {
@@ -4892,8 +4896,15 @@ ble_gattc_rx_read_type_adata(uint16_t conn_handle, uint16_t cid,
                                          &rx_entry);
     if (proc != NULL) {
         rc = rx_entry->cb(proc, adata);
-        ble_gattc_process_status(proc, rc);
+        /* We need to put procedure on head of the queue since caller expects
+         * to process the same proc again.
+         */
+        ble_gattc_process_status(proc, rc, true);
+    } else {
+        rc = -1;
     }
+
+    return rc;
 }
 
 /**
@@ -4916,7 +4927,7 @@ ble_gattc_rx_read_type_complete(uint16_t conn_handle, uint16_t cid, int status)
         &rx_entry);
     if (proc != NULL) {
         rc = rx_entry->cb(proc, status);
-        ble_gattc_process_status(proc, rc);
+        ble_gattc_process_status(proc, rc, false);
     }
 }
 
@@ -4939,7 +4950,7 @@ ble_gattc_rx_read_group_type_adata(uint16_t conn_handle, uint16_t cid,
                                               BLE_GATT_OP_DISC_ALL_SVCS);
     if (proc != NULL) {
         rc = ble_gattc_disc_all_svcs_rx_adata(proc, adata);
-        ble_gattc_process_status(proc, rc);
+        ble_gattc_process_status(proc, rc, false);
     }
 }
 
@@ -4961,7 +4972,7 @@ ble_gattc_rx_read_group_type_complete(uint16_t conn_handle, uint16_t cid, int st
                                                   BLE_GATT_OP_DISC_ALL_SVCS);
     if (proc != NULL) {
         rc = ble_gattc_disc_all_svcs_rx_complete(proc, status);
-        ble_gattc_process_status(proc, rc);
+        ble_gattc_process_status(proc, rc, false);
     }
 }
 
@@ -4985,7 +4996,7 @@ ble_gattc_rx_read_rsp(uint16_t conn_handle, uint16_t cid, int status, struct os_
                                          &rx_entry);
     if (proc != NULL) {
         rc = rx_entry->cb(proc, status, om);
-        ble_gattc_process_status(proc, rc);
+        ble_gattc_process_status(proc, rc, false);
     }
 }
 
@@ -5008,7 +5019,7 @@ ble_gattc_rx_read_blob_rsp(uint16_t conn_handle, uint16_t cid, int status,
                                               BLE_GATT_OP_READ_LONG);
     if (proc != NULL) {
         rc = ble_gattc_read_long_rx_read_rsp(proc, status, om);
-        ble_gattc_process_status(proc, rc);
+        ble_gattc_process_status(proc, rc, false);
     }
 }
 
@@ -5032,7 +5043,7 @@ ble_gattc_rx_read_mult_rsp(uint16_t conn_handle, uint16_t cid, int status,
     proc = ble_gattc_extract_first_by_conn_cid_op(conn_handle, cid, op);
     if (proc != NULL) {
         ble_gattc_read_mult_cb(proc, status, 0, om);
-        ble_gattc_process_status(proc, BLE_HS_EDONE);
+        ble_gattc_process_status(proc, BLE_HS_EDONE, false);
     }
 }
 
@@ -5053,7 +5064,7 @@ ble_gattc_rx_write_rsp(uint16_t conn_handle, uint16_t cid)
                                               BLE_GATT_OP_WRITE);
     if (proc != NULL) {
         ble_gattc_write_cb(proc, 0, 0);
-        ble_gattc_process_status(proc, BLE_HS_EDONE);
+        ble_gattc_process_status(proc, BLE_HS_EDONE, false);
     }
 }
 
@@ -5079,7 +5090,7 @@ ble_gattc_rx_prep_write_rsp(uint16_t conn_handle, uint16_t cid, int status,
                                          &rx_entry);
     if (proc != NULL) {
         rc = rx_entry->cb(proc, status, handle, offset, om);
-        ble_gattc_process_status(proc, rc);
+        ble_gattc_process_status(proc, rc, false);
     }
 }
 
@@ -5102,7 +5113,7 @@ ble_gattc_rx_exec_write_rsp(uint16_t conn_handle, uint16_t cid, int status)
                                          ble_gattc_rx_exec_entries, &rx_entry);
     if (proc != NULL) {
         rc = rx_entry->cb(proc, status);
-        ble_gattc_process_status(proc, rc);
+        ble_gattc_process_status(proc, rc, false);
     }
 }
 
@@ -5123,7 +5134,7 @@ ble_gatts_rx_indicate_rsp(uint16_t conn_handle, uint16_t cid)
                                               BLE_GATT_OP_INDICATE);
     if (proc != NULL) {
         ble_gatts_indicate_rx_rsp(proc);
-        ble_gattc_process_status(proc, BLE_HS_EDONE);
+        ble_gattc_process_status(proc, BLE_HS_EDONE, false);
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -754,12 +754,16 @@ ble_gattc_proc_free(struct ble_gattc_proc *proc)`
`754`	`754`	`}`
`755`	`755`
`756`	`756`	`static void`
`757`		`-ble_gattc_proc_insert(struct ble_gattc_proc *proc)`
	`757`	`+ble_gattc_proc_insert(struct ble_gattc_proc *proc, bool insert_head)`
`758`	`758`	`{`
`759`	`759`	`ble_gattc_dbg_assert_proc_not_inserted(proc);`
`760`	`760`
`761`	`761`	`ble_hs_lock();`
`762`		`- STAILQ_INSERT_TAIL(&ble_gattc_procs, proc, next);`
	`762`	`+ if (insert_head) {`
	`763`	`+ STAILQ_INSERT_HEAD(&ble_gattc_procs, proc, next);`
	`764`	`+ } else {`
	`765`	`+ STAILQ_INSERT_TAIL(&ble_gattc_procs, proc, next);`
	`766`	`+ }`
`763`	`767`	`ble_hs_unlock();`
`764`	`768`	`}`
`765`	`769`
`@@ -790,15 +794,15 @@ ble_gattc_proc_set_resume_timer(struct ble_gattc_proc *proc)`
`790`	`794`	`}`
`791`	`795`
`792`	`796`	`static void`
`793`		`-ble_gattc_process_status(struct ble_gattc_proc *proc, int status)`
	`797`	`+ble_gattc_process_status(struct ble_gattc_proc *proc, int status, bool insert_head)`
`794`	`798`	`{`
`795`	`799`	`switch (status) {`
`796`	`800`	`case 0:`
`797`	`801`	`if (!(proc->flags & BLE_GATTC_PROC_F_STALLED)) {`
`798`	`802`	`ble_gattc_proc_set_exp_timer(proc);`
`799`	`803`	`}`
`800`	`804`
`801`		`- ble_gattc_proc_insert(proc);`
	`805`	`+ ble_gattc_proc_insert(proc, insert_head);`
`802`	`806`	`ble_hs_timer_resched();`
`803`	`807`	`break;`
`804`	`808`
`@@ -1187,7 +1191,7 @@ ble_gattc_resume_procs(void)`
`1187`	`1191`
`1188`	`1192`	`proc->flags &= ~BLE_GATTC_PROC_F_STALLED;`
`1189`	`1193`	`rc = resume_cb(proc);`
`1190`		`- ble_gattc_process_status(proc, rc);`
	`1194`	`+ ble_gattc_process_status(proc, rc, false);`
`1191`	`1195`	`}`
`1192`	`1196`	`}`
`1193`	`1197`
`@@ -1398,7 +1402,7 @@ ble_gattc_exchange_mtu(uint16_t conn_handle, ble_gatt_mtu_fn cb, void cb_arg)`
`1398`	`1402`	`STATS_INC(ble_gattc_stats, mtu_fail);`
`1399`	`1403`	`}`
`1400`	`1404`
`1401`		`- ble_gattc_process_status(proc, rc);`
	`1405`	`+ ble_gattc_process_status(proc, rc, false);`
`1402`	`1406`	`return rc;`
`1403`	`1407`	`}`
`1404`	`1408`
`@@ -1623,7 +1627,7 @@ ble_gattc_disc_all_svcs(uint16_t conn_handle, ble_gatt_disc_svc_fn *cb,`
`1623`	`1627`	`STATS_INC(ble_gattc_stats, disc_all_svcs_fail);`
`1624`	`1628`	`}`
`1625`	`1629`
`1626`		`- ble_gattc_process_status(proc, rc);`
	`1630`	`+ ble_gattc_process_status(proc, rc, false);`
`1627`	`1631`	`return rc;`
`1628`	`1632`	`}`
`1629`	`1633`
`@@ -1837,7 +1841,7 @@ ble_gattc_disc_svc_by_uuid(uint16_t conn_handle, const ble_uuid_t *uuid,`
`1837`	`1841`	`STATS_INC(ble_gattc_stats, disc_svc_uuid_fail);`
`1838`	`1842`	`}`
`1839`	`1843`
`1840`		`- ble_gattc_process_status(proc, rc);`
	`1844`	`+ ble_gattc_process_status(proc, rc, false);`
`1841`	`1845`	`return rc;`
`1842`	`1846`	`}`
`1843`	`1847`
`@@ -2153,7 +2157,7 @@ ble_gattc_find_inc_svcs(uint16_t conn_handle, uint16_t start_handle,`
`2153`	`2157`	`STATS_INC(ble_gattc_stats, find_inc_svcs_fail);`
`2154`	`2158`	`}`
`2155`	`2159`
`2156`		`- ble_gattc_process_status(proc, rc);`
	`2160`	`+ ble_gattc_process_status(proc, rc, false);`
`2157`	`2161`	`return rc;`
`2158`	`2162`	`}`
`2159`	`2163`
`@@ -2386,7 +2390,7 @@ ble_gattc_disc_all_chrs(uint16_t conn_handle, uint16_t start_handle,`
`2386`	`2390`	`STATS_INC(ble_gattc_stats, disc_all_chrs_fail);`
`2387`	`2391`	`}`
`2388`	`2392`
`2389`		`- ble_gattc_process_status(proc, rc);`
	`2393`	`+ ble_gattc_process_status(proc, rc, false);`
`2390`	`2394`	`return rc;`
`2391`	`2395`	`}`
`2392`	`2396`
`@@ -2626,7 +2630,7 @@ ble_gattc_disc_chrs_by_uuid(uint16_t conn_handle, uint16_t start_handle,`
`2626`	`2630`	`STATS_INC(ble_gattc_stats, disc_chrs_uuid_fail);`
`2627`	`2631`	`}`
`2628`	`2632`
`2629`		`- ble_gattc_process_status(proc, rc);`
	`2633`	`+ ble_gattc_process_status(proc, rc, false);`
`2630`	`2634`	`return rc;`
`2631`	`2635`	`}`
`2632`	`2636`
`@@ -2836,7 +2840,7 @@ ble_gattc_disc_all_dscs(uint16_t conn_handle, uint16_t start_handle,`
`2836`	`2840`	`STATS_INC(ble_gattc_stats, disc_all_dscs_fail);`
`2837`	`2841`	`}`
`2838`	`2842`
`2839`		`- ble_gattc_process_status(proc, rc);`
	`2843`	`+ ble_gattc_process_status(proc, rc, false);`
`2840`	`2844`	`return rc;`
`2841`	`2845`	`}`
`2842`	`2846`
`@@ -2971,7 +2975,7 @@ ble_gattc_read(uint16_t conn_handle, uint16_t attr_handle,`
`2971`	`2975`	`STATS_INC(ble_gattc_stats, read_fail);`
`2972`	`2976`	`}`
`2973`	`2977`
`2974`		`- ble_gattc_process_status(proc, rc);`
	`2978`	`+ ble_gattc_process_status(proc, rc, false);`
`2975`	`2979`	`return rc;`
`2976`	`2980`	`}`
`2977`	`2981`
`@@ -3135,7 +3139,7 @@ ble_gattc_read_by_uuid(uint16_t conn_handle, uint16_t start_handle,`
`3135`	`3139`	`STATS_INC(ble_gattc_stats, read_uuid_fail);`
`3136`	`3140`	`}`
`3137`	`3141`
`3138`		`- ble_gattc_process_status(proc, rc);`
	`3142`	`+ ble_gattc_process_status(proc, rc, false);`
`3139`	`3143`	`return rc;`
`3140`	`3144`	`}`
`3141`	`3145`
`@@ -3331,7 +3335,7 @@ ble_gattc_read_long(uint16_t conn_handle, uint16_t handle, uint16_t offset,`
`3331`	`3335`	`STATS_INC(ble_gattc_stats, read_long_fail);`
`3332`	`3336`	`}`
`3333`	`3337`
`3334`		`- ble_gattc_process_status(proc, rc);`
	`3338`	`+ ble_gattc_process_status(proc, rc, false);`
`3335`	`3339`	`return rc;`
`3336`	`3340`	`}`
`3337`	`3341`
`@@ -3555,7 +3559,7 @@ ble_gattc_read_mult_internal(uint16_t conn_handle, const uint16_t *handles,`
`3555`	`3559`	`STATS_INC(ble_gattc_stats, read_mult_fail);`
`3556`	`3560`	`}`
`3557`	`3561`
`3558`		`- ble_gattc_process_status(proc, rc);`
	`3562`	`+ ble_gattc_process_status(proc, rc, false);`
`3559`	`3563`	`return rc;`
`3560`	`3564`	`}`
`3561`	`3565`
`@@ -3730,7 +3734,7 @@ ble_gattc_write(uint16_t conn_handle, uint16_t attr_handle,`
`3730`	`3734`	`/* Free the mbuf in case the send failed. */`
`3731`	`3735`	`os_mbuf_free_chain(txom);`
`3732`	`3736`
`3733`		`- ble_gattc_process_status(proc, rc);`
	`3737`	`+ ble_gattc_process_status(proc, rc, false);`
`3734`	`3738`	`return rc;`
`3735`	`3739`	`}`
`3736`	`3740`
`@@ -4048,7 +4052,7 @@ ble_gattc_write_long(uint16_t conn_handle, uint16_t attr_handle,`
`4048`	`4052`	`/* Free the mbuf in case of failure. */`
`4049`	`4053`	`os_mbuf_free_chain(txom);`
`4050`	`4054`
`4051`		`- ble_gattc_process_status(proc, rc);`
	`4055`	`+ ble_gattc_process_status(proc, rc, false);`
`4052`	`4056`	`return rc;`
`4053`	`4057`	`}`
`4054`	`4058`
`@@ -4337,7 +4341,7 @@ ble_gattc_write_reliable(uint16_t conn_handle,`
`4337`	`4341`	`attrs[i].om = NULL;`
`4338`	`4342`	`}`
`4339`	`4343`
`4340`		`- ble_gattc_process_status(proc, rc);`
	`4344`	`+ ble_gattc_process_status(proc, rc, false);`
`4341`	`4345`	`return rc;`
`4342`	`4346`	`}`
`4343`	`4347`
`@@ -4709,7 +4713,7 @@ ble_gatts_indicate_custom(uint16_t conn_handle, uint16_t chr_val_handle,`
`4709`	`4713`	`/* Tell the application that an indication transmission was attempted. */`
`4710`	`4714`	`ble_gap_notify_tx_event(rc, conn_handle, chr_val_handle, 1);`
`4711`	`4715`
`4712`		`- ble_gattc_process_status(proc, rc);`
	`4716`	`+ ble_gattc_process_status(proc, rc, false);`
`4713`	`4717`	`os_mbuf_free_chain(txom);`
`4714`	`4718`	`return rc;`
`4715`	`4719`	`}`
`@@ -4777,7 +4781,7 @@ ble_gattc_rx_mtu(uint16_t conn_handle, uint16_t cid, int status, uint16_t chan_m`
`4777`	`4781`	`proc = ble_gattc_extract_first_by_conn_cid_op(conn_handle, BLE_L2CAP_CID_ATT, BLE_GATT_OP_MTU);`
`4778`	`4782`	`if (proc != NULL) {`
`4779`	`4783`	`ble_gattc_mtu_cb(proc, status, 0, chan_mtu);`
`4780`		`- ble_gattc_process_status(proc, BLE_HS_EDONE);`
	`4784`	`+ ble_gattc_process_status(proc, BLE_HS_EDONE, false);`
`4781`	`4785`	`}`
`4782`	`4786`	`}`
`4783`	`4787`
`@@ -4800,7 +4804,7 @@ ble_gattc_rx_find_info_idata(uint16_t conn_handle, uint16_t cid,`
`4800`	`4804`	`BLE_GATT_OP_DISC_ALL_DSCS);`
`4801`	`4805`	`if (proc != NULL) {`
`4802`	`4806`	`rc = ble_gattc_disc_all_dscs_rx_idata(proc, idata);`
`4803`		`- ble_gattc_process_status(proc, rc);`
	`4807`	`+ ble_gattc_process_status(proc, rc, false);`
`4804`	`4808`	`}`
`4805`	`4809`	`}`
`4806`	`4810`
`@@ -4822,7 +4826,7 @@ ble_gattc_rx_find_info_complete(uint16_t conn_handle, uint16_t cid, int status)`
`4822`	`4826`	`BLE_GATT_OP_DISC_ALL_DSCS);`
`4823`	`4827`	`if (proc != NULL) {`
`4824`	`4828`	`rc = ble_gattc_disc_all_dscs_rx_complete(proc, status);`
`4825`		`- ble_gattc_process_status(proc, rc);`
	`4829`	`+ ble_gattc_process_status(proc, rc, false);`
`4826`	`4830`	`}`
`4827`	`4831`	`}`
`4828`	`4832`
`@@ -4845,7 +4849,7 @@ ble_gattc_rx_find_type_value_hinfo(uint16_t conn_handle, uint16_t cid,`
`4845`	`4849`	`BLE_GATT_OP_DISC_SVC_UUID);`
`4846`	`4850`	`if (proc != NULL) {`
`4847`	`4851`	`rc = ble_gattc_disc_svc_uuid_rx_hinfo(proc, hinfo);`
`4848`		`- ble_gattc_process_status(proc, rc);`
	`4852`	`+ ble_gattc_process_status(proc, rc, false);`
`4849`	`4853`	`}`
`4850`	`4854`	`}`
`4851`	`4855`
`@@ -4867,15 +4871,15 @@ ble_gattc_rx_find_type_value_complete(uint16_t conn_handle, uint16_t cid, int st`
`4867`	`4871`	`BLE_GATT_OP_DISC_SVC_UUID);`
`4868`	`4872`	`if (proc != NULL) {`
`4869`	`4873`	`rc = ble_gattc_disc_svc_uuid_rx_complete(proc, status);`
`4870`		`- ble_gattc_process_status(proc, rc);`
	`4874`	`+ ble_gattc_process_status(proc, rc, false);`
`4871`	`4875`	`}`
`4872`	`4876`	`}`
`4873`	`4877`
`4874`	`4878`	`/**`
`4875`	`4879`	`* Dispatches an incoming "attribute data" entry from a read-by-type-response`
`4876`	`4880`	`* to the appropriate active GATT procedure.`
`4877`	`4881`	`*/`
`4878`		`-void`
	`4882`	`+int`
`4879`	`4883`	`ble_gattc_rx_read_type_adata(uint16_t conn_handle, uint16_t cid,`
`4880`	`4884`	`struct ble_att_read_type_adata *adata)`
`4881`	`4885`	`{`
`@@ -4892,8 +4896,15 @@ ble_gattc_rx_read_type_adata(uint16_t conn_handle, uint16_t cid,`
`4892`	`4896`	`&rx_entry);`
`4893`	`4897`	`if (proc != NULL) {`
`4894`	`4898`	`rc = rx_entry->cb(proc, adata);`
`4895`		`- ble_gattc_process_status(proc, rc);`
	`4899`	`+ /* We need to put procedure on head of the queue since caller expects`
	`4900`	`+ * to process the same proc again.`
	`4901`	`+ */`
	`4902`	`+ ble_gattc_process_status(proc, rc, true);`
	`4903`	`+ } else {`
	`4904`	`+ rc = -1;`
`4896`	`4905`	`}`
	`4906`	`+`
	`4907`	`+ return rc;`
`4897`	`4908`	`}`
`4898`	`4909`
`4899`	`4910`	`/**`
`@@ -4916,7 +4927,7 @@ ble_gattc_rx_read_type_complete(uint16_t conn_handle, uint16_t cid, int status)`
`4916`	`4927`	`&rx_entry);`
`4917`	`4928`	`if (proc != NULL) {`
`4918`	`4929`	`rc = rx_entry->cb(proc, status);`
`4919`		`- ble_gattc_process_status(proc, rc);`
	`4930`	`+ ble_gattc_process_status(proc, rc, false);`
`4920`	`4931`	`}`
`4921`	`4932`	`}`
`4922`	`4933`
`@@ -4939,7 +4950,7 @@ ble_gattc_rx_read_group_type_adata(uint16_t conn_handle, uint16_t cid,`
`4939`	`4950`	`BLE_GATT_OP_DISC_ALL_SVCS);`
`4940`	`4951`	`if (proc != NULL) {`
`4941`	`4952`	`rc = ble_gattc_disc_all_svcs_rx_adata(proc, adata);`
`4942`		`- ble_gattc_process_status(proc, rc);`
	`4953`	`+ ble_gattc_process_status(proc, rc, false);`
`4943`	`4954`	`}`
`4944`	`4955`	`}`
`4945`	`4956`
`@@ -4961,7 +4972,7 @@ ble_gattc_rx_read_group_type_complete(uint16_t conn_handle, uint16_t cid, int st`
`4961`	`4972`	`BLE_GATT_OP_DISC_ALL_SVCS);`
`4962`	`4973`	`if (proc != NULL) {`
`4963`	`4974`	`rc = ble_gattc_disc_all_svcs_rx_complete(proc, status);`
`4964`		`- ble_gattc_process_status(proc, rc);`
	`4975`	`+ ble_gattc_process_status(proc, rc, false);`
`4965`	`4976`	`}`
`4966`	`4977`	`}`
`4967`	`4978`
`@@ -4985,7 +4996,7 @@ ble_gattc_rx_read_rsp(uint16_t conn_handle, uint16_t cid, int status, struct os_`
`4985`	`4996`	`&rx_entry);`
`4986`	`4997`	`if (proc != NULL) {`
`4987`	`4998`	`rc = rx_entry->cb(proc, status, om);`
`4988`		`- ble_gattc_process_status(proc, rc);`
	`4999`	`+ ble_gattc_process_status(proc, rc, false);`
`4989`	`5000`	`}`
`4990`	`5001`	`}`
`4991`	`5002`
`@@ -5008,7 +5019,7 @@ ble_gattc_rx_read_blob_rsp(uint16_t conn_handle, uint16_t cid, int status,`
`5008`	`5019`	`BLE_GATT_OP_READ_LONG);`
`5009`	`5020`	`if (proc != NULL) {`
`5010`	`5021`	`rc = ble_gattc_read_long_rx_read_rsp(proc, status, om);`
`5011`		`- ble_gattc_process_status(proc, rc);`
	`5022`	`+ ble_gattc_process_status(proc, rc, false);`
`5012`	`5023`	`}`
`5013`	`5024`	`}`
`5014`	`5025`
`@@ -5032,7 +5043,7 @@ ble_gattc_rx_read_mult_rsp(uint16_t conn_handle, uint16_t cid, int status,`
`5032`	`5043`	`proc = ble_gattc_extract_first_by_conn_cid_op(conn_handle, cid, op);`
`5033`	`5044`	`if (proc != NULL) {`
`5034`	`5045`	`ble_gattc_read_mult_cb(proc, status, 0, om);`
`5035`		`- ble_gattc_process_status(proc, BLE_HS_EDONE);`
	`5046`	`+ ble_gattc_process_status(proc, BLE_HS_EDONE, false);`
`5036`	`5047`	`}`
`5037`	`5048`	`}`
`5038`	`5049`
`@@ -5053,7 +5064,7 @@ ble_gattc_rx_write_rsp(uint16_t conn_handle, uint16_t cid)`
`5053`	`5064`	`BLE_GATT_OP_WRITE);`
`5054`	`5065`	`if (proc != NULL) {`
`5055`	`5066`	`ble_gattc_write_cb(proc, 0, 0);`
`5056`		`- ble_gattc_process_status(proc, BLE_HS_EDONE);`
	`5067`	`+ ble_gattc_process_status(proc, BLE_HS_EDONE, false);`
`5057`	`5068`	`}`
`5058`	`5069`	`}`
`5059`	`5070`
`@@ -5079,7 +5090,7 @@ ble_gattc_rx_prep_write_rsp(uint16_t conn_handle, uint16_t cid, int status,`
`5079`	`5090`	`&rx_entry);`
`5080`	`5091`	`if (proc != NULL) {`
`5081`	`5092`	`rc = rx_entry->cb(proc, status, handle, offset, om);`
`5082`		`- ble_gattc_process_status(proc, rc);`
	`5093`	`+ ble_gattc_process_status(proc, rc, false);`
`5083`	`5094`	`}`
`5084`	`5095`	`}`
`5085`	`5096`
`@@ -5102,7 +5113,7 @@ ble_gattc_rx_exec_write_rsp(uint16_t conn_handle, uint16_t cid, int status)`
`5102`	`5113`	`ble_gattc_rx_exec_entries, &rx_entry);`
`5103`	`5114`	`if (proc != NULL) {`
`5104`	`5115`	`rc = rx_entry->cb(proc, status);`
`5105`		`- ble_gattc_process_status(proc, rc);`
	`5116`	`+ ble_gattc_process_status(proc, rc, false);`
`5106`	`5117`	`}`
`5107`	`5118`	`}`
`5108`	`5119`
`@@ -5123,7 +5134,7 @@ ble_gatts_rx_indicate_rsp(uint16_t conn_handle, uint16_t cid)`
`5123`	`5134`	`BLE_GATT_OP_INDICATE);`
`5124`	`5135`	`if (proc != NULL) {`
`5125`	`5136`	`ble_gatts_indicate_rx_rsp(proc);`
`5126`		`- ble_gattc_process_status(proc, BLE_HS_EDONE);`
	`5137`	`+ ble_gattc_process_status(proc, BLE_HS_EDONE, false);`
`5127`	`5138`	`}`
`5128`	`5139`	`}`
`5129`	`5140`