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