return 0;
}
+_public_ int sd_bus_negotiate_attach_creds(sd_bus *bus, int b) {
+ assert_return(bus, -EINVAL);
+ assert_return(bus->state == BUS_UNSET, -EPERM);
+ assert_return(!bus_pid_changed(bus), -ECHILD);
+
+ SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_CREDS, b);
+ return 0;
+}
+
+_public_ int sd_bus_negotiate_attach_names(sd_bus *bus, int b) {
+ assert_return(bus, -EINVAL);
+ assert_return(bus->state == BUS_UNSET, -EPERM);
+ assert_return(!bus_pid_changed(bus), -ECHILD);
+
+ SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_NAMES, b);
+ return 0;
+}
+
_public_ int sd_bus_negotiate_attach_comm(sd_bus *bus, int b) {
assert_return(bus, -EINVAL);
assert_return(bus->state == BUS_UNSET, -EPERM);
if (r < 0)
return r;
- return sd_bus_send_with_reply(bus, m, hello_callback, NULL, 0, &bus->hello_serial);
+ return sd_bus_call_async(bus, m, hello_callback, NULL, 0, &bus->hello_serial);
}
int bus_start_running(sd_bus *bus) {
return 0;
}
-_public_ int sd_bus_send_with_reply(
+_public_ int sd_bus_call_async(
sd_bus *bus,
sd_bus_message *m,
sd_bus_message_handler_t callback,
r = prioq_put(bus->reply_callbacks_prioq, c, &c->prioq_idx);
if (r < 0) {
c->timeout = 0;
- sd_bus_send_with_reply_cancel(bus, c->serial);
+ sd_bus_call_async_cancel(bus, c->serial);
return r;
}
}
r = sd_bus_send(bus, m, serial);
if (r < 0) {
- sd_bus_send_with_reply_cancel(bus, c->serial);
+ sd_bus_call_async_cancel(bus, c->serial);
return r;
}
return r;
}
-_public_ int sd_bus_send_with_reply_cancel(sd_bus *bus, uint64_t serial) {
+_public_ int sd_bus_call_async_cancel(sd_bus *bus, uint64_t serial) {
struct reply_callback *c;
assert_return(bus, -EINVAL);
}
}
-_public_ int sd_bus_send_with_reply_and_block(
+_public_ int sd_bus_call(
sd_bus *bus,
sd_bus_message *m,
uint64_t usec,
sd_bus_message_unref(incoming);
return -EIO;
+
+ } else if (incoming->header->serial == serial &&
+ bus->unique_name &&
+ incoming->sender &&
+ streq(bus->unique_name, incoming->sender)) {
+
+ /* Our own message? Somebody is trying
+ * to send its own client a message,
+ * let's not dead-lock, let's fail
+ * immediately. */
+
+ sd_bus_message_unref(incoming);
+ return -ELOOP;
}
/* There's already guaranteed to be room for
}
static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- void *bus = userdata;
+ sd_bus *bus = userdata;
int r;
assert(bus);
}
static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
- void *bus = userdata;
+ sd_bus *bus = userdata;
int r;
assert(bus);
int r;
assert_return(bus, -EINVAL);
- assert_return(event, -EINVAL);
assert_return(!bus->event, -EBUSY);
assert(!bus->input_io_event_source);
assert(!bus->output_io_event_source);
assert(!bus->time_event_source);
- bus->event = sd_event_ref(event);
+ if (event)
+ bus->event = sd_event_ref(event);
+ else {
+ r = sd_event_default(&bus->event);
+ if (r < 0)
+ return r;
+ }
- r = sd_event_add_io(event, bus->input_fd, 0, io_callback, bus, &bus->input_io_event_source);
+ r = sd_event_add_io(bus->event, bus->input_fd, 0, io_callback, bus, &bus->input_io_event_source);
if (r < 0)
goto fail;
goto fail;
if (bus->output_fd != bus->input_fd) {
- r = sd_event_add_io(event, bus->output_fd, 0, io_callback, bus, &bus->output_io_event_source);
+ r = sd_event_add_io(bus->event, bus->output_fd, 0, io_callback, bus, &bus->output_io_event_source);
if (r < 0)
goto fail;
if (r < 0)
goto fail;
- r = sd_event_add_monotonic(event, 0, 0, time_callback, bus, &bus->time_event_source);
+ r = sd_event_add_monotonic(bus->event, 0, 0, time_callback, bus, &bus->time_event_source);
if (r < 0)
goto fail;
if (r < 0)
goto fail;
- r = sd_event_add_quit(event, quit_callback, bus, &bus->quit_event_source);
+ r = sd_event_add_quit(bus->event, quit_callback, bus, &bus->quit_event_source);
if (r < 0)
goto fail;
return 0;
}
-sd_bus_message* sd_bus_get_current(sd_bus *bus) {
+_public_ sd_bus_message* sd_bus_get_current(sd_bus *bus) {
assert_return(bus, NULL);
return bus->current;
}
+
+static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
+ sd_bus *b = NULL;
+ int r;
+
+ assert(bus_open);
+ assert(default_bus);
+
+ if (!ret)
+ return !!*default_bus;
+
+ if (*default_bus) {
+ *ret = sd_bus_ref(*default_bus);
+ return 0;
+ }
+
+ r = bus_open(&b);
+ if (r < 0)
+ return r;
+
+ b->default_bus_ptr = default_bus;
+ b->tid = gettid();
+ *default_bus = b;
+
+ *ret = b;
+ return 1;
+}
+
+_public_ int sd_bus_default_system(sd_bus **ret) {
+ static __thread sd_bus *default_system_bus = NULL;
+
+ return bus_default(sd_bus_open_system, &default_system_bus, ret);
+}
+
+_public_ int sd_bus_default_user(sd_bus **ret) {
+ static __thread sd_bus *default_user_bus = NULL;
+
+ return bus_default(sd_bus_open_user, &default_user_bus, ret);
+}
+
+_public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
+ assert_return(b, -EINVAL);
+ assert_return(tid, -EINVAL);
+ assert_return(!bus_pid_changed(b), -ECHILD);
+
+ if (b->tid != 0) {
+ *tid = b->tid;
+ return 0;
+ }
+
+ if (b->event)
+ return sd_event_get_tid(b->event, tid);
+
+ return -ENXIO;
+}