2 This file is part of PulseAudio.
4 Copyright 2004-2006 Lennart Poettering
6 PulseAudio is free software; you can redistribute it and/or modify
7 it under the terms of the GNU Lesser General Public License as
8 published by the Free Software Foundation; either version 2.1 of the
9 License, or (at your option) any later version.
11 PulseAudio is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public
17 License along with PulseAudio; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
30 #include <avahi-client/client.h>
31 #include <avahi-client/publish.h>
32 #include <avahi-common/alternative.h>
33 #include <avahi-common/error.h>
34 #include <avahi-common/domain.h>
36 #include <pulse/xmalloc.h>
37 #include <pulse/util.h>
38 #include <pulse/thread-mainloop.h>
40 #include <pulsecore/parseaddr.h>
41 #include <pulsecore/sink.h>
42 #include <pulsecore/source.h>
43 #include <pulsecore/native-common.h>
44 #include <pulsecore/core-util.h>
45 #include <pulsecore/log.h>
46 #include <pulsecore/dynarray.h>
47 #include <pulsecore/modargs.h>
48 #include <pulsecore/avahi-wrap.h>
49 #include <pulsecore/protocol-native.h>
51 #include "module-zeroconf-publish-symdef.h"
53 PA_MODULE_AUTHOR("Lennart Poettering");
54 PA_MODULE_DESCRIPTION("mDNS/DNS-SD Service Publisher");
55 PA_MODULE_VERSION(PACKAGE_VERSION
);
56 PA_MODULE_LOAD_ONCE(true);
58 #define SERVICE_TYPE_SINK "_pulse-sink._tcp"
59 #define SERVICE_TYPE_SOURCE "_pulse-source._tcp"
60 #define SERVICE_TYPE_SERVER "_pulse-server._tcp"
61 #define SERVICE_SUBTYPE_SINK_HARDWARE "_hardware._sub."SERVICE_TYPE_SINK
62 #define SERVICE_SUBTYPE_SINK_VIRTUAL "_virtual._sub."SERVICE_TYPE_SINK
63 #define SERVICE_SUBTYPE_SOURCE_HARDWARE "_hardware._sub."SERVICE_TYPE_SOURCE
64 #define SERVICE_SUBTYPE_SOURCE_VIRTUAL "_virtual._sub."SERVICE_TYPE_SOURCE
65 #define SERVICE_SUBTYPE_SOURCE_MONITOR "_monitor._sub."SERVICE_TYPE_SOURCE
66 #define SERVICE_SUBTYPE_SOURCE_NON_MONITOR "_non-monitor._sub."SERVICE_TYPE_SOURCE
69 * Note: Because the core avahi-client calls result in synchronous D-Bus
70 * communication, calling any of those functions in the PA mainloop context
71 * could lead to the mainloop being blocked for long periods.
73 * To avoid this, we create a threaded-mainloop for Avahi calls, and push all
74 * D-Bus communication into that thread. The thumb-rule for the split is:
76 * 1. If access to PA data structures is needed, use the PA mainloop context
78 * 2. If a (blocking) avahi-client call is needed, use the Avahi mainloop
80 * We do have message queue to pass messages from the Avahi mainloop to the PA
84 static const char* const valid_modargs
[] = {
92 typedef struct avahi_msg avahi_msg
;
93 PA_DEFINE_PRIVATE_CLASS(avahi_msg
, pa_msgobject
);
96 AVAHI_MESSAGE_PUBLISH_ALL
,
97 AVAHI_MESSAGE_SHUTDOWN_START
,
98 AVAHI_MESSAGE_SHUTDOWN_COMPLETE
,
101 enum service_subtype
{
110 struct userdata
*userdata
;
111 AvahiEntryGroup
*entry_group
;
113 const char *service_type
;
114 enum service_subtype subtype
;
120 pa_proplist
*proplist
;
124 pa_thread_mq thread_mq
;
130 pa_mainloop_api
*api
;
131 pa_threaded_mainloop
*mainloop
;
133 AvahiPoll
*avahi_poll
;
136 pa_hashmap
*services
; /* protect with mainloop lock */
139 AvahiEntryGroup
*main_entry_group
;
141 pa_hook_slot
*sink_new_slot
, *source_new_slot
, *sink_unlink_slot
, *source_unlink_slot
, *sink_changed_slot
, *source_changed_slot
;
143 pa_native_protocol
*native
;
146 /* Runs in PA mainloop context */
147 static void get_service_data(struct service
*s
, pa_object
*device
) {
150 if (pa_sink_isinstance(device
)) {
151 pa_sink
*sink
= PA_SINK(device
);
154 s
->service_type
= SERVICE_TYPE_SINK
;
155 s
->ss
= sink
->sample_spec
;
156 s
->cm
= sink
->channel_map
;
157 s
->name
= pa_xstrdup(sink
->name
);
158 s
->proplist
= pa_proplist_copy(sink
->proplist
);
159 s
->subtype
= sink
->flags
& PA_SINK_HARDWARE
? SUBTYPE_HARDWARE
: SUBTYPE_VIRTUAL
;
161 } else if (pa_source_isinstance(device
)) {
162 pa_source
*source
= PA_SOURCE(device
);
165 s
->service_type
= SERVICE_TYPE_SOURCE
;
166 s
->ss
= source
->sample_spec
;
167 s
->cm
= source
->channel_map
;
168 s
->name
= pa_xstrdup(source
->name
);
169 s
->proplist
= pa_proplist_copy(source
->proplist
);
170 s
->subtype
= source
->monitor_of
? SUBTYPE_MONITOR
: (source
->flags
& PA_SOURCE_HARDWARE
? SUBTYPE_HARDWARE
: SUBTYPE_VIRTUAL
);
173 pa_assert_not_reached();
176 /* Can be used in either PA or Avahi mainloop context since the bits of u->core
177 * that we access don't change after startup. */
178 static AvahiStringList
* txt_record_server_data(pa_core
*c
, AvahiStringList
*l
) {
184 l
= avahi_string_list_add_pair(l
, "server-version", PACKAGE_NAME
" "PACKAGE_VERSION
);
186 t
= pa_get_user_name_malloc();
187 l
= avahi_string_list_add_pair(l
, "user-name", t
);
191 l
= avahi_string_list_add_pair(l
, "machine-id", t
);
194 t
= pa_uname_string();
195 l
= avahi_string_list_add_pair(l
, "uname", t
);
198 l
= avahi_string_list_add_pair(l
, "fqdn", pa_get_fqdn(s
, sizeof(s
)));
199 l
= avahi_string_list_add_printf(l
, "cookie=0x%08x", c
->cookie
);
204 static void publish_service(pa_mainloop_api
*api
, void *service
);
206 /* Runs in Avahi mainloop context */
207 static void service_entry_group_callback(AvahiEntryGroup
*g
, AvahiEntryGroupState state
, void *userdata
) {
208 struct service
*s
= userdata
;
214 case AVAHI_ENTRY_GROUP_ESTABLISHED
:
215 pa_log_info("Successfully established service %s.", s
->service_name
);
218 case AVAHI_ENTRY_GROUP_COLLISION
: {
221 t
= avahi_alternative_service_name(s
->service_name
);
222 pa_log_info("Name collision, renaming %s to %s.", s
->service_name
, t
);
223 pa_xfree(s
->service_name
);
226 publish_service(NULL
, s
);
230 case AVAHI_ENTRY_GROUP_FAILURE
: {
231 pa_log("Failed to register service: %s", avahi_strerror(avahi_client_errno(avahi_entry_group_get_client(g
))));
233 avahi_entry_group_free(g
);
234 s
->entry_group
= NULL
;
239 case AVAHI_ENTRY_GROUP_UNCOMMITED
:
240 case AVAHI_ENTRY_GROUP_REGISTERING
:
245 static void service_free(struct service
*s
);
247 /* Can run in either context */
248 static uint16_t compute_port(struct userdata
*u
) {
253 for (i
= pa_native_protocol_servers(u
->native
); i
; i
= pa_strlist_next(i
)) {
256 if (pa_parse_address(pa_strlist_data(i
), &a
) >= 0 &&
257 (a
.type
== PA_PARSED_ADDRESS_TCP4
||
258 a
.type
== PA_PARSED_ADDRESS_TCP6
||
259 a
.type
== PA_PARSED_ADDRESS_TCP_AUTO
) &&
262 pa_xfree(a
.path_or_host
);
266 pa_xfree(a
.path_or_host
);
269 return PA_NATIVE_DEFAULT_PORT
;
272 /* Runs in Avahi mainloop context */
273 static void publish_service(pa_mainloop_api
*api PA_GCC_UNUSED
, void *service
) {
274 struct service
*s
= (struct service
*) service
;
276 AvahiStringList
*txt
= NULL
;
277 char cm
[PA_CHANNEL_MAP_SNPRINT_MAX
];
280 const char * const subtype_text
[] = {
281 [SUBTYPE_HARDWARE
] = "hardware",
282 [SUBTYPE_VIRTUAL
] = "virtual",
283 [SUBTYPE_MONITOR
] = "monitor"
288 if (!s
->userdata
->client
|| avahi_client_get_state(s
->userdata
->client
) != AVAHI_CLIENT_S_RUNNING
)
291 if (!s
->entry_group
) {
292 if (!(s
->entry_group
= avahi_entry_group_new(s
->userdata
->client
, service_entry_group_callback
, s
))) {
293 pa_log("avahi_entry_group_new(): %s", avahi_strerror(avahi_client_errno(s
->userdata
->client
)));
297 avahi_entry_group_reset(s
->entry_group
);
299 txt
= txt_record_server_data(s
->userdata
->core
, txt
);
301 txt
= avahi_string_list_add_pair(txt
, "device", s
->name
);
302 txt
= avahi_string_list_add_printf(txt
, "rate=%u", s
->ss
.rate
);
303 txt
= avahi_string_list_add_printf(txt
, "channels=%u", s
->ss
.channels
);
304 txt
= avahi_string_list_add_pair(txt
, "format", pa_sample_format_to_string(s
->ss
.format
));
305 txt
= avahi_string_list_add_pair(txt
, "channel_map", pa_channel_map_snprint(cm
, sizeof(cm
), &s
->cm
));
306 txt
= avahi_string_list_add_pair(txt
, "subtype", subtype_text
[s
->subtype
]);
308 if ((t
= pa_proplist_gets(s
->proplist
, PA_PROP_DEVICE_DESCRIPTION
)))
309 txt
= avahi_string_list_add_pair(txt
, "description", t
);
310 if ((t
= pa_proplist_gets(s
->proplist
, PA_PROP_DEVICE_ICON_NAME
)))
311 txt
= avahi_string_list_add_pair(txt
, "icon-name", t
);
312 if ((t
= pa_proplist_gets(s
->proplist
, PA_PROP_DEVICE_VENDOR_NAME
)))
313 txt
= avahi_string_list_add_pair(txt
, "vendor-name", t
);
314 if ((t
= pa_proplist_gets(s
->proplist
, PA_PROP_DEVICE_PRODUCT_NAME
)))
315 txt
= avahi_string_list_add_pair(txt
, "product-name", t
);
316 if ((t
= pa_proplist_gets(s
->proplist
, PA_PROP_DEVICE_CLASS
)))
317 txt
= avahi_string_list_add_pair(txt
, "class", t
);
318 if ((t
= pa_proplist_gets(s
->proplist
, PA_PROP_DEVICE_FORM_FACTOR
)))
319 txt
= avahi_string_list_add_pair(txt
, "form-factor", t
);
321 if (avahi_entry_group_add_service_strlst(
323 AVAHI_IF_UNSPEC
, AVAHI_PROTO_UNSPEC
,
329 compute_port(s
->userdata
),
332 pa_log("avahi_entry_group_add_service_strlst(): %s", avahi_strerror(avahi_client_errno(s
->userdata
->client
)));
336 if (avahi_entry_group_add_service_subtype(
338 AVAHI_IF_UNSPEC
, AVAHI_PROTO_UNSPEC
,
343 s
->is_sink
? (s
->subtype
== SUBTYPE_HARDWARE
? SERVICE_SUBTYPE_SINK_HARDWARE
: SERVICE_SUBTYPE_SINK_VIRTUAL
) :
344 (s
->subtype
== SUBTYPE_HARDWARE
? SERVICE_SUBTYPE_SOURCE_HARDWARE
: (s
->subtype
== SUBTYPE_VIRTUAL
? SERVICE_SUBTYPE_SOURCE_VIRTUAL
: SERVICE_SUBTYPE_SOURCE_MONITOR
))) < 0) {
346 pa_log("avahi_entry_group_add_service_subtype(): %s", avahi_strerror(avahi_client_errno(s
->userdata
->client
)));
350 if (!s
->is_sink
&& s
->subtype
!= SUBTYPE_MONITOR
) {
351 if (avahi_entry_group_add_service_subtype(
353 AVAHI_IF_UNSPEC
, AVAHI_PROTO_UNSPEC
,
358 SERVICE_SUBTYPE_SOURCE_NON_MONITOR
) < 0) {
360 pa_log("avahi_entry_group_add_service_subtype(): %s", avahi_strerror(avahi_client_errno(s
->userdata
->client
)));
365 if (avahi_entry_group_commit(s
->entry_group
) < 0) {
366 pa_log("avahi_entry_group_commit(): %s", avahi_strerror(avahi_client_errno(s
->userdata
->client
)));
371 pa_log_debug("Successfully created entry group for %s.", s
->service_name
);
375 /* Remove this service */
377 pa_hashmap_remove(s
->userdata
->services
, s
->key
);
381 avahi_string_list_free(txt
);
384 /* Runs in PA mainloop context */
385 static struct service
*get_service(struct userdata
*u
, pa_object
*device
) {
391 pa_object_assert_ref(device
);
393 pa_threaded_mainloop_lock(u
->mainloop
);
395 if ((s
= pa_hashmap_get(u
->services
, device
)))
398 s
= pa_xnew(struct service
, 1);
401 s
->entry_group
= NULL
;
403 get_service_data(s
, device
);
405 if (!(n
= pa_proplist_gets(s
->proplist
, PA_PROP_DEVICE_DESCRIPTION
)))
408 hn
= pa_get_host_name_malloc();
409 un
= pa_get_user_name_malloc();
411 s
->service_name
= pa_truncate_utf8(pa_sprintf_malloc("%s@%s: %s", un
, hn
, n
), AVAHI_LABEL_MAX
-1);
416 pa_hashmap_put(u
->services
, device
, s
);
419 pa_threaded_mainloop_unlock(u
->mainloop
);
424 /* Run from Avahi mainloop context */
425 static void service_free(struct service
*s
) {
428 if (s
->entry_group
) {
429 pa_log_debug("Removing entry group for %s.", s
->service_name
);
430 avahi_entry_group_free(s
->entry_group
);
433 pa_xfree(s
->service_name
);
436 pa_proplist_free(s
->proplist
);
441 /* Runs in PA mainloop context */
442 static bool shall_ignore(pa_object
*o
) {
443 pa_object_assert_ref(o
);
445 if (pa_sink_isinstance(o
))
446 return !!(PA_SINK(o
)->flags
& PA_SINK_NETWORK
);
448 if (pa_source_isinstance(o
))
449 return PA_SOURCE(o
)->monitor_of
|| (PA_SOURCE(o
)->flags
& PA_SOURCE_NETWORK
);
451 pa_assert_not_reached();
454 /* Runs in PA mainloop context */
455 static pa_hook_result_t
device_new_or_changed_cb(pa_core
*c
, pa_object
*o
, struct userdata
*u
) {
457 pa_object_assert_ref(o
);
459 if (!shall_ignore(o
)) {
460 pa_threaded_mainloop_lock(u
->mainloop
);
461 pa_mainloop_api_once(u
->api
, publish_service
, get_service(u
, o
));
462 pa_threaded_mainloop_unlock(u
->mainloop
);
468 /* Runs in PA mainloop context */
469 static pa_hook_result_t
device_unlink_cb(pa_core
*c
, pa_object
*o
, struct userdata
*u
) {
473 pa_object_assert_ref(o
);
475 pa_threaded_mainloop_lock(u
->mainloop
);
477 if ((s
= pa_hashmap_remove(u
->services
, o
)))
480 pa_threaded_mainloop_unlock(u
->mainloop
);
485 static int publish_main_service(struct userdata
*u
);
487 /* Runs in Avahi mainloop context */
488 static void main_entry_group_callback(AvahiEntryGroup
*g
, AvahiEntryGroupState state
, void *userdata
) {
489 struct userdata
*u
= userdata
;
494 case AVAHI_ENTRY_GROUP_ESTABLISHED
:
495 pa_log_info("Successfully established main service.");
498 case AVAHI_ENTRY_GROUP_COLLISION
: {
501 t
= avahi_alternative_service_name(u
->service_name
);
502 pa_log_info("Name collision: renaming main service %s to %s.", u
->service_name
, t
);
503 pa_xfree(u
->service_name
);
506 publish_main_service(u
);
510 case AVAHI_ENTRY_GROUP_FAILURE
: {
511 pa_log("Failed to register main service: %s", avahi_strerror(avahi_client_errno(avahi_entry_group_get_client(g
))));
513 avahi_entry_group_free(g
);
514 u
->main_entry_group
= NULL
;
518 case AVAHI_ENTRY_GROUP_UNCOMMITED
:
519 case AVAHI_ENTRY_GROUP_REGISTERING
:
524 /* Runs in Avahi mainloop context */
525 static int publish_main_service(struct userdata
*u
) {
526 AvahiStringList
*txt
= NULL
;
531 if (!u
->main_entry_group
) {
532 if (!(u
->main_entry_group
= avahi_entry_group_new(u
->client
, main_entry_group_callback
, u
))) {
533 pa_log("avahi_entry_group_new() failed: %s", avahi_strerror(avahi_client_errno(u
->client
)));
537 avahi_entry_group_reset(u
->main_entry_group
);
539 txt
= txt_record_server_data(u
->core
, txt
);
541 if (avahi_entry_group_add_service_strlst(
543 AVAHI_IF_UNSPEC
, AVAHI_PROTO_UNSPEC
,
552 pa_log("avahi_entry_group_add_service_strlst() failed: %s", avahi_strerror(avahi_client_errno(u
->client
)));
556 if (avahi_entry_group_commit(u
->main_entry_group
) < 0) {
557 pa_log("avahi_entry_group_commit() failed: %s", avahi_strerror(avahi_client_errno(u
->client
)));
564 avahi_string_list_free(txt
);
569 /* Runs in PA mainloop context */
570 static int publish_all_services(struct userdata
*u
) {
578 pa_log_debug("Publishing services in Zeroconf");
580 for (sink
= PA_SINK(pa_idxset_first(u
->core
->sinks
, &idx
)); sink
; sink
= PA_SINK(pa_idxset_next(u
->core
->sinks
, &idx
)))
581 if (!shall_ignore(PA_OBJECT(sink
))) {
582 pa_threaded_mainloop_lock(u
->mainloop
);
583 pa_mainloop_api_once(u
->api
, publish_service
, get_service(u
, PA_OBJECT(sink
)));
584 pa_threaded_mainloop_unlock(u
->mainloop
);
587 for (source
= PA_SOURCE(pa_idxset_first(u
->core
->sources
, &idx
)); source
; source
= PA_SOURCE(pa_idxset_next(u
->core
->sources
, &idx
)))
588 if (!shall_ignore(PA_OBJECT(source
))) {
589 pa_threaded_mainloop_lock(u
->mainloop
);
590 pa_mainloop_api_once(u
->api
, publish_service
, get_service(u
, PA_OBJECT(source
)));
591 pa_threaded_mainloop_unlock(u
->mainloop
);
594 if (publish_main_service(u
) < 0)
603 /* Runs in Avahi mainloop context */
604 static void unpublish_all_services(struct userdata
*u
, bool rem
) {
610 pa_log_debug("Unpublishing services in Zeroconf");
612 while ((s
= pa_hashmap_iterate(u
->services
, &state
, NULL
))) {
613 if (s
->entry_group
) {
615 pa_log_debug("Removing entry group for %s.", s
->service_name
);
616 avahi_entry_group_free(s
->entry_group
);
617 s
->entry_group
= NULL
;
619 avahi_entry_group_reset(s
->entry_group
);
620 pa_log_debug("Resetting entry group for %s.", s
->service_name
);
625 if (u
->main_entry_group
) {
627 pa_log_debug("Removing main entry group.");
628 avahi_entry_group_free(u
->main_entry_group
);
629 u
->main_entry_group
= NULL
;
631 avahi_entry_group_reset(u
->main_entry_group
);
632 pa_log_debug("Resetting main entry group.");
637 /* Runs in PA mainloop context */
638 static int avahi_process_msg(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
639 struct userdata
*u
= (struct userdata
*) data
;
642 case AVAHI_MESSAGE_PUBLISH_ALL
:
643 publish_all_services(u
);
646 case AVAHI_MESSAGE_SHUTDOWN_START
:
647 pa_module_unload(u
->core
, u
->module
, true);
650 case AVAHI_MESSAGE_SHUTDOWN_COMPLETE
:
651 /* pa__done() is waiting for this */
655 pa_assert_not_reached();
661 /* Runs in Avahi mainloop context */
662 static void client_callback(AvahiClient
*c
, AvahiClientState state
, void *userdata
) {
663 struct userdata
*u
= userdata
;
671 case AVAHI_CLIENT_S_RUNNING
:
672 /* Collect all sinks/sources, and publish them */
673 pa_asyncmsgq_post(u
->thread_mq
.outq
, PA_MSGOBJECT(u
->msg
), AVAHI_MESSAGE_PUBLISH_ALL
, u
, 0, NULL
, NULL
);
676 case AVAHI_CLIENT_S_COLLISION
:
677 pa_log_debug("Host name collision");
678 unpublish_all_services(u
, false);
681 case AVAHI_CLIENT_FAILURE
:
682 if (avahi_client_errno(c
) == AVAHI_ERR_DISCONNECTED
) {
685 pa_log_debug("Avahi daemon disconnected.");
687 unpublish_all_services(u
, true);
688 avahi_client_free(u
->client
);
690 if (!(u
->client
= avahi_client_new(u
->avahi_poll
, AVAHI_CLIENT_NO_FAIL
, client_callback
, u
, &error
))) {
691 pa_log("avahi_client_new() failed: %s", avahi_strerror(error
));
692 pa_module_unload_request(u
->module
, true);
702 /* Runs in Avahi mainloop context */
703 static void create_client(pa_mainloop_api
*api PA_GCC_UNUSED
, void *userdata
) {
704 struct userdata
*u
= (struct userdata
*) userdata
;
707 pa_thread_mq_install(&u
->thread_mq
);
709 if (!(u
->client
= avahi_client_new(u
->avahi_poll
, AVAHI_CLIENT_NO_FAIL
, client_callback
, u
, &error
))) {
710 pa_log("avahi_client_new() failed: %s", avahi_strerror(error
));
714 pa_log_debug("Started Avahi threaded mainloop");
719 pa_asyncmsgq_post(u
->thread_mq
.outq
, PA_MSGOBJECT(u
->msg
), AVAHI_MESSAGE_SHUTDOWN_START
, u
, 0, NULL
, NULL
);
722 int pa__init(pa_module
*m
) {
725 pa_modargs
*ma
= NULL
;
728 if (!(ma
= pa_modargs_new(m
->argument
, valid_modargs
))) {
729 pa_log("Failed to parse module arguments.");
733 m
->userdata
= u
= pa_xnew(struct userdata
, 1);
736 u
->native
= pa_native_protocol_get(u
->core
);
738 u
->rtpoll
= pa_rtpoll_new();
739 u
->mainloop
= pa_threaded_mainloop_new();
740 u
->api
= pa_threaded_mainloop_get_api(u
->mainloop
);
742 pa_thread_mq_init(&u
->thread_mq
, u
->core
->mainloop
, u
->rtpoll
);
743 u
->msg
= pa_msgobject_new(avahi_msg
);
744 u
->msg
->parent
.process_msg
= avahi_process_msg
;
746 u
->avahi_poll
= pa_avahi_poll_new(u
->api
);
748 u
->services
= pa_hashmap_new_full(pa_idxset_trivial_hash_func
, pa_idxset_trivial_compare_func
, NULL
, (pa_free_cb_t
) service_free
);
750 u
->sink_new_slot
= pa_hook_connect(&m
->core
->hooks
[PA_CORE_HOOK_SINK_PUT
], PA_HOOK_LATE
, (pa_hook_cb_t
) device_new_or_changed_cb
, u
);
751 u
->sink_changed_slot
= pa_hook_connect(&m
->core
->hooks
[PA_CORE_HOOK_SINK_PROPLIST_CHANGED
], PA_HOOK_LATE
, (pa_hook_cb_t
) device_new_or_changed_cb
, u
);
752 u
->sink_unlink_slot
= pa_hook_connect(&m
->core
->hooks
[PA_CORE_HOOK_SINK_UNLINK
], PA_HOOK_LATE
, (pa_hook_cb_t
) device_unlink_cb
, u
);
753 u
->source_new_slot
= pa_hook_connect(&m
->core
->hooks
[PA_CORE_HOOK_SOURCE_PUT
], PA_HOOK_LATE
, (pa_hook_cb_t
) device_new_or_changed_cb
, u
);
754 u
->source_changed_slot
= pa_hook_connect(&m
->core
->hooks
[PA_CORE_HOOK_SOURCE_PROPLIST_CHANGED
], PA_HOOK_LATE
, (pa_hook_cb_t
) device_new_or_changed_cb
, u
);
755 u
->source_unlink_slot
= pa_hook_connect(&m
->core
->hooks
[PA_CORE_HOOK_SOURCE_UNLINK
], PA_HOOK_LATE
, (pa_hook_cb_t
) device_unlink_cb
, u
);
757 u
->main_entry_group
= NULL
;
759 un
= pa_get_user_name_malloc();
760 hn
= pa_get_host_name_malloc();
761 u
->service_name
= pa_truncate_utf8(pa_sprintf_malloc("%s@%s", un
, hn
), AVAHI_LABEL_MAX
-1);
765 pa_threaded_mainloop_set_name(u
->mainloop
, "avahi-ml");
766 pa_threaded_mainloop_start(u
->mainloop
);
768 pa_threaded_mainloop_lock(u
->mainloop
);
769 pa_mainloop_api_once(u
->api
, create_client
, u
);
770 pa_threaded_mainloop_unlock(u
->mainloop
);
785 /* Runs in Avahi mainloop context */
786 static void client_free(pa_mainloop_api
*api PA_GCC_UNUSED
, void *userdata
) {
787 struct userdata
*u
= (struct userdata
*) userdata
;
789 pa_hashmap_free(u
->services
);
791 if (u
->main_entry_group
)
792 avahi_entry_group_free(u
->main_entry_group
);
795 avahi_client_free(u
->client
);
798 pa_avahi_poll_free(u
->avahi_poll
);
800 pa_asyncmsgq_post(u
->thread_mq
.outq
, PA_MSGOBJECT(u
->msg
), AVAHI_MESSAGE_SHUTDOWN_COMPLETE
, NULL
, 0, NULL
, NULL
);
803 void pa__done(pa_module
*m
) {
807 if (!(u
= m
->userdata
))
810 pa_mainloop_api_once(u
->api
, client_free
, u
);
811 pa_asyncmsgq_wait_for(u
->thread_mq
.outq
, AVAHI_MESSAGE_SHUTDOWN_COMPLETE
);
813 pa_threaded_mainloop_stop(u
->mainloop
);
814 pa_threaded_mainloop_free(u
->mainloop
);
816 pa_thread_mq_done(&u
->thread_mq
);
817 pa_rtpoll_free(u
->rtpoll
);
819 if (u
->sink_new_slot
)
820 pa_hook_slot_free(u
->sink_new_slot
);
821 if (u
->source_new_slot
)
822 pa_hook_slot_free(u
->source_new_slot
);
823 if (u
->sink_changed_slot
)
824 pa_hook_slot_free(u
->sink_changed_slot
);
825 if (u
->source_changed_slot
)
826 pa_hook_slot_free(u
->source_changed_slot
);
827 if (u
->sink_unlink_slot
)
828 pa_hook_slot_free(u
->sink_unlink_slot
);
829 if (u
->source_unlink_slot
)
830 pa_hook_slot_free(u
->source_unlink_slot
);
833 pa_native_protocol_unref(u
->native
);
836 pa_xfree(u
->service_name
);