int pa_client_conf_env(pa_client_conf *c) {
char *e;
if ((e = getenv(ENV_DEFAULT_SINK))) {
pa_xfree(c->default_sink);
c->default_sink = pa_xstrdup(e);
}
if ((e = getenv(ENV_DEFAULT_SOURCE))) {
pa_xfree(c->default_source);
c->default_source = pa_xstrdup(e);
}
if ((e = getenv(ENV_DEFAULT_SERVER))) {
pa_xfree(c->default_server);
c->default_server = pa_xstrdup(e);
}
if ((e = getenv(ENV_DAEMON_BINARY))) {
pa_xfree(c->daemon_binary);
c->daemon_binary = pa_xstrdup(e);
}
if ((e = getenv(ENV_COOKIE_FILE))) {
pa_xfree(c->cookie_file);
c->cookie_file = pa_xstrdup(e);
return pa_client_conf_load_cookie(c);
}
return 0;
}
int pa_client_conf_env(pa_client_conf *c) {
char *e;
if ((e = getenv(ENV_DEFAULT_SINK))) {
pa_xfree(c->default_sink);
c->default_sink = pa_xstrdup(e);
}
if ((e = getenv(ENV_DEFAULT_SOURCE))) {
pa_xfree(c->default_source);
c->default_source = pa_xstrdup(e);
}
if ((e = getenv(ENV_DEFAULT_SERVER))) {
pa_xfree(c->default_server);
c->default_server = pa_xstrdup(e);
/* We disable autospawning automatically if a specific server was set */
c->autospawn = FALSE;
}
if ((e = getenv(ENV_DAEMON_BINARY))) {
pa_xfree(c->daemon_binary);
c->daemon_binary = pa_xstrdup(e);
}
if ((e = getenv(ENV_COOKIE_FILE))) {
pa_xfree(c->cookie_file);
c->cookie_file = pa_xstrdup(e);
return pa_client_conf_load_cookie(c);
}
return 0;
}
/* Runs in PA mainloop context */
static void get_service_data(struct service *s, pa_object *device) {
pa_assert(s);
if (pa_sink_isinstance(device)) {
pa_sink *sink = PA_SINK(device);
s->is_sink = true;
s->service_type = SERVICE_TYPE_SINK;
s->ss = sink->sample_spec;
s->cm = sink->channel_map;
s->name = pa_xstrdup(sink->name);
s->proplist = pa_proplist_copy(sink->proplist);
s->subtype = sink->flags & PA_SINK_HARDWARE ? SUBTYPE_HARDWARE : SUBTYPE_VIRTUAL;
} else if (pa_source_isinstance(device)) {
pa_source *source = PA_SOURCE(device);
s->is_sink = false;
s->service_type = SERVICE_TYPE_SOURCE;
s->ss = source->sample_spec;
s->cm = source->channel_map;
s->name = pa_xstrdup(source->name);
s->proplist = pa_proplist_copy(source->proplist);
s->subtype = source->monitor_of ? SUBTYPE_MONITOR : (source->flags & PA_SOURCE_HARDWARE ? SUBTYPE_HARDWARE : SUBTYPE_VIRTUAL);
} else
pa_assert_not_reached();
}
static int parse_categories(
const char *filename,
unsigned line,
const char *section,
const char *lvalue,
const char *rvalue,
void *data,
void *userdata) {
struct rule *r = userdata;
const char *state = NULL;
char *c;
while ((c = pa_split(rvalue, ";", &state))) {
if (pa_streq(c, "Game")) {
pa_xfree(r->role);
r->role = pa_xstrdup("game");
} else if (pa_streq(c, "Telephony")) {
pa_xfree(r->role);
r->role = pa_xstrdup("phone");
}
pa_xfree(c);
}
return 0;
}
static
struct pa_policy_context_variable *add_variable(struct pa_policy_context *ctx,
const char *name)
{
struct pa_policy_context_variable *var;
struct pa_policy_context_variable *last;
for (last = (struct pa_policy_context_variable *)&ctx->variables;
last->next != NULL;
last = last->next)
{
var = last->next;
if (!strcmp(name, var->name))
return var;
}
var = pa_xmalloc0(sizeof(*var));
var->name = pa_xstrdup(name);
var->value = pa_xstrdup("");
last->next = var;
pa_log_debug("created context variable '%s'", var->name);
return var;
}
void pa_log_set_ident(const char *p) {
pa_xfree(log_ident);
pa_xfree(log_ident_local);
log_ident = pa_xstrdup(p);
if (!(log_ident_local = pa_utf8_to_locale(log_ident)))
log_ident_local = pa_xstrdup(log_ident);
}
pa_client_conf *pa_client_conf_new(void) {
pa_client_conf *c = pa_xmemdup(&default_conf, sizeof(default_conf));
c->daemon_binary = pa_xstrdup(PA_BINARY);
c->extra_arguments = pa_xstrdup("--log-target=syslog");
c->cookie_file = pa_xstrdup(PA_NATIVE_COOKIE_FILE);
return c;
}
static struct port_info *port_info_new(pa_device_port *port) {
struct port_info *p_info;
if (port) {
p_info = pa_xnew0(struct port_info, 1);
p_info->name = pa_xstrdup(port->name);
p_info->offset = port->latency_offset;
if (port->preferred_profile)
p_info->profile = pa_xstrdup(port->preferred_profile);
} else
static struct tunnel *tunnel_new(
AvahiIfIndex interface, AvahiProtocol protocol,
const char *name, const char *type, const char *domain) {
struct tunnel *t;
t = pa_xnew(struct tunnel, 1);
t->interface = interface;
t->protocol = protocol;
t->name = pa_xstrdup(name);
t->type = pa_xstrdup(type);
t->domain = pa_xstrdup(domain);
t->module_index = PA_IDXSET_INVALID;
return t;
}
static void headers_read(pa_rtsp_client *c) {
char* token;
char delimiters[] = ";";
pa_assert(c);
pa_assert(c->response_headers);
pa_assert(c->callback);
/* Deal with a SETUP response */
if (STATE_SETUP == c->state) {
const char* token_state = NULL;
const char* pc = NULL;
c->session = pa_xstrdup(pa_headerlist_gets(c->response_headers, "Session"));
c->transport = pa_xstrdup(pa_headerlist_gets(c->response_headers, "Transport"));
if (!c->session || !c->transport) {
pa_log("Invalid SETUP response.");
return;
}
/* Now parse out the server port component of the response. */
while ((token = pa_split(c->transport, delimiters, &token_state))) {
if ((pc = strchr(token, '='))) {
if (0 == strncmp(token, "server_port", 11)) {
uint32_t p;
if (pa_atou(pc + 1, &p) < 0 || p <= 0 || p > 0xffff) {
pa_log("Invalid SETUP response (invalid server_port).");
pa_xfree(token);
return;
}
c->rtp_port = p;
pa_xfree(token);
break;
}
}
pa_xfree(token);
}
if (0 == c->rtp_port) {
/* Error no server_port in response */
pa_log("Invalid SETUP response (no port number).");
return;
}
}
/* Call our callback */
c->callback(c, c->state, c->response_headers, c->userdata);
}
int pa_daemon_conf_env(pa_daemon_conf *c) {
char *e;
pa_assert(c);
if ((e = getenv(ENV_DL_SEARCH_PATH))) {
pa_xfree(c->dl_search_path);
c->dl_search_path = pa_xstrdup(e);
}
if ((e = getenv(ENV_SCRIPT_FILE))) {
pa_xfree(c->default_script_file);
c->default_script_file = pa_xstrdup(e);
}
return 0;
}
int pa_format_info_get_prop_string(const pa_format_info *f, const char *key, char **v) {
const char *str = NULL;
json_object *o;
pa_assert(f);
pa_assert(key);
pa_assert(v);
str = pa_proplist_gets(f->plist, key);
if (!str)
return -PA_ERR_NOENTITY;
o = json_tokener_parse(str);
if (is_error(o)) {
pa_log_debug("Failed to parse format info property '%s'.", key);
return -PA_ERR_INVALID;
}
if (json_object_get_type(o) != json_type_string) {
pa_log_debug("Format info property '%s' type is not string.", key);
json_object_put(o);
return -PA_ERR_INVALID;
}
*v = pa_xstrdup(json_object_get_string(o));
json_object_put(o);
return 0;
}
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_flist *pa_flist_new_with_name(unsigned size, const char *name) {
pa_flist *l;
unsigned i;
pa_assert(name);
if (!size)
size = FLIST_SIZE;
l = pa_xmalloc0(sizeof(pa_flist) + sizeof(pa_flist_elem) * size);
l->name = pa_xstrdup(name);
l->size = size;
while (1 << l->tag_shift < (int) size)
l->tag_shift++;
l->index_mask = (1 << l->tag_shift) - 1;
l->tag_mask = INT_MAX - l->index_mask;
pa_atomic_store(&l->stored, -1);
pa_atomic_store(&l->empty, -1);
for (i=0; i < size; i++) {
stack_push(l, &l->empty, &l->table[i]);
}
return l;
}
pa_client *pa_client_new(pa_core *core, pa_client_new_data *data) {
pa_client *c;
pa_core_assert_ref(core);
pa_assert(data);
if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_CLIENT_NEW], data) < 0)
return NULL;
c = pa_xnew(pa_client, 1);
c->core = core;
c->proplist = pa_proplist_copy(data->proplist);
c->driver = pa_xstrdup(pa_path_get_filename(data->driver));
c->module = data->module;
c->sink_inputs = pa_idxset_new(NULL, NULL);
c->source_outputs = pa_idxset_new(NULL, NULL);
c->userdata = NULL;
c->kill = NULL;
c->send_event = NULL;
pa_assert_se(pa_idxset_put(core->clients, c, &c->index) >= 0);
pa_log_info("Created %u \"%s\"", c->index, pa_strnull(pa_proplist_gets(c->proplist, PA_PROP_APPLICATION_NAME)));
pa_subscription_post(core, PA_SUBSCRIPTION_EVENT_CLIENT|PA_SUBSCRIPTION_EVENT_NEW, c->index);
pa_hook_fire(&core->hooks[PA_CORE_HOOK_CLIENT_PUT], c);
pa_core_check_idle(core);
return c;
}
pa_inotify *pa_inotify_start(const char *filename, void *userdata, pa_inotify_cb cb, pa_core *core) {
pa_inotify *i = pa_xnew0(pa_inotify, 1);
pa_assert(i);
i->core = core;
pa_core_ref(core);
i->filename = pa_xstrdup(filename);
i->callback_data = userdata;
i->callback = cb;
i->fd = inotify_init1(IN_CLOEXEC|IN_NONBLOCK);
if (i->fd < 0) {
pa_log("inotify_init1() failed: %s", pa_cstrerror(errno));
pa_inotify_stop(i);
return NULL;
}
if (inotify_add_watch(i->fd, filename, IN_DELETE_SELF|IN_MOVE_SELF) < 0) {
pa_log("inotify_add_watch() failed: %s", pa_cstrerror(errno));
pa_inotify_stop(i);
return NULL;
}
pa_assert_se(i->io_event = core->mainloop->io_new(core->mainloop, i->fd, PA_IO_EVENT_INPUT, inotify_cb, i));
return i;
}
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;
}
static void register_profile(pa_bluetooth_backend *b, const char *profile, const char *uuid) {
DBusMessage *m;
DBusMessageIter i, d;
dbus_bool_t autoconnect;
dbus_uint16_t version, chan;
pa_log_debug("Registering Profile %s %s", profile, uuid);
pa_assert_se(m = dbus_message_new_method_call(BLUEZ_SERVICE, "/org/bluez", BLUEZ_PROFILE_MANAGER_INTERFACE, "RegisterProfile"));
dbus_message_iter_init_append(m, &i);
pa_assert_se(dbus_message_iter_append_basic(&i, DBUS_TYPE_OBJECT_PATH, &profile));
pa_assert_se(dbus_message_iter_append_basic(&i, DBUS_TYPE_STRING, &uuid));
dbus_message_iter_open_container(&i, DBUS_TYPE_ARRAY, DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING
DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &d);
if (pa_streq (uuid, PA_BLUETOOTH_UUID_HSP_HS)) {
/* In the headset role, the connection will only be initiated from the remote side */
autoconnect = 0;
pa_dbus_append_basic_variant_dict_entry(&d, "AutoConnect", DBUS_TYPE_BOOLEAN, &autoconnect);
chan = HSP_HS_DEFAULT_CHANNEL;
pa_dbus_append_basic_variant_dict_entry(&d, "Channel", DBUS_TYPE_UINT16, &chan);
/* HSP version 1.2 */
version = 0x0102;
pa_dbus_append_basic_variant_dict_entry(&d, "Version", DBUS_TYPE_UINT16, &version);
}
dbus_message_iter_close_container(&i, &d);
send_and_add_to_pending(b, m, register_profile_reply, pa_xstrdup(profile));
}
static void parse(pa_dynarray*a, const char *s, unsigned args) {
int infty = 0;
const char delimiter[] = " \t\n\r";
const char *p;
pa_assert(a);
pa_assert(s);
if (args == 0)
infty = 1;
p = s+strspn(s, delimiter);
while (*p && (infty || args >= 2)) {
size_t l = strcspn(p, delimiter);
char *n = pa_xstrndup(p, l);
pa_dynarray_append(a, n);
p += l;
p += strspn(p, delimiter);
args--;
}
if (args && *p) {
char *n = pa_xstrdup(p);
pa_dynarray_append(a, n);
}
}
int pa_scache_add_file_lazy(pa_core *c, const char *name, const char *filename, uint32_t *idx) {
pa_scache_entry *e;
#ifdef OS_IS_WIN32
char buf[MAX_PATH];
if (ExpandEnvironmentStrings(filename, buf, MAX_PATH))
filename = buf;
#endif
pa_assert(c);
pa_assert(name);
pa_assert(filename);
if (!(e = scache_add_item(c, name)))
return -1;
e->lazy = TRUE;
e->filename = pa_xstrdup(filename);
pa_proplist_sets(e->proplist, PA_PROP_MEDIA_FILENAME, filename);
if (!c->scache_auto_unload_event)
c->scache_auto_unload_event = pa_core_rttime_new(c, pa_rtclock_now() + UNLOAD_POLL_TIME, timeout_callback, c);
if (idx)
*idx = e->index;
return 0;
}
static char *parse_host(const char *s, uint16_t *ret_port) {
pa_assert(s);
pa_assert(ret_port);
if (*s == '[') {
char *e;
if (!(e = strchr(s+1, ']')))
return NULL;
if (e[1] == ':') {
uint32_t p;
if (pa_atou(e+2, &p) < 0)
return NULL;
*ret_port = (uint16_t) p;
} else if (e[1] != 0)
return NULL;
return pa_xstrndup(s+1, (size_t) (e-s-1));
} else {
char *e;
uint32_t p;
if (!(e = strrchr(s, ':')))
return pa_xstrdup(s);
if (pa_atou(e+1, &p) < 0)
return NULL;
*ret_port = (uint16_t) p;
return pa_xstrndup(s, (size_t) (e-s));
}
}
static
struct pa_policy_activity_variable *get_activity_variable(struct userdata *u, struct pa_policy_context *ctx,
const char *device)
{
struct pa_policy_activity_variable *var;
struct pa_policy_activity_variable *last;
for (last = (struct pa_policy_activity_variable *)&ctx->activities;
last->next != NULL;
last = last->next)
{
var = last->next;
if (!strcmp(device, var->device))
return var;
}
var = pa_xmalloc0(sizeof(*var));
var->device = pa_xstrdup(device);
var->userdata = u;
var->default_state = -1;
last->next = var;
pa_log_debug("created context activity variable '%s'", var->device);
return var;
}
void
pa_policy_context_add_property_action(struct pa_policy_context_rule *rule,
int lineno,
enum pa_policy_object_type obj_type,
enum pa_classify_method obj_classify,
const char *obj_name,
const char *prop_name,
enum pa_policy_value_type value_type,
... /* value_arg */)
{
union pa_policy_context_action *action;
struct pa_policy_set_property *setprop;
va_list value_arg;
action = pa_xmalloc0(sizeof(*action));
setprop = &action->setprop;
setprop->type = pa_policy_set_property;
setprop->lineno = lineno;
setprop->object.type = obj_type;
match_setup(&setprop->object.match, obj_classify, obj_name, NULL);
setprop->property = pa_xstrdup(prop_name);
va_start(value_arg, value_type);
value_setup(&setprop->value, value_type, value_arg);
va_end(value_arg);
append_action(&rule->actions, action);
}
int pa_format_info_get_prop_string(pa_format_info *f, const char *key, char **v) {
const char *str = NULL;
json_object *o;
pa_assert(f);
pa_assert(key);
pa_assert(v);
str = pa_proplist_gets(f->plist, key);
if (!str)
return -PA_ERR_NOENTITY;
o = json_tokener_parse(str);
if (is_error(o))
return -PA_ERR_INVALID;
if (json_object_get_type(o) != json_type_string) {
json_object_put(o);
return -PA_ERR_INVALID;
}
*v = pa_xstrdup(json_object_get_string(o));
json_object_put(o);
return 0;
}
static pa_autoload_entry* entry_new(pa_core *c, const char *name) {
pa_autoload_entry *e = NULL;
pa_core_assert_ref(c);
pa_assert(name);
if (c->autoload_hashmap && (e = pa_hashmap_get(c->autoload_hashmap, name)))
return NULL;
e = pa_xnew(pa_autoload_entry, 1);
e->core = c;
e->name = pa_xstrdup(name);
e->module = e->argument = NULL;
e->in_action = 0;
if (!c->autoload_hashmap)
c->autoload_hashmap = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
pa_assert(c->autoload_hashmap);
pa_hashmap_put(c->autoload_hashmap, e->name, e);
if (!c->autoload_idxset)
c->autoload_idxset = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
pa_idxset_put(c->autoload_idxset, e, &e->index);
pa_subscription_post(c, PA_SUBSCRIPTION_EVENT_AUTOLOAD|PA_SUBSCRIPTION_EVENT_NEW, e->index);
return e;
}
pa_socket_server* pa_socket_server_new_ipv4(pa_mainloop_api *m, uint32_t address, uint16_t port, pa_bool_t fallback, const char *tcpwrap_service) {
pa_socket_server *ss;
int fd = -1;
struct sockaddr_in sa;
int on = 1;
pa_assert(m);
pa_assert(port);
if ((fd = pa_socket_cloexec(PF_INET, SOCK_STREAM, 0)) < 0) {
pa_log("socket(PF_INET): %s", pa_cstrerror(errno));
goto fail;
}
#ifdef SO_REUSEADDR
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const void *) &on, sizeof(on)) < 0)
pa_log("setsockopt(): %s", pa_cstrerror(errno));
#endif
pa_make_tcp_socket_low_delay(fd);
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons(port);
sa.sin_addr.s_addr = htonl(address);
if (bind(fd, (struct sockaddr *) &sa, sizeof(sa)) < 0) {
if (errno == EADDRINUSE && fallback) {
sa.sin_port = 0;
if (bind(fd, (struct sockaddr *) &sa, sizeof(sa)) >= 0)
goto good;
}
pa_log("bind(): %s", pa_cstrerror(errno));
goto fail;
good:
;
}
if (listen(fd, 5) < 0) {
pa_log("listen(): %s", pa_cstrerror(errno));
goto fail;
}
if ((ss = pa_socket_server_new(m, fd))) {
ss->type = SOCKET_SERVER_IPV4;
ss->tcpwrap_service = pa_xstrdup(tcpwrap_service);
}
return ss;
fail:
if (fd >= 0)
pa_close(fd);
return NULL;
}
int pa_format_info_get_prop_string(const pa_format_info *f, const char *key, char **v) {
const char *str = NULL;
pa_json_object *o;
pa_assert(f);
pa_assert(key);
pa_assert(v);
str = pa_proplist_gets(f->plist, key);
if (!str)
return -PA_ERR_NOENTITY;
o = pa_json_parse(str);
if (!o) {
pa_log_debug("Failed to parse format info property '%s'.", key);
return -PA_ERR_INVALID;
}
if (pa_json_object_get_type(o) != PA_JSON_TYPE_STRING) {
pa_log_debug("Format info property '%s' type is not string.", key);
pa_json_object_free(o);
return -PA_ERR_INVALID;
}
*v = pa_xstrdup(pa_json_object_get_string(o));
pa_json_object_free(o);
return 0;
}
void pa_classify_add_stream(struct userdata *u, const char *prop,
enum pa_classify_method method, const char *arg,
const char *clnam, const char *sname, uid_t uid,
const char *exe, const char *grnam,
uint32_t flags, const char *port)
{
struct pa_classify *classify;
struct pa_policy_group *group;
pa_assert(u);
pa_assert_se((classify = u->classify));
if (((prop && method && arg) || uid != (uid_t)-1 || exe) && grnam) {
if (port) {
if ((group = pa_policy_group_find(u, grnam)) == NULL) {
flags &= ~PA_POLICY_LOCAL_ROUTE;
pa_log("can't find group '%s' for stream", grnam);
}
else {
group->portname = pa_xstrdup(port);
pa_log_debug("set portname '%s' for group '%s'", port, grnam);
}
}
streams_add(&classify->streams.defs, prop,method,arg,
clnam, sname, uid, exe, grnam, flags);
}
}
char *pa_sample_spec_to_mime_type(const pa_sample_spec *ss, const pa_channel_map *cm) {
pa_assert(pa_channel_map_compatible(cm, ss));
pa_assert(pa_sample_spec_valid(ss));
if (!pa_sample_spec_is_mime(ss, cm))
return NULL;
switch (ss->format) {
case PA_SAMPLE_S16BE:
case PA_SAMPLE_S24BE:
case PA_SAMPLE_U8:
/* Stupid UPnP implementations (PS3...) choke on spaces in
* the mime type, that's why we write only ';' here,
* instead of '; '. */
return pa_sprintf_malloc("audio/%s;rate=%u;channels=%u",
ss->format == PA_SAMPLE_S16BE ? "L16" :
(ss->format == PA_SAMPLE_S24BE ? "L24" : "L8"),
ss->rate, ss->channels);
case PA_SAMPLE_ULAW:
return pa_xstrdup("audio/basic");
default:
pa_assert_not_reached();
}
}
static struct port_info *port_info_new(pa_device_port *port) {
struct port_info *p_info;
if (port) {
p_info = pa_xnew(struct port_info, 1);
p_info->name = pa_xstrdup(port->name);
p_info->offset = port->latency_offset;
} else
