2017-11-18 17:09:20 +01:00
|
|
|
/* SPDX-License-Identifier: LGPL-2.1+ */
|
2013-10-09 02:37:10 +02:00
|
|
|
|
|
|
|
#include <pthread.h>
|
2015-11-16 22:09:36 +01:00
|
|
|
#include <stdlib.h>
|
2013-10-09 02:37:10 +02:00
|
|
|
|
|
|
|
#include "sd-bus.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
|
2015-10-27 03:01:06 +01:00
|
|
|
#include "alloc-util.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "bus-dump.h"
|
2013-10-09 02:37:10 +02:00
|
|
|
#include "bus-internal.h"
|
|
|
|
#include "bus-message.h"
|
2015-08-27 16:32:22 +02:00
|
|
|
#include "bus-util.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "log.h"
|
|
|
|
#include "macro.h"
|
|
|
|
#include "strv.h"
|
|
|
|
#include "util.h"
|
2013-10-09 02:37:10 +02:00
|
|
|
|
|
|
|
struct context {
|
|
|
|
int fds[2];
|
|
|
|
bool quit;
|
|
|
|
char *something;
|
2013-10-11 20:02:16 +02:00
|
|
|
char *automatic_string_property;
|
2013-10-11 06:10:15 +02:00
|
|
|
uint32_t automatic_integer_property;
|
2013-10-09 02:37:10 +02:00
|
|
|
};
|
|
|
|
|
2015-04-29 18:35:10 +02:00
|
|
|
static int something_handler(sd_bus_message *m, void *userdata, sd_bus_error *error) {
|
2013-10-09 02:37:10 +02:00
|
|
|
struct context *c = userdata;
|
|
|
|
const char *s;
|
|
|
|
char *n = NULL;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
r = sd_bus_message_read(m, "s", &s);
|
|
|
|
assert_se(r > 0);
|
|
|
|
|
2016-10-23 17:43:27 +02:00
|
|
|
n = strjoin("<<<", s, ">>>");
|
2013-10-09 02:37:10 +02:00
|
|
|
assert_se(n);
|
|
|
|
|
|
|
|
free(c->something);
|
|
|
|
c->something = n;
|
|
|
|
|
|
|
|
log_info("AlterSomething() called, got %s, returning %s", s, n);
|
|
|
|
|
2013-12-02 15:28:20 +01:00
|
|
|
/* This should fail, since the return type doesn't match */
|
|
|
|
assert_se(sd_bus_reply_method_return(m, "u", 4711) == -ENOMSG);
|
|
|
|
|
2013-11-21 01:51:16 +01:00
|
|
|
r = sd_bus_reply_method_return(m, "s", n);
|
2013-10-09 02:37:10 +02:00
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-04-29 18:35:10 +02:00
|
|
|
static int exit_handler(sd_bus_message *m, void *userdata, sd_bus_error *error) {
|
2013-10-09 02:37:10 +02:00
|
|
|
struct context *c = userdata;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
c->quit = true;
|
|
|
|
|
|
|
|
log_info("Exit called");
|
|
|
|
|
2013-11-21 01:51:16 +01:00
|
|
|
r = sd_bus_reply_method_return(m, "");
|
2013-10-09 02:37:10 +02:00
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-11-21 19:34:37 +01:00
|
|
|
static int get_handler(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
|
2013-10-09 02:37:10 +02:00
|
|
|
struct context *c = userdata;
|
|
|
|
int r;
|
|
|
|
|
2013-11-21 19:34:37 +01:00
|
|
|
log_info("property get for %s called, returning \"%s\".", property, c->something);
|
2013-10-09 02:37:10 +02:00
|
|
|
|
|
|
|
r = sd_bus_message_append(reply, "s", c->something);
|
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-11-21 19:34:37 +01:00
|
|
|
static int set_handler(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *value, void *userdata, sd_bus_error *error) {
|
2013-10-09 02:37:10 +02:00
|
|
|
struct context *c = userdata;
|
|
|
|
const char *s;
|
|
|
|
char *n;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
log_info("property set for %s called", property);
|
|
|
|
|
|
|
|
r = sd_bus_message_read(value, "s", &s);
|
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
n = strdup(s);
|
|
|
|
assert_se(n);
|
|
|
|
|
|
|
|
free(c->something);
|
|
|
|
c->something = n;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-11-21 19:34:37 +01:00
|
|
|
static int value_handler(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
|
2013-10-09 02:37:10 +02:00
|
|
|
_cleanup_free_ char *s = NULL;
|
2015-08-24 12:56:37 +02:00
|
|
|
const char *x;
|
2013-10-09 02:37:10 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert_se(asprintf(&s, "object %p, path %s", userdata, path) >= 0);
|
|
|
|
r = sd_bus_message_append(reply, "s", s);
|
|
|
|
assert_se(r >= 0);
|
|
|
|
|
2015-08-24 12:56:37 +02:00
|
|
|
assert_se(x = startswith(path, "/value/"));
|
2013-10-09 02:37:10 +02:00
|
|
|
|
|
|
|
assert_se(PTR_TO_UINT(userdata) == 30);
|
|
|
|
|
2013-10-11 05:22:00 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-04-29 18:35:10 +02:00
|
|
|
static int notify_test(sd_bus_message *m, void *userdata, sd_bus_error *error) {
|
2013-10-11 05:22:00 +02:00
|
|
|
int r;
|
|
|
|
|
2015-04-29 18:35:10 +02:00
|
|
|
assert_se(sd_bus_emit_properties_changed(sd_bus_message_get_bus(m), m->path, "org.freedesktop.systemd.ValueTest", "Value", NULL) >= 0);
|
2013-10-11 05:22:00 +02:00
|
|
|
|
2013-11-21 01:51:16 +01:00
|
|
|
r = sd_bus_reply_method_return(m, NULL);
|
2013-10-11 05:22:00 +02:00
|
|
|
assert_se(r >= 0);
|
2013-10-09 02:37:10 +02:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-04-29 18:35:10 +02:00
|
|
|
static int notify_test2(sd_bus_message *m, void *userdata, sd_bus_error *error) {
|
2013-12-22 03:22:34 +01:00
|
|
|
int r;
|
|
|
|
|
2015-04-29 18:35:10 +02:00
|
|
|
assert_se(sd_bus_emit_properties_changed_strv(sd_bus_message_get_bus(m), m->path, "org.freedesktop.systemd.ValueTest", NULL) >= 0);
|
2013-12-22 03:22:34 +01:00
|
|
|
|
|
|
|
r = sd_bus_reply_method_return(m, NULL);
|
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-04-29 18:35:10 +02:00
|
|
|
static int emit_interfaces_added(sd_bus_message *m, void *userdata, sd_bus_error *error) {
|
2013-10-11 23:22:29 +02:00
|
|
|
int r;
|
|
|
|
|
2015-07-21 12:59:56 +02:00
|
|
|
assert_se(sd_bus_emit_interfaces_added(sd_bus_message_get_bus(m), "/value/a/x", "org.freedesktop.systemd.ValueTest", NULL) >= 0);
|
2013-10-11 23:22:29 +02:00
|
|
|
|
2013-11-21 01:51:16 +01:00
|
|
|
r = sd_bus_reply_method_return(m, NULL);
|
2013-10-11 23:22:29 +02:00
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-04-29 18:35:10 +02:00
|
|
|
static int emit_interfaces_removed(sd_bus_message *m, void *userdata, sd_bus_error *error) {
|
2013-10-11 23:22:29 +02:00
|
|
|
int r;
|
|
|
|
|
2015-07-21 12:59:56 +02:00
|
|
|
assert_se(sd_bus_emit_interfaces_removed(sd_bus_message_get_bus(m), "/value/a/x", "org.freedesktop.systemd.ValueTest", NULL) >= 0);
|
2013-10-11 23:22:29 +02:00
|
|
|
|
2013-11-21 01:51:16 +01:00
|
|
|
r = sd_bus_reply_method_return(m, NULL);
|
2013-10-11 23:22:29 +02:00
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-04-29 18:35:10 +02:00
|
|
|
static int emit_object_added(sd_bus_message *m, void *userdata, sd_bus_error *error) {
|
bus: add sd_bus_emit_object_{added/removed}()
This implements two new helpers, discussed on systemd-devel about 1 year
ago:
sd_bus_emit_object_added()
sd_bus_emit_object_removed()
Both calls are equivalent to their respective counterpart
sd_bus_emit_interfaces_{added/removed}(), but can figure out the list of
interfaces themselves, instead of requiring the caller to provide them.
Furthermore, both calls properly deal with builtin interfaces provided via
org.freedesktop.DBus.* and alike.
Both calls simply traverse a node and all its parent nodes to figure out a
list of all interfaces registered as vtable or fallback. It then appends
each of them, similar to the interfaces_{added/removed}() helpers.
Note that interfaces_{added/removed}() runs a parent traversal for *each*
passed interface. Therefore, it can simply bail out, once it found a
parent node that implements a given interface.
With object_{added/removed}() we cannot know the registered interfaces in
advance, thus, we cannot run one traversal per node. Instead, we run a
single traversal and remember all interfaces that we added. Therefore, a
child-interface overrides all conflicting parent-interfaces. We keep a
"Set *s" context to track those while climbing up the tree.
2014-12-30 11:37:35 +01:00
|
|
|
int r;
|
|
|
|
|
2015-07-21 12:59:56 +02:00
|
|
|
assert_se(sd_bus_emit_object_added(sd_bus_message_get_bus(m), "/value/a/x") >= 0);
|
bus: add sd_bus_emit_object_{added/removed}()
This implements two new helpers, discussed on systemd-devel about 1 year
ago:
sd_bus_emit_object_added()
sd_bus_emit_object_removed()
Both calls are equivalent to their respective counterpart
sd_bus_emit_interfaces_{added/removed}(), but can figure out the list of
interfaces themselves, instead of requiring the caller to provide them.
Furthermore, both calls properly deal with builtin interfaces provided via
org.freedesktop.DBus.* and alike.
Both calls simply traverse a node and all its parent nodes to figure out a
list of all interfaces registered as vtable or fallback. It then appends
each of them, similar to the interfaces_{added/removed}() helpers.
Note that interfaces_{added/removed}() runs a parent traversal for *each*
passed interface. Therefore, it can simply bail out, once it found a
parent node that implements a given interface.
With object_{added/removed}() we cannot know the registered interfaces in
advance, thus, we cannot run one traversal per node. Instead, we run a
single traversal and remember all interfaces that we added. Therefore, a
child-interface overrides all conflicting parent-interfaces. We keep a
"Set *s" context to track those while climbing up the tree.
2014-12-30 11:37:35 +01:00
|
|
|
|
|
|
|
r = sd_bus_reply_method_return(m, NULL);
|
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-04-29 18:35:10 +02:00
|
|
|
static int emit_object_removed(sd_bus_message *m, void *userdata, sd_bus_error *error) {
|
bus: add sd_bus_emit_object_{added/removed}()
This implements two new helpers, discussed on systemd-devel about 1 year
ago:
sd_bus_emit_object_added()
sd_bus_emit_object_removed()
Both calls are equivalent to their respective counterpart
sd_bus_emit_interfaces_{added/removed}(), but can figure out the list of
interfaces themselves, instead of requiring the caller to provide them.
Furthermore, both calls properly deal with builtin interfaces provided via
org.freedesktop.DBus.* and alike.
Both calls simply traverse a node and all its parent nodes to figure out a
list of all interfaces registered as vtable or fallback. It then appends
each of them, similar to the interfaces_{added/removed}() helpers.
Note that interfaces_{added/removed}() runs a parent traversal for *each*
passed interface. Therefore, it can simply bail out, once it found a
parent node that implements a given interface.
With object_{added/removed}() we cannot know the registered interfaces in
advance, thus, we cannot run one traversal per node. Instead, we run a
single traversal and remember all interfaces that we added. Therefore, a
child-interface overrides all conflicting parent-interfaces. We keep a
"Set *s" context to track those while climbing up the tree.
2014-12-30 11:37:35 +01:00
|
|
|
int r;
|
|
|
|
|
2015-07-21 12:59:56 +02:00
|
|
|
assert_se(sd_bus_emit_object_removed(sd_bus_message_get_bus(m), "/value/a/x") >= 0);
|
bus: add sd_bus_emit_object_{added/removed}()
This implements two new helpers, discussed on systemd-devel about 1 year
ago:
sd_bus_emit_object_added()
sd_bus_emit_object_removed()
Both calls are equivalent to their respective counterpart
sd_bus_emit_interfaces_{added/removed}(), but can figure out the list of
interfaces themselves, instead of requiring the caller to provide them.
Furthermore, both calls properly deal with builtin interfaces provided via
org.freedesktop.DBus.* and alike.
Both calls simply traverse a node and all its parent nodes to figure out a
list of all interfaces registered as vtable or fallback. It then appends
each of them, similar to the interfaces_{added/removed}() helpers.
Note that interfaces_{added/removed}() runs a parent traversal for *each*
passed interface. Therefore, it can simply bail out, once it found a
parent node that implements a given interface.
With object_{added/removed}() we cannot know the registered interfaces in
advance, thus, we cannot run one traversal per node. Instead, we run a
single traversal and remember all interfaces that we added. Therefore, a
child-interface overrides all conflicting parent-interfaces. We keep a
"Set *s" context to track those while climbing up the tree.
2014-12-30 11:37:35 +01:00
|
|
|
|
|
|
|
r = sd_bus_reply_method_return(m, NULL);
|
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-10-09 02:37:10 +02:00
|
|
|
static const sd_bus_vtable vtable[] = {
|
|
|
|
SD_BUS_VTABLE_START(0),
|
2013-10-11 06:10:15 +02:00
|
|
|
SD_BUS_METHOD("AlterSomething", "s", "s", something_handler, 0),
|
|
|
|
SD_BUS_METHOD("Exit", "", "", exit_handler, 0),
|
2013-10-09 02:37:10 +02:00
|
|
|
SD_BUS_WRITABLE_PROPERTY("Something", "s", get_handler, set_handler, 0, 0),
|
2013-10-11 20:02:16 +02:00
|
|
|
SD_BUS_WRITABLE_PROPERTY("AutomaticStringProperty", "s", NULL, NULL, offsetof(struct context, automatic_string_property), 0),
|
|
|
|
SD_BUS_WRITABLE_PROPERTY("AutomaticIntegerProperty", "u", NULL, NULL, offsetof(struct context, automatic_integer_property), 0),
|
2013-10-11 23:22:29 +02:00
|
|
|
SD_BUS_METHOD("NoOperation", NULL, NULL, NULL, 0),
|
|
|
|
SD_BUS_METHOD("EmitInterfacesAdded", NULL, NULL, emit_interfaces_added, 0),
|
|
|
|
SD_BUS_METHOD("EmitInterfacesRemoved", NULL, NULL, emit_interfaces_removed, 0),
|
bus: add sd_bus_emit_object_{added/removed}()
This implements two new helpers, discussed on systemd-devel about 1 year
ago:
sd_bus_emit_object_added()
sd_bus_emit_object_removed()
Both calls are equivalent to their respective counterpart
sd_bus_emit_interfaces_{added/removed}(), but can figure out the list of
interfaces themselves, instead of requiring the caller to provide them.
Furthermore, both calls properly deal with builtin interfaces provided via
org.freedesktop.DBus.* and alike.
Both calls simply traverse a node and all its parent nodes to figure out a
list of all interfaces registered as vtable or fallback. It then appends
each of them, similar to the interfaces_{added/removed}() helpers.
Note that interfaces_{added/removed}() runs a parent traversal for *each*
passed interface. Therefore, it can simply bail out, once it found a
parent node that implements a given interface.
With object_{added/removed}() we cannot know the registered interfaces in
advance, thus, we cannot run one traversal per node. Instead, we run a
single traversal and remember all interfaces that we added. Therefore, a
child-interface overrides all conflicting parent-interfaces. We keep a
"Set *s" context to track those while climbing up the tree.
2014-12-30 11:37:35 +01:00
|
|
|
SD_BUS_METHOD("EmitObjectAdded", NULL, NULL, emit_object_added, 0),
|
|
|
|
SD_BUS_METHOD("EmitObjectRemoved", NULL, NULL, emit_object_removed, 0),
|
2013-10-09 02:37:10 +02:00
|
|
|
SD_BUS_VTABLE_END
|
|
|
|
};
|
|
|
|
|
|
|
|
static const sd_bus_vtable vtable2[] = {
|
|
|
|
SD_BUS_VTABLE_START(0),
|
2013-10-11 06:10:15 +02:00
|
|
|
SD_BUS_METHOD("NotifyTest", "", "", notify_test, 0),
|
2013-12-22 03:22:34 +01:00
|
|
|
SD_BUS_METHOD("NotifyTest2", "", "", notify_test2, 0),
|
2013-10-11 05:22:00 +02:00
|
|
|
SD_BUS_PROPERTY("Value", "s", value_handler, 10, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
|
2013-12-22 03:22:34 +01:00
|
|
|
SD_BUS_PROPERTY("Value2", "s", value_handler, 10, SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
|
|
|
|
SD_BUS_PROPERTY("Value3", "s", value_handler, 10, SD_BUS_VTABLE_PROPERTY_CONST),
|
|
|
|
SD_BUS_PROPERTY("Value4", "s", value_handler, 10, 0),
|
2015-08-25 01:45:33 +02:00
|
|
|
SD_BUS_PROPERTY("AnExplicitProperty", "s", NULL, offsetof(struct context, something), SD_BUS_VTABLE_PROPERTY_EXPLICIT|SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
|
2013-10-09 02:37:10 +02:00
|
|
|
SD_BUS_VTABLE_END
|
|
|
|
};
|
|
|
|
|
2014-05-15 01:15:30 +02:00
|
|
|
static int enumerator_callback(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
|
2013-10-09 02:37:10 +02:00
|
|
|
|
|
|
|
if (object_path_startswith("/value", path))
|
2018-10-31 17:03:50 +01:00
|
|
|
assert_se(*nodes = strv_new("/value/a", "/value/b", "/value/c"));
|
2013-10-09 02:37:10 +02:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-07-21 12:59:56 +02:00
|
|
|
static int enumerator2_callback(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
|
|
|
|
|
|
|
|
if (object_path_startswith("/value/a", path))
|
2018-10-31 17:03:50 +01:00
|
|
|
assert_se(*nodes = strv_new("/value/a/x", "/value/a/y", "/value/a/z"));
|
2015-07-21 12:59:56 +02:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-10-09 02:37:10 +02:00
|
|
|
static void *server(void *p) {
|
|
|
|
struct context *c = p;
|
|
|
|
sd_bus *bus = NULL;
|
|
|
|
sd_id128_t id;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
c->quit = false;
|
|
|
|
|
|
|
|
assert_se(sd_id128_randomize(&id) >= 0);
|
|
|
|
|
|
|
|
assert_se(sd_bus_new(&bus) >= 0);
|
|
|
|
assert_se(sd_bus_set_fd(bus, c->fds[0], c->fds[0]) >= 0);
|
|
|
|
assert_se(sd_bus_set_server(bus, 1, id) >= 0);
|
|
|
|
|
2014-05-15 01:15:30 +02:00
|
|
|
assert_se(sd_bus_add_object_vtable(bus, NULL, "/foo", "org.freedesktop.systemd.test", vtable, c) >= 0);
|
|
|
|
assert_se(sd_bus_add_object_vtable(bus, NULL, "/foo", "org.freedesktop.systemd.test2", vtable, c) >= 0);
|
|
|
|
assert_se(sd_bus_add_fallback_vtable(bus, NULL, "/value", "org.freedesktop.systemd.ValueTest", vtable2, NULL, UINT_TO_PTR(20)) >= 0);
|
|
|
|
assert_se(sd_bus_add_node_enumerator(bus, NULL, "/value", enumerator_callback, NULL) >= 0);
|
2015-07-21 12:59:56 +02:00
|
|
|
assert_se(sd_bus_add_node_enumerator(bus, NULL, "/value/a", enumerator2_callback, NULL) >= 0);
|
2014-05-15 01:15:30 +02:00
|
|
|
assert_se(sd_bus_add_object_manager(bus, NULL, "/value") >= 0);
|
2015-07-21 12:59:56 +02:00
|
|
|
assert_se(sd_bus_add_object_manager(bus, NULL, "/value/a") >= 0);
|
2013-10-09 02:37:10 +02:00
|
|
|
|
|
|
|
assert_se(sd_bus_start(bus) >= 0);
|
|
|
|
|
|
|
|
log_error("Entering event loop on server");
|
|
|
|
|
|
|
|
while (!c->quit) {
|
|
|
|
log_error("Loop!");
|
|
|
|
|
|
|
|
r = sd_bus_process(bus, NULL);
|
|
|
|
if (r < 0) {
|
2014-11-28 13:19:16 +01:00
|
|
|
log_error_errno(r, "Failed to process requests: %m");
|
2013-10-09 02:37:10 +02:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (r == 0) {
|
|
|
|
r = sd_bus_wait(bus, (uint64_t) -1);
|
|
|
|
if (r < 0) {
|
2014-11-28 13:19:16 +01:00
|
|
|
log_error_errno(r, "Failed to wait: %m");
|
2013-10-09 02:37:10 +02:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
r = 0;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
if (bus) {
|
|
|
|
sd_bus_flush(bus);
|
|
|
|
sd_bus_unref(bus);
|
|
|
|
}
|
|
|
|
|
|
|
|
return INT_TO_PTR(r);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int client(struct context *c) {
|
tree-wide: expose "p"-suffix unref calls in public APIs to make gcc cleanup easy
GLIB has recently started to officially support the gcc cleanup
attribute in its public API, hence let's do the same for our APIs.
With this patch we'll define an xyz_unrefp() call for each public
xyz_unref() call, to make it easy to use inside a
__attribute__((cleanup())) expression. Then, all code is ported over to
make use of this.
The new calls are also documented in the man pages, with examples how to
use them (well, I only added docs where the _unref() call itself already
had docs, and the examples, only cover sd_bus_unrefp() and
sd_event_unrefp()).
This also renames sd_lldp_free() to sd_lldp_unref(), since that's how we
tend to call our destructors these days.
Note that this defines no public macro that wraps gcc's attribute and
makes it easier to use. While I think it's our duty in the library to
make our stuff easy to use, I figure it's not our duty to make gcc's own
features easy to use on its own. Most likely, client code which wants to
make use of this should define its own:
#define _cleanup_(function) __attribute__((cleanup(function)))
Or similar, to make the gcc feature easier to use.
Making this logic public has the benefit that we can remove three header
files whose only purpose was to define these functions internally.
See #2008.
2015-11-27 19:13:45 +01:00
|
|
|
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
|
|
|
|
_cleanup_(sd_bus_unrefp) sd_bus *bus = NULL;
|
|
|
|
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
|
2013-10-09 02:37:10 +02:00
|
|
|
const char *s;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert_se(sd_bus_new(&bus) >= 0);
|
|
|
|
assert_se(sd_bus_set_fd(bus, c->fds[1], c->fds[1]) >= 0);
|
|
|
|
assert_se(sd_bus_start(bus) >= 0);
|
|
|
|
|
2013-10-11 19:33:39 +02:00
|
|
|
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "NoOperation", &error, NULL, NULL);
|
|
|
|
assert_se(r >= 0);
|
|
|
|
|
2013-10-09 02:37:10 +02:00
|
|
|
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "AlterSomething", &error, &reply, "s", "hallo");
|
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
r = sd_bus_message_read(reply, "s", &s);
|
|
|
|
assert_se(r >= 0);
|
|
|
|
assert_se(streq(s, "<<<hallo>>>"));
|
|
|
|
|
|
|
|
sd_bus_message_unref(reply);
|
|
|
|
reply = NULL;
|
|
|
|
|
|
|
|
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "Doesntexist", &error, &reply, "");
|
|
|
|
assert_se(r < 0);
|
2013-10-16 06:10:04 +02:00
|
|
|
assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_UNKNOWN_METHOD));
|
2013-10-09 02:37:10 +02:00
|
|
|
|
|
|
|
sd_bus_error_free(&error);
|
|
|
|
|
|
|
|
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "AlterSomething", &error, &reply, "as", 1, "hallo");
|
|
|
|
assert_se(r < 0);
|
2013-10-16 06:10:04 +02:00
|
|
|
assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_INVALID_ARGS));
|
2013-10-09 02:37:10 +02:00
|
|
|
|
|
|
|
sd_bus_error_free(&error);
|
|
|
|
|
|
|
|
r = sd_bus_get_property(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "Something", &error, &reply, "s");
|
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
r = sd_bus_message_read(reply, "s", &s);
|
|
|
|
assert_se(r >= 0);
|
|
|
|
assert_se(streq(s, "<<<hallo>>>"));
|
|
|
|
|
|
|
|
sd_bus_message_unref(reply);
|
|
|
|
reply = NULL;
|
|
|
|
|
|
|
|
r = sd_bus_set_property(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "Something", &error, "s", "test");
|
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
r = sd_bus_get_property(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "Something", &error, &reply, "s");
|
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
r = sd_bus_message_read(reply, "s", &s);
|
|
|
|
assert_se(r >= 0);
|
|
|
|
assert_se(streq(s, "test"));
|
|
|
|
|
|
|
|
sd_bus_message_unref(reply);
|
|
|
|
reply = NULL;
|
|
|
|
|
2013-10-11 20:02:16 +02:00
|
|
|
r = sd_bus_set_property(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "AutomaticIntegerProperty", &error, "u", 815);
|
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
assert_se(c->automatic_integer_property == 815);
|
|
|
|
|
|
|
|
r = sd_bus_set_property(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "AutomaticStringProperty", &error, "s", "Du Dödel, Du!");
|
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
assert_se(streq(c->automatic_string_property, "Du Dödel, Du!"));
|
|
|
|
|
2013-10-09 02:37:10 +02:00
|
|
|
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.DBus.Introspectable", "Introspect", &error, &reply, "");
|
2013-10-11 04:52:38 +02:00
|
|
|
assert_se(r >= 0);
|
2013-10-09 02:37:10 +02:00
|
|
|
|
|
|
|
r = sd_bus_message_read(reply, "s", &s);
|
|
|
|
assert_se(r >= 0);
|
|
|
|
fputs(s, stdout);
|
|
|
|
|
|
|
|
sd_bus_message_unref(reply);
|
|
|
|
reply = NULL;
|
|
|
|
|
|
|
|
r = sd_bus_get_property(bus, "org.freedesktop.systemd.test", "/value/xuzz", "org.freedesktop.systemd.ValueTest", "Value", &error, &reply, "s");
|
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
r = sd_bus_message_read(reply, "s", &s);
|
|
|
|
assert_se(r >= 0);
|
|
|
|
log_info("read %s", s);
|
|
|
|
|
|
|
|
sd_bus_message_unref(reply);
|
|
|
|
reply = NULL;
|
|
|
|
|
|
|
|
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/", "org.freedesktop.DBus.Introspectable", "Introspect", &error, &reply, "");
|
2013-10-11 04:52:38 +02:00
|
|
|
assert_se(r >= 0);
|
2013-10-09 02:37:10 +02:00
|
|
|
|
|
|
|
r = sd_bus_message_read(reply, "s", &s);
|
|
|
|
assert_se(r >= 0);
|
|
|
|
fputs(s, stdout);
|
|
|
|
|
|
|
|
sd_bus_message_unref(reply);
|
|
|
|
reply = NULL;
|
|
|
|
|
|
|
|
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/value", "org.freedesktop.DBus.Introspectable", "Introspect", &error, &reply, "");
|
2013-10-11 04:52:38 +02:00
|
|
|
assert_se(r >= 0);
|
2013-10-09 02:37:10 +02:00
|
|
|
|
|
|
|
r = sd_bus_message_read(reply, "s", &s);
|
|
|
|
assert_se(r >= 0);
|
|
|
|
fputs(s, stdout);
|
|
|
|
|
|
|
|
sd_bus_message_unref(reply);
|
|
|
|
reply = NULL;
|
|
|
|
|
|
|
|
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/value/a", "org.freedesktop.DBus.Introspectable", "Introspect", &error, &reply, "");
|
2013-10-11 04:52:38 +02:00
|
|
|
assert_se(r >= 0);
|
2013-10-09 02:37:10 +02:00
|
|
|
|
|
|
|
r = sd_bus_message_read(reply, "s", &s);
|
|
|
|
assert_se(r >= 0);
|
|
|
|
fputs(s, stdout);
|
|
|
|
|
|
|
|
sd_bus_message_unref(reply);
|
|
|
|
reply = NULL;
|
|
|
|
|
|
|
|
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.DBus.Properties", "GetAll", &error, &reply, "s", "");
|
2013-10-11 04:52:38 +02:00
|
|
|
assert_se(r >= 0);
|
2013-10-09 02:37:10 +02:00
|
|
|
|
2020-01-23 18:42:54 +01:00
|
|
|
sd_bus_message_dump(reply, stdout, SD_BUS_MESSAGE_DUMP_WITH_HEADER);
|
2013-10-09 02:37:10 +02:00
|
|
|
|
|
|
|
sd_bus_message_unref(reply);
|
|
|
|
reply = NULL;
|
|
|
|
|
|
|
|
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/value/a", "org.freedesktop.DBus.Properties", "GetAll", &error, &reply, "s", "org.freedesktop.systemd.ValueTest2");
|
|
|
|
assert_se(r < 0);
|
2013-10-16 06:10:04 +02:00
|
|
|
assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_UNKNOWN_INTERFACE));
|
2013-10-09 02:37:10 +02:00
|
|
|
sd_bus_error_free(&error);
|
|
|
|
|
2013-10-11 04:52:38 +02:00
|
|
|
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.DBus.ObjectManager", "GetManagedObjects", &error, &reply, "");
|
|
|
|
assert_se(r < 0);
|
2013-10-16 06:10:04 +02:00
|
|
|
assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_UNKNOWN_METHOD));
|
2013-10-11 04:52:38 +02:00
|
|
|
sd_bus_error_free(&error);
|
|
|
|
|
|
|
|
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/value", "org.freedesktop.DBus.ObjectManager", "GetManagedObjects", &error, &reply, "");
|
|
|
|
assert_se(r >= 0);
|
|
|
|
|
2020-01-23 18:42:54 +01:00
|
|
|
sd_bus_message_dump(reply, stdout, SD_BUS_MESSAGE_DUMP_WITH_HEADER);
|
2013-10-11 04:52:38 +02:00
|
|
|
|
|
|
|
sd_bus_message_unref(reply);
|
|
|
|
reply = NULL;
|
|
|
|
|
2013-10-11 05:22:00 +02:00
|
|
|
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/value/a", "org.freedesktop.systemd.ValueTest", "NotifyTest", &error, NULL, "");
|
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
r = sd_bus_process(bus, &reply);
|
|
|
|
assert_se(r > 0);
|
|
|
|
|
|
|
|
assert_se(sd_bus_message_is_signal(reply, "org.freedesktop.DBus.Properties", "PropertiesChanged"));
|
2020-01-23 18:42:54 +01:00
|
|
|
sd_bus_message_dump(reply, stdout, SD_BUS_MESSAGE_DUMP_WITH_HEADER);
|
2013-12-22 03:22:34 +01:00
|
|
|
|
|
|
|
sd_bus_message_unref(reply);
|
|
|
|
reply = NULL;
|
|
|
|
|
|
|
|
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/value/a", "org.freedesktop.systemd.ValueTest", "NotifyTest2", &error, NULL, "");
|
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
r = sd_bus_process(bus, &reply);
|
|
|
|
assert_se(r > 0);
|
|
|
|
|
|
|
|
assert_se(sd_bus_message_is_signal(reply, "org.freedesktop.DBus.Properties", "PropertiesChanged"));
|
2020-01-23 18:42:54 +01:00
|
|
|
sd_bus_message_dump(reply, stdout, SD_BUS_MESSAGE_DUMP_WITH_HEADER);
|
2013-10-11 23:22:29 +02:00
|
|
|
|
|
|
|
sd_bus_message_unref(reply);
|
|
|
|
reply = NULL;
|
|
|
|
|
|
|
|
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "EmitInterfacesAdded", &error, NULL, "");
|
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
r = sd_bus_process(bus, &reply);
|
|
|
|
assert_se(r > 0);
|
|
|
|
|
|
|
|
assert_se(sd_bus_message_is_signal(reply, "org.freedesktop.DBus.ObjectManager", "InterfacesAdded"));
|
2020-01-23 18:42:54 +01:00
|
|
|
sd_bus_message_dump(reply, stdout, SD_BUS_MESSAGE_DUMP_WITH_HEADER);
|
2013-10-11 23:22:29 +02:00
|
|
|
|
|
|
|
sd_bus_message_unref(reply);
|
|
|
|
reply = NULL;
|
|
|
|
|
|
|
|
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "EmitInterfacesRemoved", &error, NULL, "");
|
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
r = sd_bus_process(bus, &reply);
|
|
|
|
assert_se(r > 0);
|
|
|
|
|
|
|
|
assert_se(sd_bus_message_is_signal(reply, "org.freedesktop.DBus.ObjectManager", "InterfacesRemoved"));
|
2020-01-23 18:42:54 +01:00
|
|
|
sd_bus_message_dump(reply, stdout, SD_BUS_MESSAGE_DUMP_WITH_HEADER);
|
bus: add sd_bus_emit_object_{added/removed}()
This implements two new helpers, discussed on systemd-devel about 1 year
ago:
sd_bus_emit_object_added()
sd_bus_emit_object_removed()
Both calls are equivalent to their respective counterpart
sd_bus_emit_interfaces_{added/removed}(), but can figure out the list of
interfaces themselves, instead of requiring the caller to provide them.
Furthermore, both calls properly deal with builtin interfaces provided via
org.freedesktop.DBus.* and alike.
Both calls simply traverse a node and all its parent nodes to figure out a
list of all interfaces registered as vtable or fallback. It then appends
each of them, similar to the interfaces_{added/removed}() helpers.
Note that interfaces_{added/removed}() runs a parent traversal for *each*
passed interface. Therefore, it can simply bail out, once it found a
parent node that implements a given interface.
With object_{added/removed}() we cannot know the registered interfaces in
advance, thus, we cannot run one traversal per node. Instead, we run a
single traversal and remember all interfaces that we added. Therefore, a
child-interface overrides all conflicting parent-interfaces. We keep a
"Set *s" context to track those while climbing up the tree.
2014-12-30 11:37:35 +01:00
|
|
|
|
|
|
|
sd_bus_message_unref(reply);
|
|
|
|
reply = NULL;
|
|
|
|
|
|
|
|
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "EmitObjectAdded", &error, NULL, "");
|
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
r = sd_bus_process(bus, &reply);
|
|
|
|
assert_se(r > 0);
|
|
|
|
|
|
|
|
assert_se(sd_bus_message_is_signal(reply, "org.freedesktop.DBus.ObjectManager", "InterfacesAdded"));
|
2020-01-23 18:42:54 +01:00
|
|
|
sd_bus_message_dump(reply, stdout, SD_BUS_MESSAGE_DUMP_WITH_HEADER);
|
bus: add sd_bus_emit_object_{added/removed}()
This implements two new helpers, discussed on systemd-devel about 1 year
ago:
sd_bus_emit_object_added()
sd_bus_emit_object_removed()
Both calls are equivalent to their respective counterpart
sd_bus_emit_interfaces_{added/removed}(), but can figure out the list of
interfaces themselves, instead of requiring the caller to provide them.
Furthermore, both calls properly deal with builtin interfaces provided via
org.freedesktop.DBus.* and alike.
Both calls simply traverse a node and all its parent nodes to figure out a
list of all interfaces registered as vtable or fallback. It then appends
each of them, similar to the interfaces_{added/removed}() helpers.
Note that interfaces_{added/removed}() runs a parent traversal for *each*
passed interface. Therefore, it can simply bail out, once it found a
parent node that implements a given interface.
With object_{added/removed}() we cannot know the registered interfaces in
advance, thus, we cannot run one traversal per node. Instead, we run a
single traversal and remember all interfaces that we added. Therefore, a
child-interface overrides all conflicting parent-interfaces. We keep a
"Set *s" context to track those while climbing up the tree.
2014-12-30 11:37:35 +01:00
|
|
|
|
|
|
|
sd_bus_message_unref(reply);
|
|
|
|
reply = NULL;
|
|
|
|
|
|
|
|
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "EmitObjectRemoved", &error, NULL, "");
|
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
r = sd_bus_process(bus, &reply);
|
|
|
|
assert_se(r > 0);
|
|
|
|
|
|
|
|
assert_se(sd_bus_message_is_signal(reply, "org.freedesktop.DBus.ObjectManager", "InterfacesRemoved"));
|
2020-01-23 18:42:54 +01:00
|
|
|
sd_bus_message_dump(reply, stdout, SD_BUS_MESSAGE_DUMP_WITH_HEADER);
|
2013-10-11 05:22:00 +02:00
|
|
|
|
|
|
|
sd_bus_message_unref(reply);
|
|
|
|
reply = NULL;
|
|
|
|
|
2013-10-09 02:37:10 +02:00
|
|
|
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "Exit", &error, NULL, "");
|
|
|
|
assert_se(r >= 0);
|
|
|
|
|
|
|
|
sd_bus_flush(bus);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int main(int argc, char *argv[]) {
|
2013-11-21 19:34:37 +01:00
|
|
|
struct context c = {};
|
2013-10-09 02:37:10 +02:00
|
|
|
pthread_t s;
|
|
|
|
void *p;
|
|
|
|
int r, q;
|
|
|
|
|
2013-10-11 06:10:15 +02:00
|
|
|
c.automatic_integer_property = 4711;
|
2013-10-11 20:02:16 +02:00
|
|
|
assert_se(c.automatic_string_property = strdup("dudeldu"));
|
2013-10-11 06:10:15 +02:00
|
|
|
|
2013-10-09 02:37:10 +02:00
|
|
|
assert_se(socketpair(AF_UNIX, SOCK_STREAM, 0, c.fds) >= 0);
|
|
|
|
|
|
|
|
r = pthread_create(&s, NULL, server, &c);
|
|
|
|
if (r != 0)
|
|
|
|
return -r;
|
|
|
|
|
|
|
|
r = client(&c);
|
|
|
|
|
|
|
|
q = pthread_join(s, &p);
|
|
|
|
if (q != 0)
|
|
|
|
return -q;
|
|
|
|
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
if (PTR_TO_INT(p) < 0)
|
|
|
|
return PTR_TO_INT(p);
|
|
|
|
|
|
|
|
free(c.something);
|
2013-10-11 20:02:16 +02:00
|
|
|
free(c.automatic_string_property);
|
2013-10-09 02:37:10 +02:00
|
|
|
|
|
|
|
return EXIT_SUCCESS;
|
|
|
|
}
|