bool mgmt_cancel(struct mgmt *mgmt, unsigned int id)
{
struct mgmt_request *request;
if (!mgmt || !id)
return false;
request = queue_remove_if(mgmt->request_queue, match_request_id,
UINT_TO_PTR(id));
if (request)
goto done;
request = queue_remove_if(mgmt->reply_queue, match_request_id,
UINT_TO_PTR(id));
if (request)
goto done;
request = queue_remove_if(mgmt->pending_list, match_request_id,
UINT_TO_PTR(id));
if (!request)
return false;
done:
destroy_request(request);
wakeup_writer(mgmt);
return true;
}
static void bt_health_unregister_app(const void *buf, uint16_t len)
{
const struct hal_cmd_health_unreg_app *cmd = buf;
struct health_app *app;
DBG("");
app = queue_remove_if(apps, match_app_by_id, INT_TO_PTR(cmd->app_id));
if (!app) {
ipc_send_rsp(hal_ipc, HAL_SERVICE_ID_HEALTH,
HAL_OP_HEALTH_UNREG_APP, HAL_STATUS_INVALID);
return;
}
send_app_reg_notify(app, HAL_HEALTH_APP_DEREG_SUCCESS);
if (record_id > 0) {
bt_adapter_remove_record(record_id);
record_id = 0;
}
free_health_app(app);
ipc_send_rsp(hal_ipc, HAL_SERVICE_ID_HEALTH,
HAL_OP_HEALTH_UNREG_APP, HAL_STATUS_SUCCESS);
}
bool bt_att_cancel(struct bt_att *att, unsigned int id)
{
struct att_send_op *op;
if (!att || !id)
return false;
if (att->pending_req && att->pending_req->id == id) {
/* Don't cancel the pending request; remove it's handlers */
cancel_att_send_op(att->pending_req);
return true;
}
if (att->pending_ind && att->pending_ind->id == id) {
/* Don't cancel the pending indication; remove it's handlers */
cancel_att_send_op(att->pending_ind);
return true;
}
op = queue_remove_if(att->req_queue, match_op_id, UINT_TO_PTR(id));
if (op)
goto done;
op = queue_remove_if(att->ind_queue, match_op_id, UINT_TO_PTR(id));
if (op)
goto done;
op = queue_remove_if(att->write_queue, match_op_id, UINT_TO_PTR(id));
if (op)
goto done;
if (!op)
return false;
done:
destroy_att_send_op(op);
wakeup_writer(att);
return true;
}
bool bt_hci_cancel(struct bt_hci *hci, unsigned int id)
{
struct cmd *cmd;
if (!hci || !id)
return false;
cmd = queue_remove_if(hci->cmd_queue, match_cmd_id, UINT_TO_PTR(id));
if (!cmd) {
cmd = queue_remove_if(hci->rsp_queue, match_cmd_id,
UINT_TO_PTR(id));
if (!cmd)
return false;
}
cmd_free(cmd);
wakeup_writer(hci);
return true;
}
static void del_index(struct timeval *tv, uint16_t index,
const void *data, uint16_t size)
{
struct hci_dev *dev;
dev = queue_remove_if(dev_list, dev_match_index, UINT_TO_PTR(index));
if (!dev) {
fprintf(stderr, "Remove for an unexisting device\n");
return;
}
dev_destroy(dev);
}
bool bt_att_cancel(struct bt_att *att, unsigned int id)
{
struct att_send_op *op;
if (!att || !id)
return false;
if (att->pending_req && att->pending_req->id == id) {
op = att->pending_req;
goto done;
}
if (att->pending_ind && att->pending_ind->id == id) {
op = att->pending_ind;
goto done;
}
op = queue_remove_if(att->req_queue, match_op_id, UINT_TO_PTR(id));
if (op)
goto done;
op = queue_remove_if(att->ind_queue, match_op_id, UINT_TO_PTR(id));
if (op)
goto done;
op = queue_remove_if(att->write_queue, match_op_id, UINT_TO_PTR(id));
if (op)
goto done;
if (!op)
return false;
done:
destroy_att_send_op(op);
wakeup_writer(att);
return true;
}
bool bt_uhid_unregister(struct bt_uhid *uhid, unsigned int id)
{
struct uhid_notify *notify;
if (!uhid || !id)
return false;
notify = queue_remove_if(uhid->notify_list, match_notify_id,
UINT_TO_PTR(id));
if (!notify)
return false;
free(notify);
return true;
}
bool bt_hci_unregister(struct bt_hci *hci, unsigned int id)
{
struct evt *evt;
if (!hci || !id)
return false;
evt = queue_remove_if(hci->evt_list, match_evt_id, UINT_TO_PTR(id));
if (!evt)
return false;
evt_free(evt);
return true;
}
bool bt_att_unregister(struct bt_att *att, unsigned int id)
{
struct att_notify *notify;
if (!att || !id)
return false;
notify = queue_remove_if(att->notify_list, match_notify_id,
UINT_TO_PTR(id));
if (!notify)
return false;
destroy_att_notify(notify);
return true;
}
bool bt_att_unregister_disconnect(struct bt_att *att, unsigned int id)
{
struct att_disconn *disconn;
if (!att || !id)
return false;
disconn = queue_remove_if(att->disconn_list, match_disconn_id,
UINT_TO_PTR(id));
if (!disconn)
return false;
destroy_att_disconn(disconn);
return true;
}
bool hfp_hf_unregister(struct hfp_hf *hfp, const char *prefix)
{
struct cmd_handler *handler;
/* Cast to void as queue_remove needs that */
handler = queue_remove_if(hfp->event_handlers,
match_handler_event_prefix,
(void *) prefix);
if (!handler)
return false;
destroy_event_handler(handler);
return true;
}
unsigned int queue_remove_all(struct queue *queue, queue_match_func_t function,
void *user_data, queue_destroy_func_t destroy)
{
struct queue_entry *entry;
unsigned int count = 0;
if (!queue)
return 0;
entry = queue->head;
if (function) {
while (entry) {
void *data;
data = queue_remove_if(queue, function, user_data);
if (!data)
break;
if (destroy)
destroy(data);
count++;
}
queue->entries -= count;
} else {
queue->head = NULL;
queue->tail = NULL;
queue->entries = 0;
while (entry) {
struct queue_entry *tmp = entry;
entry = entry->next;
if (destroy)
destroy(tmp->data);
queue_entry_unref(tmp);
count++;
}
}
return count;
}
bool gatt_db_attribute_write_result(struct gatt_db_attribute *attrib,
unsigned int id, int err)
{
struct pending_write *p;
if (!attrib || !id)
return false;
p = queue_remove_if(attrib->pending_writes, find_pending,
UINT_TO_PTR(id));
if (!p)
return false;
pending_write_result(p, err);
return true;
}
bool gatt_db_attribute_read_result(struct gatt_db_attribute *attrib,
unsigned int id, int err,
const uint8_t *value, size_t length)
{
struct pending_read *p;
if (!attrib || !id)
return false;
p = queue_remove_if(attrib->pending_reads, find_pending,
UINT_TO_PTR(id));
if (!p)
return false;
pending_read_result(p, err, value, length);
return true;
}
bool hfp_gw_unregister(struct hfp_gw *hfp, const char *prefix)
{
struct cmd_handler *handler;
char *lookup_prefix;
lookup_prefix = strdup(prefix);
if (!lookup_prefix)
return false;
handler = queue_remove_if(hfp->cmd_handlers, match_handler_prefix,
lookup_prefix);
free(lookup_prefix);
if (!handler)
return false;
destroy_cmd_handler(handler);
return true;
}
static void process_response(struct bt_hci *hci, uint16_t opcode,
const void *data, size_t size)
{
struct cmd *cmd;
if (opcode == BT_HCI_CMD_NOP)
goto done;
cmd = queue_remove_if(hci->rsp_queue, match_cmd_opcode,
UINT_TO_PTR(opcode));
if (!cmd)
return;
if (cmd->callback)
cmd->callback(data, size, cmd->user_data);
cmd_free(cmd);
done:
wakeup_writer(hci);
}
static void request_complete(struct mgmt *mgmt, uint8_t status,
uint16_t opcode, uint16_t index,
uint16_t length, const void *param)
{
struct opcode_index match = { .opcode = opcode, .index = index };
struct mgmt_request *request;
request = queue_remove_if(mgmt->pending_list,
match_request_opcode_index, &match);
if (request) {
if (request->callback)
request->callback(status, length, param,
request->user_data);
destroy_request(request);
}
if (mgmt->destroyed)
return;
wakeup_writer(mgmt);
}
bool mgmt_unregister(struct mgmt *mgmt, unsigned int id)
{
struct mgmt_notify *notify;
if (!mgmt || !id)
return false;
notify = queue_remove_if(mgmt->notify_list, match_notify_id,
UINT_TO_PTR(id));
if (!notify)
return false;
if (!mgmt->in_notify) {
destroy_notify(notify);
return true;
}
notify->removed = true;
mgmt->need_notify_cleanup = true;
return true;
}
static DBusMessage *characteristic_stop_notify(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
struct characteristic *chrc = user_data;
struct bt_gatt_client *gatt = chrc->service->client->gatt;
const char *sender = dbus_message_get_sender(msg);
struct notify_client *client;
if (!chrc->notifying)
return btd_error_failed(msg, "Not notifying");
client = queue_remove_if(chrc->notify_clients, match_notify_sender,
(void *) sender);
if (!client)
return btd_error_failed(msg, "No notify session started");
queue_remove(chrc->service->client->all_notify_clients, client);
bt_gatt_client_unregister_notify(gatt, client->notify_id);
update_notifying(chrc);
notify_client_unref(client);
return dbus_message_new_method_return(msg);
}
