#include "set.h"
#include "missing.h"
#include "def.h"
+#include "cgroup-util.h"
#include "sd-bus.h"
#include "bus-internal.h"
}
static void bus_reset_queues(sd_bus *b) {
- unsigned i;
-
assert(b);
- for (i = 0; i < b->rqueue_size; i++)
- sd_bus_message_unref(b->rqueue[i]);
+ while (b->rqueue_size > 0)
+ sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
+
free(b->rqueue);
+ b->rqueue = NULL;
+ b->rqueue_allocated = 0;
- for (i = 0; i < b->wqueue_size; i++)
- sd_bus_message_unref(b->wqueue[i]);
- free(b->wqueue);
+ while (b->wqueue_size > 0)
+ sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
- b->rqueue = b->wqueue = NULL;
- b->rqueue_allocated = b->wqueue_allocated = 0;
- b->rqueue_size = b->wqueue_size = 0;
+ free(b->wqueue);
+ b->wqueue = NULL;
+ b->wqueue_allocated = 0;
}
static void bus_free(sd_bus *b) {
sd_bus_detach_event(b);
+ if (b->default_bus_ptr)
+ *b->default_bus_ptr = NULL;
+
bus_close_fds(b);
if (b->kdbus_buffer)
return bus_send_hello(bus);
}
+_public_ int sd_bus_open(sd_bus **ret) {
+ const char *e;
+ sd_bus *b;
+ int r;
+
+ assert_return(ret, -EINVAL);
+
+ /* Let's connect to the starter bus if it is set, and
+ * otherwise to the bus that is appropropriate for the scope
+ * we are running in */
+
+ e = secure_getenv("DBUS_STARTER_BUS_TYPE");
+ if (e) {
+ if (streq(e, "system"))
+ return sd_bus_open_system(ret);
+ else if (streq(e, "session") || streq(e, "user"))
+ return sd_bus_open_user(ret);
+ }
+
+ e = secure_getenv("DBUS_STARTER_ADDRESS");
+ if (!e) {
+ if (cg_pid_get_owner_uid(0, NULL) >= 0)
+ return sd_bus_open_user(ret);
+ else
+ return sd_bus_open_system(ret);
+ }
+
+ r = sd_bus_new(&b);
+ if (r < 0)
+ return r;
+
+ r = sd_bus_set_address(b, e);
+ if (r < 0)
+ goto fail;
+
+ b->bus_client = true;
+
+ /* We don't know whether the bus is trusted or not, so better
+ * be safe, and authenticate everything */
+ b->trusted = false;
+ b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
+
+ r = sd_bus_start(b);
+ if (r < 0)
+ goto fail;
+
+ *ret = b;
+ return 0;
+
+fail:
+ bus_free(b);
+ return r;
+}
+
_public_ int sd_bus_open_system(sd_bus **ret) {
const char *e;
sd_bus *b;
if (!bus)
return NULL;
- i = REFCNT_DEC(bus->n_ref);
- if (i != bus->rqueue_size + bus->wqueue_size)
- return NULL;
+ if (REFCNT_GET(bus->n_ref) == bus->rqueue_size + bus->wqueue_size + 1) {
+ bool q = true;
+
+ for (i = 0; i < bus->rqueue_size; i++)
+ if (bus->rqueue[i]->n_ref > 1) {
+ q = false;
+ break;
+ }
- for (i = 0; i < bus->rqueue_size; i++)
- if (bus->rqueue[i]->n_ref > 1)
- return NULL;
+ if (q) {
+ for (i = 0; i < bus->wqueue_size; i++)
+ if (bus->wqueue[i]->n_ref > 1) {
+ q = false;
+ break;
+ }
+ }
- for (i = 0; i < bus->wqueue_size; i++)
- if (bus->wqueue[i]->n_ref > 1)
- return NULL;
+ /* We are the only holders on the messages, and the
+ * messages are the only holders on us, so let's drop
+ * the messages and thus implicitly also kill our own
+ * last references */
- /* we are the only holders on the messages */
- bus_free(bus);
+ bus_reset_queues(bus);
+ }
+
+ i = REFCNT_DEC(bus->n_ref);
+ if (i > 0)
+ return NULL;
+ bus_free(bus);
return NULL;
}
return bus_default(sd_bus_open_user, &default_user_bus, ret);
}
+_public_ int sd_bus_default(sd_bus **ret) {
+
+ const char *e;
+
+ /* Let's try our best to reuse another cached connection. If
+ * the starter bus type is set, connect via our normal
+ * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
+ * we can share the connection with the user/system default
+ * bus. */
+
+ e = secure_getenv("DBUS_STARTER_BUS_TYPE");
+ if (e) {
+ if (streq(e, "system"))
+ return sd_bus_default_system(ret);
+ else if (streq(e, "user") || streq(e, "session"))
+ return sd_bus_default_user(ret);
+ }
+
+ /* No type is specified, so we have not other option than to
+ * use the starter address if it is set. */
+
+ e = secure_getenv("DBUS_STARTER_ADDRESS");
+ if (e) {
+ static thread_local sd_bus *default_starter_bus = NULL;
+
+ return bus_default(sd_bus_open, &default_starter_bus, ret);
+ }
+
+ /* Finally, if nothing is set use the cached connection for
+ * the right scope */
+
+ if (cg_pid_get_owner_uid(0, NULL) >= 0)
+ return sd_bus_default_user(ret);
+ else
+ return sd_bus_default_system(ret);
+}
+
_public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
assert_return(b, -EINVAL);
assert_return(tid, -EINVAL);
~ianmdlvl / elogind.git / blobdiff