2 This file is part of PulseAudio.
4 Copyright 2004-2008 Lennart Poettering
5 Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
7 PulseAudio is free software; you can redistribute it and/or modify
8 it under the terms of the GNU Lesser General Public License as published
9 by the Free Software Foundation; either version 2.1 of the License,
10 or (at your option) any later version.
12 PulseAudio is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with PulseAudio; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
30 #include <sys/types.h>
36 #ifdef HAVE_SYS_WAIT_H
44 #include <pulse/version.h>
45 #include <pulse/xmalloc.h>
46 #include <pulse/util.h>
47 #include <pulse/mainloop.h>
48 #include <pulse/timeval.h>
49 #include <pulse/fork-detect.h>
50 #include <pulse/client-conf.h>
52 #include <pulse/client-conf-x11.h>
55 #include <pulsecore/core-error.h>
56 #include <pulsecore/i18n.h>
57 #include <pulsecore/native-common.h>
58 #include <pulsecore/pdispatch.h>
59 #include <pulsecore/pstream.h>
60 #include <pulsecore/hashmap.h>
61 #include <pulsecore/socket-client.h>
62 #include <pulsecore/pstream-util.h>
63 #include <pulsecore/core-rtclock.h>
64 #include <pulsecore/core-util.h>
65 #include <pulsecore/log.h>
66 #include <pulsecore/socket.h>
67 #include <pulsecore/creds.h>
68 #include <pulsecore/macro.h>
69 #include <pulsecore/proplist-util.h>
74 void pa_command_extension(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
76 static const pa_pdispatch_cb_t command_table[PA_COMMAND_MAX] = {
77 [PA_COMMAND_REQUEST] = pa_command_request,
78 [PA_COMMAND_OVERFLOW] = pa_command_overflow_or_underflow,
79 [PA_COMMAND_UNDERFLOW] = pa_command_overflow_or_underflow,
80 [PA_COMMAND_PLAYBACK_STREAM_KILLED] = pa_command_stream_killed,
81 [PA_COMMAND_RECORD_STREAM_KILLED] = pa_command_stream_killed,
82 [PA_COMMAND_PLAYBACK_STREAM_MOVED] = pa_command_stream_moved,
83 [PA_COMMAND_RECORD_STREAM_MOVED] = pa_command_stream_moved,
84 [PA_COMMAND_PLAYBACK_STREAM_SUSPENDED] = pa_command_stream_suspended,
85 [PA_COMMAND_RECORD_STREAM_SUSPENDED] = pa_command_stream_suspended,
86 [PA_COMMAND_STARTED] = pa_command_stream_started,
87 [PA_COMMAND_SUBSCRIBE_EVENT] = pa_command_subscribe_event,
88 [PA_COMMAND_EXTENSION] = pa_command_extension,
89 [PA_COMMAND_PLAYBACK_STREAM_EVENT] = pa_command_stream_event,
90 [PA_COMMAND_RECORD_STREAM_EVENT] = pa_command_stream_event,
91 [PA_COMMAND_CLIENT_EVENT] = pa_command_client_event,
92 [PA_COMMAND_PLAYBACK_BUFFER_ATTR_CHANGED] = pa_command_stream_buffer_attr,
93 [PA_COMMAND_RECORD_BUFFER_ATTR_CHANGED] = pa_command_stream_buffer_attr
95 static void context_free(pa_context *c);
98 static DBusHandlerResult filter_cb(DBusConnection *bus, DBusMessage *message, void *userdata);
101 pa_context *pa_context_new(pa_mainloop_api *mainloop, const char *name) {
102 return pa_context_new_with_proplist(mainloop, name, NULL);
105 static void reset_callbacks(pa_context *c) {
108 c->state_callback = NULL;
109 c->state_userdata = NULL;
111 c->subscribe_callback = NULL;
112 c->subscribe_userdata = NULL;
114 c->event_callback = NULL;
115 c->event_userdata = NULL;
117 c->ext_device_manager.callback = NULL;
118 c->ext_device_manager.userdata = NULL;
120 c->ext_device_restore.callback = NULL;
121 c->ext_device_restore.userdata = NULL;
123 c->ext_stream_restore.callback = NULL;
124 c->ext_stream_restore.userdata = NULL;
126 c->ext_node_manager.callback = NULL;
127 c->ext_node_manager.userdata = NULL;
130 pa_context *pa_context_new_with_proplist(pa_mainloop_api *mainloop, const char *name, pa_proplist *p) {
135 if (pa_detect_fork())
140 c = pa_xnew0(pa_context, 1);
143 c->proplist = p ? pa_proplist_copy(p) : pa_proplist_new();
146 pa_proplist_sets(c->proplist, PA_PROP_APPLICATION_NAME, name);
149 c->system_bus = c->session_bus = NULL;
151 c->mainloop = mainloop;
152 c->playback_streams = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
153 c->record_streams = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
154 c->client_index = PA_INVALID_INDEX;
155 c->use_rtclock = pa_mainloop_is_our_api(mainloop);
157 PA_LLIST_HEAD_INIT(pa_stream, c->streams);
158 PA_LLIST_HEAD_INIT(pa_operation, c->operations);
161 c->state = PA_CONTEXT_UNCONNECTED;
167 pa_check_signal_is_blocked(SIGPIPE);
171 c->conf = pa_client_conf_new();
172 pa_client_conf_load(c->conf, NULL);
174 pa_client_conf_from_x11(c->conf, NULL);
176 pa_client_conf_env(c->conf);
178 if (!(c->mempool = pa_mempool_new(!c->conf->disable_shm, c->conf->shm_size))) {
180 if (!c->conf->disable_shm)
181 c->mempool = pa_mempool_new(FALSE, c->conf->shm_size);
192 static void context_unlink(pa_context *c) {
197 s = c->streams ? pa_stream_ref(c->streams) : NULL;
199 pa_stream *n = s->next ? pa_stream_ref(s->next) : NULL;
200 pa_stream_set_state(s, c->state == PA_CONTEXT_FAILED ? PA_STREAM_FAILED : PA_STREAM_TERMINATED);
205 while (c->operations)
206 pa_operation_cancel(c->operations);
209 pa_pdispatch_unref(c->pdispatch);
214 pa_pstream_unlink(c->pstream);
215 pa_pstream_unref(c->pstream);
220 pa_socket_client_unref(c->client);
227 static void context_free(pa_context *c) {
235 dbus_connection_remove_filter(pa_dbus_wrap_connection_get(c->system_bus), filter_cb, c);
236 pa_dbus_wrap_connection_free(c->system_bus);
239 if (c->session_bus) {
241 dbus_connection_remove_filter(pa_dbus_wrap_connection_get(c->session_bus), filter_cb, c);
242 pa_dbus_wrap_connection_free(c->session_bus);
246 if (c->record_streams)
247 pa_hashmap_free(c->record_streams, NULL, NULL);
248 if (c->playback_streams)
249 pa_hashmap_free(c->playback_streams, NULL, NULL);
252 pa_mempool_free(c->mempool);
255 pa_client_conf_free(c->conf);
257 pa_strlist_free(c->server_list);
260 pa_proplist_free(c->proplist);
266 pa_context* pa_context_ref(pa_context *c) {
268 pa_assert(PA_REFCNT_VALUE(c) >= 1);
274 void pa_context_unref(pa_context *c) {
276 pa_assert(PA_REFCNT_VALUE(c) >= 1);
278 if (PA_REFCNT_DEC(c) <= 0)
282 void pa_context_set_state(pa_context *c, pa_context_state_t st) {
284 pa_assert(PA_REFCNT_VALUE(c) >= 1);
293 if (c->state_callback)
294 c->state_callback(c, c->state_userdata);
296 if (st == PA_CONTEXT_FAILED || st == PA_CONTEXT_TERMINATED)
302 int pa_context_set_error(pa_context *c, int error) {
303 pa_assert(error >= 0);
304 pa_assert(error < PA_ERR_MAX);
312 void pa_context_fail(pa_context *c, int error) {
314 pa_assert(PA_REFCNT_VALUE(c) >= 1);
316 pa_context_set_error(c, error);
317 pa_context_set_state(c, PA_CONTEXT_FAILED);
320 static void pstream_die_callback(pa_pstream *p, void *userdata) {
321 pa_context *c = userdata;
326 pa_context_fail(c, PA_ERR_CONNECTIONTERMINATED);
329 static void pstream_packet_callback(pa_pstream *p, pa_packet *packet, const pa_creds *creds, void *userdata) {
330 pa_context *c = userdata;
338 if (pa_pdispatch_run(c->pdispatch, packet, creds, c) < 0)
339 pa_context_fail(c, PA_ERR_PROTOCOL);
344 static void pstream_memblock_callback(pa_pstream *p, uint32_t channel, int64_t offset, pa_seek_mode_t seek, const pa_memchunk *chunk, void *userdata) {
345 pa_context *c = userdata;
350 pa_assert(chunk->length > 0);
352 pa_assert(PA_REFCNT_VALUE(c) >= 1);
356 if ((s = pa_hashmap_get(c->record_streams, PA_UINT32_TO_PTR(channel)))) {
358 if (chunk->memblock) {
359 pa_memblockq_seek(s->record_memblockq, offset, seek, TRUE);
360 pa_memblockq_push_align(s->record_memblockq, chunk);
362 pa_memblockq_seek(s->record_memblockq, offset+chunk->length, seek, TRUE);
364 if (s->read_callback) {
367 if ((l = pa_memblockq_get_length(s->record_memblockq)) > 0)
368 s->read_callback(s, l, s->read_userdata);
375 int pa_context_handle_error(pa_context *c, uint32_t command, pa_tagstruct *t, pa_bool_t fail) {
378 pa_assert(PA_REFCNT_VALUE(c) >= 1);
380 if (command == PA_COMMAND_ERROR) {
383 if (pa_tagstruct_getu32(t, &err) < 0 ||
384 !pa_tagstruct_eof(t)) {
385 pa_context_fail(c, PA_ERR_PROTOCOL);
389 } else if (command == PA_COMMAND_TIMEOUT)
390 err = PA_ERR_TIMEOUT;
392 pa_context_fail(c, PA_ERR_PROTOCOL);
397 pa_context_fail(c, PA_ERR_PROTOCOL);
401 if (err >= PA_ERR_MAX)
402 err = PA_ERR_UNKNOWN;
405 pa_context_fail(c, (int) err);
409 pa_context_set_error(c, (int) err);
414 static void setup_complete_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
415 pa_context *c = userdata;
419 pa_assert(c->state == PA_CONTEXT_AUTHORIZING || c->state == PA_CONTEXT_SETTING_NAME);
423 if (command != PA_COMMAND_REPLY) {
424 pa_context_handle_error(c, command, t, TRUE);
429 case PA_CONTEXT_AUTHORIZING: {
431 pa_bool_t shm_on_remote = FALSE;
433 if (pa_tagstruct_getu32(t, &c->version) < 0 ||
434 !pa_tagstruct_eof(t)) {
435 pa_context_fail(c, PA_ERR_PROTOCOL);
439 /* Minimum supported version */
440 if (c->version < 8) {
441 pa_context_fail(c, PA_ERR_VERSION);
445 /* Starting with protocol version 13 the MSB of the version
446 tag reflects if shm is available for this connection or
448 if (c->version >= 13) {
449 shm_on_remote = !!(c->version & 0x80000000U);
450 c->version &= 0x7FFFFFFFU;
453 pa_log_debug("Protocol version: remote %u, local %u", c->version, PA_PROTOCOL_VERSION);
455 /* Enable shared memory support if possible */
457 if (c->version < 10 || (c->version >= 13 && !shm_on_remote))
462 /* Only enable SHM if both sides are owned by the same
463 * user. This is a security measure because otherwise
464 * data private to the user might leak. */
467 const pa_creds *creds;
468 if (!(creds = pa_pdispatch_creds(pd)) || getuid() != creds->uid)
473 pa_log_debug("Negotiated SHM: %s", pa_yes_no(c->do_shm));
474 pa_pstream_enable_shm(c->pstream, c->do_shm);
476 reply = pa_tagstruct_command(c, PA_COMMAND_SET_CLIENT_NAME, &tag);
478 if (c->version >= 13) {
479 pa_init_proplist(c->proplist);
480 pa_tagstruct_put_proplist(reply, c->proplist);
482 pa_tagstruct_puts(reply, pa_proplist_gets(c->proplist, PA_PROP_APPLICATION_NAME));
484 pa_pstream_send_tagstruct(c->pstream, reply);
485 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, setup_complete_callback, c, NULL);
487 pa_context_set_state(c, PA_CONTEXT_SETTING_NAME);
491 case PA_CONTEXT_SETTING_NAME :
493 if ((c->version >= 13 && (pa_tagstruct_getu32(t, &c->client_index) < 0 ||
494 c->client_index == PA_INVALID_INDEX)) ||
495 !pa_tagstruct_eof(t)) {
496 pa_context_fail(c, PA_ERR_PROTOCOL);
500 pa_context_set_state(c, PA_CONTEXT_READY);
504 pa_assert_not_reached();
511 static void setup_context(pa_context *c, pa_iochannel *io) {
520 pa_assert(!c->pstream);
521 c->pstream = pa_pstream_new(c->mainloop, io, c->mempool);
523 pa_pstream_set_die_callback(c->pstream, pstream_die_callback, c);
524 pa_pstream_set_receive_packet_callback(c->pstream, pstream_packet_callback, c);
525 pa_pstream_set_receive_memblock_callback(c->pstream, pstream_memblock_callback, c);
527 pa_assert(!c->pdispatch);
528 c->pdispatch = pa_pdispatch_new(c->mainloop, c->use_rtclock, command_table, PA_COMMAND_MAX);
530 if (!c->conf->cookie_valid)
531 pa_log_info(_("No cookie loaded. Attempting to connect without."));
533 t = pa_tagstruct_command(c, PA_COMMAND_AUTH, &tag);
536 pa_mempool_is_shared(c->mempool) &&
539 pa_log_debug("SHM possible: %s", pa_yes_no(c->do_shm));
541 /* Starting with protocol version 13 we use the MSB of the version
542 * tag for informing the other side if we could do SHM or not */
543 pa_tagstruct_putu32(t, PA_PROTOCOL_VERSION | (c->do_shm ? 0x80000000U : 0));
544 pa_tagstruct_put_arbitrary(t, c->conf->cookie, sizeof(c->conf->cookie));
550 if (pa_iochannel_creds_supported(io))
551 pa_iochannel_creds_enable(io);
553 ucred.uid = getuid();
554 ucred.gid = getgid();
556 pa_pstream_send_tagstruct_with_creds(c->pstream, t, &ucred);
559 pa_pstream_send_tagstruct(c->pstream, t);
562 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, setup_complete_callback, c, NULL);
564 pa_context_set_state(c, PA_CONTEXT_AUTHORIZING);
569 #ifdef ENABLE_LEGACY_RUNTIME_DIR
570 static char *get_old_legacy_runtime_dir(void) {
574 if (!pa_get_user_name(u, sizeof(u)))
577 p = pa_sprintf_malloc("/tmp/pulse-%s", u);
579 if (stat(p, &st) < 0) {
585 if (st.st_uid != getuid()) {
594 static char *get_very_old_legacy_runtime_dir(void) {
598 if (!pa_get_home_dir(h, sizeof(h)))
601 p = pa_sprintf_malloc("%s/.pulse", h);
603 if (stat(p, &st) < 0) {
609 if (st.st_uid != getuid()) {
619 static pa_strlist *prepend_per_user(pa_strlist *l) {
622 #ifdef ENABLE_LEGACY_RUNTIME_DIR
625 /* The very old per-user instance path (< 0.9.11). This is supported only to ease upgrades */
626 if ((legacy_dir = get_very_old_legacy_runtime_dir())) {
627 char *p = pa_sprintf_malloc("%s" PA_PATH_SEP PA_NATIVE_DEFAULT_UNIX_SOCKET, legacy_dir);
628 l = pa_strlist_prepend(l, p);
630 pa_xfree(legacy_dir);
633 /* The old per-user instance path (< 0.9.12). This is supported only to ease upgrades */
634 if ((legacy_dir = get_old_legacy_runtime_dir())) {
635 char *p = pa_sprintf_malloc("%s" PA_PATH_SEP PA_NATIVE_DEFAULT_UNIX_SOCKET, legacy_dir);
636 l = pa_strlist_prepend(l, p);
638 pa_xfree(legacy_dir);
642 /* The per-user instance */
643 if ((ufn = pa_runtime_path(PA_NATIVE_DEFAULT_UNIX_SOCKET))) {
644 l = pa_strlist_prepend(l, ufn);
653 static int context_autospawn(pa_context *c) {
660 if (sigaction(SIGCHLD, NULL, &sa) < 0) {
661 pa_log_debug("sigaction() failed: %s", pa_cstrerror(errno));
662 pa_context_fail(c, PA_ERR_INTERNAL);
667 if ((sa.sa_flags & SA_NOCLDWAIT) || sa.sa_handler == SIG_IGN) {
669 if (sa.sa_handler == SIG_IGN) {
671 pa_log_debug("Process disabled waitpid(), cannot autospawn.");
672 pa_context_fail(c, PA_ERR_CONNECTIONREFUSED);
676 pa_log_debug("Trying to autospawn...");
678 if (c->spawn_api.prefork)
679 c->spawn_api.prefork();
681 if ((pid = fork()) < 0) {
682 pa_log_error(_("fork(): %s"), pa_cstrerror(errno));
683 pa_context_fail(c, PA_ERR_INTERNAL);
685 if (c->spawn_api.postfork)
686 c->spawn_api.postfork();
692 const char *state = NULL;
693 const char * argv[32];
696 if (c->spawn_api.atfork)
697 c->spawn_api.atfork();
699 /* We leave most of the cleaning up of the process environment
700 * to the executable. We only clean up the file descriptors to
701 * make sure the executable can actually be loaded
706 argv[n++] = c->conf->daemon_binary;
707 argv[n++] = "--start";
709 while (n < PA_ELEMENTSOF(argv)-1) {
712 if (!(a = pa_split_spaces(c->conf->extra_arguments, &state)))
719 pa_assert(n <= PA_ELEMENTSOF(argv));
721 execv(argv[0], (char * const *) argv);
727 if (c->spawn_api.postfork)
728 c->spawn_api.postfork();
731 r = waitpid(pid, &status, 0);
732 } while (r < 0 && errno == EINTR);
736 if (errno != ESRCH) {
737 pa_log(_("waitpid(): %s"), pa_cstrerror(errno));
738 pa_context_fail(c, PA_ERR_INTERNAL);
742 /* hmm, something already reaped our child, so we assume
743 * startup worked, even if we cannot know */
745 } else if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
746 pa_context_fail(c, PA_ERR_CONNECTIONREFUSED);
761 #endif /* OS_IS_WIN32 */
763 static void on_connection(pa_socket_client *client, pa_iochannel*io, void *userdata);
766 static void track_pulseaudio_on_dbus(pa_context *c, DBusBusType type, pa_dbus_wrap_connection **conn) {
772 dbus_error_init(&error);
774 if (!(*conn = pa_dbus_wrap_connection_new(c->mainloop, c->use_rtclock, type, &error)) || dbus_error_is_set(&error)) {
775 pa_log_warn("Unable to contact DBUS: %s: %s", error.name, error.message);
779 if (!dbus_connection_add_filter(pa_dbus_wrap_connection_get(*conn), filter_cb, c, NULL)) {
780 pa_log_warn("Failed to add filter function");
783 c->filter_added = TRUE;
785 if (pa_dbus_add_matches(
786 pa_dbus_wrap_connection_get(*conn), &error,
787 "type='signal',sender='" DBUS_SERVICE_DBUS "',interface='" DBUS_INTERFACE_DBUS "',member='NameOwnerChanged',arg0='org.pulseaudio.Server',arg1=''", NULL) < 0) {
789 pa_log_warn("Unable to track org.pulseaudio.Server: %s: %s", error.name, error.message);
797 pa_dbus_wrap_connection_free(*conn);
801 dbus_error_free(&error);
805 static int try_next_connection(pa_context *c) {
810 pa_assert(!c->client);
816 c->server_list = pa_strlist_pop(c->server_list, &u);
821 if (c->do_autospawn) {
823 if ((r = context_autospawn(c)) < 0)
826 /* Autospawn only once */
827 c->do_autospawn = FALSE;
829 /* Connect only to per-user sockets this time */
830 c->server_list = prepend_per_user(c->server_list);
832 /* Retry connection */
838 if (c->no_fail && !c->server_specified) {
840 track_pulseaudio_on_dbus(c, DBUS_BUS_SESSION, &c->session_bus);
842 track_pulseaudio_on_dbus(c, DBUS_BUS_SYSTEM, &c->system_bus);
845 pa_context_fail(c, PA_ERR_CONNECTIONREFUSED);
850 pa_log_debug("Trying to connect to %s...", u);
853 c->server = pa_xstrdup(u);
855 if (!(c->client = pa_socket_client_new_string(c->mainloop, c->use_rtclock, u, PA_NATIVE_DEFAULT_PORT)))
858 c->is_local = !!pa_socket_client_is_local(c->client);
859 pa_socket_client_set_callback(c->client, on_connection, c);
871 static void on_connection(pa_socket_client *client, pa_iochannel*io, void *userdata) {
872 pa_context *c = userdata;
873 int saved_errno = errno;
877 pa_assert(c->state == PA_CONTEXT_CONNECTING);
881 pa_socket_client_unref(client);
885 /* Try the next item in the list */
886 if (saved_errno == ECONNREFUSED ||
887 saved_errno == ETIMEDOUT ||
888 saved_errno == EHOSTUNREACH) {
889 try_next_connection(c);
893 pa_context_fail(c, PA_ERR_CONNECTIONREFUSED);
897 setup_context(c, io);
904 static DBusHandlerResult filter_cb(DBusConnection *bus, DBusMessage *message, void *userdata) {
905 pa_context *c = userdata;
906 pa_bool_t is_session;
912 if (c->state != PA_CONTEXT_CONNECTING)
918 /* FIXME: We probably should check if this is actually the NameOwnerChanged we were looking for */
920 is_session = c->session_bus && bus == pa_dbus_wrap_connection_get(c->session_bus);
921 pa_log_debug("Rock!! PulseAudio might be back on %s bus", is_session ? "session" : "system");
924 /* The user instance via PF_LOCAL */
925 c->server_list = prepend_per_user(c->server_list);
927 /* The system wide instance via PF_LOCAL */
928 c->server_list = pa_strlist_prepend(c->server_list, PA_SYSTEM_RUNTIME_PATH PA_PATH_SEP PA_NATIVE_DEFAULT_UNIX_SOCKET);
931 try_next_connection(c);
934 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
938 int pa_context_connect(
941 pa_context_flags_t flags,
942 const pa_spawn_api *api) {
947 pa_assert(PA_REFCNT_VALUE(c) >= 1);
949 PA_CHECK_VALIDITY(c, !pa_detect_fork(), PA_ERR_FORKED);
950 PA_CHECK_VALIDITY(c, c->state == PA_CONTEXT_UNCONNECTED, PA_ERR_BADSTATE);
951 PA_CHECK_VALIDITY(c, !(flags & ~(PA_CONTEXT_NOAUTOSPAWN|PA_CONTEXT_NOFAIL)), PA_ERR_INVALID);
952 PA_CHECK_VALIDITY(c, !server || *server, PA_ERR_INVALID);
955 c->conf->autospawn = FALSE;
957 server = c->conf->default_server;
961 c->no_fail = !!(flags & PA_CONTEXT_NOFAIL);
962 c->server_specified = !!server;
963 pa_assert(!c->server_list);
966 if (!(c->server_list = pa_strlist_parse(server))) {
967 pa_context_fail(c, PA_ERR_INVALIDSERVER);
974 /* Prepend in reverse order */
976 /* Follow the X display */
977 if (c->conf->auto_connect_display) {
978 if ((d = getenv("DISPLAY"))) {
979 d = pa_xstrndup(d, strcspn(d, ":"));
982 c->server_list = pa_strlist_prepend(c->server_list, d);
988 /* Add TCP/IP on the localhost */
989 if (c->conf->auto_connect_localhost) {
990 c->server_list = pa_strlist_prepend(c->server_list, "tcp6:[::1]");
991 c->server_list = pa_strlist_prepend(c->server_list, "tcp4:127.0.0.1");
994 /* The system wide instance via PF_LOCAL */
995 c->server_list = pa_strlist_prepend(c->server_list, PA_SYSTEM_RUNTIME_PATH PA_PATH_SEP PA_NATIVE_DEFAULT_UNIX_SOCKET);
997 /* The user instance via PF_LOCAL */
998 c->server_list = prepend_per_user(c->server_list);
1001 /* Set up autospawning */
1002 if (!(flags & PA_CONTEXT_NOAUTOSPAWN) && c->conf->autospawn) {
1006 pa_log_debug("Not doing autospawn since we are root.");
1008 c->do_autospawn = TRUE;
1011 c->spawn_api = *api;
1016 pa_context_set_state(c, PA_CONTEXT_CONNECTING);
1017 r = try_next_connection(c);
1020 pa_context_unref(c);
1025 void pa_context_disconnect(pa_context *c) {
1027 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1029 if (pa_detect_fork())
1032 if (PA_CONTEXT_IS_GOOD(c->state))
1033 pa_context_set_state(c, PA_CONTEXT_TERMINATED);
1036 pa_context_state_t pa_context_get_state(pa_context *c) {
1038 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1043 int pa_context_errno(pa_context *c) {
1046 return PA_ERR_INVALID;
1048 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1053 void pa_context_set_state_callback(pa_context *c, pa_context_notify_cb_t cb, void *userdata) {
1055 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1057 if (pa_detect_fork())
1060 if (c->state == PA_CONTEXT_TERMINATED || c->state == PA_CONTEXT_FAILED)
1063 c->state_callback = cb;
1064 c->state_userdata = userdata;
1067 void pa_context_set_event_callback(pa_context *c, pa_context_event_cb_t cb, void *userdata) {
1069 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1071 if (pa_detect_fork())
1074 if (c->state == PA_CONTEXT_TERMINATED || c->state == PA_CONTEXT_FAILED)
1077 c->event_callback = cb;
1078 c->event_userdata = userdata;
1081 int pa_context_is_pending(pa_context *c) {
1083 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1085 PA_CHECK_VALIDITY(c, !pa_detect_fork(), PA_ERR_FORKED);
1086 PA_CHECK_VALIDITY(c, PA_CONTEXT_IS_GOOD(c->state), PA_ERR_BADSTATE);
1088 return (c->pstream && pa_pstream_is_pending(c->pstream)) ||
1089 (c->pdispatch && pa_pdispatch_is_pending(c->pdispatch)) ||
1093 static void set_dispatch_callbacks(pa_operation *o);
1095 static void pdispatch_drain_callback(pa_pdispatch*pd, void *userdata) {
1096 set_dispatch_callbacks(userdata);
1099 static void pstream_drain_callback(pa_pstream *s, void *userdata) {
1100 set_dispatch_callbacks(userdata);
1103 static void set_dispatch_callbacks(pa_operation *o) {
1107 pa_assert(PA_REFCNT_VALUE(o) >= 1);
1108 pa_assert(o->context);
1109 pa_assert(PA_REFCNT_VALUE(o->context) >= 1);
1110 pa_assert(o->context->state == PA_CONTEXT_READY);
1112 pa_pstream_set_drain_callback(o->context->pstream, NULL, NULL);
1113 pa_pdispatch_set_drain_callback(o->context->pdispatch, NULL, NULL);
1115 if (pa_pdispatch_is_pending(o->context->pdispatch)) {
1116 pa_pdispatch_set_drain_callback(o->context->pdispatch, pdispatch_drain_callback, o);
1120 if (pa_pstream_is_pending(o->context->pstream)) {
1121 pa_pstream_set_drain_callback(o->context->pstream, pstream_drain_callback, o);
1127 pa_context_notify_cb_t cb = (pa_context_notify_cb_t) o->callback;
1128 cb(o->context, o->userdata);
1131 pa_operation_done(o);
1132 pa_operation_unref(o);
1136 pa_operation* pa_context_drain(pa_context *c, pa_context_notify_cb_t cb, void *userdata) {
1140 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1142 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1143 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1144 PA_CHECK_VALIDITY_RETURN_NULL(c, pa_context_is_pending(c), PA_ERR_BADSTATE);
1146 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1147 set_dispatch_callbacks(pa_operation_ref(o));
1152 void pa_context_simple_ack_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
1153 pa_operation *o = userdata;
1158 pa_assert(PA_REFCNT_VALUE(o) >= 1);
1163 if (command != PA_COMMAND_REPLY) {
1164 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
1168 } else if (!pa_tagstruct_eof(t)) {
1169 pa_context_fail(o->context, PA_ERR_PROTOCOL);
1174 pa_context_success_cb_t cb = (pa_context_success_cb_t) o->callback;
1175 cb(o->context, success, o->userdata);
1179 pa_operation_done(o);
1180 pa_operation_unref(o);
1183 pa_operation* pa_context_send_simple_command(pa_context *c, uint32_t command, pa_pdispatch_cb_t internal_cb, pa_operation_cb_t cb, void *userdata) {
1189 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1191 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1192 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1194 o = pa_operation_new(c, NULL, cb, userdata);
1196 t = pa_tagstruct_command(c, command, &tag);
1197 pa_pstream_send_tagstruct(c->pstream, t);
1198 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, internal_cb, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1203 pa_operation* pa_context_exit_daemon(pa_context *c, pa_context_success_cb_t cb, void *userdata) {
1205 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1207 return pa_context_send_simple_command(c, PA_COMMAND_EXIT, pa_context_simple_ack_callback, (pa_operation_cb_t) cb, userdata);
1210 pa_operation* pa_context_set_default_sink(pa_context *c, const char *name, pa_context_success_cb_t cb, void *userdata) {
1216 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1218 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1219 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1221 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1222 t = pa_tagstruct_command(c, PA_COMMAND_SET_DEFAULT_SINK, &tag);
1223 pa_tagstruct_puts(t, name);
1224 pa_pstream_send_tagstruct(c->pstream, t);
1225 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1230 pa_operation* pa_context_set_default_source(pa_context *c, const char *name, pa_context_success_cb_t cb, void *userdata) {
1236 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1238 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1239 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1241 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1242 t = pa_tagstruct_command(c, PA_COMMAND_SET_DEFAULT_SOURCE, &tag);
1243 pa_tagstruct_puts(t, name);
1244 pa_pstream_send_tagstruct(c->pstream, t);
1245 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1250 int pa_context_is_local(pa_context *c) {
1252 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1254 PA_CHECK_VALIDITY_RETURN_ANY(c, !pa_detect_fork(), PA_ERR_FORKED, -1);
1255 PA_CHECK_VALIDITY_RETURN_ANY(c, PA_CONTEXT_IS_GOOD(c->state), PA_ERR_BADSTATE, -1);
1257 return !!c->is_local;
1260 pa_operation* pa_context_set_name(pa_context *c, const char *name, pa_context_success_cb_t cb, void *userdata) {
1264 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1267 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1268 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1270 if (c->version >= 13) {
1271 pa_proplist *p = pa_proplist_new();
1273 pa_proplist_sets(p, PA_PROP_APPLICATION_NAME, name);
1274 o = pa_context_proplist_update(c, PA_UPDATE_REPLACE, p, cb, userdata);
1275 pa_proplist_free(p);
1280 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1281 t = pa_tagstruct_command(c, PA_COMMAND_SET_CLIENT_NAME, &tag);
1282 pa_tagstruct_puts(t, name);
1283 pa_pstream_send_tagstruct(c->pstream, t);
1284 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1290 const char* pa_get_library_version(void) {
1291 return pa_get_headers_version();
1294 const char* pa_context_get_server(pa_context *c) {
1296 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1298 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1299 PA_CHECK_VALIDITY_RETURN_NULL(c, c->server, PA_ERR_NOENTITY);
1301 if (*c->server == '{') {
1302 char *e = strchr(c->server+1, '}');
1303 return e ? e+1 : c->server;
1309 uint32_t pa_context_get_protocol_version(pa_context *c) {
1310 return PA_PROTOCOL_VERSION;
1313 uint32_t pa_context_get_server_protocol_version(pa_context *c) {
1315 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1317 PA_CHECK_VALIDITY_RETURN_ANY(c, !pa_detect_fork(), PA_ERR_FORKED, PA_INVALID_INDEX);
1318 PA_CHECK_VALIDITY_RETURN_ANY(c, PA_CONTEXT_IS_GOOD(c->state), PA_ERR_BADSTATE, PA_INVALID_INDEX);
1323 pa_tagstruct *pa_tagstruct_command(pa_context *c, uint32_t command, uint32_t *tag) {
1329 t = pa_tagstruct_new(NULL, 0);
1330 pa_tagstruct_putu32(t, command);
1331 pa_tagstruct_putu32(t, *tag = c->ctag++);
1336 uint32_t pa_context_get_index(pa_context *c) {
1338 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1340 PA_CHECK_VALIDITY_RETURN_ANY(c, !pa_detect_fork(), PA_ERR_FORKED, PA_INVALID_INDEX);
1341 PA_CHECK_VALIDITY_RETURN_ANY(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE, PA_INVALID_INDEX);
1342 PA_CHECK_VALIDITY_RETURN_ANY(c, c->version >= 13, PA_ERR_NOTSUPPORTED, PA_INVALID_INDEX);
1344 return c->client_index;
1347 pa_operation *pa_context_proplist_update(pa_context *c, pa_update_mode_t mode, pa_proplist *p, pa_context_success_cb_t cb, void *userdata) {
1353 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1355 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1356 PA_CHECK_VALIDITY_RETURN_NULL(c, mode == PA_UPDATE_SET || mode == PA_UPDATE_MERGE || mode == PA_UPDATE_REPLACE, PA_ERR_INVALID);
1357 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1358 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 13, PA_ERR_NOTSUPPORTED);
1360 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1362 t = pa_tagstruct_command(c, PA_COMMAND_UPDATE_CLIENT_PROPLIST, &tag);
1363 pa_tagstruct_putu32(t, (uint32_t) mode);
1364 pa_tagstruct_put_proplist(t, p);
1366 pa_pstream_send_tagstruct(c->pstream, t);
1367 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1369 /* Please note that we don't update c->proplist here, because we
1370 * don't export that field */
1375 pa_operation *pa_context_proplist_remove(pa_context *c, const char *const keys[], pa_context_success_cb_t cb, void *userdata) {
1379 const char * const *k;
1382 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1384 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1385 PA_CHECK_VALIDITY_RETURN_NULL(c, keys && keys[0], PA_ERR_INVALID);
1386 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1387 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 13, PA_ERR_NOTSUPPORTED);
1389 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1391 t = pa_tagstruct_command(c, PA_COMMAND_REMOVE_CLIENT_PROPLIST, &tag);
1393 for (k = keys; *k; k++)
1394 pa_tagstruct_puts(t, *k);
1396 pa_tagstruct_puts(t, NULL);
1398 pa_pstream_send_tagstruct(c->pstream, t);
1399 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1401 /* Please note that we don't update c->proplist here, because we
1402 * don't export that field */
1407 void pa_command_extension(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
1408 pa_context *c = userdata;
1413 pa_assert(command == PA_COMMAND_EXTENSION);
1416 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1420 if (c->version < 15) {
1421 pa_context_fail(c, PA_ERR_PROTOCOL);
1425 if (pa_tagstruct_getu32(t, &idx) < 0 ||
1426 pa_tagstruct_gets(t, &name) < 0) {
1427 pa_context_fail(c, PA_ERR_PROTOCOL);
1431 if (pa_streq(name, "module-device-manager"))
1432 pa_ext_device_manager_command(c, tag, t);
1433 else if (pa_streq(name, "module-device-restore"))
1434 pa_ext_device_restore_command(c, tag, t);
1435 else if (pa_streq(name, "module-stream-restore"))
1436 pa_ext_stream_restore_command(c, tag, t);
1437 else if (pa_streq(name, "module-node-manager"))
1438 pa_ext_node_manager_command(c, tag, t);
1440 pa_log(_("Received message for unknown extension '%s'"), name);
1443 pa_context_unref(c);
1447 void pa_command_client_event(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
1448 pa_context *c = userdata;
1449 pa_proplist *pl = NULL;
1453 pa_assert(command == PA_COMMAND_CLIENT_EVENT);
1456 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1460 if (c->version < 15) {
1461 pa_context_fail(c, PA_ERR_PROTOCOL);
1465 pl = pa_proplist_new();
1467 if (pa_tagstruct_gets(t, &event) < 0 ||
1468 pa_tagstruct_get_proplist(t, pl) < 0 ||
1469 !pa_tagstruct_eof(t) || !event) {
1470 pa_context_fail(c, PA_ERR_PROTOCOL);
1474 if (c->event_callback)
1475 c->event_callback(c, event, pl, c->event_userdata);
1478 pa_context_unref(c);
1481 pa_proplist_free(pl);
1484 pa_time_event* pa_context_rttime_new(pa_context *c, pa_usec_t usec, pa_time_event_cb_t cb, void *userdata) {
1488 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1489 pa_assert(c->mainloop);
1491 if (usec == PA_USEC_INVALID)
1492 return c->mainloop->time_new(c->mainloop, NULL, cb, userdata);
1494 pa_timeval_rtstore(&tv, usec, c->use_rtclock);
1496 return c->mainloop->time_new(c->mainloop, &tv, cb, userdata);
1499 void pa_context_rttime_restart(pa_context *c, pa_time_event *e, pa_usec_t usec) {
1503 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1504 pa_assert(c->mainloop);
1507 if (usec == PA_USEC_INVALID)
1508 c->mainloop->time_restart(e, NULL);
1510 pa_timeval_rtstore(&tv, usec, c->use_rtclock);
1511 c->mainloop->time_restart(e, &tv);
1515 size_t pa_context_get_tile_size(pa_context *c, const pa_sample_spec *ss) {
1519 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1521 PA_CHECK_VALIDITY_RETURN_ANY(c, !pa_detect_fork(), PA_ERR_FORKED, (size_t) -1);
1522 PA_CHECK_VALIDITY_RETURN_ANY(c, !ss || pa_sample_spec_valid(ss), PA_ERR_INVALID, (size_t) -1);
1524 fs = ss ? pa_frame_size(ss) : 1;
1525 mbs = PA_ROUND_DOWN(pa_mempool_block_size_max(c->mempool), fs);
1526 return PA_MAX(mbs, fs);