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/dynarray.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_stream_restore
.callback
= NULL
;
132 c
->ext_stream_restore
.userdata
= NULL
;
135 pa_context
*pa_context_new_with_proplist(pa_mainloop_api
*mainloop
, const char *name
, pa_proplist
*p
) {
140 if (pa_detect_fork())
145 c
= pa_xnew(pa_context
, 1);
148 c
->proplist
= p
? pa_proplist_copy(p
) : pa_proplist_new();
151 pa_proplist_sets(c
->proplist
, PA_PROP_APPLICATION_NAME
, name
);
154 c
->system_bus
= c
->session_bus
= NULL
;
156 c
->mainloop
= mainloop
;
160 c
->playback_streams
= pa_dynarray_new();
161 c
->record_streams
= pa_dynarray_new();
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
;
176 c
->server_list
= NULL
;
181 c
->server_specified
= FALSE
;
183 c
->do_autospawn
= FALSE
;
184 memset(&c
->spawn_api
, 0, sizeof(c
->spawn_api
));
188 pa_check_signal_is_blocked(SIGPIPE
);
192 c
->conf
= pa_client_conf_new();
193 pa_client_conf_load(c
->conf
, NULL
);
195 pa_client_conf_from_x11(c
->conf
, NULL
);
197 pa_client_conf_env(c
->conf
);
199 if (!(c
->mempool
= pa_mempool_new(!c
->conf
->disable_shm
, c
->conf
->shm_size
))) {
201 if (!c
->conf
->disable_shm
)
202 c
->mempool
= pa_mempool_new(FALSE
, c
->conf
->shm_size
);
213 static void context_unlink(pa_context
*c
) {
218 s
= c
->streams
? pa_stream_ref(c
->streams
) : NULL
;
220 pa_stream
*n
= s
->next
? pa_stream_ref(s
->next
) : NULL
;
221 pa_stream_set_state(s
, c
->state
== PA_CONTEXT_FAILED
? PA_STREAM_FAILED
: PA_STREAM_TERMINATED
);
226 while (c
->operations
)
227 pa_operation_cancel(c
->operations
);
230 pa_pdispatch_unref(c
->pdispatch
);
235 pa_pstream_unlink(c
->pstream
);
236 pa_pstream_unref(c
->pstream
);
241 pa_socket_client_unref(c
->client
);
248 static void context_free(pa_context
*c
) {
255 dbus_connection_remove_filter(pa_dbus_wrap_connection_get(c
->system_bus
), filter_cb
, c
);
256 pa_dbus_wrap_connection_free(c
->system_bus
);
259 if (c
->session_bus
) {
260 dbus_connection_remove_filter(pa_dbus_wrap_connection_get(c
->session_bus
), filter_cb
, c
);
261 pa_dbus_wrap_connection_free(c
->session_bus
);
265 if (c
->record_streams
)
266 pa_dynarray_free(c
->record_streams
, NULL
, NULL
);
267 if (c
->playback_streams
)
268 pa_dynarray_free(c
->playback_streams
, NULL
, NULL
);
271 pa_mempool_free(c
->mempool
);
274 pa_client_conf_free(c
->conf
);
276 pa_strlist_free(c
->server_list
);
279 pa_proplist_free(c
->proplist
);
285 pa_context
* pa_context_ref(pa_context
*c
) {
287 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
293 void pa_context_unref(pa_context
*c
) {
295 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
297 if (PA_REFCNT_DEC(c
) <= 0)
301 void pa_context_set_state(pa_context
*c
, pa_context_state_t st
) {
303 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
312 if (c
->state_callback
)
313 c
->state_callback(c
, c
->state_userdata
);
315 if (st
== PA_CONTEXT_FAILED
|| st
== PA_CONTEXT_TERMINATED
)
321 int pa_context_set_error(pa_context
*c
, int error
) {
322 pa_assert(error
>= 0);
323 pa_assert(error
< PA_ERR_MAX
);
331 void pa_context_fail(pa_context
*c
, int error
) {
333 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
335 pa_context_set_error(c
, error
);
336 pa_context_set_state(c
, PA_CONTEXT_FAILED
);
339 static void pstream_die_callback(pa_pstream
*p
, void *userdata
) {
340 pa_context
*c
= userdata
;
345 pa_context_fail(c
, PA_ERR_CONNECTIONTERMINATED
);
348 static void pstream_packet_callback(pa_pstream
*p
, pa_packet
*packet
, const pa_creds
*creds
, void *userdata
) {
349 pa_context
*c
= userdata
;
357 if (pa_pdispatch_run(c
->pdispatch
, packet
, creds
, c
) < 0)
358 pa_context_fail(c
, PA_ERR_PROTOCOL
);
363 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
) {
364 pa_context
*c
= userdata
;
369 pa_assert(chunk
->length
> 0);
371 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
375 if ((s
= pa_dynarray_get(c
->record_streams
, channel
))) {
377 if (chunk
->memblock
) {
378 pa_memblockq_seek(s
->record_memblockq
, offset
, seek
, TRUE
);
379 pa_memblockq_push_align(s
->record_memblockq
, chunk
);
381 pa_memblockq_seek(s
->record_memblockq
, offset
+chunk
->length
, seek
, TRUE
);
383 if (s
->read_callback
) {
386 if ((l
= pa_memblockq_get_length(s
->record_memblockq
)) > 0)
387 s
->read_callback(s
, l
, s
->read_userdata
);
394 int pa_context_handle_error(pa_context
*c
, uint32_t command
, pa_tagstruct
*t
, pa_bool_t fail
) {
397 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
399 if (command
== PA_COMMAND_ERROR
) {
402 if (pa_tagstruct_getu32(t
, &err
) < 0 ||
403 !pa_tagstruct_eof(t
)) {
404 pa_context_fail(c
, PA_ERR_PROTOCOL
);
408 } else if (command
== PA_COMMAND_TIMEOUT
)
409 err
= PA_ERR_TIMEOUT
;
411 pa_context_fail(c
, PA_ERR_PROTOCOL
);
416 pa_context_fail(c
, PA_ERR_PROTOCOL
);
420 if (err
>= PA_ERR_MAX
)
421 err
= PA_ERR_UNKNOWN
;
424 pa_context_fail(c
, (int) err
);
428 pa_context_set_error(c
, (int) err
);
433 static void setup_complete_callback(pa_pdispatch
*pd
, uint32_t command
, uint32_t tag
, pa_tagstruct
*t
, void *userdata
) {
434 pa_context
*c
= userdata
;
438 pa_assert(c
->state
== PA_CONTEXT_AUTHORIZING
|| c
->state
== PA_CONTEXT_SETTING_NAME
);
442 if (command
!= PA_COMMAND_REPLY
) {
443 pa_context_handle_error(c
, command
, t
, TRUE
);
448 case PA_CONTEXT_AUTHORIZING
: {
450 pa_bool_t shm_on_remote
= FALSE
;
452 if (pa_tagstruct_getu32(t
, &c
->version
) < 0 ||
453 !pa_tagstruct_eof(t
)) {
454 pa_context_fail(c
, PA_ERR_PROTOCOL
);
458 /* Minimum supported version */
459 if (c
->version
< 8) {
460 pa_context_fail(c
, PA_ERR_VERSION
);
464 /* Starting with protocol version 13 the MSB of the version
465 tag reflects if shm is available for this connection or
467 if (c
->version
>= 13) {
468 shm_on_remote
= !!(c
->version
& 0x80000000U
);
469 c
->version
&= 0x7FFFFFFFU
;
472 pa_log_debug("Protocol version: remote %u, local %u", c
->version
, PA_PROTOCOL_VERSION
);
474 /* Enable shared memory support if possible */
476 if (c
->version
< 10 || (c
->version
>= 13 && !shm_on_remote
))
481 /* Only enable SHM if both sides are owned by the same
482 * user. This is a security measure because otherwise
483 * data private to the user might leak. */
486 const pa_creds
*creds
;
487 if (!(creds
= pa_pdispatch_creds(pd
)) || getuid() != creds
->uid
)
492 pa_log_debug("Negotiated SHM: %s", pa_yes_no(c
->do_shm
));
493 pa_pstream_enable_shm(c
->pstream
, c
->do_shm
);
495 reply
= pa_tagstruct_command(c
, PA_COMMAND_SET_CLIENT_NAME
, &tag
);
497 if (c
->version
>= 13) {
498 pa_init_proplist(c
->proplist
);
499 pa_tagstruct_put_proplist(reply
, c
->proplist
);
501 pa_tagstruct_puts(reply
, pa_proplist_gets(c
->proplist
, PA_PROP_APPLICATION_NAME
));
503 pa_pstream_send_tagstruct(c
->pstream
, reply
);
504 pa_pdispatch_register_reply(c
->pdispatch
, tag
, DEFAULT_TIMEOUT
, setup_complete_callback
, c
, NULL
);
506 pa_context_set_state(c
, PA_CONTEXT_SETTING_NAME
);
510 case PA_CONTEXT_SETTING_NAME
:
512 if ((c
->version
>= 13 && (pa_tagstruct_getu32(t
, &c
->client_index
) < 0 ||
513 c
->client_index
== PA_INVALID_INDEX
)) ||
514 !pa_tagstruct_eof(t
)) {
515 pa_context_fail(c
, PA_ERR_PROTOCOL
);
519 pa_context_set_state(c
, PA_CONTEXT_READY
);
523 pa_assert_not_reached();
530 static void setup_context(pa_context
*c
, pa_iochannel
*io
) {
539 pa_assert(!c
->pstream
);
540 c
->pstream
= pa_pstream_new(c
->mainloop
, io
, c
->mempool
);
542 pa_pstream_set_die_callback(c
->pstream
, pstream_die_callback
, c
);
543 pa_pstream_set_recieve_packet_callback(c
->pstream
, pstream_packet_callback
, c
);
544 pa_pstream_set_recieve_memblock_callback(c
->pstream
, pstream_memblock_callback
, c
);
546 pa_assert(!c
->pdispatch
);
547 c
->pdispatch
= pa_pdispatch_new(c
->mainloop
, c
->use_rtclock
, command_table
, PA_COMMAND_MAX
);
549 if (!c
->conf
->cookie_valid
)
550 pa_log_info(_("No cookie loaded. Attempting to connect without."));
552 t
= pa_tagstruct_command(c
, PA_COMMAND_AUTH
, &tag
);
555 pa_mempool_is_shared(c
->mempool
) &&
558 pa_log_debug("SHM possible: %s", pa_yes_no(c
->do_shm
));
560 /* Starting with protocol version 13 we use the MSB of the version
561 * tag for informing the other side if we could do SHM or not */
562 pa_tagstruct_putu32(t
, PA_PROTOCOL_VERSION
| (c
->do_shm
? 0x80000000U
: 0));
563 pa_tagstruct_put_arbitrary(t
, c
->conf
->cookie
, sizeof(c
->conf
->cookie
));
569 if (pa_iochannel_creds_supported(io
))
570 pa_iochannel_creds_enable(io
);
572 ucred
.uid
= getuid();
573 ucred
.gid
= getgid();
575 pa_pstream_send_tagstruct_with_creds(c
->pstream
, t
, &ucred
);
578 pa_pstream_send_tagstruct(c
->pstream
, t
);
581 pa_pdispatch_register_reply(c
->pdispatch
, tag
, DEFAULT_TIMEOUT
, setup_complete_callback
, c
, NULL
);
583 pa_context_set_state(c
, PA_CONTEXT_AUTHORIZING
);
588 #ifdef ENABLE_LEGACY_RUNTIME_DIR
589 static char *get_old_legacy_runtime_dir(void) {
593 if (!pa_get_user_name(u
, sizeof(u
)))
596 p
= pa_sprintf_malloc("/tmp/pulse-%s", u
);
598 if (stat(p
, &st
) < 0) {
603 if (st
.st_uid
!= getuid()) {
611 static char *get_very_old_legacy_runtime_dir(void) {
615 if (!pa_get_home_dir(h
, sizeof(h
)))
618 p
= pa_sprintf_malloc("%s/.pulse", h
);
620 if (stat(p
, &st
) < 0) {
625 if (st
.st_uid
!= getuid()) {
634 static pa_strlist
*prepend_per_user(pa_strlist
*l
) {
637 #ifdef ENABLE_LEGACY_RUNTIME_DIR
638 static char *legacy_dir
;
640 /* The very old per-user instance path (< 0.9.11). This is supported only to ease upgrades */
641 if ((legacy_dir
= get_very_old_legacy_runtime_dir())) {
642 char *p
= pa_sprintf_malloc("%s" PA_PATH_SEP PA_NATIVE_DEFAULT_UNIX_SOCKET
, legacy_dir
);
643 l
= pa_strlist_prepend(l
, p
);
645 pa_xfree(legacy_dir
);
648 /* The old per-user instance path (< 0.9.12). This is supported only to ease upgrades */
649 if ((legacy_dir
= get_old_legacy_runtime_dir())) {
650 char *p
= pa_sprintf_malloc("%s" PA_PATH_SEP PA_NATIVE_DEFAULT_UNIX_SOCKET
, legacy_dir
);
651 l
= pa_strlist_prepend(l
, p
);
653 pa_xfree(legacy_dir
);
657 /* The per-user instance */
658 if ((ufn
= pa_runtime_path(PA_NATIVE_DEFAULT_UNIX_SOCKET
))) {
659 l
= pa_strlist_prepend(l
, ufn
);
668 static int context_autospawn(pa_context
*c
) {
675 if (sigaction(SIGCHLD
, NULL
, &sa
) < 0) {
676 pa_log_debug("sigaction() failed: %s", pa_cstrerror(errno
));
677 pa_context_fail(c
, PA_ERR_INTERNAL
);
681 if ((sa
.sa_flags
& SA_NOCLDWAIT
) || sa
.sa_handler
== SIG_IGN
) {
682 pa_log_debug("Process disabled waitpid(), cannot autospawn.");
683 pa_context_fail(c
, PA_ERR_CONNECTIONREFUSED
);
687 pa_log_debug("Trying to autospawn...");
689 if (c
->spawn_api
.prefork
)
690 c
->spawn_api
.prefork();
692 if ((pid
= fork()) < 0) {
693 pa_log_error(_("fork(): %s"), pa_cstrerror(errno
));
694 pa_context_fail(c
, PA_ERR_INTERNAL
);
696 if (c
->spawn_api
.postfork
)
697 c
->spawn_api
.postfork();
703 const char *state
= NULL
;
705 const char * argv
[MAX_ARGS
+1];
708 if (c
->spawn_api
.atfork
)
709 c
->spawn_api
.atfork();
717 argv
[n
++] = c
->conf
->daemon_binary
;
718 argv
[n
++] = "--start";
720 while (n
< MAX_ARGS
) {
723 if (!(a
= pa_split_spaces(c
->conf
->extra_arguments
, &state
)))
731 execv(argv
[0], (char * const *) argv
);
738 if (c
->spawn_api
.postfork
)
739 c
->spawn_api
.postfork();
742 r
= waitpid(pid
, &status
, 0);
743 } while (r
< 0 && errno
== EINTR
);
747 if (errno
!= ESRCH
) {
748 pa_log(_("waitpid(): %s"), pa_cstrerror(errno
));
749 pa_context_fail(c
, PA_ERR_INTERNAL
);
753 /* hmm, something already reaped our child, so we assume
754 * startup worked, even if we cannot know */
756 } else if (!WIFEXITED(status
) || WEXITSTATUS(status
) != 0) {
757 pa_context_fail(c
, PA_ERR_CONNECTIONREFUSED
);
772 #endif /* OS_IS_WIN32 */
774 static void on_connection(pa_socket_client
*client
, pa_iochannel
*io
, void *userdata
);
777 static void track_pulseaudio_on_dbus(pa_context
*c
, DBusBusType type
, pa_dbus_wrap_connection
**conn
) {
783 dbus_error_init(&error
);
785 if (!(*conn
= pa_dbus_wrap_connection_new(c
->mainloop
, c
->use_rtclock
, type
, &error
)) || dbus_error_is_set(&error
)) {
786 pa_log_warn("Unable to contact DBUS: %s: %s", error
.name
, error
.message
);
790 if (!dbus_connection_add_filter(pa_dbus_wrap_connection_get(*conn
), filter_cb
, c
, NULL
)) {
791 pa_log_warn("Failed to add filter function");
795 if (pa_dbus_add_matches(
796 pa_dbus_wrap_connection_get(*conn
), &error
,
797 "type='signal',sender='" DBUS_SERVICE_DBUS
"',interface='" DBUS_INTERFACE_DBUS
"',member='NameOwnerChanged',arg0='org.pulseaudio.Server',arg1=''", NULL
) < 0) {
799 pa_log_warn("Unable to track org.pulseaudio.Server: %s: %s", error
.name
, error
.message
);
807 pa_dbus_wrap_connection_free(*conn
);
811 dbus_error_free(&error
);
815 static int try_next_connection(pa_context
*c
) {
820 pa_assert(!c
->client
);
826 c
->server_list
= pa_strlist_pop(c
->server_list
, &u
);
831 if (c
->do_autospawn
) {
833 if ((r
= context_autospawn(c
)) < 0)
836 /* Autospawn only once */
837 c
->do_autospawn
= FALSE
;
839 /* Connect only to per-user sockets this time */
840 c
->server_list
= prepend_per_user(c
->server_list
);
842 /* Retry connection */
848 if (c
->no_fail
&& !c
->server_specified
) {
850 track_pulseaudio_on_dbus(c
, DBUS_BUS_SESSION
, &c
->session_bus
);
852 track_pulseaudio_on_dbus(c
, DBUS_BUS_SYSTEM
, &c
->system_bus
);
855 pa_context_fail(c
, PA_ERR_CONNECTIONREFUSED
);
860 pa_log_debug("Trying to connect to %s...", u
);
863 c
->server
= pa_xstrdup(u
);
865 if (!(c
->client
= pa_socket_client_new_string(c
->mainloop
, c
->use_rtclock
, u
, PA_NATIVE_DEFAULT_PORT
)))
868 c
->is_local
= !!pa_socket_client_is_local(c
->client
);
869 pa_socket_client_set_callback(c
->client
, on_connection
, c
);
881 static void on_connection(pa_socket_client
*client
, pa_iochannel
*io
, void *userdata
) {
882 pa_context
*c
= userdata
;
883 int saved_errno
= errno
;
887 pa_assert(c
->state
== PA_CONTEXT_CONNECTING
);
891 pa_socket_client_unref(client
);
895 /* Try the next item in the list */
896 if (saved_errno
== ECONNREFUSED
||
897 saved_errno
== ETIMEDOUT
||
898 saved_errno
== EHOSTUNREACH
) {
899 try_next_connection(c
);
903 pa_context_fail(c
, PA_ERR_CONNECTIONREFUSED
);
907 setup_context(c
, io
);
914 static DBusHandlerResult
filter_cb(DBusConnection
*bus
, DBusMessage
*message
, void *userdata
) {
915 pa_context
*c
= userdata
;
916 pa_bool_t is_session
;
922 if (c
->state
!= PA_CONTEXT_CONNECTING
)
928 /* FIXME: We probably should check if this is actually the NameOwnerChanged we were looking for */
930 is_session
= c
->session_bus
&& bus
== pa_dbus_wrap_connection_get(c
->session_bus
);
931 pa_log_debug("Rock!! PulseAudio might be back on %s bus", is_session
? "session" : "system");
934 /* The user instance via PF_LOCAL */
935 c
->server_list
= prepend_per_user(c
->server_list
);
937 /* The system wide instance via PF_LOCAL */
938 c
->server_list
= pa_strlist_prepend(c
->server_list
, PA_SYSTEM_RUNTIME_PATH PA_PATH_SEP PA_NATIVE_DEFAULT_UNIX_SOCKET
);
941 try_next_connection(c
);
944 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED
;
948 int pa_context_connect(
951 pa_context_flags_t flags
,
952 const pa_spawn_api
*api
) {
957 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
959 PA_CHECK_VALIDITY(c
, !pa_detect_fork(), PA_ERR_FORKED
);
960 PA_CHECK_VALIDITY(c
, c
->state
== PA_CONTEXT_UNCONNECTED
, PA_ERR_BADSTATE
);
961 PA_CHECK_VALIDITY(c
, !(flags
& ~(PA_CONTEXT_NOAUTOSPAWN
|PA_CONTEXT_NOFAIL
)), PA_ERR_INVALID
);
962 PA_CHECK_VALIDITY(c
, !server
|| *server
, PA_ERR_INVALID
);
965 c
->conf
->autospawn
= FALSE
;
967 server
= c
->conf
->default_server
;
971 c
->no_fail
= !!(flags
& PA_CONTEXT_NOFAIL
);
972 c
->server_specified
= !!server
;
973 pa_assert(!c
->server_list
);
976 if (!(c
->server_list
= pa_strlist_parse(server
))) {
977 pa_context_fail(c
, PA_ERR_INVALIDSERVER
);
984 /* Prepend in reverse order */
986 /* Follow the X display */
987 if ((d
= getenv("DISPLAY"))) {
988 d
= pa_xstrndup(d
, strcspn(d
, ":"));
991 c
->server_list
= pa_strlist_prepend(c
->server_list
, d
);
996 /* Add TCP/IP on the localhost */
997 c
->server_list
= pa_strlist_prepend(c
->server_list
, "tcp6:[::1]");
998 c
->server_list
= pa_strlist_prepend(c
->server_list
, "tcp4:127.0.0.1");
1000 /* The system wide instance via PF_LOCAL */
1001 c
->server_list
= pa_strlist_prepend(c
->server_list
, PA_SYSTEM_RUNTIME_PATH PA_PATH_SEP PA_NATIVE_DEFAULT_UNIX_SOCKET
);
1003 /* The user instance via PF_LOCAL */
1004 c
->server_list
= prepend_per_user(c
->server_list
);
1007 /* Set up autospawning */
1008 if (!(flags
& PA_CONTEXT_NOAUTOSPAWN
) && c
->conf
->autospawn
) {
1011 pa_log_debug("Not doing autospawn since we are root.");
1013 c
->do_autospawn
= TRUE
;
1016 c
->spawn_api
= *api
;
1020 pa_context_set_state(c
, PA_CONTEXT_CONNECTING
);
1021 r
= try_next_connection(c
);
1024 pa_context_unref(c
);
1029 void pa_context_disconnect(pa_context
*c
) {
1031 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
1033 if (pa_detect_fork())
1036 if (PA_CONTEXT_IS_GOOD(c
->state
))
1037 pa_context_set_state(c
, PA_CONTEXT_TERMINATED
);
1040 pa_context_state_t
pa_context_get_state(pa_context
*c
) {
1042 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
1047 int pa_context_errno(pa_context
*c
) {
1049 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
1054 void pa_context_set_state_callback(pa_context
*c
, pa_context_notify_cb_t cb
, void *userdata
) {
1056 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
1058 if (pa_detect_fork())
1061 if (c
->state
== PA_CONTEXT_TERMINATED
|| c
->state
== PA_CONTEXT_FAILED
)
1064 c
->state_callback
= cb
;
1065 c
->state_userdata
= userdata
;
1068 void pa_context_set_event_callback(pa_context
*c
, pa_context_event_cb_t cb
, void *userdata
) {
1070 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
1072 if (pa_detect_fork())
1075 if (c
->state
== PA_CONTEXT_TERMINATED
|| c
->state
== PA_CONTEXT_FAILED
)
1078 c
->event_callback
= cb
;
1079 c
->event_userdata
= userdata
;
1082 int pa_context_is_pending(pa_context
*c
) {
1084 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
1086 PA_CHECK_VALIDITY(c
, !pa_detect_fork(), PA_ERR_FORKED
);
1087 PA_CHECK_VALIDITY(c
, PA_CONTEXT_IS_GOOD(c
->state
), PA_ERR_BADSTATE
);
1089 return (c
->pstream
&& pa_pstream_is_pending(c
->pstream
)) ||
1090 (c
->pdispatch
&& pa_pdispatch_is_pending(c
->pdispatch
)) ||
1094 static void set_dispatch_callbacks(pa_operation
*o
);
1096 static void pdispatch_drain_callback(pa_pdispatch
*pd
, void *userdata
) {
1097 set_dispatch_callbacks(userdata
);
1100 static void pstream_drain_callback(pa_pstream
*s
, void *userdata
) {
1101 set_dispatch_callbacks(userdata
);
1104 static void set_dispatch_callbacks(pa_operation
*o
) {
1108 pa_assert(PA_REFCNT_VALUE(o
) >= 1);
1109 pa_assert(o
->context
);
1110 pa_assert(PA_REFCNT_VALUE(o
->context
) >= 1);
1111 pa_assert(o
->context
->state
== PA_CONTEXT_READY
);
1113 pa_pstream_set_drain_callback(o
->context
->pstream
, NULL
, NULL
);
1114 pa_pdispatch_set_drain_callback(o
->context
->pdispatch
, NULL
, NULL
);
1116 if (pa_pdispatch_is_pending(o
->context
->pdispatch
)) {
1117 pa_pdispatch_set_drain_callback(o
->context
->pdispatch
, pdispatch_drain_callback
, o
);
1121 if (pa_pstream_is_pending(o
->context
->pstream
)) {
1122 pa_pstream_set_drain_callback(o
->context
->pstream
, pstream_drain_callback
, o
);
1128 pa_context_notify_cb_t cb
= (pa_context_notify_cb_t
) o
->callback
;
1129 cb(o
->context
, o
->userdata
);
1132 pa_operation_done(o
);
1133 pa_operation_unref(o
);
1137 pa_operation
* pa_context_drain(pa_context
*c
, pa_context_notify_cb_t cb
, void *userdata
) {
1141 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
1143 PA_CHECK_VALIDITY_RETURN_NULL(c
, !pa_detect_fork(), PA_ERR_FORKED
);
1144 PA_CHECK_VALIDITY_RETURN_NULL(c
, c
->state
== PA_CONTEXT_READY
, PA_ERR_BADSTATE
);
1145 PA_CHECK_VALIDITY_RETURN_NULL(c
, pa_context_is_pending(c
), PA_ERR_BADSTATE
);
1147 o
= pa_operation_new(c
, NULL
, (pa_operation_cb_t
) cb
, userdata
);
1148 set_dispatch_callbacks(pa_operation_ref(o
));
1153 void pa_context_simple_ack_callback(pa_pdispatch
*pd
, uint32_t command
, uint32_t tag
, pa_tagstruct
*t
, void *userdata
) {
1154 pa_operation
*o
= userdata
;
1159 pa_assert(PA_REFCNT_VALUE(o
) >= 1);
1164 if (command
!= PA_COMMAND_REPLY
) {
1165 if (pa_context_handle_error(o
->context
, command
, t
, FALSE
) < 0)
1169 } else if (!pa_tagstruct_eof(t
)) {
1170 pa_context_fail(o
->context
, PA_ERR_PROTOCOL
);
1175 pa_context_success_cb_t cb
= (pa_context_success_cb_t
) o
->callback
;
1176 cb(o
->context
, success
, o
->userdata
);
1180 pa_operation_done(o
);
1181 pa_operation_unref(o
);
1184 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
) {
1190 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
1192 PA_CHECK_VALIDITY_RETURN_NULL(c
, !pa_detect_fork(), PA_ERR_FORKED
);
1193 PA_CHECK_VALIDITY_RETURN_NULL(c
, c
->state
== PA_CONTEXT_READY
, PA_ERR_BADSTATE
);
1195 o
= pa_operation_new(c
, NULL
, cb
, userdata
);
1197 t
= pa_tagstruct_command(c
, command
, &tag
);
1198 pa_pstream_send_tagstruct(c
->pstream
, t
);
1199 pa_pdispatch_register_reply(c
->pdispatch
, tag
, DEFAULT_TIMEOUT
, internal_cb
, pa_operation_ref(o
), (pa_free_cb_t
) pa_operation_unref
);
1204 pa_operation
* pa_context_exit_daemon(pa_context
*c
, pa_context_success_cb_t cb
, void *userdata
) {
1206 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
1208 return pa_context_send_simple_command(c
, PA_COMMAND_EXIT
, pa_context_simple_ack_callback
, (pa_operation_cb_t
) cb
, userdata
);
1211 pa_operation
* pa_context_set_default_sink(pa_context
*c
, const char *name
, pa_context_success_cb_t cb
, void *userdata
) {
1217 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
1219 PA_CHECK_VALIDITY_RETURN_NULL(c
, !pa_detect_fork(), PA_ERR_FORKED
);
1220 PA_CHECK_VALIDITY_RETURN_NULL(c
, c
->state
== PA_CONTEXT_READY
, PA_ERR_BADSTATE
);
1222 o
= pa_operation_new(c
, NULL
, (pa_operation_cb_t
) cb
, userdata
);
1223 t
= pa_tagstruct_command(c
, PA_COMMAND_SET_DEFAULT_SINK
, &tag
);
1224 pa_tagstruct_puts(t
, name
);
1225 pa_pstream_send_tagstruct(c
->pstream
, t
);
1226 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
);
1231 pa_operation
* pa_context_set_default_source(pa_context
*c
, const char *name
, pa_context_success_cb_t cb
, void *userdata
) {
1237 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
1239 PA_CHECK_VALIDITY_RETURN_NULL(c
, !pa_detect_fork(), PA_ERR_FORKED
);
1240 PA_CHECK_VALIDITY_RETURN_NULL(c
, c
->state
== PA_CONTEXT_READY
, PA_ERR_BADSTATE
);
1242 o
= pa_operation_new(c
, NULL
, (pa_operation_cb_t
) cb
, userdata
);
1243 t
= pa_tagstruct_command(c
, PA_COMMAND_SET_DEFAULT_SOURCE
, &tag
);
1244 pa_tagstruct_puts(t
, name
);
1245 pa_pstream_send_tagstruct(c
->pstream
, t
);
1246 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
);
1251 int pa_context_is_local(pa_context
*c
) {
1253 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
1255 PA_CHECK_VALIDITY_RETURN_ANY(c
, !pa_detect_fork(), PA_ERR_FORKED
, -1);
1256 PA_CHECK_VALIDITY_RETURN_ANY(c
, PA_CONTEXT_IS_GOOD(c
->state
), PA_ERR_BADSTATE
, -1);
1258 return !!c
->is_local
;
1261 pa_operation
* pa_context_set_name(pa_context
*c
, const char *name
, pa_context_success_cb_t cb
, void *userdata
) {
1265 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
1268 PA_CHECK_VALIDITY_RETURN_NULL(c
, !pa_detect_fork(), PA_ERR_FORKED
);
1269 PA_CHECK_VALIDITY_RETURN_NULL(c
, c
->state
== PA_CONTEXT_READY
, PA_ERR_BADSTATE
);
1271 if (c
->version
>= 13) {
1272 pa_proplist
*p
= pa_proplist_new();
1274 pa_proplist_sets(p
, PA_PROP_APPLICATION_NAME
, name
);
1275 o
= pa_context_proplist_update(c
, PA_UPDATE_REPLACE
, p
, cb
, userdata
);
1276 pa_proplist_free(p
);
1281 o
= pa_operation_new(c
, NULL
, (pa_operation_cb_t
) cb
, userdata
);
1282 t
= pa_tagstruct_command(c
, PA_COMMAND_SET_CLIENT_NAME
, &tag
);
1283 pa_tagstruct_puts(t
, name
);
1284 pa_pstream_send_tagstruct(c
->pstream
, t
);
1285 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
);
1291 const char* pa_get_library_version(void) {
1292 return PACKAGE_VERSION
;
1295 const char* pa_context_get_server(pa_context
*c
) {
1297 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
1299 PA_CHECK_VALIDITY_RETURN_NULL(c
, !pa_detect_fork(), PA_ERR_FORKED
);
1300 PA_CHECK_VALIDITY_RETURN_NULL(c
, c
->server
, PA_ERR_NOENTITY
);
1302 if (*c
->server
== '{') {
1303 char *e
= strchr(c
->server
+1, '}');
1304 return e
? e
+1 : c
->server
;
1310 uint32_t pa_context_get_protocol_version(pa_context
*c
) {
1311 return PA_PROTOCOL_VERSION
;
1314 uint32_t pa_context_get_server_protocol_version(pa_context
*c
) {
1316 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
1318 PA_CHECK_VALIDITY_RETURN_ANY(c
, !pa_detect_fork(), PA_ERR_FORKED
, PA_INVALID_INDEX
);
1319 PA_CHECK_VALIDITY_RETURN_ANY(c
, PA_CONTEXT_IS_GOOD(c
->state
), PA_ERR_BADSTATE
, PA_INVALID_INDEX
);
1324 pa_tagstruct
*pa_tagstruct_command(pa_context
*c
, uint32_t command
, uint32_t *tag
) {
1330 t
= pa_tagstruct_new(NULL
, 0);
1331 pa_tagstruct_putu32(t
, command
);
1332 pa_tagstruct_putu32(t
, *tag
= c
->ctag
++);
1337 uint32_t pa_context_get_index(pa_context
*c
) {
1339 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
1341 PA_CHECK_VALIDITY_RETURN_ANY(c
, !pa_detect_fork(), PA_ERR_FORKED
, PA_INVALID_INDEX
);
1342 PA_CHECK_VALIDITY_RETURN_ANY(c
, c
->state
== PA_CONTEXT_READY
, PA_ERR_BADSTATE
, PA_INVALID_INDEX
);
1343 PA_CHECK_VALIDITY_RETURN_ANY(c
, c
->version
>= 13, PA_ERR_NOTSUPPORTED
, PA_INVALID_INDEX
);
1345 return c
->client_index
;
1348 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
) {
1354 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
1356 PA_CHECK_VALIDITY_RETURN_NULL(c
, !pa_detect_fork(), PA_ERR_FORKED
);
1357 PA_CHECK_VALIDITY_RETURN_NULL(c
, mode
== PA_UPDATE_SET
|| mode
== PA_UPDATE_MERGE
|| mode
== PA_UPDATE_REPLACE
, PA_ERR_INVALID
);
1358 PA_CHECK_VALIDITY_RETURN_NULL(c
, c
->state
== PA_CONTEXT_READY
, PA_ERR_BADSTATE
);
1359 PA_CHECK_VALIDITY_RETURN_NULL(c
, c
->version
>= 13, PA_ERR_NOTSUPPORTED
);
1361 o
= pa_operation_new(c
, NULL
, (pa_operation_cb_t
) cb
, userdata
);
1363 t
= pa_tagstruct_command(c
, PA_COMMAND_UPDATE_CLIENT_PROPLIST
, &tag
);
1364 pa_tagstruct_putu32(t
, (uint32_t) mode
);
1365 pa_tagstruct_put_proplist(t
, p
);
1367 pa_pstream_send_tagstruct(c
->pstream
, t
);
1368 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
);
1370 /* Please note that we don't update c->proplist here, because we
1371 * don't export that field */
1376 pa_operation
*pa_context_proplist_remove(pa_context
*c
, const char *const keys
[], pa_context_success_cb_t cb
, void *userdata
) {
1380 const char * const *k
;
1383 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
1385 PA_CHECK_VALIDITY_RETURN_NULL(c
, !pa_detect_fork(), PA_ERR_FORKED
);
1386 PA_CHECK_VALIDITY_RETURN_NULL(c
, keys
&& keys
[0], PA_ERR_INVALID
);
1387 PA_CHECK_VALIDITY_RETURN_NULL(c
, c
->state
== PA_CONTEXT_READY
, PA_ERR_BADSTATE
);
1388 PA_CHECK_VALIDITY_RETURN_NULL(c
, c
->version
>= 13, PA_ERR_NOTSUPPORTED
);
1390 o
= pa_operation_new(c
, NULL
, (pa_operation_cb_t
) cb
, userdata
);
1392 t
= pa_tagstruct_command(c
, PA_COMMAND_REMOVE_CLIENT_PROPLIST
, &tag
);
1394 for (k
= keys
; *k
; k
++)
1395 pa_tagstruct_puts(t
, *k
);
1397 pa_tagstruct_puts(t
, NULL
);
1399 pa_pstream_send_tagstruct(c
->pstream
, t
);
1400 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
);
1402 /* Please note that we don't update c->proplist here, because we
1403 * don't export that field */
1408 void pa_command_extension(pa_pdispatch
*pd
, uint32_t command
, uint32_t tag
, pa_tagstruct
*t
, void *userdata
) {
1409 pa_context
*c
= userdata
;
1414 pa_assert(command
== PA_COMMAND_EXTENSION
);
1417 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
1421 if (c
->version
< 15) {
1422 pa_context_fail(c
, PA_ERR_PROTOCOL
);
1426 if (pa_tagstruct_getu32(t
, &idx
) < 0 ||
1427 pa_tagstruct_gets(t
, &name
) < 0) {
1428 pa_context_fail(c
, PA_ERR_PROTOCOL
);
1432 if (!strcmp(name
, "module-stream-restore"))
1433 pa_ext_stream_restore_command(c
, tag
, t
);
1435 pa_log(_("Received message for unknown extension '%s'"), name
);
1438 pa_context_unref(c
);
1442 void pa_command_client_event(pa_pdispatch
*pd
, uint32_t command
, uint32_t tag
, pa_tagstruct
*t
, void *userdata
) {
1443 pa_context
*c
= userdata
;
1444 pa_proplist
*pl
= NULL
;
1448 pa_assert(command
== PA_COMMAND_CLIENT_EVENT
);
1451 pa_assert(PA_REFCNT_VALUE(c
) >= 1);
1455 if (c
->version
< 15) {
1456 pa_context_fail(c
, PA_ERR_PROTOCOL
);
1460 pl
= pa_proplist_new();
1462 if (pa_tagstruct_gets(t
, &event
) < 0 ||
1463 pa_tagstruct_get_proplist(t
, pl
) < 0 ||
1464 !pa_tagstruct_eof(t
) || !event
) {
1465 pa_context_fail(c
, PA_ERR_PROTOCOL
);
1469 if (c
->event_callback
)
1470 c
->event_callback(c
, event
, pl
, c
->event_userdata
);
1473 pa_context_unref(c
);
1476 pa_proplist_free(pl
);
1479 pa_time_event
* pa_context_rttime_new(pa_context
*c
, pa_usec_t usec
, pa_time_event_cb_t cb
, void *userdata
) {
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(c
->mainloop
);
1499 if (usec
== PA_USEC_INVALID
)
1500 c
->mainloop
->time_restart(e
, NULL
);
1502 pa_timeval_rtstore(&tv
, usec
, c
->use_rtclock
);
1503 c
->mainloop
->time_restart(e
, &tv
);