This file is part of polypaudio.
polypaudio is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published
+ 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.
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 General Public License
+ You should have received a copy of the GNU Lesser General Public License
along with polypaudio; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA.
#include <sys/stat.h>
#include <errno.h>
#include <sys/wait.h>
+#include <signal.h>
#include "polyplib-internal.h"
#include "polyplib-context.h"
#include "dynarray.h"
#include "socket-client.h"
#include "pstream-util.h"
-#include "authkey.h"
#include "util.h"
#include "xmalloc.h"
#include "log.h"
-#include "config-client.h"
+#include "client-conf.h"
+#include "socket-util.h"
+
+#ifdef HAVE_X11
+#include "client-conf-x11.h"
+#endif
+
+#define AUTOSPAWN_LOCK "autospawn.lock"
+
-#define DEFAULT_SERVER "/tmp/polypaudio/native"
static const struct pa_pdispatch_command command_table[PA_COMMAND_MAX] = {
[PA_COMMAND_REQUEST] = { pa_command_request },
[PA_COMMAND_SUBSCRIBE_EVENT] = { pa_command_subscribe_event },
};
+static void unlock_autospawn_lock_file(struct pa_context *c) {
+ assert(c);
+
+ if (c->autospawn_lock_fd >= 0) {
+ pa_unlock_lockfile(c->autospawn_lock_fd);
+ c->autospawn_lock_fd = -1;
+ }
+
+}
+
struct pa_context *pa_context_new(struct pa_mainloop_api *mainloop, const char *name) {
struct pa_context *c;
assert(mainloop && name);
c->memblock_stat = pa_memblock_stat_new();
c->local = -1;
+ c->server_list = NULL;
+ c->autospawn_lock_fd = -1;
+ memset(&c->spawn_api, 0, sizeof(c->spawn_api));
+ c->do_autospawn = 0;
pa_check_signal_is_blocked(SIGPIPE);
c->conf = pa_client_conf_new();
pa_client_conf_load(c->conf, NULL);
+#ifdef HAVE_X11
+ pa_client_conf_from_x11(c->conf, NULL);
+#endif
pa_client_conf_env(c->conf);
return c;
static void context_free(struct pa_context *c) {
assert(c);
+ unlock_autospawn_lock_file(c);
+
while (c->operations)
pa_operation_cancel(c->operations);
if (c->conf)
pa_client_conf_free(c->conf);
+
+ pa_strlist_free(c->server_list);
pa_xfree(c->name);
pa_xfree(c);
pa_context_ref(c);
if ((s = pa_dynarray_get(c->record_streams, channel))) {
- if (s->read_callback)
+ if (s->read_callback) {
s->read_callback(s, (uint8_t*) chunk->memblock->data + chunk->index, chunk->length, s->read_userdata);
+ s->counter += chunk->length;
+ }
}
pa_context_unref(c);
}
int pa_context_handle_error(struct pa_context *c, uint32_t command, struct pa_tagstruct *t) {
- assert(c && t);
+ assert(c);
if (command == PA_COMMAND_ERROR) {
+ assert(t);
+
if (pa_tagstruct_getu32(t, &c->error) < 0) {
pa_context_fail(c, PA_ERROR_PROTOCOL);
return -1;
c->pdispatch = pa_pdispatch_new(c->mainloop, command_table, PA_COMMAND_MAX);
assert(c->pdispatch);
- if (pa_authkey_load_from_home(PA_NATIVE_COOKIE_FILE, c->auth_cookie, sizeof(c->auth_cookie)) < 0) {
+ if (!c->conf->cookie_valid) {
pa_context_fail(c, PA_ERROR_AUTHKEY);
goto finish;
}
assert(t);
pa_tagstruct_putu32(t, PA_COMMAND_AUTH);
pa_tagstruct_putu32(t, tag = c->ctag++);
- pa_tagstruct_put_arbitrary(t, c->auth_cookie, sizeof(c->auth_cookie));
+ pa_tagstruct_put_arbitrary(t, c->conf->cookie, sizeof(c->conf->cookie));
pa_pstream_send_tagstruct(c->pstream, t);
pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, setup_complete_callback, c);
pa_context_unref(c);
}
-static void on_connection(struct pa_socket_client *client, struct pa_iochannel*io, void *userdata) {
- struct pa_context *c = userdata;
- assert(client && c && c->state == PA_CONTEXT_CONNECTING);
-
- pa_context_ref(c);
-
- pa_socket_client_unref(client);
- c->client = NULL;
-
- if (!io) {
- pa_context_fail(c, PA_ERROR_CONNECTIONREFUSED);
- goto finish;
- }
+static void on_connection(struct pa_socket_client *client, struct pa_iochannel*io, void *userdata);
- setup_context(c, io);
-
-finish:
- pa_context_unref(c);
-}
-
-static struct sockaddr *resolve_server(const char *server, size_t *len) {
- struct sockaddr *sa;
- struct addrinfo hints, *result = NULL;
- char *port, host[256];
- assert(server && len);
-
- snprintf(host, sizeof(host), "%s", server);
- host[strcspn(host, ":")] = 0;
-
- if ((port = strrchr(server, ':')))
- port++;
-
- if (!port)
- port = DEFAULT_PORT;
-
- memset(&hints, 0, sizeof(hints));
- hints.ai_family = PF_UNSPEC;
- hints.ai_socktype = SOCK_STREAM;
- hints.ai_protocol = 0;
-
- if (getaddrinfo(host, port, &hints, &result) != 0)
- return NULL;
- assert(result);
-
- sa = pa_xmalloc(*len = result->ai_addrlen);
- memcpy(sa, result->ai_addr, *len);
-
- freeaddrinfo(result);
-
- return sa;
-}
-
-static int default_server_is_running(void) {
- struct stat st;
-
- if (DEFAULT_SERVER[0] != '/')
- return 1;
-
- if (stat(DEFAULT_SERVER, &st) < 0)
- return 0;
-
- return 1;
-}
-
-static int context_connect_spawn(struct pa_context *c, const struct pa_spawn_api *api) {
+static int context_connect_spawn(struct pa_context *c) {
pid_t pid;
int status, r;
int fds[2] = { -1, -1} ;
goto fail;
}
- if (api && api->prefork)
- api->prefork();
+ pa_fd_set_cloexec(fds[0], 1);
+
+ pa_socket_low_delay(fds[0]);
+ pa_socket_low_delay(fds[1]);
+
+ if (c->spawn_api.prefork)
+ c->spawn_api.prefork();
if ((pid = fork()) < 0) {
pa_log(__FILE__": fork() failed: %s\n", strerror(errno));
pa_context_fail(c, PA_ERROR_INTERNAL);
- if (api && api->postfork)
- api->postfork();
+ if (c->spawn_api.postfork)
+ c->spawn_api.postfork();
goto fail;
} else if (!pid) {
/* Child */
-
+
char t[128];
const char *state = NULL;
#define MAX_ARGS 64
char *argv[MAX_ARGS+1];
- int n = 0;
+ int n;
+ /* Not required, since fds[0] has CLOEXEC enabled anyway */
close(fds[0]);
- if (api && api->atfork)
- api->atfork();
+ if (c->spawn_api.atfork)
+ c->spawn_api.atfork();
- snprintf(t, sizeof(t), "%s=1", ENV_AUTOSPAWNED);
- putenv(t);
+ /* 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]);
- argv[n++] = pa_xstrdup(t);
+ argv[n++] = strdup(t);
while (n < MAX_ARGS) {
char *a;
if (!(a = pa_split_spaces(c->conf->extra_arguments, &state)))
break;
-
+
argv[n++] = a;
}
argv[n++] = NULL;
execv(argv[0], argv);
- exit(1);
+ _exit(1);
+#undef MAX_ARGS
}
/* Parent */
r = waitpid(pid, &status, 0);
- if (api && api->postfork)
- api->postfork();
+ if (c->spawn_api.postfork)
+ c->spawn_api.postfork();
if (r < 0) {
pa_log(__FILE__": waitpid() failed: %s\n", strerror(errno));
c->local = 1;
io = pa_iochannel_new(c->mainloop, fds[0], fds[0]);
+
setup_context(c, io);
+ unlock_autospawn_lock_file(c);
pa_context_unref(c);
if (fds[1] != -1)
close(fds[1]);
+ unlock_autospawn_lock_file(c);
+
pa_context_unref(c);
return -1;
}
+static int try_next_connection(struct pa_context *c) {
+ char *u = NULL;
+ int r = -1;
+ assert(c && !c->client);
+
+ for (;;) {
+ if (u)
+ pa_xfree(u);
+ u = NULL;
+
+ c->server_list = pa_strlist_pop(c->server_list, &u);
+
+ if (!u) {
+
+ if (c->do_autospawn) {
+ r = context_connect_spawn(c);
+ goto finish;
+ }
+
+ pa_context_fail(c, PA_ERROR_CONNECTIONREFUSED);
+ goto finish;
+ }
+
+/* pa_log(__FILE__": Trying to connect to %s...\n", u); */
+
+ if (!(c->client = pa_socket_client_new_string(c->mainloop, u, PA_NATIVE_DEFAULT_PORT)))
+ continue;
+
+ c->local = pa_socket_client_is_local(c->client);
+ pa_socket_client_set_callback(c->client, on_connection, c);
+ break;
+ }
+
+ r = 0;
+
+finish:
+ if (u)
+ pa_xfree(u);
+
+ return r;
+}
+
+static void on_connection(struct pa_socket_client *client, struct pa_iochannel*io, void *userdata) {
+ struct pa_context *c = userdata;
+ assert(client && c && c->state == PA_CONTEXT_CONNECTING);
+
+ pa_context_ref(c);
+
+ pa_socket_client_unref(client);
+ c->client = NULL;
+
+ if (!io) {
+ /* Try the item in the list */
+ if (errno == ECONNREFUSED || errno == ETIMEDOUT || errno == EHOSTUNREACH) {
+ try_next_connection(c);
+ goto finish;
+ }
+
+ pa_context_fail(c, PA_ERROR_CONNECTIONREFUSED);
+ goto finish;
+ }
+
+ unlock_autospawn_lock_file(c);
+ setup_context(c, io);
+
+finish:
+ pa_context_unref(c);
+}
+
int pa_context_connect(struct pa_context *c, const char *server, int spawn, const struct pa_spawn_api *api) {
int r = -1;
assert(c && c->ref >= 1 && c->state == PA_CONTEXT_UNCONNECTED);
if (!server)
server = c->conf->default_server;
- if (!server && spawn && c->conf->autospawn && !default_server_is_running())
- return context_connect_spawn(c, api);
-
- server = DEFAULT_SERVER;
pa_context_ref(c);
- assert(!c->client);
+ assert(!c->server_list);
- if (*server == '/') {
- if (!(c->client = pa_socket_client_new_unix(c->mainloop, server))) {
- pa_context_fail(c, PA_ERROR_CONNECTIONREFUSED);
+ if (server) {
+ if (!(c->server_list = pa_strlist_parse(server))) {
+ pa_context_fail(c, PA_ERROR_INVALIDSERVER);
goto finish;
}
-
- c->local = 1;
} else {
- struct sockaddr* sa;
- size_t sa_len;
+ char *d;
+ char ufn[PATH_MAX];
- if (!(sa = resolve_server(server, &sa_len))) {
- pa_context_fail(c, PA_ERROR_INVALIDSERVER);
- goto finish;
- }
+ /* Prepend in reverse order */
+
+ if ((d = getenv("DISPLAY")))
+ c->server_list = pa_strlist_prepend(c->server_list, d);
+
+ c->server_list = pa_strlist_prepend(c->server_list, "tcp6:localhost");
+ c->server_list = pa_strlist_prepend(c->server_list, "localhost");
+ c->server_list = pa_strlist_prepend(c->server_list, pa_runtime_path(PA_NATIVE_DEFAULT_UNIX_SOCKET, ufn, sizeof(ufn)));
- c->client = pa_socket_client_new_sockaddr(c->mainloop, sa, sa_len);
- pa_xfree(sa);
+ /* Wrap the connection attempts in a single transaction for sane autospwan locking */
+ if (spawn && c->conf->autospawn) {
+ char lf[PATH_MAX];
- if (!c->client) {
- pa_context_fail(c, PA_ERROR_CONNECTIONREFUSED);
- goto finish;
+ pa_runtime_path(AUTOSPAWN_LOCK, lf, sizeof(lf));
+ assert(c->autospawn_lock_fd <= 0);
+ c->autospawn_lock_fd = pa_lock_lockfile(lf);
+
+ if (api)
+ c->spawn_api = *api;
+ c->do_autospawn = 1;
}
- c->local = 0;
}
- pa_socket_client_set_callback(c->client, on_connection, c);
pa_context_set_state(c, PA_CONTEXT_CONNECTING);
-
- r = 0;
+ r = try_next_connection(c);
finish:
pa_context_unref(c);
return pa_operation_ref(o);
}
-const char* pa_get_library_version(void) {
- return PACKAGE_VERSION;
-}
-
struct pa_operation* pa_context_set_default_sink(struct pa_context *c, const char *name, void(*cb)(struct pa_context*c, int success, void *userdata), void *userdata) {
struct pa_tagstruct *t;
struct pa_operation *o;
return pa_operation_ref(o);
}
+
+const char* pa_get_library_version(void) {
+ return PACKAGE_VERSION;
+}
+