void ubus_abort_request(struct ubus_context *ctx, struct ubus_request *req)
{
- if (!list_empty(&req->list))
+ if (list_empty(&req->list))
return;
req->cancelled = true;
uloop_cancelled = cancelled;
}
ctx->stack_depth--;
+ if (ctx->stack_depth)
+ uloop_cancelled = true;
if (timeout)
uloop_timeout_cancel(&cb.timeout);
if (ret < 0)
return ret;
- if (timeout < 0)
+ if (timeout < 0) {
+ ubus_abort_request(ctx, &req.req);
return 0;
+ }
return ubus_complete_request(ctx, &req.req, timeout);
}
static bool ubus_get_status(struct ubus_msghdr *hdr, int *ret)
{
- struct blob_attr **attrbuf = ubus_parse_msg(hdr->data);
+ struct blob_attr **attrbuf = ubus_parse_msg(ubus_msghdr_data(hdr));
if (!attrbuf[UBUS_ATTR_STATUS])
return false;
static void
ubus_process_req_data(struct ubus_request *req, struct ubus_msghdr *hdr)
{
+ struct blob_attr *msg_data = ubus_msghdr_data(hdr);
struct ubus_pending_data *data;
int len;
if (!req->blocked) {
req->blocked = true;
- req_data_cb(req, hdr->type, hdr->data);
+ req_data_cb(req, hdr->type, msg_data);
__ubus_process_req_data(req);
req->blocked = false;
return;
}
- len = blob_raw_len(hdr->data);
+ len = blob_raw_len(msg_data);
data = calloc(1, sizeof(*data) + len);
if (!data)
return;
data->type = hdr->type;
- memcpy(data->data, hdr->data, len);
+ memcpy(data->data, msg_data, len);
list_add(&data->list, &req->pending);
}
struct blob_attr **tb;
struct blob_attr *cur;
int rem, idx = 1;
- int ret;
+ int ret = 0;
nreq = container_of(req, struct ubus_notify_request, req);
nreq->pending &= ~(1 << id);
if (!id) {
/* first id: ubusd's status message with a list of ids */
- tb = ubus_parse_msg(hdr->data);
+ tb = ubus_parse_msg(ubus_msghdr_data(hdr));
if (tb[UBUS_ATTR_SUBSCRIBERS]) {
blob_for_each_attr(cur, tb[UBUS_ATTR_SUBSCRIBERS], rem) {
if (!blob_check_type(blob_data(cur), blob_len(cur), BLOB_ATTR_INT32))