/***
This file is part of PulseAudio.
-
+
+ Copyright 2004-2006 Lennart Poettering
+ Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
+
PulseAudio is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
-
+
PulseAudio is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
-
+
You should have received a copy of the GNU Lesser General Public License
along with PulseAudio; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
#endif
#include <stdio.h>
-#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <pulsecore/log.h>
#include <pulsecore/socket-util.h>
#include <pulsecore/creds.h>
+#include <pulsecore/macro.h>
#include "internal.h"
[PA_COMMAND_UNDERFLOW] = pa_command_overflow_or_underflow,
[PA_COMMAND_PLAYBACK_STREAM_KILLED] = pa_command_stream_killed,
[PA_COMMAND_RECORD_STREAM_KILLED] = pa_command_stream_killed,
+ [PA_COMMAND_PLAYBACK_STREAM_MOVED] = pa_command_stream_moved,
+ [PA_COMMAND_RECORD_STREAM_MOVED] = pa_command_stream_moved,
+ [PA_COMMAND_PLAYBACK_STREAM_SUSPENDED] = pa_command_stream_suspended,
+ [PA_COMMAND_RECORD_STREAM_SUSPENDED] = pa_command_stream_suspended,
[PA_COMMAND_SUBSCRIBE_EVENT] = pa_command_subscribe_event
};
static void unlock_autospawn_lock_file(pa_context *c) {
- assert(c);
-
+ pa_assert(c);
+
if (c->autospawn_lock_fd >= 0) {
char lf[PATH_MAX];
pa_runtime_path(AUTOSPAWN_LOCK, lf, sizeof(lf));
-
+
pa_unlock_lockfile(lf, c->autospawn_lock_fd);
c->autospawn_lock_fd = -1;
}
}
+static void context_free(pa_context *c);
+
pa_context *pa_context_new(pa_mainloop_api *mainloop, const char *name) {
pa_context *c;
-
- assert(mainloop);
- assert(name);
-
+
+ pa_assert(mainloop);
+ pa_assert(name);
+
c = pa_xnew(pa_context, 1);
- c->ref = 1;
+ PA_REFCNT_INIT(c);
c->name = pa_xstrdup(name);
c->mainloop = mainloop;
c->client = NULL;
PA_LLIST_HEAD_INIT(pa_stream, c->streams);
PA_LLIST_HEAD_INIT(pa_operation, c->operations);
-
+
c->error = PA_OK;
c->state = PA_CONTEXT_UNCONNECTED;
c->ctag = 0;
c->do_autospawn = 0;
#ifndef MSG_NOSIGNAL
-#ifdef SIGPIPE
+#ifdef SIGPIPE
pa_check_signal_is_blocked(SIGPIPE);
#endif
#endif
#endif
pa_client_conf_env(c->conf);
- c->mempool = pa_mempool_new(!c->conf->disable_shm);
+ if (!(c->mempool = pa_mempool_new(!c->conf->disable_shm))) {
+
+ if (!c->conf->disable_shm)
+ c->mempool = pa_mempool_new(0);
+
+ if (!c->mempool) {
+ context_free(c);
+ return NULL;
+ }
+ }
return c;
}
static void context_free(pa_context *c) {
- assert(c);
+ pa_assert(c);
unlock_autospawn_lock_file(c);
if (c->pdispatch)
pa_pdispatch_unref(c->pdispatch);
if (c->pstream) {
- pa_pstream_close(c->pstream);
+ pa_pstream_unlink(c->pstream);
pa_pstream_unref(c->pstream);
}
-
+
if (c->record_streams)
pa_dynarray_free(c->record_streams, NULL, NULL);
if (c->playback_streams)
pa_dynarray_free(c->playback_streams, NULL, NULL);
- pa_mempool_free(c->mempool);
+ if (c->mempool)
+ pa_mempool_free(c->mempool);
if (c->conf)
pa_client_conf_free(c->conf);
pa_strlist_free(c->server_list);
-
+
pa_xfree(c->name);
pa_xfree(c->server);
pa_xfree(c);
}
pa_context* pa_context_ref(pa_context *c) {
- assert(c);
- assert(c->ref >= 1);
-
- c->ref++;
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
+
+ PA_REFCNT_INC(c);
return c;
}
void pa_context_unref(pa_context *c) {
- assert(c);
- assert(c->ref >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
- if (--c->ref <= 0)
+ if (PA_REFCNT_DEC(c) <= 0)
context_free(c);
}
void pa_context_set_state(pa_context *c, pa_context_state_t st) {
- assert(c);
- assert(c->ref >= 1);
-
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
+
if (c->state == st)
return;
if (st == PA_CONTEXT_FAILED || st == PA_CONTEXT_TERMINATED) {
pa_stream *s;
-
+
s = c->streams ? pa_stream_ref(c->streams) : NULL;
while (s) {
pa_stream *n = s->next ? pa_stream_ref(s->next) : NULL;
if (c->pdispatch)
pa_pdispatch_unref(c->pdispatch);
c->pdispatch = NULL;
-
+
if (c->pstream) {
- pa_pstream_close(c->pstream);
+ pa_pstream_unlink(c->pstream);
pa_pstream_unref(c->pstream);
}
c->pstream = NULL;
-
+
if (c->client)
pa_socket_client_unref(c->client);
c->client = NULL;
}
void pa_context_fail(pa_context *c, int error) {
- assert(c);
- assert(c->ref >= 1);
-
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
+
pa_context_set_error(c, error);
pa_context_set_state(c, PA_CONTEXT_FAILED);
}
int pa_context_set_error(pa_context *c, int error) {
- assert(error >= 0);
- assert(error < PA_ERR_MAX);
+ pa_assert(error >= 0);
+ pa_assert(error < PA_ERR_MAX);
if (c)
c->error = error;
static void pstream_die_callback(pa_pstream *p, void *userdata) {
pa_context *c = userdata;
- assert(p);
- assert(c);
-
+ pa_assert(p);
+ pa_assert(c);
+
pa_context_fail(c, PA_ERR_CONNECTIONTERMINATED);
}
static void pstream_packet_callback(pa_pstream *p, pa_packet *packet, const pa_creds *creds, void *userdata) {
pa_context *c = userdata;
-
- assert(p);
- assert(packet);
- assert(c);
+
+ pa_assert(p);
+ pa_assert(packet);
+ pa_assert(c);
pa_context_ref(c);
-
+
if (pa_pdispatch_run(c->pdispatch, packet, creds, c) < 0)
pa_context_fail(c, PA_ERR_PROTOCOL);
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) {
pa_context *c = userdata;
pa_stream *s;
-
- assert(p);
- assert(chunk);
- assert(chunk->memblock);
- assert(chunk->length);
- assert(c);
- assert(c->ref >= 1);
+
+ pa_assert(p);
+ pa_assert(chunk);
+ pa_assert(chunk->memblock);
+ pa_assert(chunk->length);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
pa_context_ref(c);
if ((s = pa_dynarray_get(c->record_streams, channel))) {
- assert(seek == PA_SEEK_RELATIVE && offset == 0);
+ pa_assert(seek == PA_SEEK_RELATIVE);
+ pa_assert(offset == 0);
pa_memblockq_seek(s->record_memblockq, offset, seek);
pa_memblockq_push_align(s->record_memblockq, chunk);
-
+
if (s->read_callback) {
size_t l;
}
int pa_context_handle_error(pa_context *c, uint32_t command, pa_tagstruct *t) {
- assert(c);
- assert(c->ref >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
if (command == PA_COMMAND_ERROR) {
- assert(t);
-
+ pa_assert(t);
+
if (pa_tagstruct_getu32(t, &c->error) < 0) {
pa_context_fail(c, PA_ERR_PROTOCOL);
return -1;
-
+
}
} else if (command == PA_COMMAND_TIMEOUT)
c->error = PA_ERR_TIMEOUT;
static void setup_complete_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
pa_context *c = userdata;
-
- assert(pd);
- assert(c);
- assert(c->state == PA_CONTEXT_AUTHORIZING || c->state == PA_CONTEXT_SETTING_NAME);
+
+ pa_assert(pd);
+ pa_assert(c);
+ pa_assert(c->state == PA_CONTEXT_AUTHORIZING || c->state == PA_CONTEXT_SETTING_NAME);
pa_context_ref(c);
-
+
if (command != PA_COMMAND_REPLY) {
-
+
if (pa_context_handle_error(c, command, t) < 0)
pa_context_fail(c, PA_ERR_PROTOCOL);
/* Enable shared memory support if possible */
if (c->version >= 10 &&
pa_mempool_is_shared(c->mempool) &&
- c->is_local) {
+ c->is_local > 0) {
/* Only enable SHM if both sides are owned by the same
* user. This is a security measure because otherwise
* data private to the user might leak. */
-#ifdef HAVE_CREDS
+#ifdef HAVE_CREDS
const pa_creds *creds;
if ((creds = pa_pdispatch_creds(pd)))
if (getuid() == creds->uid)
case PA_CONTEXT_SETTING_NAME :
pa_context_set_state(c, PA_CONTEXT_READY);
break;
-
+
default:
- assert(0);
+ pa_assert(0);
}
finish:
static void setup_context(pa_context *c, pa_iochannel *io) {
pa_tagstruct *t;
uint32_t tag;
-
- assert(c);
- assert(io);
+
+ pa_assert(c);
+ pa_assert(io);
pa_context_ref(c);
-
- assert(!c->pstream);
+
+ pa_assert(!c->pstream);
c->pstream = pa_pstream_new(c->mainloop, io, c->mempool);
pa_pstream_set_die_callback(c->pstream, pstream_die_callback, c);
pa_pstream_set_recieve_packet_callback(c->pstream, pstream_packet_callback, c);
pa_pstream_set_recieve_memblock_callback(c->pstream, pstream_memblock_callback, c);
- assert(!c->pdispatch);
+ pa_assert(!c->pdispatch);
c->pdispatch = pa_pdispatch_new(c->mainloop, command_table, PA_COMMAND_MAX);
if (!c->conf->cookie_valid)
ucred.uid = getuid();
ucred.gid = getgid();
-
+
pa_pstream_send_tagstruct_with_creds(c->pstream, t, &ucred);
}
#else
pa_pstream_send_tagstruct(c->pstream, t);
#endif
-
+
pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, setup_complete_callback, c, NULL);
pa_context_set_state(c, PA_CONTEXT_AUTHORIZING);
pa_iochannel *io;
pa_context_ref(c);
-
+
if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds) < 0) {
pa_log("socketpair(): %s", pa_cstrerror(errno));
pa_context_fail(c, PA_ERR_INTERNAL);
goto fail;
}
- pa_fd_set_cloexec(fds[0], 1);
-
- pa_socket_low_delay(fds[0]);
- pa_socket_low_delay(fds[1]);
+ pa_make_fd_cloexec(fds[0]);
+
+ pa_make_socket_low_delay(fds[0]);
+ pa_make_socket_low_delay(fds[1]);
if (c->spawn_api.prefork)
c->spawn_api.prefork();
if (c->spawn_api.postfork)
c->spawn_api.postfork();
-
+
goto fail;
} else if (!pid) {
/* Child */
int n;
/* Not required, since fds[0] has CLOEXEC enabled anyway */
- close(fds[0]);
-
+ pa_assert_se(pa_close(fds[0]) == 0);
+
if (c->spawn_api.atfork)
c->spawn_api.atfork();
/* Setup argv */
n = 0;
-
+
argv[n++] = c->conf->daemon_binary;
argv[n++] = "--daemonize=yes";
-
- snprintf(t, sizeof(t), "-Lmodule-native-protocol-fd fd=%i", fds[1]);
+
+ pa_snprintf(t, sizeof(t), "-Lmodule-native-protocol-fd fd=%i", fds[1]);
argv[n++] = strdup(t);
while (n < MAX_ARGS) {
if (!(a = pa_split_spaces(c->conf->extra_arguments, &state)))
break;
-
+
argv[n++] = a;
}
execv(argv[0], (char * const *) argv);
_exit(1);
#undef MAX_ARGS
- }
+ }
/* Parent */
if (c->spawn_api.postfork)
c->spawn_api.postfork();
-
+
if (r < 0) {
pa_log("waitpid(): %s", pa_cstrerror(errno));
pa_context_fail(c, PA_ERR_INTERNAL);
goto fail;
}
- close(fds[1]);
+ pa_assert_se(pa_close(fds[1]) == 0);
c->is_local = 1;
-
+
io = pa_iochannel_new(c->mainloop, fds[0], fds[0]);
setup_context(c, io);
return 0;
fail:
- if (fds[0] != -1)
- close(fds[0]);
- if (fds[1] != -1)
- close(fds[1]);
+ pa_close_pipe(fds);
unlock_autospawn_lock_file(c);
static int try_next_connection(pa_context *c) {
char *u = NULL;
int r = -1;
-
- assert(c);
- assert(!c->client);
+
+ pa_assert(c);
+ pa_assert(!c->client);
for (;;) {
pa_xfree(u);
u = NULL;
-
+
c->server_list = pa_strlist_pop(c->server_list, &u);
-
+
if (!u) {
#ifndef OS_IS_WIN32
goto finish;
}
#endif
-
+
pa_context_fail(c, PA_ERR_CONNECTIONREFUSED);
goto finish;
}
-
- pa_log_debug("Trying to connect to %s...", u);
+
+ pa_log_debug("Trying to connect to %s...", u);
pa_xfree(c->server);
c->server = pa_xstrdup(u);
if (!(c->client = pa_socket_client_new_string(c->mainloop, u, PA_NATIVE_DEFAULT_PORT)))
continue;
-
+
c->is_local = pa_socket_client_is_local(c->client);
pa_socket_client_set_callback(c->client, on_connection, c);
break;
finish:
pa_xfree(u);
-
+
return r;
}
static void on_connection(pa_socket_client *client, pa_iochannel*io, void *userdata) {
pa_context *c = userdata;
-
- assert(client);
- assert(c);
- assert(c->state == PA_CONTEXT_CONNECTING);
+
+ pa_assert(client);
+ pa_assert(c);
+ pa_assert(c->state == PA_CONTEXT_CONNECTING);
pa_context_ref(c);
const char *server,
pa_context_flags_t flags,
const pa_spawn_api *api) {
-
+
int r = -1;
-
- assert(c);
- assert(c->ref >= 1);
+
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
PA_CHECK_VALIDITY(c, c->state == PA_CONTEXT_UNCONNECTED, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY(c, !(flags & ~PA_CONTEXT_NOAUTOSPAWN), PA_ERR_INVALID);
pa_context_ref(c);
- assert(!c->server_list);
-
+ pa_assert(!c->server_list);
+
if (server) {
if (!(c->server_list = pa_strlist_parse(server))) {
pa_context_fail(c, PA_ERR_INVALIDSERVER);
char ufn[PATH_MAX];
/* Prepend in reverse order */
-
+
if ((d = getenv("DISPLAY"))) {
char *e;
d = pa_xstrdup(d);
pa_xfree(d);
}
-
+
c->server_list = pa_strlist_prepend(c->server_list, "tcp6:localhost");
c->server_list = pa_strlist_prepend(c->server_list, "tcp4:localhost");
pa_runtime_path(AUTOSPAWN_LOCK, lf, sizeof(lf));
pa_make_secure_parent_dir(lf, 0700, (uid_t)-1, (gid_t)-1);
- assert(c->autospawn_lock_fd <= 0);
+ pa_assert(c->autospawn_lock_fd <= 0);
c->autospawn_lock_fd = pa_lock_lockfile(lf);
if (api)
pa_context_set_state(c, PA_CONTEXT_CONNECTING);
r = try_next_connection(c);
-
+
finish:
pa_context_unref(c);
-
+
return r;
}
void pa_context_disconnect(pa_context *c) {
- assert(c);
- assert(c->ref >= 1);
-
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
+
pa_context_set_state(c, PA_CONTEXT_TERMINATED);
}
pa_context_state_t pa_context_get_state(pa_context *c) {
- assert(c);
- assert(c->ref >= 1);
-
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
+
return c->state;
}
int pa_context_errno(pa_context *c) {
- assert(c);
- assert(c->ref >= 1);
-
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
+
return c->error;
}
void pa_context_set_state_callback(pa_context *c, pa_context_notify_cb_t cb, void *userdata) {
- assert(c);
- assert(c->ref >= 1);
-
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
+
c->state_callback = cb;
c->state_userdata = userdata;
}
int pa_context_is_pending(pa_context *c) {
- assert(c);
- assert(c->ref >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
PA_CHECK_VALIDITY(c,
c->state == PA_CONTEXT_CONNECTING ||
static void set_dispatch_callbacks(pa_operation *o) {
int done = 1;
-
- assert(o);
- assert(o->ref >= 1);
- assert(o->context);
- assert(o->context->ref >= 1);
- assert(o->context->state == PA_CONTEXT_READY);
+
+ pa_assert(o);
+ pa_assert(PA_REFCNT_VALUE(o) >= 1);
+ pa_assert(o->context);
+ pa_assert(PA_REFCNT_VALUE(o->context) >= 1);
+ pa_assert(o->context->state == PA_CONTEXT_READY);
pa_pstream_set_drain_callback(o->context->pstream, NULL, NULL);
pa_pdispatch_set_drain_callback(o->context->pdispatch, NULL, NULL);
-
+
if (pa_pdispatch_is_pending(o->context->pdispatch)) {
pa_pdispatch_set_drain_callback(o->context->pdispatch, pdispatch_drain_callback, o);
done = 0;
pa_context_notify_cb_t cb = (pa_context_notify_cb_t) o->callback;
cb(o->context, o->userdata);
}
-
+
pa_operation_done(o);
pa_operation_unref(o);
}
pa_operation* pa_context_drain(pa_context *c, pa_context_notify_cb_t cb, void *userdata) {
pa_operation *o;
-
- assert(c);
- assert(c->ref >= 1);
+
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, pa_context_is_pending(c), PA_ERR_BADSTATE);
-
+
o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
set_dispatch_callbacks(pa_operation_ref(o));
void pa_context_simple_ack_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
pa_operation *o = userdata;
int success = 1;
-
- assert(pd);
- assert(o);
- assert(o->ref >= 1);
+
+ pa_assert(pd);
+ pa_assert(o);
+ pa_assert(PA_REFCNT_VALUE(o) >= 1);
if (!o->context)
goto finish;
pa_operation *o;
uint32_t tag;
- assert(c);
- assert(c->ref >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
pa_tagstruct *t;
pa_operation *o;
uint32_t tag;
-
- assert(c);
- assert(c->ref >= 1);
+
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
-
+
o = pa_operation_new(c, NULL, cb, userdata);
t = pa_tagstruct_command(c, command, &tag);
pa_tagstruct *t;
pa_operation *o;
uint32_t tag;
-
- assert(c);
- assert(c->ref >= 1);
+
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
pa_operation *o;
uint32_t tag;
- assert(c);
- assert(c->ref >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
-
+
o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
t = pa_tagstruct_command(c, PA_COMMAND_SET_DEFAULT_SOURCE, &tag);
}
int pa_context_is_local(pa_context *c) {
- assert(c);
-
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
+
+ PA_CHECK_VALIDITY(c, c->is_local >= 0, PA_ERR_BADSTATE);
+
return c->is_local;
}
pa_operation *o;
uint32_t tag;
- assert(c);
- assert(c->ref >= 1);
- assert(name);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
+ pa_assert(name);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
-
+
o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
t = pa_tagstruct_command(c, PA_COMMAND_SET_CLIENT_NAME, &tag);
}
const char* pa_context_get_server(pa_context *c) {
- assert(c);
- assert(c->ref >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
if (!c->server)
return NULL;
-
+
if (*c->server == '{') {
char *e = strchr(c->server+1, '}');
return e ? e+1 : c->server;
}
-
+
return c->server;
}
}
uint32_t pa_context_get_server_protocol_version(pa_context *c) {
- assert(c);
- assert(c->ref >= 1);
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
return c->version;
}
pa_tagstruct *pa_tagstruct_command(pa_context *c, uint32_t command, uint32_t *tag) {
pa_tagstruct *t;
- assert(c);
- assert(tag);
-
+ pa_assert(c);
+ pa_assert(tag);
+
t = pa_tagstruct_new(NULL, 0);
pa_tagstruct_putu32(t, command);
pa_tagstruct_putu32(t, *tag = c->ctag++);