static pa_hook_result_t device_new_hook_cb(pa_core *c, pa_object *o, struct userdata *u) {
struct device_info *d;
pa_source *source;
pa_sink *sink;
pa_assert(c);
pa_object_assert_ref(o);
pa_assert(u);
source = pa_source_isinstance(o) ? PA_SOURCE(o) : NULL;
sink = pa_sink_isinstance(o) ? PA_SINK(o) : NULL;
/* Never suspend monitors */
if (source && source->monitor_of)
return PA_HOOK_OK;
pa_assert(source || sink);
d = pa_xnew(struct device_info, 1);
d->userdata = u;
d->source = source ? pa_source_ref(source) : NULL;
d->sink = sink ? pa_sink_ref(sink) : NULL;
d->time_event = pa_core_rttime_new(c, PA_USEC_INVALID, timeout_cb, d);
pa_hashmap_put(u->device_infos, o, d);
if ((d->sink && pa_sink_check_suspend(d->sink) <= 0) ||
(d->source && pa_source_check_suspend(d->source) <= 0))
restart(d);
return PA_HOOK_OK;
}
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;
}
static struct service *get_service(struct userdata *u, pa_object *device) {
struct service *s;
char *hn, *un;
const char *n;
pa_assert(u);
pa_object_assert_ref(device);
if ((s = pa_hashmap_get(u->services, device)))
return s;
s = pa_xnew0(struct service, 1);
s->userdata = u;
s->device = device;
if (pa_sink_isinstance(device)) {
if (!(n = pa_proplist_gets(PA_SINK(device)->proplist, PA_PROP_DEVICE_DESCRIPTION)))
n = PA_SINK(device)->name;
} else {
if (!(n = pa_proplist_gets(PA_SOURCE(device)->proplist, PA_PROP_DEVICE_DESCRIPTION)))
n = PA_SOURCE(device)->name;
}
hn = pa_get_host_name_malloc();
un = pa_get_user_name_malloc();
s->service_name = pa_truncate_utf8(pa_sprintf_malloc("%s@%s: %s", un, hn, n), kDNSServiceMaxDomainName-1);
pa_xfree(un);
pa_xfree(hn);
pa_hashmap_put(u->services, s->device, s);
return s;
}
static void card_changed(struct userdata *u, struct udev_device *dev) {
struct device *d;
const char *path;
const char *t;
char *n;
pa_assert(u);
pa_assert(dev);
/* Maybe /dev/snd is now available? */
setup_inotify(u);
path = udev_device_get_devpath(dev);
if ((d = pa_hashmap_get(u->devices, path))) {
verify_access(u, d);
return;
}
d = pa_xnew0(struct device, 1);
d->path = pa_xstrdup(path);
d->module = PA_INVALID_INDEX;
PA_INIT_RATELIMIT(d->ratelimit, 10*PA_USEC_PER_SEC, 5);
if (!(t = udev_device_get_property_value(dev, "PULSE_NAME")))
if (!(t = udev_device_get_property_value(dev, "ID_ID")))
if (!(t = udev_device_get_property_value(dev, "ID_PATH")))
t = path_get_card_id(path);
n = pa_namereg_make_valid_name(t);
d->card_name = pa_sprintf_malloc("alsa_card.%s", n);
d->args = pa_sprintf_malloc("device_id=\"%s\" "
"name=\"%s\" "
"card_name=\"%s\" "
"namereg_fail=false "
"tsched=%s "
"fixed_latency_range=%s "
"ignore_dB=%s "
"deferred_volume=%s "
"use_ucm=1 "
"card_properties=\"module-udev-detect.discovered=1\"",
path_get_card_id(path),
n,
d->card_name,
pa_yes_no(u->use_tsched),
pa_yes_no(u->fixed_latency_range),
pa_yes_no(u->ignore_dB),
pa_yes_no(u->deferred_volume));
pa_xfree(n);
pa_hashmap_put(u->devices, d->path, d);
verify_access(u, d);
}
/* Self-locked */
pa_memblock* pa_memimport_get(pa_memimport *i, uint32_t block_id, uint32_t shm_id, size_t offset, size_t size) {
pa_memblock *b = NULL;
pa_memimport_segment *seg;
pa_assert(i);
pa_mutex_lock(i->mutex);
if ((b = pa_hashmap_get(i->blocks, PA_UINT32_TO_PTR(block_id)))) {
pa_memblock_ref(b);
goto finish;
}
if (pa_hashmap_size(i->blocks) >= PA_MEMIMPORT_SLOTS_MAX)
goto finish;
if (!(seg = pa_hashmap_get(i->segments, PA_UINT32_TO_PTR(shm_id))))
if (!(seg = segment_attach(i, shm_id)))
goto finish;
if (offset+size > seg->memory.size)
goto finish;
if (!(b = pa_flist_pop(PA_STATIC_FLIST_GET(unused_memblocks))))
b = pa_xnew(pa_memblock, 1);
PA_REFCNT_INIT(b);
b->pool = i->pool;
b->type = PA_MEMBLOCK_IMPORTED;
b->read_only = true;
b->is_silence = false;
pa_atomic_ptr_store(&b->data, (uint8_t*) seg->memory.ptr + offset);
b->length = size;
pa_atomic_store(&b->n_acquired, 0);
pa_atomic_store(&b->please_signal, 0);
b->per_type.imported.id = block_id;
b->per_type.imported.segment = seg;
pa_hashmap_put(i->blocks, PA_UINT32_TO_PTR(block_id), b);
seg->n_blocks++;
stat_add(b);
finish:
pa_mutex_unlock(i->mutex);
return b;
}
static pa_hook_result_t device_new_hook_cb(pa_core *c, pa_object *o, struct userdata *u) {
struct device_info *d;
pa_source *source;
pa_sink *sink;
const char *timeout_str;
int32_t timeout;
bool timeout_valid;
pa_assert(c);
pa_object_assert_ref(o);
pa_assert(u);
source = pa_source_isinstance(o) ? PA_SOURCE(o) : NULL;
sink = pa_sink_isinstance(o) ? PA_SINK(o) : NULL;
/* Never suspend monitors */
if (source && source->monitor_of)
return PA_HOOK_OK;
pa_assert(source || sink);
timeout_str = pa_proplist_gets(sink ? sink->proplist : source->proplist, "module-suspend-on-idle.timeout");
if (timeout_str && pa_atoi(timeout_str, &timeout) >= 0)
timeout_valid = true;
else
timeout_valid = false;
if (timeout_valid && timeout < 0)
return PA_HOOK_OK;
d = pa_xnew(struct device_info, 1);
d->userdata = u;
d->source = source ? pa_source_ref(source) : NULL;
d->sink = sink ? pa_sink_ref(sink) : NULL;
d->time_event = pa_core_rttime_new(c, PA_USEC_INVALID, timeout_cb, d);
if (timeout_valid)
d->timeout = timeout * PA_USEC_PER_SEC;
else
d->timeout = d->userdata->timeout;
pa_hashmap_put(u->device_infos, o, d);
if ((d->sink && pa_sink_check_suspend(d->sink) <= 0) ||
(d->source && pa_source_check_suspend(d->source) <= 0))
restart(d);
return PA_HOOK_OK;
}
int pa_shared_set(pa_core *c, const char *name, void *data) {
pa_shared *p;
pa_assert(c);
pa_assert(name);
pa_assert(data);
pa_assert(c->shared);
if (pa_hashmap_get(c->shared, name))
return -1;
p = shared_new(name, data);
pa_hashmap_put(c->shared, p->name, p);
return 0;
}
int pa_property_set(pa_core *c, const char *name, void *data) {
pa_property *p;
pa_assert(c);
pa_assert(name);
pa_assert(data);
pa_assert(c->properties);
if (pa_hashmap_get(c->properties, name))
return -1;
p = property_new(name, data);
pa_hashmap_put(c->properties, p->name, p);
return 0;
}
/* Should be called locked */
static pa_memimport_segment* segment_attach(pa_memimport *i, uint32_t shm_id) {
pa_memimport_segment* seg;
if (pa_hashmap_size(i->segments) >= PA_MEMIMPORT_SEGMENTS_MAX)
return NULL;
seg = pa_xnew0(pa_memimport_segment, 1);
if (pa_shm_attach_ro(&seg->memory, shm_id) < 0) {
pa_xfree(seg);
return NULL;
}
seg->import = i;
seg->trap = pa_memtrap_add(seg->memory.ptr, seg->memory.size);
pa_hashmap_put(i->segments, PA_UINT32_TO_PTR(seg->memory.id), seg);
return seg;
}
int mv_parse_steps(struct mv_userdata *u, const char *route, const char *step_string_call, const char *step_string_media) {
int count1 = 0;
int count2 = 0;
struct mv_volume_steps_set *set;
struct mv_volume_steps call_steps;
struct mv_volume_steps media_steps;
pa_assert(u);
pa_assert(u->steps);
pa_assert(route);
if (!step_string_call || !step_string_media) {
return 0;
}
count1 = mv_parse_single_steps(&call_steps, step_string_call);
if (count1 < 1) {
pa_log_warn("failed to parse call steps; %s", step_string_call);
return -1;
}
mv_normalize_steps(&call_steps);
count2 = mv_parse_single_steps(&media_steps, step_string_media);
if (count2 < 1) {
pa_log_warn("failed to parse media steps; %s", step_string_media);
return -1;
}
mv_normalize_steps(&media_steps);
set = pa_xnew0(struct mv_volume_steps_set, 1);
set->route = pa_xstrdup(route);
set->call = call_steps;
set->media = media_steps;
pa_log_debug("adding %d call and %d media steps with route %s",
set->call.n_steps,
set->media.n_steps,
set->route);
pa_hashmap_put(u->steps, set->route, set);
return count1 + count2;
}
int pa_cond_wait(pa_cond *c, pa_mutex *m) {
HANDLE event;
assert(c);
assert(m);
event = CreateEvent(NULL, FALSE, FALSE, NULL);
assert(event);
pa_hashmap_put(c->wait_events, event, event);
pa_mutex_unlock(m);
WaitForSingleObject(event, INFINITE);
pa_mutex_lock(m);
pa_hashmap_remove(c->wait_events, event);
CloseHandle(event);
return 0;
}
static void apply_cork(struct userdata *u, pa_sink *s, pa_sink_input *ignore, pa_bool_t cork) {
pa_sink_input *j;
uint32_t idx;
pa_assert(u);
pa_sink_assert_ref(s);
for (j = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); j; j = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx))) {
pa_bool_t corked;
const char *role;
if (j == ignore)
continue;
if (!(role = pa_proplist_gets(j->proplist, PA_PROP_MEDIA_ROLE)))
continue;
if (!pa_streq(role, "video") &&
!pa_streq(role, "music"))
continue;
corked = !!pa_hashmap_get(u->cork_state, j);
if (cork && !corked) {
pa_hashmap_put(u->cork_state, j, PA_INT_TO_PTR(1));
pa_sink_input_set_mute(j, TRUE, FALSE);
pa_sink_input_send_event(j, PA_STREAM_EVENT_REQUEST_CORK, NULL);
} else if (!cork) {
pa_hashmap_remove(u->cork_state, j);
if (corked) {
pa_sink_input_set_mute(j, FALSE, FALSE);
pa_sink_input_send_event(j, PA_STREAM_EVENT_REQUEST_UNCORK, NULL);
}
}
}
}
static pa_hook_result_t process(struct userdata *u, pa_proplist *p) {
struct rule *r;
time_t now;
const char *pn;
pa_assert(u);
pa_assert(p);
if (!(pn = pa_proplist_gets(p, PA_PROP_APPLICATION_PROCESS_BINARY)))
return PA_HOOK_OK;
if (*pn == '.' || strchr(pn, '/'))
return PA_HOOK_OK;
time(&now);
pa_log_debug("Looking for .desktop file for %s", pn);
if ((r = pa_hashmap_get(u->cache, pn))) {
if (now-r->timestamp > STAT_INTERVAL) {
r->timestamp = now;
update_rule(r);
}
} else {
make_room(u->cache);
r = pa_xnew0(struct rule, 1);
r->process_name = pa_xstrdup(pn);
r->timestamp = now;
pa_hashmap_put(u->cache, r->process_name, r);
update_rule(r);
}
apply_rule(r, p);
return PA_HOOK_OK;
}
static void devices_add(struct pa_classify_device **p_devices, const char *type,
const char *prop, enum pa_classify_method method, const char *arg,
pa_hashmap *ports, uint32_t flags)
{
struct pa_classify_device *devs;
struct pa_classify_device_def *d;
size_t newsize;
const char *method_name;
char *ports_string = NULL; /* Just for log output. */
pa_strbuf *buf; /* For building ports_string. */
pa_assert(p_devices);
pa_assert_se((devs = *p_devices));
newsize = sizeof(*devs) + sizeof(devs->defs[0]) * (devs->ndef + 1);
devs = *p_devices = pa_xrealloc(devs, newsize);
d = devs->defs + devs->ndef;
memset(d+1, 0, sizeof(devs->defs[0]));
d->type = pa_xstrdup(type);
d->prop = pa_xstrdup(prop);
buf = pa_strbuf_new();
if (ports && !pa_hashmap_isempty(ports)) {
struct pa_classify_port_entry *port;
void *state;
pa_bool_t first = TRUE;
/* Copy the ports hashmap to d->data.ports. */
d->data.ports = pa_hashmap_new(pa_idxset_string_hash_func,
pa_idxset_string_compare_func);
PA_HASHMAP_FOREACH(port, ports, state) {
struct pa_classify_port_entry *port_copy =
pa_xnew(struct pa_classify_port_entry, 1);
port_copy->device_name = pa_xstrdup(port->device_name);
port_copy->port_name = pa_xstrdup(port->port_name);
pa_hashmap_put(d->data.ports, port_copy->device_name, port_copy);
if (!first) {
pa_strbuf_putc(buf, ',');
}
first = FALSE;
pa_strbuf_printf(buf, "%s:%s", port->device_name, port->port_name);
}
}
d->data.flags = flags;
switch (method) {
case pa_method_equals:
method_name = "equals";
d->method = pa_classify_method_equals;
d->arg.string = pa_xstrdup(arg);
break;
case pa_method_startswith:
method_name = "startswidth";
d->method = pa_classify_method_startswith;
d->arg.string = pa_xstrdup(arg);
break;
case pa_method_matches:
method_name = "matches";
if (regcomp(&d->arg.rexp, arg, 0) == 0) {
d->method = pa_classify_method_matches;
break;
}
/* intentional fall trough */
default:
pa_log("%s: invalid device definition %s", __FUNCTION__, type);
memset(d, 0, sizeof(*d));
pa_strbuf_free(buf);
return;
}
devs->ndef++;
ports_string = pa_strbuf_tostring_free(buf);
pa_log_info("device '%s' added (%s|%s|%s|%s|0x%04x)",
type, d->prop, method_name, arg, ports_string, d->data.flags);
pa_xfree(ports_string);
}
static void resolver_cb(
AvahiServiceResolver *r,
AvahiIfIndex interface, AvahiProtocol protocol,
AvahiResolverEvent event,
const char *name, const char *type, const char *domain,
const char *host_name, const AvahiAddress *a, uint16_t port,
AvahiStringList *txt,
AvahiLookupResultFlags flags,
void *userdata) {
struct userdata *u = userdata;
struct tunnel *tnl;
pa_assert(u);
tnl = tunnel_new(interface, protocol, name, type, domain);
if (event != AVAHI_RESOLVER_FOUND)
pa_log("Resolving of '%s' failed: %s", name, avahi_strerror(avahi_client_errno(u->client)));
else {
char *device = NULL, *dname, *module_name, *args;
const char *t;
char at[AVAHI_ADDRESS_STR_MAX], cmt[PA_CHANNEL_MAP_SNPRINT_MAX];
pa_sample_spec ss;
pa_channel_map cm;
AvahiStringList *l;
pa_bool_t channel_map_set = FALSE;
pa_module *m;
ss = u->core->default_sample_spec;
cm = u->core->default_channel_map;
for (l = txt; l; l = l->next) {
char *key, *value;
pa_assert_se(avahi_string_list_get_pair(l, &key, &value, NULL) == 0);
if (pa_streq(key, "device")) {
pa_xfree(device);
device = value;
value = NULL;
} else if (pa_streq(key, "rate"))
ss.rate = (uint32_t) atoi(value);
else if (pa_streq(key, "channels"))
ss.channels = (uint8_t) atoi(value);
else if (pa_streq(key, "format"))
ss.format = pa_parse_sample_format(value);
else if (pa_streq(key, "channel_map")) {
pa_channel_map_parse(&cm, value);
channel_map_set = TRUE;
}
avahi_free(key);
avahi_free(value);
}
if (!channel_map_set && cm.channels != ss.channels)
pa_channel_map_init_extend(&cm, ss.channels, PA_CHANNEL_MAP_DEFAULT);
if (!pa_sample_spec_valid(&ss)) {
pa_log("Service '%s' contains an invalid sample specification.", name);
avahi_free(device);
goto finish;
}
if (!pa_channel_map_valid(&cm) || cm.channels != ss.channels) {
pa_log("Service '%s' contains an invalid channel map.", name);
avahi_free(device);
goto finish;
}
if (device)
dname = pa_sprintf_malloc("tunnel.%s.%s", host_name, device);
else
dname = pa_sprintf_malloc("tunnel.%s", host_name);
if (!pa_namereg_is_valid_name(dname)) {
pa_log("Cannot construct valid device name from credentials of service '%s'.", dname);
avahi_free(device);
pa_xfree(dname);
goto finish;
}
t = strstr(type, "sink") ? "sink" : "source";
module_name = pa_sprintf_malloc("module-tunnel-%s", t);
args = pa_sprintf_malloc("server=[%s]:%u "
"%s=%s "
"format=%s "
"channels=%u "
"rate=%u "
"%s_name=%s "
"channel_map=%s",
avahi_address_snprint(at, sizeof(at), a), port,
t, device,
pa_sample_format_to_string(ss.format),
ss.channels,
ss.rate,
t, dname,
pa_channel_map_snprint(cmt, sizeof(cmt), &cm));
pa_log_debug("Loading %s with arguments '%s'", module_name, args);
if ((m = pa_module_load(u->core, module_name, args))) {
tnl->module_index = m->index;
pa_hashmap_put(u->tunnels, tnl, tnl);
tnl = NULL;
}
pa_xfree(module_name);
pa_xfree(dname);
pa_xfree(args);
avahi_free(device);
}
finish:
avahi_service_resolver_free(r);
if (tnl)
tunnel_free(tnl);
}
static void resolver_cb(
AvahiServiceResolver *r,
AvahiIfIndex interface, AvahiProtocol protocol,
AvahiResolverEvent event,
const char *name, const char *type, const char *domain,
const char *host_name, const AvahiAddress *a, uint16_t port,
AvahiStringList *txt,
AvahiLookupResultFlags flags,
void *userdata) {
struct userdata *u = userdata;
struct tunnel *tnl;
char *device = NULL, *nicename, *dname, *vname, *args;
char *tp = NULL, *et = NULL, *cn = NULL;
char *ch = NULL, *ss = NULL, *sr = NULL;
char *t = NULL;
char at[AVAHI_ADDRESS_STR_MAX];
AvahiStringList *l;
pa_module *m;
pa_assert(u);
tnl = tunnel_new(interface, protocol, name, type, domain);
if (event != AVAHI_RESOLVER_FOUND) {
pa_log("Resolving of '%s' failed: %s", name, avahi_strerror(avahi_client_errno(u->client)));
goto finish;
}
if ((nicename = strstr(name, "@"))) {
++nicename;
if (strlen(nicename) > 0) {
pa_log_debug("Found RAOP: %s", nicename);
nicename = pa_escape(nicename, "\"'");
} else
nicename = NULL;
}
for (l = txt; l; l = l->next) {
char *key, *value;
pa_assert_se(avahi_string_list_get_pair(l, &key, &value, NULL) == 0);
pa_log_debug("Found key: '%s' with value: '%s'", key, value);
if (pa_streq(key, "device")) {
device = value;
value = NULL;
} else if (pa_streq(key, "tp")) {
/* Transport protocol:
* - TCP = only TCP,
* - UDP = only UDP,
* - TCP,UDP = both supported (UDP should be prefered) */
pa_xfree(tp);
if (pa_str_in_list(value, ",", "UDP"))
tp = pa_xstrdup("UDP");
else if (pa_str_in_list(value, ",", "TCP"))
tp = pa_xstrdup("TCP");
else
tp = pa_xstrdup(value);
} else if (pa_streq(key, "et")) {
/* Supported encryption types:
* - 0 = none,
* - 1 = RSA,
* - 2 = FairPlay,
* - 3 = MFiSAP,
* - 4 = FairPlay SAPv2.5. */
pa_xfree(et);
if (pa_str_in_list(value, ",", "1"))
et = pa_xstrdup("RSA");
else
et = pa_xstrdup("none");
} else if (pa_streq(key, "cn")) {
/* Suported audio codecs:
* - 0 = PCM,
* - 1 = ALAC,
* - 2 = AAC,
* - 3 = AAC ELD. */
pa_xfree(cn);
if (pa_str_in_list(value, ",", "1"))
cn = pa_xstrdup("ALAC");
else
cn = pa_xstrdup("PCM");
} else if (pa_streq(key, "md")) {
/* Supported metadata types:
* - 0 = text,
* - 1 = artwork,
* - 2 = progress. */
} else if (pa_streq(key, "pw")) {
/* Requires password ? (true/false) */
} else if (pa_streq(key, "ch")) {
/* Number of channels */
pa_xfree(ch);
ch = pa_xstrdup(value);
} else if (pa_streq(key, "ss")) {
/* Sample size */
pa_xfree(ss);
ss = pa_xstrdup(value);
} else if (pa_streq(key, "sr")) {
/* Sample rate */
pa_xfree(sr);
sr = pa_xstrdup(value);
}
avahi_free(key);
avahi_free(value);
}
if (device)
dname = pa_sprintf_malloc("raop_output.%s.%s", host_name, device);
else
dname = pa_sprintf_malloc("raop_output.%s", host_name);
if (!(vname = pa_namereg_make_valid_name(dname))) {
pa_log("Cannot construct valid device name from '%s'.", dname);
avahi_free(device);
pa_xfree(dname);
pa_xfree(tp);
pa_xfree(et);
pa_xfree(cn);
pa_xfree(ch);
pa_xfree(ss);
pa_xfree(sr);
goto finish;
}
avahi_free(device);
pa_xfree(dname);
avahi_address_snprint(at, sizeof(at), a);
if (nicename) {
args = pa_sprintf_malloc("server=[%s]:%u "
"sink_name=%s "
"sink_properties='device.description=\"%s (%s:%u)\"'",
at, port,
vname,
nicename, at, port);
pa_xfree(nicename);
} else {
args = pa_sprintf_malloc("server=[%s]:%u "
"sink_name=%s"
"sink_properties='device.description=\"%s:%u\"'",
at, port,
vname,
at, port);
}
if (tp != NULL) {
t = args;
args = pa_sprintf_malloc("%s protocol=%s", args, tp);
pa_xfree(tp);
pa_xfree(t);
}
if (et != NULL) {
t = args;
args = pa_sprintf_malloc("%s encryption=%s", args, et);
pa_xfree(et);
pa_xfree(t);
}
if (cn != NULL) {
t = args;
args = pa_sprintf_malloc("%s codec=%s", args, cn);
pa_xfree(cn);
pa_xfree(t);
}
if (ch != NULL) {
t = args;
args = pa_sprintf_malloc("%s channels=%s", args, ch);
pa_xfree(ch);
pa_xfree(t);
}
if (ss != NULL) {
t = args;
args = pa_sprintf_malloc("%s format=%s", args, ss);
pa_xfree(ss);
pa_xfree(t);
}
if (sr != NULL) {
t = args;
args = pa_sprintf_malloc("%s rate=%s", args, sr);
pa_xfree(sr);
pa_xfree(t);
}
pa_log_debug("Loading module-raop-sink with arguments '%s'", args);
if ((m = pa_module_load(u->core, "module-raop-sink", args))) {
tnl->module_index = m->index;
pa_hashmap_put(u->tunnels, tnl, tnl);
tnl = NULL;
}
pa_xfree(vname);
pa_xfree(args);
finish:
avahi_service_resolver_free(r);
if (tnl)
tunnel_free(tnl);
}
static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint32_t idx, void *userdata) {
struct userdata *u = userdata;
pa_sink_input *si = NULL;
pa_source_output *so = NULL;
struct rule *r;
char *name;
pa_assert(c);
pa_assert(u);
if (t != (PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_NEW) &&
t != (PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE) &&
t != (PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_NEW) &&
t != (PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE))
return;
if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SINK_INPUT) {
if (!(si = pa_idxset_get_by_index(c->sink_inputs, idx)))
return;
if (!si->client || !(name = client_name(si->client)))
return;
} else {
pa_assert((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT);
if (!(so = pa_idxset_get_by_index(c->source_outputs, idx)))
return;
if (!so->client || !(name = client_name(so->client)))
return;
}
if ((r = pa_hashmap_get(u->hashmap, name))) {
pa_xfree(name);
if (si) {
if (!r->volume_is_set || !pa_cvolume_equal(pa_sink_input_get_volume(si), &r->volume)) {
pa_log_info("Saving volume for <%s>", r->name);
r->volume = *pa_sink_input_get_volume(si);
r->volume_is_set = TRUE;
u->modified = TRUE;
}
if (!r->sink || strcmp(si->sink->name, r->sink) != 0) {
pa_log_info("Saving sink for <%s>", r->name);
pa_xfree(r->sink);
r->sink = pa_xstrdup(si->sink->name);
u->modified = TRUE;
}
} else {
pa_assert(so);
if (!r->source || strcmp(so->source->name, r->source) != 0) {
pa_log_info("Saving source for <%s>", r->name);
pa_xfree(r->source);
r->source = pa_xstrdup(so->source->name);
u->modified = TRUE;
}
}
} else {
pa_log_info("Creating new entry for <%s>", name);
r = pa_xnew(struct rule, 1);
r->name = name;
if (si) {
r->volume = *pa_sink_input_get_volume(si);
r->volume_is_set = TRUE;
r->sink = pa_xstrdup(si->sink->name);
r->source = NULL;
} else {
pa_assert(so);
r->volume_is_set = FALSE;
r->sink = NULL;
r->source = pa_xstrdup(so->source->name);
}
pa_hashmap_put(u->hashmap, r->name, r);
u->modified = TRUE;
}
if (u->modified && !u->save_time_event) {
struct timeval tv;
pa_gettimeofday(&tv);
tv.tv_sec += SAVE_INTERVAL;
u->save_time_event = u->core->mainloop->time_new(u->core->mainloop, &tv, save_time_callback, u);
}
}
static int load_rules(struct userdata *u) {
FILE *f;
int n = 0;
int ret = -1;
char buf_name[256], buf_volume[256], buf_sink[256], buf_source[256];
char *ln = buf_name;
f = u->table_file ?
fopen(u->table_file, "r") :
pa_open_config_file(NULL, DEFAULT_VOLUME_TABLE_FILE, NULL, &u->table_file, "r");
if (!f) {
if (errno == ENOENT) {
pa_log_info("starting with empty ruleset.");
ret = 0;
} else
pa_log("failed to open file '%s': %s", u->table_file, pa_cstrerror(errno));
goto finish;
}
pa_lock_fd(fileno(f), 1);
while (!feof(f)) {
struct rule *rule;
pa_cvolume v;
pa_bool_t v_is_set;
if (!fgets(ln, sizeof(buf_name), f))
break;
n++;
pa_strip_nl(ln);
if (ln[0] == '#')
continue;
if (ln == buf_name) {
ln = buf_volume;
continue;
}
if (ln == buf_volume) {
ln = buf_sink;
continue;
}
if (ln == buf_sink) {
ln = buf_source;
continue;
}
pa_assert(ln == buf_source);
if (buf_volume[0]) {
if (!parse_volume(buf_volume, &v)) {
pa_log("parse failure in %s:%u, stopping parsing", u->table_file, n);
goto finish;
}
v_is_set = TRUE;
} else
v_is_set = FALSE;
ln = buf_name;
if (pa_hashmap_get(u->hashmap, buf_name)) {
pa_log("double entry in %s:%u, ignoring", u->table_file, n);
continue;
}
rule = pa_xnew(struct rule, 1);
rule->name = pa_xstrdup(buf_name);
if ((rule->volume_is_set = v_is_set))
rule->volume = v;
rule->sink = buf_sink[0] ? pa_xstrdup(buf_sink) : NULL;
rule->source = buf_source[0] ? pa_xstrdup(buf_source) : NULL;
pa_hashmap_put(u->hashmap, rule->name, rule);
}
if (ln != buf_name) {
pa_log("invalid number of lines in %s.", u->table_file);
goto finish;
}
ret = 0;
finish:
if (f) {
pa_lock_fd(fileno(f), 0);
fclose(f);
}
return ret;
}
static void resolver_cb(
AvahiServiceResolver *r,
AvahiIfIndex interface, AvahiProtocol protocol,
AvahiResolverEvent event,
const char *name, const char *type, const char *domain,
const char *host_name, const AvahiAddress *a, uint16_t port,
AvahiStringList *txt,
AvahiLookupResultFlags flags,
void *userdata) {
struct userdata *u = userdata;
struct tunnel *tnl;
pa_assert(u);
tnl = tunnel_new(interface, protocol, name, type, domain);
if (event != AVAHI_RESOLVER_FOUND)
pa_log("Resolving of '%s' failed: %s", name, avahi_strerror(avahi_client_errno(u->client)));
else {
char *device = NULL, *nicename, *dname, *vname, *args;
char at[AVAHI_ADDRESS_STR_MAX];
AvahiStringList *l;
pa_module *m;
if ((nicename = strstr(name, "@"))) {
++nicename;
if (strlen(nicename) > 0) {
pa_log_debug("Found RAOP: %s", nicename);
nicename = pa_escape(nicename, "\"'");
} else
nicename = NULL;
}
for (l = txt; l; l = l->next) {
char *key, *value;
pa_assert_se(avahi_string_list_get_pair(l, &key, &value, NULL) == 0);
pa_log_debug("Found key: '%s' with value: '%s'", key, value);
if (pa_streq(key, "device")) {
pa_xfree(device);
device = value;
value = NULL;
}
avahi_free(key);
avahi_free(value);
}
if (device)
dname = pa_sprintf_malloc("raop.%s.%s", host_name, device);
else
dname = pa_sprintf_malloc("raop.%s", host_name);
if (!(vname = pa_namereg_make_valid_name(dname))) {
pa_log("Cannot construct valid device name from '%s'.", dname);
avahi_free(device);
pa_xfree(dname);
goto finish;
}
pa_xfree(dname);
if (nicename) {
args = pa_sprintf_malloc("server=[%s]:%u "
"sink_name=%s "
"sink_properties='device.description=\"%s\"'",
avahi_address_snprint(at, sizeof(at), a), port,
vname,
nicename);
pa_xfree(nicename);
} else {
args = pa_sprintf_malloc("server=[%s]:%u "
"sink_name=%s",
avahi_address_snprint(at, sizeof(at), a), port,
vname);
}
pa_log_debug("Loading module-raop-sink with arguments '%s'", args);
if ((m = pa_module_load(u->core, "module-raop-sink", args))) {
tnl->module_index = m->index;
pa_hashmap_put(u->tunnels, tnl, tnl);
tnl = NULL;
}
pa_xfree(vname);
pa_xfree(args);
avahi_free(device);
}
finish:
avahi_service_resolver_free(r);
if (tnl)
tunnel_free(tnl);
}
int handle_event(struct userdata *u) {
int opcode;
int ret = 0;
do {
if ((opcode = read_byte(u)) < 0) {
if (errno == EINTR || errno == EAGAIN)
break;
goto fail;
}
switch (opcode) {
case '!':
/* The helper tool is now initialized */
ret = 1;
break;
case '+': {
char *name;
struct pa_module_info *m;
unsigned i, j;
if (!(name = read_string(u)))
goto fail;
if (!(m = pa_hashmap_get(u->module_infos, name))) {
m = pa_xnew(struct pa_module_info, 1);
m->userdata = u;
m->name = name;
m->n_items = 0;
pa_hashmap_put(u->module_infos, m->name, m);
} else
pa_xfree(name);
i = 0;
while (i < MAX_MODULES) {
char *module, *args;
if (!(module = read_string(u))) {
if (i > m->n_items) m->n_items = i;
goto fail;
}
if (!*module) {
pa_xfree(module);
break;
}
if (!(args = read_string(u))) {
pa_xfree(module);
if (i > m->n_items) m->n_items = i;
goto fail;
}
load_module(m, i, module, args, i >= m->n_items);
i++;
pa_xfree(module);
pa_xfree(args);
}
/* Unload all removed modules */
for (j = i; j < m->n_items; j++)
unload_one_module(m, j);
m->n_items = i;
break;
}
case '-': {
char *name;
if (!(name = read_string(u)))
goto fail;
pa_hashmap_remove_and_free(u->module_infos, name);
pa_xfree(name);
break;
}
}
