HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/shared/qmp-client.c

37,913 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 89b85511267844c7e5a332c087d2cc58003e1e28

Lines 1001–1124 of 1,124

        int r;
 
        assert_return(c, -EINVAL);
        assert_return(command, -EINVAL);
 
        /* If we're on a fiber sharing the QMP client's event loop, use the async + suspend path so
         * multiple concurrent qmp_client_call() invocations across fibers don't deadlock each other
         * on the process+wait pump. */
        if (sd_fiber_is_running() && qmp_client_get_event(c) == sd_fiber_get_event())
                return qmp_client_call_suspend(c, command, args, ret_result, reterr_error_desc);
 
        _cleanup_(qmp_slot_unrefp) QmpSlot *slot = NULL;
 
        /* NULL callback marks this as a synchronous slot: dispatch_reply matches on id like
         * any other slot (so stray unknown-id replies still get logged and dropped), but
         * pins c->current for us instead of invoking a callback. The slot is non-floating so
         * we can observe dispatch by watching slot->client go NULL. */
        r = qmp_client_send(c, command, args, /* callback= */ NULL, /* userdata= */ NULL, &slot);
        if (r < 0)
                return r;
 
        /* Pump the loop until our sync slot fires (disconnected by dispatch, c->current pinned). */
        for (;;) {
                if (c->state == QMP_CLIENT_DISCONNECTED)
                        return -ECONNRESET;
 
                if (!slot->client) {
                        assert(c->current);
                        break;
                }
 
                r = qmp_client_process(c);
                if (r < 0)
                        return r;
                if (r > 0)
                        continue;
 
                r = qmp_client_wait(c, USEC_INFINITY);
                if (r < 0)
                        return r;
        }
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *current = TAKE_PTR(c->current);
        r = qmp_parse_response(current, &result, &desc);
        if (r < 0 && r != -EIO)
                return r;
 
        /* QMP-level error: copy the description into *ret_error_desc when the caller asked for it,
         * and surface the failure via the return value (matching qmp_client_call_suspend() /
         * sd_bus_call()'s "negative on error" convention). */
        if (desc) {
                if (reterr_error_desc)
                        *reterr_error_desc = TAKE_PTR(desc);
                return -EIO;
        }
 
        if (ret_result)
                *ret_result = TAKE_PTR(result);
        if (reterr_error_desc)
                *reterr_error_desc = NULL;
 
        return 1;
}
 
void qmp_client_bind_event(QmpClient *c, qmp_event_callback_t callback, void *userdata) {
        assert(c);
        c->event_callback = callback;
        c->event_userdata = userdata;
}
 
void qmp_client_bind_disconnect(QmpClient *c, qmp_disconnect_callback_t callback, void *userdata) {
        assert(c);
        c->disconnect_callback = callback;
        c->disconnect_userdata = userdata;
}
 
int qmp_client_set_description(QmpClient *c, const char *description) {
        assert(c);
        return json_stream_set_description(&c->stream, description);
}
 
sd_event* qmp_client_get_event(QmpClient *c) {
        assert(c);
        return json_stream_get_event(&c->stream);
}
 
uint64_t qmp_client_next_fdset_id(QmpClient *c) {
        assert(c);
        return c->next_fdset_id++;
}
 
bool qmp_schema_has_member(sd_json_variant *schema, const char *member_name) {
        sd_json_variant *entry;
 
        assert(member_name);
 
        if (!sd_json_variant_is_array(schema))
                return false;
 
        JSON_VARIANT_ARRAY_FOREACH(entry, schema) {
                if (!sd_json_variant_is_object(entry))
                        continue;
 
                sd_json_variant *meta = sd_json_variant_by_key(entry, "meta-type");
                if (!meta || !streq_ptr(sd_json_variant_string(meta), "object"))
                        continue;
 
                sd_json_variant *members = sd_json_variant_by_key(entry, "members");
                if (!sd_json_variant_is_array(members))
                        continue;
 
                sd_json_variant *m;
                JSON_VARIANT_ARRAY_FOREACH(m, members) {
                        if (!sd_json_variant_is_object(m))
                                continue;
                        sd_json_variant *mn = sd_json_variant_by_key(m, "name");
                        if (mn && streq_ptr(sd_json_variant_string(mn), member_name))
                                return true;
                }
        }
 
        return false;
}