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>
38 #ifdef HAVE_SYS_WAIT_H
42 #ifdef HAVE_SYS_SOCKET_H
43 #include <sys/socket.h>
52 #include <pulse/version.h>
53 #include <pulse/xmalloc.h>
54 #include <pulse/utf8.h>
55 #include <pulse/util.h>
56 #include <pulse/i18n.h>
57 #include <pulse/mainloop.h>
58 #include <pulse/timeval.h>
60 #include <pulsecore/winsock.h>
61 #include <pulsecore/core-error.h>
63 #include <pulsecore/native-common.h>
64 #include <pulsecore/pdispatch.h>
65 #include <pulsecore/pstream.h>
66 #include <pulsecore/hashmap.h>
67 #include <pulsecore/socket-client.h>
68 #include <pulsecore/pstream-util.h>
69 #include <pulsecore/core-rtclock.h>
70 #include <pulsecore/core-util.h>
71 #include <pulsecore/log.h>
72 #include <pulsecore/socket-util.h>
73 #include <pulsecore/creds.h>
74 #include <pulsecore/macro.h>
75 #include <pulsecore/proplist-util.h>
79 #include "client-conf.h"
80 #include "fork-detect.h"
83 #include "client-conf-x11.h"
88 void pa_command_extension(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
90 static const pa_pdispatch_cb_t command_table[PA_COMMAND_MAX] = {
91 [PA_COMMAND_REQUEST] = pa_command_request,
92 [PA_COMMAND_OVERFLOW] = pa_command_overflow_or_underflow,
93 [PA_COMMAND_UNDERFLOW] = pa_command_overflow_or_underflow,
94 [PA_COMMAND_PLAYBACK_STREAM_KILLED] = pa_command_stream_killed,
95 [PA_COMMAND_RECORD_STREAM_KILLED] = pa_command_stream_killed,
96 [PA_COMMAND_PLAYBACK_STREAM_MOVED] = pa_command_stream_moved,
97 [PA_COMMAND_RECORD_STREAM_MOVED] = pa_command_stream_moved,
98 [PA_COMMAND_PLAYBACK_STREAM_SUSPENDED] = pa_command_stream_suspended,
99 [PA_COMMAND_RECORD_STREAM_SUSPENDED] = pa_command_stream_suspended,
100 [PA_COMMAND_STARTED] = pa_command_stream_started,
101 [PA_COMMAND_SUBSCRIBE_EVENT] = pa_command_subscribe_event,
102 [PA_COMMAND_EXTENSION] = pa_command_extension,
103 [PA_COMMAND_PLAYBACK_STREAM_EVENT] = pa_command_stream_event,
104 [PA_COMMAND_RECORD_STREAM_EVENT] = pa_command_stream_event,
105 [PA_COMMAND_CLIENT_EVENT] = pa_command_client_event,
106 [PA_COMMAND_PLAYBACK_BUFFER_ATTR_CHANGED] = pa_command_stream_buffer_attr,
107 [PA_COMMAND_RECORD_BUFFER_ATTR_CHANGED] = pa_command_stream_buffer_attr
109 static void context_free(pa_context *c);
112 static DBusHandlerResult filter_cb(DBusConnection *bus, DBusMessage *message, void *userdata);
115 pa_context *pa_context_new(pa_mainloop_api *mainloop, const char *name) {
116 return pa_context_new_with_proplist(mainloop, name, NULL);
119 static void reset_callbacks(pa_context *c) {
122 c->state_callback = NULL;
123 c->state_userdata = NULL;
125 c->subscribe_callback = NULL;
126 c->subscribe_userdata = NULL;
128 c->event_callback = NULL;
129 c->event_userdata = NULL;
131 c->ext_device_manager.callback = NULL;
132 c->ext_device_manager.userdata = NULL;
134 c->ext_stream_restore.callback = NULL;
135 c->ext_stream_restore.userdata = NULL;
138 pa_context *pa_context_new_with_proplist(pa_mainloop_api *mainloop, const char *name, pa_proplist *p) {
143 if (pa_detect_fork())
148 c = pa_xnew0(pa_context, 1);
151 c->proplist = p ? pa_proplist_copy(p) : pa_proplist_new();
154 pa_proplist_sets(c->proplist, PA_PROP_APPLICATION_NAME, name);
157 c->system_bus = c->session_bus = NULL;
159 c->mainloop = mainloop;
160 c->playback_streams = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
161 c->record_streams = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
162 c->client_index = PA_INVALID_INDEX;
163 c->use_rtclock = pa_mainloop_is_our_api(mainloop);
165 PA_LLIST_HEAD_INIT(pa_stream, c->streams);
166 PA_LLIST_HEAD_INIT(pa_operation, c->operations);
169 c->state = PA_CONTEXT_UNCONNECTED;
175 pa_check_signal_is_blocked(SIGPIPE);
179 c->conf = pa_client_conf_new();
180 pa_client_conf_load(c->conf, NULL);
182 pa_client_conf_from_x11(c->conf, NULL);
184 pa_client_conf_env(c->conf);
186 if (!(c->mempool = pa_mempool_new(!c->conf->disable_shm, c->conf->shm_size))) {
188 if (!c->conf->disable_shm)
189 c->mempool = pa_mempool_new(FALSE, c->conf->shm_size);
200 static void context_unlink(pa_context *c) {
205 s = c->streams ? pa_stream_ref(c->streams) : NULL;
207 pa_stream *n = s->next ? pa_stream_ref(s->next) : NULL;
208 pa_stream_set_state(s, c->state == PA_CONTEXT_FAILED ? PA_STREAM_FAILED : PA_STREAM_TERMINATED);
213 while (c->operations)
214 pa_operation_cancel(c->operations);
217 pa_pdispatch_unref(c->pdispatch);
222 pa_pstream_unlink(c->pstream);
223 pa_pstream_unref(c->pstream);
228 pa_socket_client_unref(c->client);
235 static void context_free(pa_context *c) {
243 dbus_connection_remove_filter(pa_dbus_wrap_connection_get(c->system_bus), filter_cb, c);
244 pa_dbus_wrap_connection_free(c->system_bus);
247 if (c->session_bus) {
249 dbus_connection_remove_filter(pa_dbus_wrap_connection_get(c->session_bus), filter_cb, c);
250 pa_dbus_wrap_connection_free(c->session_bus);
254 if (c->record_streams)
255 pa_hashmap_free(c->record_streams, NULL, NULL);
256 if (c->playback_streams)
257 pa_hashmap_free(c->playback_streams, NULL, NULL);
260 pa_mempool_free(c->mempool);
263 pa_client_conf_free(c->conf);
265 pa_strlist_free(c->server_list);
268 pa_proplist_free(c->proplist);
274 pa_context* pa_context_ref(pa_context *c) {
276 pa_assert(PA_REFCNT_VALUE(c) >= 1);
282 void pa_context_unref(pa_context *c) {
284 pa_assert(PA_REFCNT_VALUE(c) >= 1);
286 if (PA_REFCNT_DEC(c) <= 0)
290 void pa_context_set_state(pa_context *c, pa_context_state_t st) {
292 pa_assert(PA_REFCNT_VALUE(c) >= 1);
301 if (c->state_callback)
302 c->state_callback(c, c->state_userdata);
304 if (st == PA_CONTEXT_FAILED || st == PA_CONTEXT_TERMINATED)
310 int pa_context_set_error(pa_context *c, int error) {
311 pa_assert(error >= 0);
312 pa_assert(error < PA_ERR_MAX);
320 void pa_context_fail(pa_context *c, int error) {
322 pa_assert(PA_REFCNT_VALUE(c) >= 1);
324 pa_context_set_error(c, error);
325 pa_context_set_state(c, PA_CONTEXT_FAILED);
328 static void pstream_die_callback(pa_pstream *p, void *userdata) {
329 pa_context *c = userdata;
334 pa_context_fail(c, PA_ERR_CONNECTIONTERMINATED);
337 static void pstream_packet_callback(pa_pstream *p, pa_packet *packet, const pa_creds *creds, void *userdata) {
338 pa_context *c = userdata;
346 if (pa_pdispatch_run(c->pdispatch, packet, creds, c) < 0)
347 pa_context_fail(c, PA_ERR_PROTOCOL);
352 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) {
353 pa_context *c = userdata;
358 pa_assert(chunk->length > 0);
360 pa_assert(PA_REFCNT_VALUE(c) >= 1);
364 if ((s = pa_hashmap_get(c->record_streams, PA_UINT32_TO_PTR(channel)))) {
366 if (chunk->memblock) {
367 pa_memblockq_seek(s->record_memblockq, offset, seek, TRUE);
368 pa_memblockq_push_align(s->record_memblockq, chunk);
370 pa_memblockq_seek(s->record_memblockq, offset+chunk->length, seek, TRUE);
372 if (s->read_callback) {
375 if ((l = pa_memblockq_get_length(s->record_memblockq)) > 0)
376 s->read_callback(s, l, s->read_userdata);
383 int pa_context_handle_error(pa_context *c, uint32_t command, pa_tagstruct *t, pa_bool_t fail) {
386 pa_assert(PA_REFCNT_VALUE(c) >= 1);
388 if (command == PA_COMMAND_ERROR) {
391 if (pa_tagstruct_getu32(t, &err) < 0 ||
392 !pa_tagstruct_eof(t)) {
393 pa_context_fail(c, PA_ERR_PROTOCOL);
397 } else if (command == PA_COMMAND_TIMEOUT)
398 err = PA_ERR_TIMEOUT;
400 pa_context_fail(c, PA_ERR_PROTOCOL);
405 pa_context_fail(c, PA_ERR_PROTOCOL);
409 if (err >= PA_ERR_MAX)
410 err = PA_ERR_UNKNOWN;
413 pa_context_fail(c, (int) err);
417 pa_context_set_error(c, (int) err);
422 static void setup_complete_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
423 pa_context *c = userdata;
427 pa_assert(c->state == PA_CONTEXT_AUTHORIZING || c->state == PA_CONTEXT_SETTING_NAME);
431 if (command != PA_COMMAND_REPLY) {
432 pa_context_handle_error(c, command, t, TRUE);
437 case PA_CONTEXT_AUTHORIZING: {
439 pa_bool_t shm_on_remote = FALSE;
441 if (pa_tagstruct_getu32(t, &c->version) < 0 ||
442 !pa_tagstruct_eof(t)) {
443 pa_context_fail(c, PA_ERR_PROTOCOL);
447 /* Minimum supported version */
448 if (c->version < 8) {
449 pa_context_fail(c, PA_ERR_VERSION);
453 /* Starting with protocol version 13 the MSB of the version
454 tag reflects if shm is available for this connection or
456 if (c->version >= 13) {
457 shm_on_remote = !!(c->version & 0x80000000U);
458 c->version &= 0x7FFFFFFFU;
461 pa_log_debug("Protocol version: remote %u, local %u", c->version, PA_PROTOCOL_VERSION);
463 /* Enable shared memory support if possible */
465 if (c->version < 10 || (c->version >= 13 && !shm_on_remote))
470 /* Only enable SHM if both sides are owned by the same
471 * user. This is a security measure because otherwise
472 * data private to the user might leak. */
475 const pa_creds *creds;
476 if (!(creds = pa_pdispatch_creds(pd)) || getuid() != creds->uid)
481 pa_log_debug("Negotiated SHM: %s", pa_yes_no(c->do_shm));
482 pa_pstream_enable_shm(c->pstream, c->do_shm);
484 reply = pa_tagstruct_command(c, PA_COMMAND_SET_CLIENT_NAME, &tag);
486 if (c->version >= 13) {
487 pa_init_proplist(c->proplist);
488 pa_tagstruct_put_proplist(reply, c->proplist);
490 pa_tagstruct_puts(reply, pa_proplist_gets(c->proplist, PA_PROP_APPLICATION_NAME));
492 pa_pstream_send_tagstruct(c->pstream, reply);
493 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, setup_complete_callback, c, NULL);
495 pa_context_set_state(c, PA_CONTEXT_SETTING_NAME);
499 case PA_CONTEXT_SETTING_NAME :
501 if ((c->version >= 13 && (pa_tagstruct_getu32(t, &c->client_index) < 0 ||
502 c->client_index == PA_INVALID_INDEX)) ||
503 !pa_tagstruct_eof(t)) {
504 pa_context_fail(c, PA_ERR_PROTOCOL);
508 pa_context_set_state(c, PA_CONTEXT_READY);
512 pa_assert_not_reached();
519 static void setup_context(pa_context *c, pa_iochannel *io) {
528 pa_assert(!c->pstream);
529 c->pstream = pa_pstream_new(c->mainloop, io, c->mempool);
531 pa_pstream_set_die_callback(c->pstream, pstream_die_callback, c);
532 pa_pstream_set_recieve_packet_callback(c->pstream, pstream_packet_callback, c);
533 pa_pstream_set_recieve_memblock_callback(c->pstream, pstream_memblock_callback, c);
535 pa_assert(!c->pdispatch);
536 c->pdispatch = pa_pdispatch_new(c->mainloop, c->use_rtclock, command_table, PA_COMMAND_MAX);
538 if (!c->conf->cookie_valid)
539 pa_log_info(_("No cookie loaded. Attempting to connect without."));
541 t = pa_tagstruct_command(c, PA_COMMAND_AUTH, &tag);
544 pa_mempool_is_shared(c->mempool) &&
547 pa_log_debug("SHM possible: %s", pa_yes_no(c->do_shm));
549 /* Starting with protocol version 13 we use the MSB of the version
550 * tag for informing the other side if we could do SHM or not */
551 pa_tagstruct_putu32(t, PA_PROTOCOL_VERSION | (c->do_shm ? 0x80000000U : 0));
552 pa_tagstruct_put_arbitrary(t, c->conf->cookie, sizeof(c->conf->cookie));
558 if (pa_iochannel_creds_supported(io))
559 pa_iochannel_creds_enable(io);
561 ucred.uid = getuid();
562 ucred.gid = getgid();
564 pa_pstream_send_tagstruct_with_creds(c->pstream, t, &ucred);
567 pa_pstream_send_tagstruct(c->pstream, t);
570 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, setup_complete_callback, c, NULL);
572 pa_context_set_state(c, PA_CONTEXT_AUTHORIZING);
577 #ifdef ENABLE_LEGACY_RUNTIME_DIR
578 static char *get_old_legacy_runtime_dir(void) {
582 if (!pa_get_user_name(u, sizeof(u)))
585 p = pa_sprintf_malloc("/tmp/pulse-%s", u);
587 if (stat(p, &st) < 0) {
592 if (st.st_uid != getuid()) {
600 static char *get_very_old_legacy_runtime_dir(void) {
604 if (!pa_get_home_dir(h, sizeof(h)))
607 p = pa_sprintf_malloc("%s/.pulse", h);
609 if (stat(p, &st) < 0) {
614 if (st.st_uid != getuid()) {
623 static pa_strlist *prepend_per_user(pa_strlist *l) {
626 #ifdef ENABLE_LEGACY_RUNTIME_DIR
627 static char *legacy_dir;
629 /* The very old per-user instance path (< 0.9.11). This is supported only to ease upgrades */
630 if ((legacy_dir = get_very_old_legacy_runtime_dir())) {
631 char *p = pa_sprintf_malloc("%s" PA_PATH_SEP PA_NATIVE_DEFAULT_UNIX_SOCKET, legacy_dir);
632 l = pa_strlist_prepend(l, p);
634 pa_xfree(legacy_dir);
637 /* The old per-user instance path (< 0.9.12). This is supported only to ease upgrades */
638 if ((legacy_dir = get_old_legacy_runtime_dir())) {
639 char *p = pa_sprintf_malloc("%s" PA_PATH_SEP PA_NATIVE_DEFAULT_UNIX_SOCKET, legacy_dir);
640 l = pa_strlist_prepend(l, p);
642 pa_xfree(legacy_dir);
646 /* The per-user instance */
647 if ((ufn = pa_runtime_path(PA_NATIVE_DEFAULT_UNIX_SOCKET))) {
648 l = pa_strlist_prepend(l, ufn);
657 static int context_autospawn(pa_context *c) {
664 if (sigaction(SIGCHLD, NULL, &sa) < 0) {
665 pa_log_debug("sigaction() failed: %s", pa_cstrerror(errno));
666 pa_context_fail(c, PA_ERR_INTERNAL);
670 if ((sa.sa_flags & SA_NOCLDWAIT) || 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) {
1005 pa_log_debug("Not doing autospawn since we are root.");
1007 c->do_autospawn = TRUE;
1010 c->spawn_api = *api;
1014 pa_context_set_state(c, PA_CONTEXT_CONNECTING);
1015 r = try_next_connection(c);
1018 pa_context_unref(c);
1023 void pa_context_disconnect(pa_context *c) {
1025 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1027 if (pa_detect_fork())
1030 if (PA_CONTEXT_IS_GOOD(c->state))
1031 pa_context_set_state(c, PA_CONTEXT_TERMINATED);
1034 pa_context_state_t pa_context_get_state(pa_context *c) {
1036 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1041 int pa_context_errno(pa_context *c) {
1044 return PA_ERR_INVALID;
1046 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1051 void pa_context_set_state_callback(pa_context *c, pa_context_notify_cb_t cb, void *userdata) {
1053 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1055 if (pa_detect_fork())
1058 if (c->state == PA_CONTEXT_TERMINATED || c->state == PA_CONTEXT_FAILED)
1061 c->state_callback = cb;
1062 c->state_userdata = userdata;
1065 void pa_context_set_event_callback(pa_context *c, pa_context_event_cb_t cb, void *userdata) {
1067 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1069 if (pa_detect_fork())
1072 if (c->state == PA_CONTEXT_TERMINATED || c->state == PA_CONTEXT_FAILED)
1075 c->event_callback = cb;
1076 c->event_userdata = userdata;
1079 int pa_context_is_pending(pa_context *c) {
1081 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1083 PA_CHECK_VALIDITY(c, !pa_detect_fork(), PA_ERR_FORKED);
1084 PA_CHECK_VALIDITY(c, PA_CONTEXT_IS_GOOD(c->state), PA_ERR_BADSTATE);
1086 return (c->pstream && pa_pstream_is_pending(c->pstream)) ||
1087 (c->pdispatch && pa_pdispatch_is_pending(c->pdispatch)) ||
1091 static void set_dispatch_callbacks(pa_operation *o);
1093 static void pdispatch_drain_callback(pa_pdispatch*pd, void *userdata) {
1094 set_dispatch_callbacks(userdata);
1097 static void pstream_drain_callback(pa_pstream *s, void *userdata) {
1098 set_dispatch_callbacks(userdata);
1101 static void set_dispatch_callbacks(pa_operation *o) {
1105 pa_assert(PA_REFCNT_VALUE(o) >= 1);
1106 pa_assert(o->context);
1107 pa_assert(PA_REFCNT_VALUE(o->context) >= 1);
1108 pa_assert(o->context->state == PA_CONTEXT_READY);
1110 pa_pstream_set_drain_callback(o->context->pstream, NULL, NULL);
1111 pa_pdispatch_set_drain_callback(o->context->pdispatch, NULL, NULL);
1113 if (pa_pdispatch_is_pending(o->context->pdispatch)) {
1114 pa_pdispatch_set_drain_callback(o->context->pdispatch, pdispatch_drain_callback, o);
1118 if (pa_pstream_is_pending(o->context->pstream)) {
1119 pa_pstream_set_drain_callback(o->context->pstream, pstream_drain_callback, o);
1125 pa_context_notify_cb_t cb = (pa_context_notify_cb_t) o->callback;
1126 cb(o->context, o->userdata);
1129 pa_operation_done(o);
1130 pa_operation_unref(o);
1134 pa_operation* pa_context_drain(pa_context *c, pa_context_notify_cb_t cb, void *userdata) {
1138 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1140 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1141 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1142 PA_CHECK_VALIDITY_RETURN_NULL(c, pa_context_is_pending(c), PA_ERR_BADSTATE);
1144 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1145 set_dispatch_callbacks(pa_operation_ref(o));
1150 void pa_context_simple_ack_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
1151 pa_operation *o = userdata;
1156 pa_assert(PA_REFCNT_VALUE(o) >= 1);
1161 if (command != PA_COMMAND_REPLY) {
1162 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
1166 } else if (!pa_tagstruct_eof(t)) {
1167 pa_context_fail(o->context, PA_ERR_PROTOCOL);
1172 pa_context_success_cb_t cb = (pa_context_success_cb_t) o->callback;
1173 cb(o->context, success, o->userdata);
1177 pa_operation_done(o);
1178 pa_operation_unref(o);
1181 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) {
1187 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1189 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1190 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1192 o = pa_operation_new(c, NULL, cb, userdata);
1194 t = pa_tagstruct_command(c, command, &tag);
1195 pa_pstream_send_tagstruct(c->pstream, t);
1196 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, internal_cb, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1201 pa_operation* pa_context_exit_daemon(pa_context *c, pa_context_success_cb_t cb, void *userdata) {
1203 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1205 return pa_context_send_simple_command(c, PA_COMMAND_EXIT, pa_context_simple_ack_callback, (pa_operation_cb_t) cb, userdata);
1208 pa_operation* pa_context_set_default_sink(pa_context *c, const char *name, pa_context_success_cb_t cb, void *userdata) {
1214 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1216 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1217 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1219 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1220 t = pa_tagstruct_command(c, PA_COMMAND_SET_DEFAULT_SINK, &tag);
1221 pa_tagstruct_puts(t, name);
1222 pa_pstream_send_tagstruct(c->pstream, t);
1223 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);
1228 pa_operation* pa_context_set_default_source(pa_context *c, const char *name, pa_context_success_cb_t cb, void *userdata) {
1234 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1236 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1237 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1239 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1240 t = pa_tagstruct_command(c, PA_COMMAND_SET_DEFAULT_SOURCE, &tag);
1241 pa_tagstruct_puts(t, name);
1242 pa_pstream_send_tagstruct(c->pstream, t);
1243 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);
1248 int pa_context_is_local(pa_context *c) {
1250 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1252 PA_CHECK_VALIDITY_RETURN_ANY(c, !pa_detect_fork(), PA_ERR_FORKED, -1);
1253 PA_CHECK_VALIDITY_RETURN_ANY(c, PA_CONTEXT_IS_GOOD(c->state), PA_ERR_BADSTATE, -1);
1255 return !!c->is_local;
1258 pa_operation* pa_context_set_name(pa_context *c, const char *name, pa_context_success_cb_t cb, void *userdata) {
1262 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1265 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1266 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1268 if (c->version >= 13) {
1269 pa_proplist *p = pa_proplist_new();
1271 pa_proplist_sets(p, PA_PROP_APPLICATION_NAME, name);
1272 o = pa_context_proplist_update(c, PA_UPDATE_REPLACE, p, cb, userdata);
1273 pa_proplist_free(p);
1278 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1279 t = pa_tagstruct_command(c, PA_COMMAND_SET_CLIENT_NAME, &tag);
1280 pa_tagstruct_puts(t, name);
1281 pa_pstream_send_tagstruct(c->pstream, t);
1282 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);
1288 const char* pa_get_library_version(void) {
1289 return PACKAGE_VERSION;
1292 const char* pa_context_get_server(pa_context *c) {
1294 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1296 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1297 PA_CHECK_VALIDITY_RETURN_NULL(c, c->server, PA_ERR_NOENTITY);
1299 if (*c->server == '{') {
1300 char *e = strchr(c->server+1, '}');
1301 return e ? e+1 : c->server;
1307 uint32_t pa_context_get_protocol_version(pa_context *c) {
1308 return PA_PROTOCOL_VERSION;
1311 uint32_t pa_context_get_server_protocol_version(pa_context *c) {
1313 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1315 PA_CHECK_VALIDITY_RETURN_ANY(c, !pa_detect_fork(), PA_ERR_FORKED, PA_INVALID_INDEX);
1316 PA_CHECK_VALIDITY_RETURN_ANY(c, PA_CONTEXT_IS_GOOD(c->state), PA_ERR_BADSTATE, PA_INVALID_INDEX);
1321 pa_tagstruct *pa_tagstruct_command(pa_context *c, uint32_t command, uint32_t *tag) {
1327 t = pa_tagstruct_new(NULL, 0);
1328 pa_tagstruct_putu32(t, command);
1329 pa_tagstruct_putu32(t, *tag = c->ctag++);
1334 uint32_t pa_context_get_index(pa_context *c) {
1336 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1338 PA_CHECK_VALIDITY_RETURN_ANY(c, !pa_detect_fork(), PA_ERR_FORKED, PA_INVALID_INDEX);
1339 PA_CHECK_VALIDITY_RETURN_ANY(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE, PA_INVALID_INDEX);
1340 PA_CHECK_VALIDITY_RETURN_ANY(c, c->version >= 13, PA_ERR_NOTSUPPORTED, PA_INVALID_INDEX);
1342 return c->client_index;
1345 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) {
1351 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1353 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1354 PA_CHECK_VALIDITY_RETURN_NULL(c, mode == PA_UPDATE_SET || mode == PA_UPDATE_MERGE || mode == PA_UPDATE_REPLACE, PA_ERR_INVALID);
1355 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1356 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 13, PA_ERR_NOTSUPPORTED);
1358 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1360 t = pa_tagstruct_command(c, PA_COMMAND_UPDATE_CLIENT_PROPLIST, &tag);
1361 pa_tagstruct_putu32(t, (uint32_t) mode);
1362 pa_tagstruct_put_proplist(t, p);
1364 pa_pstream_send_tagstruct(c->pstream, t);
1365 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);
1367 /* Please note that we don't update c->proplist here, because we
1368 * don't export that field */
1373 pa_operation *pa_context_proplist_remove(pa_context *c, const char *const keys[], pa_context_success_cb_t cb, void *userdata) {
1377 const char * const *k;
1380 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1382 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1383 PA_CHECK_VALIDITY_RETURN_NULL(c, keys && keys[0], PA_ERR_INVALID);
1384 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1385 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 13, PA_ERR_NOTSUPPORTED);
1387 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1389 t = pa_tagstruct_command(c, PA_COMMAND_REMOVE_CLIENT_PROPLIST, &tag);
1391 for (k = keys; *k; k++)
1392 pa_tagstruct_puts(t, *k);
1394 pa_tagstruct_puts(t, NULL);
1396 pa_pstream_send_tagstruct(c->pstream, t);
1397 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);
1399 /* Please note that we don't update c->proplist here, because we
1400 * don't export that field */
1405 void pa_command_extension(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
1406 pa_context *c = userdata;
1411 pa_assert(command == PA_COMMAND_EXTENSION);
1414 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1418 if (c->version < 15) {
1419 pa_context_fail(c, PA_ERR_PROTOCOL);
1423 if (pa_tagstruct_getu32(t, &idx) < 0 ||
1424 pa_tagstruct_gets(t, &name) < 0) {
1425 pa_context_fail(c, PA_ERR_PROTOCOL);
1429 if (!strcmp(name, "module-stream-restore"))
1430 pa_ext_stream_restore_command(c, tag, t);
1431 else if (!strcmp(name, "module-device-manager"))
1432 pa_ext_device_manager_command(c, tag, t);
1434 pa_log(_("Received message for unknown extension '%s'"), name);
1437 pa_context_unref(c);
1441 void pa_command_client_event(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
1442 pa_context *c = userdata;
1443 pa_proplist *pl = NULL;
1447 pa_assert(command == PA_COMMAND_CLIENT_EVENT);
1450 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1454 if (c->version < 15) {
1455 pa_context_fail(c, PA_ERR_PROTOCOL);
1459 pl = pa_proplist_new();
1461 if (pa_tagstruct_gets(t, &event) < 0 ||
1462 pa_tagstruct_get_proplist(t, pl) < 0 ||
1463 !pa_tagstruct_eof(t) || !event) {
1464 pa_context_fail(c, PA_ERR_PROTOCOL);
1468 if (c->event_callback)
1469 c->event_callback(c, event, pl, c->event_userdata);
1472 pa_context_unref(c);
1475 pa_proplist_free(pl);
1478 pa_time_event* pa_context_rttime_new(pa_context *c, pa_usec_t usec, pa_time_event_cb_t cb, void *userdata) {
1482 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1483 pa_assert(c->mainloop);
1485 if (usec == PA_USEC_INVALID)
1486 return c->mainloop->time_new(c->mainloop, NULL, cb, userdata);
1488 pa_timeval_rtstore(&tv, usec, c->use_rtclock);
1490 return c->mainloop->time_new(c->mainloop, &tv, cb, userdata);
1493 void pa_context_rttime_restart(pa_context *c, pa_time_event *e, pa_usec_t usec) {
1497 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1498 pa_assert(c->mainloop);
1501 if (usec == PA_USEC_INVALID)
1502 c->mainloop->time_restart(e, NULL);
1504 pa_timeval_rtstore(&tv, usec, c->use_rtclock);
1505 c->mainloop->time_restart(e, &tv);
1509 size_t pa_context_get_tile_size(pa_context *c, const pa_sample_spec *ss) {
1513 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1515 PA_CHECK_VALIDITY_RETURN_ANY(c, !pa_detect_fork(), PA_ERR_FORKED, (size_t) -1);
1516 PA_CHECK_VALIDITY_RETURN_ANY(c, !ss || pa_sample_spec_valid(ss), PA_ERR_INVALID, (size_t) -1);
1518 fs = ss ? pa_frame_size(ss) : 1;
1519 mbs = PA_ROUND_DOWN(pa_mempool_block_size_max(c->mempool), fs);
1520 return PA_MAX(mbs, fs);