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
;
145 bool shutting_down
; /* Used in the main thread. */
146 bool client_freed
; /* Used in the Avahi thread. */
149 /* Runs in PA mainloop context */
150 static void get_service_data(struct service
*s
, pa_object
*device
) {
153 if (pa_sink_isinstance(device
)) {
154 pa_sink
*sink
= PA_SINK(device
);
157 s
->service_type
= SERVICE_TYPE_SINK
;
158 s
->ss
= sink
->sample_spec
;
159 s
->cm
= sink
->channel_map
;
160 s
->name
= pa_xstrdup(sink
->name
);
161 s
->proplist
= pa_proplist_copy(sink
->proplist
);
162 s
->subtype
= sink
->flags
& PA_SINK_HARDWARE
? SUBTYPE_HARDWARE
: SUBTYPE_VIRTUAL
;
164 } else if (pa_source_isinstance(device
)) {
165 pa_source
*source
= PA_SOURCE(device
);
168 s
->service_type
= SERVICE_TYPE_SOURCE
;
169 s
->ss
= source
->sample_spec
;
170 s
->cm
= source
->channel_map
;
171 s
->name
= pa_xstrdup(source
->name
);
172 s
->proplist
= pa_proplist_copy(source
->proplist
);
173 s
->subtype
= source
->monitor_of
? SUBTYPE_MONITOR
: (source
->flags
& PA_SOURCE_HARDWARE
? SUBTYPE_HARDWARE
: SUBTYPE_VIRTUAL
);
176 pa_assert_not_reached();
179 /* Can be used in either PA or Avahi mainloop context since the bits of u->core
180 * that we access don't change after startup. */
181 static AvahiStringList
* txt_record_server_data(pa_core
*c
, AvahiStringList
*l
) {
187 l
= avahi_string_list_add_pair(l
, "server-version", PACKAGE_NAME
" "PACKAGE_VERSION
);
189 t
= pa_get_user_name_malloc();
190 l
= avahi_string_list_add_pair(l
, "user-name", t
);
194 l
= avahi_string_list_add_pair(l
, "machine-id", t
);
197 t
= pa_uname_string();
198 l
= avahi_string_list_add_pair(l
, "uname", t
);
201 l
= avahi_string_list_add_pair(l
, "fqdn", pa_get_fqdn(s
, sizeof(s
)));
202 l
= avahi_string_list_add_printf(l
, "cookie=0x%08x", c
->cookie
);
207 static void publish_service(pa_mainloop_api
*api
, void *service
);
209 /* Runs in Avahi mainloop context */
210 static void service_entry_group_callback(AvahiEntryGroup
*g
, AvahiEntryGroupState state
, void *userdata
) {
211 struct service
*s
= userdata
;
217 case AVAHI_ENTRY_GROUP_ESTABLISHED
:
218 pa_log_info("Successfully established service %s.", s
->service_name
);
221 case AVAHI_ENTRY_GROUP_COLLISION
: {
224 t
= avahi_alternative_service_name(s
->service_name
);
225 pa_log_info("Name collision, renaming %s to %s.", s
->service_name
, t
);
226 pa_xfree(s
->service_name
);
229 publish_service(NULL
, s
);
233 case AVAHI_ENTRY_GROUP_FAILURE
: {
234 pa_log("Failed to register service: %s", avahi_strerror(avahi_client_errno(avahi_entry_group_get_client(g
))));
236 avahi_entry_group_free(g
);
237 s
->entry_group
= NULL
;
242 case AVAHI_ENTRY_GROUP_UNCOMMITED
:
243 case AVAHI_ENTRY_GROUP_REGISTERING
:
248 static void service_free(struct service
*s
);
250 /* Can run in either context */
251 static uint16_t compute_port(struct userdata
*u
) {
256 for (i
= pa_native_protocol_servers(u
->native
); i
; i
= pa_strlist_next(i
)) {
259 if (pa_parse_address(pa_strlist_data(i
), &a
) >= 0 &&
260 (a
.type
== PA_PARSED_ADDRESS_TCP4
||
261 a
.type
== PA_PARSED_ADDRESS_TCP6
||
262 a
.type
== PA_PARSED_ADDRESS_TCP_AUTO
) &&
265 pa_xfree(a
.path_or_host
);
269 pa_xfree(a
.path_or_host
);
272 return PA_NATIVE_DEFAULT_PORT
;
275 /* Runs in Avahi mainloop context */
276 static void publish_service(pa_mainloop_api
*api PA_GCC_UNUSED
, void *service
) {
277 struct service
*s
= (struct service
*) service
;
279 AvahiStringList
*txt
= NULL
;
280 char cm
[PA_CHANNEL_MAP_SNPRINT_MAX
];
283 const char * const subtype_text
[] = {
284 [SUBTYPE_HARDWARE
] = "hardware",
285 [SUBTYPE_VIRTUAL
] = "virtual",
286 [SUBTYPE_MONITOR
] = "monitor"
291 if (!s
->userdata
->client
|| avahi_client_get_state(s
->userdata
->client
) != AVAHI_CLIENT_S_RUNNING
)
294 if (!s
->entry_group
) {
295 if (!(s
->entry_group
= avahi_entry_group_new(s
->userdata
->client
, service_entry_group_callback
, s
))) {
296 pa_log("avahi_entry_group_new(): %s", avahi_strerror(avahi_client_errno(s
->userdata
->client
)));
300 avahi_entry_group_reset(s
->entry_group
);
302 txt
= txt_record_server_data(s
->userdata
->core
, txt
);
304 txt
= avahi_string_list_add_pair(txt
, "device", s
->name
);
305 txt
= avahi_string_list_add_printf(txt
, "rate=%u", s
->ss
.rate
);
306 txt
= avahi_string_list_add_printf(txt
, "channels=%u", s
->ss
.channels
);
307 txt
= avahi_string_list_add_pair(txt
, "format", pa_sample_format_to_string(s
->ss
.format
));
308 txt
= avahi_string_list_add_pair(txt
, "channel_map", pa_channel_map_snprint(cm
, sizeof(cm
), &s
->cm
));
309 txt
= avahi_string_list_add_pair(txt
, "subtype", subtype_text
[s
->subtype
]);
311 if ((t
= pa_proplist_gets(s
->proplist
, PA_PROP_DEVICE_DESCRIPTION
)))
312 txt
= avahi_string_list_add_pair(txt
, "description", t
);
313 if ((t
= pa_proplist_gets(s
->proplist
, PA_PROP_DEVICE_ICON_NAME
)))
314 txt
= avahi_string_list_add_pair(txt
, "icon-name", t
);
315 if ((t
= pa_proplist_gets(s
->proplist
, PA_PROP_DEVICE_VENDOR_NAME
)))
316 txt
= avahi_string_list_add_pair(txt
, "vendor-name", t
);
317 if ((t
= pa_proplist_gets(s
->proplist
, PA_PROP_DEVICE_PRODUCT_NAME
)))
318 txt
= avahi_string_list_add_pair(txt
, "product-name", t
);
319 if ((t
= pa_proplist_gets(s
->proplist
, PA_PROP_DEVICE_CLASS
)))
320 txt
= avahi_string_list_add_pair(txt
, "class", t
);
321 if ((t
= pa_proplist_gets(s
->proplist
, PA_PROP_DEVICE_FORM_FACTOR
)))
322 txt
= avahi_string_list_add_pair(txt
, "form-factor", t
);
324 if (avahi_entry_group_add_service_strlst(
326 AVAHI_IF_UNSPEC
, AVAHI_PROTO_UNSPEC
,
332 compute_port(s
->userdata
),
335 pa_log("avahi_entry_group_add_service_strlst(): %s", avahi_strerror(avahi_client_errno(s
->userdata
->client
)));
339 if (avahi_entry_group_add_service_subtype(
341 AVAHI_IF_UNSPEC
, AVAHI_PROTO_UNSPEC
,
346 s
->is_sink
? (s
->subtype
== SUBTYPE_HARDWARE
? SERVICE_SUBTYPE_SINK_HARDWARE
: SERVICE_SUBTYPE_SINK_VIRTUAL
) :
347 (s
->subtype
== SUBTYPE_HARDWARE
? SERVICE_SUBTYPE_SOURCE_HARDWARE
: (s
->subtype
== SUBTYPE_VIRTUAL
? SERVICE_SUBTYPE_SOURCE_VIRTUAL
: SERVICE_SUBTYPE_SOURCE_MONITOR
))) < 0) {
349 pa_log("avahi_entry_group_add_service_subtype(): %s", avahi_strerror(avahi_client_errno(s
->userdata
->client
)));
353 if (!s
->is_sink
&& s
->subtype
!= SUBTYPE_MONITOR
) {
354 if (avahi_entry_group_add_service_subtype(
356 AVAHI_IF_UNSPEC
, AVAHI_PROTO_UNSPEC
,
361 SERVICE_SUBTYPE_SOURCE_NON_MONITOR
) < 0) {
363 pa_log("avahi_entry_group_add_service_subtype(): %s", avahi_strerror(avahi_client_errno(s
->userdata
->client
)));
368 if (avahi_entry_group_commit(s
->entry_group
) < 0) {
369 pa_log("avahi_entry_group_commit(): %s", avahi_strerror(avahi_client_errno(s
->userdata
->client
)));
374 pa_log_debug("Successfully created entry group for %s.", s
->service_name
);
378 /* Remove this service */
380 pa_hashmap_remove_and_free(s
->userdata
->services
, s
->key
);
382 avahi_string_list_free(txt
);
385 /* Runs in PA mainloop context */
386 static struct service
*get_service(struct userdata
*u
, pa_object
*device
) {
392 pa_object_assert_ref(device
);
394 pa_threaded_mainloop_lock(u
->mainloop
);
396 if ((s
= pa_hashmap_get(u
->services
, device
)))
399 s
= pa_xnew(struct service
, 1);
402 s
->entry_group
= NULL
;
404 get_service_data(s
, device
);
406 if (!(n
= pa_proplist_gets(s
->proplist
, PA_PROP_DEVICE_DESCRIPTION
)))
409 hn
= pa_get_host_name_malloc();
410 un
= pa_get_user_name_malloc();
412 s
->service_name
= pa_truncate_utf8(pa_sprintf_malloc("%s@%s: %s", un
, hn
, n
), AVAHI_LABEL_MAX
-1);
417 pa_hashmap_put(u
->services
, device
, s
);
420 pa_threaded_mainloop_unlock(u
->mainloop
);
425 /* Run from Avahi mainloop context */
426 static void service_free(struct service
*s
) {
429 if (s
->entry_group
) {
430 pa_log_debug("Removing entry group for %s.", s
->service_name
);
431 avahi_entry_group_free(s
->entry_group
);
434 pa_xfree(s
->service_name
);
437 pa_proplist_free(s
->proplist
);
442 /* Runs in PA mainloop context */
443 static bool shall_ignore(pa_object
*o
) {
444 pa_object_assert_ref(o
);
446 if (pa_sink_isinstance(o
))
447 return !!(PA_SINK(o
)->flags
& PA_SINK_NETWORK
);
449 if (pa_source_isinstance(o
))
450 return PA_SOURCE(o
)->monitor_of
|| (PA_SOURCE(o
)->flags
& PA_SOURCE_NETWORK
);
452 pa_assert_not_reached();
455 /* Runs in PA mainloop context */
456 static pa_hook_result_t
device_new_or_changed_cb(pa_core
*c
, pa_object
*o
, struct userdata
*u
) {
458 pa_object_assert_ref(o
);
460 if (!shall_ignore(o
)) {
461 pa_threaded_mainloop_lock(u
->mainloop
);
462 pa_mainloop_api_once(u
->api
, publish_service
, get_service(u
, o
));
463 pa_threaded_mainloop_unlock(u
->mainloop
);
469 /* Runs in PA mainloop context */
470 static pa_hook_result_t
device_unlink_cb(pa_core
*c
, pa_object
*o
, struct userdata
*u
) {
472 pa_object_assert_ref(o
);
474 pa_threaded_mainloop_lock(u
->mainloop
);
475 pa_hashmap_remove_and_free(u
->services
, o
);
476 pa_threaded_mainloop_unlock(u
->mainloop
);
481 static int publish_main_service(struct userdata
*u
);
483 /* Runs in Avahi mainloop context */
484 static void main_entry_group_callback(AvahiEntryGroup
*g
, AvahiEntryGroupState state
, void *userdata
) {
485 struct userdata
*u
= userdata
;
490 case AVAHI_ENTRY_GROUP_ESTABLISHED
:
491 pa_log_info("Successfully established main service.");
494 case AVAHI_ENTRY_GROUP_COLLISION
: {
497 t
= avahi_alternative_service_name(u
->service_name
);
498 pa_log_info("Name collision: renaming main service %s to %s.", u
->service_name
, t
);
499 pa_xfree(u
->service_name
);
502 publish_main_service(u
);
506 case AVAHI_ENTRY_GROUP_FAILURE
: {
507 pa_log("Failed to register main service: %s", avahi_strerror(avahi_client_errno(avahi_entry_group_get_client(g
))));
509 avahi_entry_group_free(g
);
510 u
->main_entry_group
= NULL
;
514 case AVAHI_ENTRY_GROUP_UNCOMMITED
:
515 case AVAHI_ENTRY_GROUP_REGISTERING
:
520 /* Runs in Avahi mainloop context */
521 static int publish_main_service(struct userdata
*u
) {
522 AvahiStringList
*txt
= NULL
;
527 if (!u
->main_entry_group
) {
528 if (!(u
->main_entry_group
= avahi_entry_group_new(u
->client
, main_entry_group_callback
, u
))) {
529 pa_log("avahi_entry_group_new() failed: %s", avahi_strerror(avahi_client_errno(u
->client
)));
533 avahi_entry_group_reset(u
->main_entry_group
);
535 txt
= txt_record_server_data(u
->core
, txt
);
537 if (avahi_entry_group_add_service_strlst(
539 AVAHI_IF_UNSPEC
, AVAHI_PROTO_UNSPEC
,
548 pa_log("avahi_entry_group_add_service_strlst() failed: %s", avahi_strerror(avahi_client_errno(u
->client
)));
552 if (avahi_entry_group_commit(u
->main_entry_group
) < 0) {
553 pa_log("avahi_entry_group_commit() failed: %s", avahi_strerror(avahi_client_errno(u
->client
)));
560 avahi_string_list_free(txt
);
565 /* Runs in PA mainloop context */
566 static int publish_all_services(struct userdata
*u
) {
574 pa_log_debug("Publishing services in Zeroconf");
576 for (sink
= PA_SINK(pa_idxset_first(u
->core
->sinks
, &idx
)); sink
; sink
= PA_SINK(pa_idxset_next(u
->core
->sinks
, &idx
)))
577 if (!shall_ignore(PA_OBJECT(sink
))) {
578 pa_threaded_mainloop_lock(u
->mainloop
);
579 pa_mainloop_api_once(u
->api
, publish_service
, get_service(u
, PA_OBJECT(sink
)));
580 pa_threaded_mainloop_unlock(u
->mainloop
);
583 for (source
= PA_SOURCE(pa_idxset_first(u
->core
->sources
, &idx
)); source
; source
= PA_SOURCE(pa_idxset_next(u
->core
->sources
, &idx
)))
584 if (!shall_ignore(PA_OBJECT(source
))) {
585 pa_threaded_mainloop_lock(u
->mainloop
);
586 pa_mainloop_api_once(u
->api
, publish_service
, get_service(u
, PA_OBJECT(source
)));
587 pa_threaded_mainloop_unlock(u
->mainloop
);
590 if (publish_main_service(u
) < 0)
599 /* Runs in Avahi mainloop context */
600 static void unpublish_all_services(struct userdata
*u
, bool rem
) {
606 pa_log_debug("Unpublishing services in Zeroconf");
608 while ((s
= pa_hashmap_iterate(u
->services
, &state
, NULL
))) {
609 if (s
->entry_group
) {
611 pa_log_debug("Removing entry group for %s.", s
->service_name
);
612 avahi_entry_group_free(s
->entry_group
);
613 s
->entry_group
= NULL
;
615 avahi_entry_group_reset(s
->entry_group
);
616 pa_log_debug("Resetting entry group for %s.", s
->service_name
);
621 if (u
->main_entry_group
) {
623 pa_log_debug("Removing main entry group.");
624 avahi_entry_group_free(u
->main_entry_group
);
625 u
->main_entry_group
= NULL
;
627 avahi_entry_group_reset(u
->main_entry_group
);
628 pa_log_debug("Resetting main entry group.");
633 /* Runs in PA mainloop context */
634 static int avahi_process_msg(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
635 struct userdata
*u
= (struct userdata
*) data
;
639 if (u
->shutting_down
)
643 case AVAHI_MESSAGE_PUBLISH_ALL
:
644 publish_all_services(u
);
647 case AVAHI_MESSAGE_SHUTDOWN_START
:
648 pa_module_unload(u
->core
, u
->module
, true);
652 pa_assert_not_reached();
658 /* Runs in Avahi mainloop context */
659 static void client_callback(AvahiClient
*c
, AvahiClientState state
, void *userdata
) {
660 struct userdata
*u
= userdata
;
668 case AVAHI_CLIENT_S_RUNNING
:
669 /* Collect all sinks/sources, and publish them */
670 pa_asyncmsgq_post(u
->thread_mq
.outq
, PA_MSGOBJECT(u
->msg
), AVAHI_MESSAGE_PUBLISH_ALL
, u
, 0, NULL
, NULL
);
673 case AVAHI_CLIENT_S_COLLISION
:
674 pa_log_debug("Host name collision");
675 unpublish_all_services(u
, false);
678 case AVAHI_CLIENT_FAILURE
:
679 if (avahi_client_errno(c
) == AVAHI_ERR_DISCONNECTED
) {
682 pa_log_debug("Avahi daemon disconnected.");
684 unpublish_all_services(u
, true);
685 avahi_client_free(u
->client
);
687 if (!(u
->client
= avahi_client_new(u
->avahi_poll
, AVAHI_CLIENT_NO_FAIL
, client_callback
, u
, &error
))) {
688 pa_log("avahi_client_new() failed: %s", avahi_strerror(error
));
689 pa_module_unload_request(u
->module
, true);
699 /* Runs in Avahi mainloop context */
700 static void create_client(pa_mainloop_api
*api PA_GCC_UNUSED
, void *userdata
) {
701 struct userdata
*u
= (struct userdata
*) userdata
;
704 /* create_client() and client_free() are called via defer events. If the
705 * two defer events are created very quickly one after another, we can't
706 * assume that the defer event that runs create_client() will be dispatched
707 * before the defer event that runs client_free() (at the time of writing,
708 * pa_mainloop actually always dispatches queued defer events in reverse
709 * creation order). For that reason we must be prepared for the case where
710 * client_free() has already been called. */
714 pa_thread_mq_install(&u
->thread_mq
);
716 if (!(u
->client
= avahi_client_new(u
->avahi_poll
, AVAHI_CLIENT_NO_FAIL
, client_callback
, u
, &error
))) {
717 pa_log("avahi_client_new() failed: %s", avahi_strerror(error
));
721 pa_log_debug("Started Avahi threaded mainloop");
726 pa_asyncmsgq_post(u
->thread_mq
.outq
, PA_MSGOBJECT(u
->msg
), AVAHI_MESSAGE_SHUTDOWN_START
, u
, 0, NULL
, NULL
);
729 int pa__init(pa_module
*m
) {
732 pa_modargs
*ma
= NULL
;
735 if (!(ma
= pa_modargs_new(m
->argument
, valid_modargs
))) {
736 pa_log("Failed to parse module arguments.");
740 m
->userdata
= u
= pa_xnew0(struct userdata
, 1);
743 u
->native
= pa_native_protocol_get(u
->core
);
745 u
->rtpoll
= pa_rtpoll_new();
746 u
->mainloop
= pa_threaded_mainloop_new();
747 u
->api
= pa_threaded_mainloop_get_api(u
->mainloop
);
749 pa_thread_mq_init(&u
->thread_mq
, u
->core
->mainloop
, u
->rtpoll
);
750 u
->msg
= pa_msgobject_new(avahi_msg
);
751 u
->msg
->parent
.process_msg
= avahi_process_msg
;
753 u
->avahi_poll
= pa_avahi_poll_new(u
->api
);
755 u
->services
= pa_hashmap_new_full(pa_idxset_trivial_hash_func
, pa_idxset_trivial_compare_func
, NULL
, (pa_free_cb_t
) service_free
);
757 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
);
758 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
);
759 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
);
760 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
);
761 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
);
762 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
);
764 un
= pa_get_user_name_malloc();
765 hn
= pa_get_host_name_malloc();
766 u
->service_name
= pa_truncate_utf8(pa_sprintf_malloc("%s@%s", un
, hn
), AVAHI_LABEL_MAX
-1);
770 pa_threaded_mainloop_set_name(u
->mainloop
, "avahi-ml");
771 pa_threaded_mainloop_start(u
->mainloop
);
773 pa_threaded_mainloop_lock(u
->mainloop
);
774 pa_mainloop_api_once(u
->api
, create_client
, u
);
775 pa_threaded_mainloop_unlock(u
->mainloop
);
790 /* Runs in Avahi mainloop context */
791 static void client_free(pa_mainloop_api
*api PA_GCC_UNUSED
, void *userdata
) {
792 struct userdata
*u
= (struct userdata
*) userdata
;
794 pa_hashmap_free(u
->services
);
796 if (u
->main_entry_group
)
797 avahi_entry_group_free(u
->main_entry_group
);
800 avahi_client_free(u
->client
);
803 pa_avahi_poll_free(u
->avahi_poll
);
805 pa_asyncmsgq_post(u
->thread_mq
.outq
, PA_MSGOBJECT(u
->msg
), AVAHI_MESSAGE_SHUTDOWN_COMPLETE
, u
, 0, NULL
, NULL
);
807 u
->client_freed
= true;
810 void pa__done(pa_module
*m
) {
814 if (!(u
= m
->userdata
))
817 u
->shutting_down
= true;
819 pa_threaded_mainloop_lock(u
->mainloop
);
820 pa_mainloop_api_once(u
->api
, client_free
, u
);
821 pa_threaded_mainloop_unlock(u
->mainloop
);
822 pa_asyncmsgq_wait_for(u
->thread_mq
.outq
, AVAHI_MESSAGE_SHUTDOWN_COMPLETE
);
824 pa_threaded_mainloop_stop(u
->mainloop
);
825 pa_threaded_mainloop_free(u
->mainloop
);
827 pa_thread_mq_done(&u
->thread_mq
);
828 pa_rtpoll_free(u
->rtpoll
);
830 if (u
->sink_new_slot
)
831 pa_hook_slot_free(u
->sink_new_slot
);
832 if (u
->source_new_slot
)
833 pa_hook_slot_free(u
->source_new_slot
);
834 if (u
->sink_changed_slot
)
835 pa_hook_slot_free(u
->sink_changed_slot
);
836 if (u
->source_changed_slot
)
837 pa_hook_slot_free(u
->source_changed_slot
);
838 if (u
->sink_unlink_slot
)
839 pa_hook_slot_free(u
->sink_unlink_slot
);
840 if (u
->source_unlink_slot
)
841 pa_hook_slot_free(u
->source_unlink_slot
);
844 pa_native_protocol_unref(u
->native
);
847 pa_xfree(u
->service_name
);