static pa_x11_wrapper* x11_wrapper_new(pa_core *c, const char *name, const char *t) {
pa_x11_wrapper*w;
Display *d;
if (!(d = XOpenDisplay(name))) {
pa_log("XOpenDisplay() failed");
return NULL;
}
w = pa_xnew(pa_x11_wrapper, 1);
PA_REFCNT_INIT(w);
w->core = c;
w->property_name = pa_xstrdup(t);
w->display = d;
PA_LLIST_HEAD_INIT(pa_x11_client, w->clients);
PA_LLIST_HEAD_INIT(pa_x11_internal, w->internals);
w->defer_event = c->mainloop->defer_new(c->mainloop, defer_event, w);
w->io_event = c->mainloop->io_new(c->mainloop, ConnectionNumber(d), PA_IO_EVENT_INPUT, display_io_event, w);
XAddConnectionWatch(d, x11_watch, (XPointer) w);
pa_assert_se(pa_shared_set(c, w->property_name, w) >= 0);
return w;
}
pa_auth_cookie* pa_auth_cookie_get(pa_core *core, const char *cn, bool create, size_t size) {
pa_auth_cookie *c;
char *t;
pa_assert(core);
pa_assert(size > 0);
t = pa_sprintf_malloc("auth-cookie%s%s", cn ? "@" : "", cn ? cn : "");
if ((c = pa_shared_get(core, t))) {
pa_xfree(t);
if (c->size != size)
return NULL;
return pa_auth_cookie_ref(c);
}
c = pa_xmalloc(PA_ALIGN(sizeof(pa_auth_cookie)) + size);
PA_REFCNT_INIT(c);
c->core = core;
c->name = t;
c->size = size;
pa_assert_se(pa_shared_set(core, t, c) >= 0);
if (pa_authkey_load(cn, create, (uint8_t*) c + PA_ALIGN(sizeof(pa_auth_cookie)), size) < 0) {
pa_auth_cookie_unref(c);
return NULL;
}
return c;
}
pa_auth_cookie *pa_auth_cookie_create(pa_core *core, const void *data, size_t size) {
pa_auth_cookie *c;
char *t;
pa_assert(core);
pa_assert(data);
pa_assert(size > 0);
t = pa_xstrdup("auth-cookie");
if ((c = pa_shared_get(core, t))) {
pa_xfree(t);
if (c->size != size)
return NULL;
return pa_auth_cookie_ref(c);
}
c = pa_xmalloc(PA_ALIGN(sizeof(pa_auth_cookie)) + size);
PA_REFCNT_INIT(c);
c->core = core;
c->name = t;
c->size = size;
pa_assert_se(pa_shared_set(core, t, c) >= 0);
memcpy((uint8_t *) c + PA_ALIGN(sizeof(pa_auth_cookie)), data, size);
return c;
}
int pa_shared_replace(pa_core *c, const char *name, void *data) {
pa_assert(c);
pa_assert(name);
(void) pa_shared_remove(c, name);
return pa_shared_set(c, name, data);
}
static pa_dbus_connection* dbus_connection_new(pa_core *c, pa_dbus_wrap_connection *conn, const char *name) {
pa_dbus_connection *pconn;
pconn = pa_xnew(pa_dbus_connection, 1);
PA_REFCNT_INIT(pconn);
pconn->core = c;
pconn->property_name = name;
pconn->connection = conn;
pa_shared_set(c, name, pconn);
return pconn;
}
static pa_simple_protocol* simple_protocol_new(pa_core *c) {
pa_simple_protocol *p;
pa_assert(c);
p = pa_xnew(pa_simple_protocol, 1);
PA_REFCNT_INIT(p);
p->core = c;
p->connections = pa_idxset_new(NULL, NULL);
pa_assert_se(pa_shared_set(c, "simple-protocol", p) >= 0);
return p;
}
pa_reserve_monitor_wrapper* pa_reserve_monitor_wrapper_get(pa_core *c, const char *device_name) {
pa_reserve_monitor_wrapper *w;
int k;
char *t;
#ifdef HAVE_DBUS
DBusError error;
dbus_error_init(&error);
#endif
pa_assert(c);
pa_assert(device_name);
t = pa_sprintf_malloc("reserve-monitor-wrapper@%s", device_name);
if ((w = pa_shared_get(c, t))) {
pa_xfree(t);
pa_assert(PA_REFCNT_VALUE(w) >= 1);
PA_REFCNT_INC(w);
return w;
}
w = pa_xnew0(pa_reserve_monitor_wrapper, 1);
PA_REFCNT_INIT(w);
w->core = c;
pa_hook_init(&w->hook, w);
w->shared_name = t;
pa_assert_se(pa_shared_set(c, w->shared_name, w) >= 0);
#ifdef HAVE_DBUS
if (!(w->connection = pa_dbus_bus_get(c, DBUS_BUS_SESSION, &error)) || dbus_error_is_set(&error)) {
pa_log_debug("Unable to contact D-Bus session bus: %s: %s", error.name, error.message);
/* We don't treat this as error here because we want allow PA
* to run even when no session bus is available. */
return w;
}
if ((k = rm_watch(
&w->monitor,
pa_dbus_connection_get(w->connection),
device_name,
change_cb,
NULL)) < 0) {
pa_log_debug("Failed to create watch on device '%s': %s", device_name, pa_cstrerror(-k));
goto fail;
}
pa_log_debug("Successfully create reservation lock monitor for device '%s'", device_name);
rm_set_userdata(w->monitor, w);
return w;
fail:
dbus_error_free(&error);
reserve_monitor_wrapper_free(w);
return NULL;
#else
return w;
#endif
}
pa_reserve_wrapper* pa_reserve_wrapper_get(pa_core *c, const char *device_name) {
pa_reserve_wrapper *r;
int k;
char *t;
#ifdef HAVE_DBUS
DBusError error;
dbus_error_init(&error);
#endif
pa_assert(c);
pa_assert(device_name);
t = pa_sprintf_malloc("reserve-wrapper@%s", device_name);
if ((r = pa_shared_get(c, t))) {
pa_xfree(t);
pa_assert(PA_REFCNT_VALUE(r) >= 1);
PA_REFCNT_INC(r);
return r;
}
r = pa_xnew0(pa_reserve_wrapper, 1);
PA_REFCNT_INIT(r);
r->core = c;
pa_hook_init(&r->hook, r);
r->shared_name = t;
pa_assert_se(pa_shared_set(c, r->shared_name, r) >= 0);
#ifdef HAVE_DBUS
if (!(r->connection = pa_dbus_bus_get(c, DBUS_BUS_SESSION, &error)) || dbus_error_is_set(&error)) {
pa_log_debug("Unable to contact D-Bus session bus: %s: %s", error.name, error.message);
/* We don't treat this as error here because we want allow PA
* to run even when no session bus is available. */
return r;
}
if ((k = rd_acquire(
&r->device,
pa_dbus_connection_get(r->connection),
device_name,
_("PulseAudio Sound Server"),
0,
request_cb,
NULL)) < 0) {
if (k == -EBUSY) {
pa_log_debug("Device '%s' already locked.", device_name);
goto fail;
} else {
pa_log_debug("Failed to acquire reservation lock on device '%s': %s", device_name, pa_cstrerror(-k));
return r;
}
}
pa_log_debug("Successfully acquired reservation lock on device '%s'", device_name);
rd_set_userdata(r->device, r);
return r;
fail:
dbus_error_free(&error);
reserve_wrapper_free(r);
return NULL;
#else
return r;
#endif
}
