Reorganised the source tree. We now have src/ with a couple of subdirs:

 * daemon/ - Contains the files specific to the polypaudio daemon.
 * modules/ - All loadable modules.
 * polyp/ - Files that are part of the public, application interface or
   are only used in libpolyp.
 * polypcore/ - All other shared files.
 * tests/ - Test programs.
 * utils/ - Utility programs.


git-svn-id: file:///home/lennart/svn/public/pulseaudio/trunk@487 fefdeb5f-60dc-0310-8127-8f9354f1896f

7 files changed, 2348 insertions, 0 deletions

diff --git a/src/utils/esdcompat.sh.in b/src/utils/esdcompat.sh.in
new file mode 100755
index 000000000..76023f52a
--- /dev/null
+++ b/src/utils/esdcompat.sh.in
@@ -0,0 +1,98 @@
+#!/bin/sh
+
+# $Id$
+#
+# This file is part of polypaudio.
+#
+# polypaudio 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.
+#
+# polypaudio 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 polypaudio; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+# USA.
+
+VERSION_STRING="@PACKAGE_NAME@ esd wrapper @PACKAGE_VERSION@"
+
+fail() {
+    echo "ERROR: $1"
+    exit 1
+}
+
+ARGS=" --log-target=syslog"
+
+for N in $(seq $#) ; do
+
+    case "$1" in
+        "")
+            ;;
+
+        -v|--version)
+            echo "$VERSION_STRING"
+            exit 0
+            ;;
+
+        -h|--help)
+            cat <<EOF
+$VERSION_STRING
+
+Usage: $0 [options]
+
+  -v --version  print version information
+  -h --help     show this help
+
+Ignored directives:
+
+  -tcp          use tcp/ip sockets in addition to unix domain
+  -promiscuous  don't require authentication
+  -d DEVICE     force esd to use sound device DEVICE
+  -b            run server in 8 bit sound mode
+  -r RATE       run server at sample rate of RATE
+  -as SECS      free audio device after SECS of inactivity
+  -unix         use unix domain sockets instead of tcp/ip
+  -public       make tcp/ip access public (other than localhost)
+  -terminate    terminate esd daemone after last client exits
+  -nobeeps      disable startup beeps
+  -trust        start esd even if use of /tmp/.esd can be insecure
+  -port PORT   listen for connections at PORT (only for tcp/ip)
+  -bind ADDRESS binds to ADDRESS (only for tcp/ip)
+EOF
+            exit 0
+            ;;
+
+        -spawnpid)
+            shift
+            ARGS="$ARGS '-Lmodule-esound-compat-spawnpid pid=$1'"
+            ;;
+
+        -spawnfd)
+            shift
+            ARGS="$ARGS '-Lmodule-esound-compat-spawnfd fd=$1'"
+            ;;
+        
+        -unix|-b|-public|-terminate|-nobeeps|-trust|-tcp|-promiscuous)  
+            # Ignore these commands
+            ;; 
+
+        -d|-r|-as|-port|-bind)
+            # Ignore these commands and their arguments
+            shift
+
+            ;;
+
+        *)
+            fail "Unknown command: $1"
+            ;;
+    esac
+
+    shift
+done
+
+eval "exec '@POLYPAUDIO_BINARY@'$ARGS"
diff --git a/src/utils/pabrowse.c b/src/utils/pabrowse.c
new file mode 100644
index 000000000..634c308a2
--- /dev/null
+++ b/src/utils/pabrowse.c
@@ -0,0 +1,139 @@
+/* $Id$ */
+
+/***
+  This file is part of polypaudio.
+ 
+  polypaudio 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.
+ 
+  polypaudio 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 polypaudio; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.
+***/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <assert.h>
+#include <signal.h>
+
+#include <polyp/mainloop.h>
+#include <polyp/mainloop-signal.h>
+#include <polyp/polyplib-browser.h>
+#include <polyp/typeid.h>
+
+static void exit_signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
+    fprintf(stderr, "Got signal, exiting\n");
+    m->quit(m, 0);
+}
+
+static void dump_server(const pa_browse_info *i) {
+    char t[16];
+
+    if (i->cookie)
+        snprintf(t, sizeof(t), "0x%08x", *i->cookie);
+    
+    printf("server: %s\n"
+           "server-version: %s\n"
+           "user-name: %s\n"
+           "fqdn: %s\n"
+           "cookie: %s\n",
+           i->server,
+           i->server_version ? i->server_version : "n/a",
+           i->user_name ? i->user_name : "n/a",
+           i->fqdn ? i->fqdn : "n/a",
+           i->cookie ? t : "n/a");
+}
+
+static void dump_device(const pa_browse_info *i) {
+    char t[16], ss[PA_SAMPLE_SPEC_SNPRINT_MAX];
+
+    if (i->sample_spec)
+        pa_sample_spec_snprint(ss, sizeof(ss), i->sample_spec);
+
+    if (i->typeid)
+        pa_typeid_to_string(*i->typeid, t, sizeof(t));
+    
+    printf("device: %s\n"
+           "description: %s\n"
+           "type: %s\n"
+           "sample spec: %s\n",
+           i->device,
+           i->description ? i->description : "n/a",
+           i->typeid ? t : "n/a",
+           i->sample_spec ? ss : "n/a");
+           
+}
+
+static void browser_callback(pa_browser *b, pa_browse_opcode c, const pa_browse_info *i, void *userdata) {
+    assert(b && i);
+
+    switch (c) {
+
+        case PA_BROWSE_NEW_SERVER:
+            printf("\n=> new server <%s>\n", i->name);
+            dump_server(i);
+            break;
+
+        case PA_BROWSE_NEW_SINK:
+            printf("\n=> new sink <%s>\n", i->name);
+            dump_server(i);
+            dump_device(i);
+            break;
+
+        case PA_BROWSE_NEW_SOURCE:
+            printf("\n=> new source <%s>\n", i->name);
+            dump_server(i);
+            dump_device(i);
+            break;
+            
+        case PA_BROWSE_REMOVE:
+            printf("\n=> removed service <%s>\n", i->name);
+            break;
+            
+        default:
+            ;
+    }
+}
+
+
+int main(int argc, char *argv[]) {
+    pa_mainloop *mainloop = NULL;
+    pa_browser *browser = NULL;
+    int ret = 1, r;
+
+    if (!(mainloop = pa_mainloop_new()))
+        goto finish;
+
+    r = pa_signal_init(pa_mainloop_get_api(mainloop));
+    assert(r == 0);
+    pa_signal_new(SIGINT, exit_signal_callback, NULL);
+    pa_signal_new(SIGTERM, exit_signal_callback, NULL);
+    signal(SIGPIPE, SIG_IGN);
+    
+    if (!(browser = pa_browser_new(pa_mainloop_get_api(mainloop))))
+        goto finish;
+
+    pa_browser_set_callback(browser, browser_callback, NULL);
+    
+    ret = 0;
+    pa_mainloop_run(mainloop, &ret);
+
+finish:
+    if (mainloop) {
+        pa_signal_done();
+        pa_mainloop_free(mainloop);
+    }
+
+    return ret;
+}
diff --git a/src/utils/pacat.c b/src/utils/pacat.c
new file mode 100644
index 000000000..bd2b64fd5
--- /dev/null
+++ b/src/utils/pacat.c
@@ -0,0 +1,541 @@
+/* $Id$ */
+
+/***
+  This file is part of polypaudio.
+ 
+  polypaudio 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.
+ 
+  polypaudio 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 polypaudio; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.
+***/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <signal.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <getopt.h>
+
+#include <polyp/polyplib.h>
+#include <polyp/polyplib-error.h>
+#include <polyp/mainloop.h>
+#include <polyp/mainloop-signal.h>
+#include <polyp/polyplib-version.h>
+
+#if PA_API_VERSION != 8
+#error Invalid Polypaudio API version
+#endif
+
+static enum { RECORD, PLAYBACK } mode = PLAYBACK;
+
+static pa_context *context = NULL;
+static pa_stream *stream = NULL;
+static pa_mainloop_api *mainloop_api = NULL;
+
+static void *buffer = NULL;
+static size_t buffer_length = 0, buffer_index = 0;
+
+static pa_io_event* stdio_event = NULL;
+
+static char *stream_name = NULL, *client_name = NULL, *device = NULL;
+
+static int verbose = 0;
+static pa_volume_t volume = PA_VOLUME_NORM;
+
+static pa_sample_spec sample_spec = {
+    .format = PA_SAMPLE_S16LE,
+    .rate = 44100,
+    .channels = 2
+};
+
+/* A shortcut for terminating the application */
+static void quit(int ret) {
+    assert(mainloop_api);
+    mainloop_api->quit(mainloop_api, ret);
+}
+
+/* Write some data to the stream */
+static void do_stream_write(size_t length) {
+    size_t l;
+    assert(length);
+
+    if (!buffer || !buffer_length)
+        return;
+    
+    l = length;
+    if (l > buffer_length)
+        l = buffer_length;
+    
+    pa_stream_write(stream, (uint8_t*) buffer + buffer_index, l, NULL, 0);
+    buffer_length -= l;
+    buffer_index += l;
+    
+    if (!buffer_length) {
+        free(buffer);
+        buffer = NULL;
+        buffer_index = buffer_length = 0;
+    }
+}
+
+/* This is called whenever new data may be written to the stream */
+static void stream_write_callback(pa_stream *s, size_t length, void *userdata) {
+    assert(s && length);
+
+    if (stdio_event)
+        mainloop_api->io_enable(stdio_event, PA_IO_EVENT_INPUT);
+
+    if (!buffer)
+        return;
+
+    do_stream_write(length);
+}
+
+/* This is called whenever new data may is available */
+static void stream_read_callback(pa_stream *s, const void*data, size_t length, void *userdata) {
+    assert(s && data && length);
+
+    if (stdio_event)
+        mainloop_api->io_enable(stdio_event, PA_IO_EVENT_OUTPUT);
+
+    if (buffer) {
+        fprintf(stderr, "Buffer overrun, dropping incoming data\n");
+        return;
+    }
+
+    buffer = malloc(buffer_length = length);
+    assert(buffer);
+    memcpy(buffer, data, length);
+    buffer_index = 0;
+}
+
+/* This routine is called whenever the stream state changes */
+static void stream_state_callback(pa_stream *s, void *userdata) {
+    assert(s);
+
+    switch (pa_stream_get_state(s)) {
+        case PA_STREAM_CREATING:
+        case PA_STREAM_TERMINATED:
+            break;
+
+        case PA_STREAM_READY:
+            if (verbose)
+                fprintf(stderr, "Stream successfully created\n");
+            break;
+            
+        case PA_STREAM_FAILED:
+        default:
+            fprintf(stderr, "Stream error: %s\n", pa_strerror(pa_context_errno(pa_stream_get_context(s))));
+            quit(1);
+    }
+}
+
+/* This is called whenever the context status changes */
+static void context_state_callback(pa_context *c, void *userdata) {
+    assert(c);
+
+    switch (pa_context_get_state(c)) {
+        case PA_CONTEXT_CONNECTING:
+        case PA_CONTEXT_AUTHORIZING:
+        case PA_CONTEXT_SETTING_NAME:
+            break;
+        
+        case PA_CONTEXT_READY:
+            
+            assert(c && !stream);
+
+            if (verbose)
+                fprintf(stderr, "Connection established.\n");
+
+            stream = pa_stream_new(c, stream_name, &sample_spec, NULL);
+            assert(stream);
+
+            pa_stream_set_state_callback(stream, stream_state_callback, NULL);
+            pa_stream_set_write_callback(stream, stream_write_callback, NULL);
+            pa_stream_set_read_callback(stream, stream_read_callback, NULL);
+
+            if (mode == PLAYBACK) {
+                pa_cvolume cv;
+                pa_stream_connect_playback(stream, device, NULL, 0, pa_cvolume_set(&cv, PA_CHANNELS_MAX, volume));
+            } else
+                pa_stream_connect_record(stream, device, NULL, 0);
+                
+            break;
+            
+        case PA_CONTEXT_TERMINATED:
+            quit(0);
+            break;
+
+        case PA_CONTEXT_FAILED:
+        default:
+            fprintf(stderr, "Connection failure: %s\n", pa_strerror(pa_context_errno(c)));
+            quit(1);
+    }
+}
+
+/* Connection draining complete */
+static void context_drain_complete(pa_context*c, void *userdata) {
+    pa_context_disconnect(c);
+}
+
+/* Stream draining complete */
+static void stream_drain_complete(pa_stream*s, int success, void *userdata) {
+    pa_operation *o;
+
+    if (!success) {
+        fprintf(stderr, "Failed to drain stream: %s\n", pa_strerror(pa_context_errno(context)));
+        quit(1);
+    }
+    
+    if (verbose)    
+        fprintf(stderr, "Playback stream drained.\n");
+
+    pa_stream_disconnect(stream);
+    pa_stream_unref(stream);
+    stream = NULL;
+    
+    if (!(o = pa_context_drain(context, context_drain_complete, NULL)))
+        pa_context_disconnect(context);
+    else {
+        pa_operation_unref(o);
+
+        if (verbose)
+            fprintf(stderr, "Draining connection to server.\n");
+    }
+}
+
+/* New data on STDIN **/
+static void stdin_callback(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_flags_t f, void *userdata) {
+    size_t l, w = 0;
+    ssize_t r;
+    assert(a == mainloop_api && e && stdio_event == e);
+
+    if (buffer) {
+        mainloop_api->io_enable(stdio_event, PA_IO_EVENT_NULL);
+        return;
+    }
+
+    if (!stream || pa_stream_get_state(stream) != PA_STREAM_READY || !(l = w = pa_stream_writable_size(stream)))
+        l = 4096;
+    
+    buffer = malloc(l);
+    assert(buffer);
+    if ((r = read(fd, buffer, l)) <= 0) {
+        if (r == 0) {
+            if (verbose)
+                fprintf(stderr, "Got EOF.\n");
+            pa_operation_unref(pa_stream_drain(stream, stream_drain_complete, NULL));
+        } else {
+            fprintf(stderr, "read() failed: %s\n", strerror(errno));
+            quit(1);
+        }
+
+        mainloop_api->io_free(stdio_event);
+        stdio_event = NULL;
+        return;
+    }
+
+    buffer_length = r;
+    buffer_index = 0;
+
+    if (w)
+        do_stream_write(w);
+}
+
+/* Some data may be written to STDOUT */
+static void stdout_callback(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_flags_t f, void *userdata) {
+    ssize_t r;
+    assert(a == mainloop_api && e && stdio_event == e);
+
+    if (!buffer) {
+        mainloop_api->io_enable(stdio_event, PA_IO_EVENT_NULL);
+        return;
+    }
+
+    assert(buffer_length);
+    
+    if ((r = write(fd, (uint8_t*) buffer+buffer_index, buffer_length)) <= 0) {
+        fprintf(stderr, "write() failed: %s\n", strerror(errno));
+        quit(1);
+
+        mainloop_api->io_free(stdio_event);
+        stdio_event = NULL;
+        return;
+    }
+
+    buffer_length -= r;
+    buffer_index += r;
+
+    if (!buffer_length) {
+        free(buffer);
+        buffer = NULL;
+        buffer_length = buffer_index = 0;
+    }
+}
+
+/* UNIX signal to quit recieved */
+static void exit_signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
+    if (verbose)
+        fprintf(stderr, "Got signal, exiting.\n");
+    quit(0);
+    
+}
+
+/* Show the current latency */
+static void stream_get_latency_callback(pa_stream *s, const pa_latency_info *i, void *userdata) {
+    pa_usec_t total;
+    int negative = 0;
+    assert(s);
+
+    if (!i) {
+        fprintf(stderr, "Failed to get latency: %s\n", pa_strerror(pa_context_errno(context)));
+        quit(1);
+        return;
+    }
+
+    total = pa_stream_get_latency(s, i, &negative);
+
+    fprintf(stderr, "Latency: buffer: %0.0f usec; sink: %0.0f usec; source: %0.0f usec; transport: %0.0f usec; total: %0.0f usec; synchronized clocks: %s.\n",
+            (float) i->buffer_usec, (float) i->sink_usec, (float) i->source_usec, (float) i->transport_usec, (float) total * (negative?-1:1),
+            i->synchronized_clocks ? "yes" : "no");
+}
+
+/* Someone requested that the latency is shown */
+static void sigusr1_signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
+    fprintf(stderr, "Got SIGUSR1, requesting latency.\n");
+    pa_operation_unref(pa_stream_get_latency_info(stream, stream_get_latency_callback, NULL));
+}
+
+
+static void help(const char *argv0) {
+
+    printf("%s [options]\n\n"
+           "  -h, --help                            Show this help\n"
+           "      --version                         Show version\n\n"
+           "  -r, --record                          Create a connection for recording\n"
+           "  -p, --playback                        Create a connection for playback\n\n"
+           "  -v, --verbose                         Enable verbose operations\n\n"
+           "  -s, --server=SERVER                   The name of the server to connect to\n"
+           "  -d, --device=DEVICE                   The name of the sink/source to connect to\n"
+           "  -n, --client-name=NAME                How to call this client on the server\n"
+           "      --stream-name=NAME                How to call this stream on the server\n"
+           "      --volume=VOLUME                   Specify the initial (linear) volume in range 0...256\n"
+           "      --rate=SAMPLERATE                 The sample rate in Hz (defaults to 44100)\n"
+           "      --format=SAMPLEFORMAT             The sample type, one of s16le, s16be, u8, float32le,\n"
+           "                                        float32be, ulaw, alaw (defaults to s16ne)\n"
+           "      --channels=CHANNELS               The number of channels, 1 for mono, 2 for stereo\n"
+           "                                        (defaults to 2)\n",
+           argv0);
+}
+
+enum {
+    ARG_VERSION = 256,
+    ARG_STREAM_NAME,
+    ARG_VOLUME,
+    ARG_SAMPLERATE,
+    ARG_SAMPLEFORMAT,
+    ARG_CHANNELS
+};
+
+int main(int argc, char *argv[]) {
+    pa_mainloop* m = NULL;
+    int ret = 1, r, c;
+    char *bn, *server = NULL;
+
+    static const struct option long_options[] = {
+        {"record",      0, NULL, 'r'},
+        {"playback",    0, NULL, 'p'},
+        {"device",      1, NULL, 'd'},
+        {"server",      1, NULL, 's'},
+        {"client-name", 1, NULL, 'n'},
+        {"stream-name", 1, NULL, ARG_STREAM_NAME},
+        {"version",     0, NULL, ARG_VERSION},
+        {"help",        0, NULL, 'h'},
+        {"verbose",     0, NULL, 'v'},
+        {"volume",      1, NULL, ARG_VOLUME},
+        {"rate",        1, NULL, ARG_SAMPLERATE},
+        {"format",      1, NULL, ARG_SAMPLEFORMAT},
+        {"channels",    1, NULL, ARG_CHANNELS},
+        {NULL,          0, NULL, 0}
+    };
+
+    if (!(bn = strrchr(argv[0], '/')))
+        bn = argv[0];
+    else
+        bn++;
+
+    if (strstr(bn, "rec") || strstr(bn, "mon"))
+        mode = RECORD;
+    else if (strstr(bn, "cat") || strstr(bn, "play"))
+        mode = PLAYBACK;
+
+    while ((c = getopt_long(argc, argv, "rpd:s:n:hv", long_options, NULL)) != -1) {
+
+        switch (c) {
+            case 'h' :
+                help(bn);
+                ret = 0;
+                goto quit;
+                
+            case ARG_VERSION:
+                printf("pacat "PACKAGE_VERSION"\nCompiled with libpolyp %s\nLinked with libpolyp %s\n", pa_get_headers_version(), pa_get_library_version());
+                ret = 0;
+                goto quit;
+
+            case 'r':
+                mode = RECORD;
+                break;
+
+            case 'p':
+                mode = PLAYBACK;
+                break;
+
+            case 'd':
+                free(device);
+                device = strdup(optarg);
+                break;
+
+            case 's':
+                free(server);
+                server = strdup(optarg);
+                break;
+
+            case 'n':
+                free(client_name);
+                client_name = strdup(optarg);
+                break;
+
+            case ARG_STREAM_NAME:
+                free(stream_name);
+                stream_name = strdup(optarg);
+                break;
+
+            case 'v':
+                verbose = 1;
+                break;
+
+            case ARG_VOLUME: {
+                int v = atoi(optarg);
+                volume = v < 0 ? 0 : v;
+                break;
+            }
+
+            case ARG_CHANNELS: 
+                sample_spec.channels = atoi(optarg);
+                break;
+
+            case ARG_SAMPLEFORMAT:
+                sample_spec.format = pa_parse_sample_format(optarg);
+                break;
+
+            case ARG_SAMPLERATE:
+                sample_spec.rate = atoi(optarg);
+                break;
+
+            default:
+                goto quit;
+        }
+    }
+
+    if (!client_name)
+        client_name = strdup(bn);
+
+    if (!stream_name)
+        stream_name = strdup(client_name);
+
+    if (!pa_sample_spec_valid(&sample_spec)) {
+        fprintf(stderr, "Invalid sample specification\n");
+        goto quit;
+    }
+    
+    if (verbose) {
+        char t[PA_SAMPLE_SPEC_SNPRINT_MAX];
+        pa_sample_spec_snprint(t, sizeof(t), &sample_spec);
+        fprintf(stderr, "Opening a %s stream with sample specification '%s'.\n", mode == RECORD ? "recording" : "playback", t);
+    }
+
+    /* Set up a new main loop */
+    if (!(m = pa_mainloop_new())) {
+        fprintf(stderr, "pa_mainloop_new() failed.\n");
+        goto quit;
+    }
+
+    mainloop_api = pa_mainloop_get_api(m);
+
+    r = pa_signal_init(mainloop_api);
+    assert(r == 0);
+    pa_signal_new(SIGINT, exit_signal_callback, NULL);
+    pa_signal_new(SIGTERM, exit_signal_callback, NULL);
+#ifdef SIGUSR1
+    pa_signal_new(SIGUSR1, sigusr1_signal_callback, NULL);
+#endif
+#ifdef SIGPIPE
+    signal(SIGPIPE, SIG_IGN);
+#endif
+    
+    if (!(stdio_event = mainloop_api->io_new(mainloop_api,
+                                             mode == PLAYBACK ? STDIN_FILENO : STDOUT_FILENO,
+                                             mode == PLAYBACK ? PA_IO_EVENT_INPUT : PA_IO_EVENT_OUTPUT,
+                                             mode == PLAYBACK ? stdin_callback : stdout_callback, NULL))) {
+        fprintf(stderr, "source_io() failed.\n");
+        goto quit;
+    }
+
+    /* Create a new connection context */
+    if (!(context = pa_context_new(mainloop_api, client_name))) {
+        fprintf(stderr, "pa_context_new() failed.\n");
+        goto quit;
+    }
+
+    pa_context_set_state_callback(context, context_state_callback, NULL);
+
+    /* Connect the context */
+    pa_context_connect(context, server, 1, NULL);
+
+    /* Run the main loop */
+    if (pa_mainloop_run(m, &ret) < 0) {
+        fprintf(stderr, "pa_mainloop_run() failed.\n");
+        goto quit;
+    }
+    
+quit:
+    if (stream)
+        pa_stream_unref(stream);
+
+    if (context)
+        pa_context_unref(context);
+
+    if (stdio_event) {
+        assert(mainloop_api);
+        mainloop_api->io_free(stdio_event);
+    }
+    
+    if (m) {
+        pa_signal_done();
+        pa_mainloop_free(m);
+    }
+
+    free(buffer);
+
+    free(server);
+    free(device);
+    free(client_name);
+    free(stream_name);
+    
+    return ret;
+}
diff --git a/src/utils/pacmd.c b/src/utils/pacmd.c
new file mode 100644
index 000000000..4054bc2c1
--- /dev/null
+++ b/src/utils/pacmd.c
@@ -0,0 +1,183 @@
+/* $Id$ */
+
+/***
+  This file is part of polypaudio.
+ 
+  polypaudio 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.
+ 
+  polypaudio 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 polypaudio; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.
+***/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <assert.h>
+#include <signal.h>
+#include <sys/select.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/un.h>
+
+#include <polypcore/util.h>
+#include <polypcore/log.h>
+#include <polypcore/pid.h>
+
+int main(PA_GCC_UNUSED int main, PA_GCC_UNUSED char*argv[]) {
+    pid_t pid ;
+    int fd = -1;
+    int ret = 1, i;
+    struct sockaddr_un sa;
+    char ibuf[256], obuf[256];
+    size_t ibuf_index, ibuf_length, obuf_index, obuf_length;
+    fd_set ifds, ofds;
+
+    if (pa_pid_file_check_running(&pid) < 0) {
+        pa_log(__FILE__": no Polypaudio daemon running\n");
+        goto fail;
+    }
+
+    if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
+        pa_log(__FILE__": socket(PF_UNIX, SOCK_STREAM, 0): %s\n", strerror(errno));
+        goto fail;
+    }
+
+    memset(&sa, 0, sizeof(sa));
+    sa.sun_family = AF_UNIX;
+    pa_runtime_path("cli", sa.sun_path, sizeof(sa.sun_path));
+
+    for (i = 0; i < 5; i++) {
+        int r;
+        
+        if ((r = connect(fd, (struct sockaddr*) &sa, sizeof(sa))) < 0 && (errno != ECONNREFUSED && errno != ENOENT)) {
+            pa_log(__FILE__": connect() failed: %s\n", strerror(errno));
+            goto fail;
+        }
+            
+        if (r >= 0)
+            break;
+
+        if (pa_pid_file_kill(SIGUSR2, NULL) < 0) {
+            pa_log(__FILE__": failed to kill Polypaudio daemon.\n");
+            goto fail;
+        }
+
+        pa_msleep(50);
+    }
+
+    if (i >= 5) {
+        pa_log(__FILE__": daemon not responding.\n");
+        goto fail;
+    }
+
+    ibuf_index = ibuf_length = obuf_index = obuf_length = 0;
+
+
+    FD_ZERO(&ifds);
+    FD_SET(0, &ifds);
+    FD_SET(fd, &ifds);
+
+    FD_ZERO(&ofds);
+    
+    for (;;) {
+        if (select(FD_SETSIZE, &ifds, &ofds, NULL, NULL) < 0) {
+            pa_log(__FILE__": select() failed: %s\n", strerror(errno));
+            goto fail;
+        }
+
+        if (FD_ISSET(0, &ifds)) {
+            ssize_t r;
+            assert(!ibuf_length);
+            
+            if ((r = read(0, ibuf, sizeof(ibuf))) <= 0) {
+                if (r == 0)
+                    break;
+                
+                pa_log(__FILE__": read() failed: %s\n", strerror(errno));
+                goto fail;
+            }
+            
+            ibuf_length = (size_t) r;
+            ibuf_index = 0;
+        }
+        
+        if (FD_ISSET(fd, &ifds)) {
+            ssize_t r;
+            assert(!obuf_length);
+
+            if ((r = read(fd, obuf, sizeof(obuf))) <= 0) {
+                if (r == 0)
+                    break;
+                
+                pa_log(__FILE__": read() failed: %s\n", strerror(errno));
+                goto fail;
+            }
+
+            obuf_length = (size_t) r;
+            obuf_index = 0;
+        }
+
+        if (FD_ISSET(1, &ofds)) {
+            ssize_t r;
+            assert(obuf_length);
+            
+            if ((r = write(1, obuf + obuf_index, obuf_length)) < 0) {
+                pa_log(__FILE__": write() failed: %s\n", strerror(errno));
+                goto fail;
+            }
+            
+            obuf_length -= (size_t) r;
+            obuf_index += obuf_index;
+
+        }
+
+        if (FD_ISSET(fd, &ofds)) {
+            ssize_t r;
+            assert(ibuf_length);
+            
+            if ((r = write(fd, ibuf + ibuf_index, ibuf_length)) < 0) {
+                pa_log(__FILE__": write() failed: %s\n", strerror(errno));
+                goto fail;
+            }
+            
+            ibuf_length -= (size_t) r;
+            ibuf_index += obuf_index;
+
+        }
+
+        FD_ZERO(&ifds);
+        FD_ZERO(&ofds);
+        
+        if (obuf_length <= 0)
+            FD_SET(fd, &ifds);
+        else
+            FD_SET(1, &ofds);
+        
+        if (ibuf_length <= 0)
+            FD_SET(0, &ifds);
+        else
+            FD_SET(fd, &ofds);
+    }
+    
+
+    ret = 0;
+    
+fail:
+    if (fd >= 0)
+        close(fd);
+    
+    return ret;
+}
diff --git a/src/utils/pactl.c b/src/utils/pactl.c
new file mode 100644
index 000000000..23bd924b8
--- /dev/null
+++ b/src/utils/pactl.c
@@ -0,0 +1,784 @@
+/* $Id$ */
+
+/***
+  This file is part of polypaudio.
+ 
+  polypaudio 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.
+ 
+  polypaudio 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 polypaudio; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.
+***/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <signal.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <getopt.h>
+
+#include <sndfile.h>
+
+#include <polyp/polyplib.h>
+#include <polyp/polyplib-error.h>
+#include <polyp/mainloop.h>
+#include <polyp/mainloop-signal.h>
+#include <polyp/sample.h>
+
+#if PA_API_VERSION != 8
+#error Invalid Polypaudio API version
+#endif
+
+#define BUFSIZE 1024
+
+static pa_context *context = NULL;
+static pa_mainloop_api *mainloop_api = NULL;
+
+static char *device = NULL, *sample_name = NULL;
+
+static SNDFILE *sndfile = NULL;
+static pa_stream *sample_stream = NULL;
+static pa_sample_spec sample_spec;
+static size_t sample_length = 0;
+
+static int actions = 1;
+
+static int nl = 0;
+
+static enum {
+    NONE,
+    EXIT,
+    STAT,
+    UPLOAD_SAMPLE,
+    PLAY_SAMPLE,
+    REMOVE_SAMPLE,
+    LIST
+} action = NONE;
+
+static void quit(int ret) {
+    assert(mainloop_api);
+    mainloop_api->quit(mainloop_api, ret);
+}
+
+
+static void context_drain_complete(pa_context *c, void *userdata) {
+    pa_context_disconnect(c);
+}
+
+static void drain(void) {
+    pa_operation *o;
+    if (!(o = pa_context_drain(context, context_drain_complete, NULL)))
+        pa_context_disconnect(context);
+    else
+        pa_operation_unref(o);
+}
+
+
+static void complete_action(void) {
+    assert(actions > 0);
+
+    if (!(--actions))
+        drain();
+}
+
+static void stat_callback(pa_context *c, const pa_stat_info *i, void *userdata) {
+    char s[128];
+    if (!i) {
+        fprintf(stderr, "Failed to get statistics: %s\n", pa_strerror(pa_context_errno(c)));
+        quit(1);
+        return;
+    }
+
+    pa_bytes_snprint(s, sizeof(s), i->memblock_total_size);
+    printf("Currently in use: %u blocks containing %s bytes total.\n", i->memblock_total, s);
+
+    pa_bytes_snprint(s, sizeof(s), i->memblock_allocated_size);
+    printf("Allocated during whole lifetime: %u blocks containing %s bytes total.\n", i->memblock_allocated, s);
+
+    pa_bytes_snprint(s, sizeof(s), i->scache_size);
+    printf("Sample cache size: %s\n", s);
+    
+    complete_action();
+}
+
+static void get_server_info_callback(pa_context *c, const pa_server_info *i, void *useerdata) {
+    char s[PA_SAMPLE_SPEC_SNPRINT_MAX];
+    
+    if (!i) {
+        fprintf(stderr, "Failed to get server information: %s\n", pa_strerror(pa_context_errno(c)));
+        quit(1);
+        return;
+    }
+
+    pa_sample_spec_snprint(s, sizeof(s), &i->sample_spec);
+
+    printf("User name: %s\n"
+           "Host Name: %s\n"
+           "Server Name: %s\n"
+           "Server Version: %s\n"
+           "Default Sample Specification: %s\n"
+           "Default Sink: %s\n"
+           "Default Source: %s\n"
+           "Cookie: %08x\n",
+           i->user_name,
+           i->host_name,
+           i->server_name,
+           i->server_version,
+           s,
+           i->default_sink_name,
+           i->default_source_name,
+           i->cookie);
+
+    complete_action();
+}
+
+static void get_sink_info_callback(pa_context *c, const pa_sink_info *i, int is_last, void *userdata) {
+    char s[PA_SAMPLE_SPEC_SNPRINT_MAX], cv[PA_CVOLUME_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
+    
+    if (is_last < 0) {
+        fprintf(stderr, "Failed to get sink information: %s\n", pa_strerror(pa_context_errno(c)));
+        quit(1);
+        return;
+    }
+
+    if (is_last) {
+        complete_action();
+        return;
+    }
+    
+    assert(i);
+
+    if (nl)
+        printf("\n");
+    nl = 1;
+
+    printf("*** Sink #%u ***\n"
+           "Name: %s\n"
+           "Driver: %s\n"
+           "Description: %s\n"
+           "Sample Specification: %s\n"
+           "Channel Map: %s\n"
+           "Owner Module: %u\n"
+           "Volume: %s\n"
+           "Monitor Source: %u\n"
+           "Latency: %0.0f usec\n",
+           i->index,
+           i->name,
+           i->driver,
+           i->description,
+           pa_sample_spec_snprint(s, sizeof(s), &i->sample_spec),
+           pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map),
+           i->owner_module,
+           pa_cvolume_snprint(cv, sizeof(cv), &i->volume),
+           i->monitor_source,
+           (double) i->latency);
+
+}
+
+static void get_source_info_callback(pa_context *c, const pa_source_info *i, int is_last, void *userdata) {
+    char s[PA_SAMPLE_SPEC_SNPRINT_MAX], t[32], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
+
+    if (is_last < 0) {
+        fprintf(stderr, "Failed to get source information: %s\n", pa_strerror(pa_context_errno(c)));
+        quit(1);
+        return;
+    }
+
+    if (is_last) {
+        complete_action();
+        return;
+    }
+    
+    assert(i);
+
+    if (nl)
+        printf("\n");
+    nl = 1;
+
+    snprintf(t, sizeof(t), "%u", i->monitor_of_sink);
+    
+    printf("*** Source #%u ***\n"
+           "Name: %s\n"
+           "Driver: %s\n"
+           "Description: %s\n"
+           "Sample Specification: %s\n"
+           "Channel Map: %s\n"
+           "Owner Module: %u\n"
+           "Monitor of Sink: %s\n"
+           "Latency: %0.0f usec\n",
+           i->index,
+           i->driver,
+           i->name,
+           i->description,
+           pa_sample_spec_snprint(s, sizeof(s), &i->sample_spec),
+           pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map),
+           i->owner_module,
+           i->monitor_of_sink != PA_INVALID_INDEX ? t : "no",
+           (double) i->latency);
+    
+}
+
+static void get_module_info_callback(pa_context *c, const pa_module_info *i, int is_last, void *userdata) {
+    char t[32];
+
+    if (is_last < 0) {
+        fprintf(stderr, "Failed to get module information: %s\n", pa_strerror(pa_context_errno(c)));
+        quit(1);
+        return;
+    }
+
+    if (is_last) {
+        complete_action();
+        return;
+    }
+    
+    assert(i);
+
+    if (nl)
+        printf("\n");
+    nl = 1;
+
+    snprintf(t, sizeof(t), "%u", i->n_used);
+    
+    printf("*** Module #%u ***\n"
+           "Name: %s\n"
+           "Argument: %s\n"
+           "Usage counter: %s\n"
+           "Auto unload: %s\n",
+           i->index,
+           i->name,
+           i->argument,
+           i->n_used != PA_INVALID_INDEX ? t : "n/a",
+           i->auto_unload ? "yes" : "no");
+}
+
+static void get_client_info_callback(pa_context *c, const pa_client_info *i, int is_last, void *userdata) {
+    char t[32];
+
+    if (is_last < 0) {
+        fprintf(stderr, "Failed to get client information: %s\n", pa_strerror(pa_context_errno(c)));
+        quit(1);
+        return;
+    }
+
+    if (is_last) {
+        complete_action();
+        return;
+    }
+    
+    assert(i);
+
+    if (nl)
+        printf("\n");
+    nl = 1;
+
+    snprintf(t, sizeof(t), "%u", i->owner_module);
+    
+    printf("*** Client #%u ***\n"
+           "Name: %s\n"
+           "Driver: %s\n"
+           "Owner Module: %s\n",
+           i->index,
+           i->name,
+           i->driver,
+           i->owner_module != PA_INVALID_INDEX ? t : "n/a");
+}
+
+static void get_sink_input_info_callback(pa_context *c, const pa_sink_input_info *i, int is_last, void *userdata) {
+    char t[32], k[32], s[PA_SAMPLE_SPEC_SNPRINT_MAX], cv[PA_CVOLUME_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
+
+    if (is_last < 0) {
+        fprintf(stderr, "Failed to get sink input information: %s\n", pa_strerror(pa_context_errno(c)));
+        quit(1);
+        return;
+    }
+
+    if (is_last) {
+        complete_action();
+        return;
+    }
+    
+    assert(i);
+
+    if (nl)
+        printf("\n");
+    nl = 1;
+
+    snprintf(t, sizeof(t), "%u", i->owner_module);
+    snprintf(k, sizeof(k), "%u", i->client);
+    
+    printf("*** Sink Input #%u ***\n"
+           "Name: %s\n"
+           "Driver: %s\n"
+           "Owner Module: %s\n"
+           "Client: %s\n"
+           "Sink: %u\n"
+           "Sample Specification: %s\n"
+           "Channel Map: %s\n"
+           "Volume: %s\n"
+           "Buffer Latency: %0.0f usec\n"
+           "Sink Latency: %0.0f usec\n"
+           "Resample method: %s\n",
+           i->index,
+           i->name,
+           i->driver,
+           i->owner_module != PA_INVALID_INDEX ? t : "n/a",
+           i->client != PA_INVALID_INDEX ? k : "n/a",
+           i->sink,
+           pa_sample_spec_snprint(s, sizeof(s), &i->sample_spec),
+           pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map),
+           pa_cvolume_snprint(cv, sizeof(cv), &i->volume),
+           (double) i->buffer_usec,
+           (double) i->sink_usec,
+           i->resample_method ? i->resample_method : "n/a");
+}
+
+
+static void get_source_output_info_callback(pa_context *c, const pa_source_output_info *i, int is_last, void *userdata) {
+    char t[32], k[32], s[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
+
+    if (is_last < 0) {
+        fprintf(stderr, "Failed to get source output information: %s\n", pa_strerror(pa_context_errno(c)));
+        quit(1);
+        return;
+    }
+
+    if (is_last) {
+        complete_action();
+        return;
+    }
+    
+    assert(i);
+
+    if (nl)
+        printf("\n");
+    nl = 1;
+
+    
+    snprintf(t, sizeof(t), "%u", i->owner_module);
+    snprintf(k, sizeof(k), "%u", i->client);
+    
+    printf("*** Source Output #%u ***\n"
+           "Name: %s\n"
+           "Driver: %s\n"
+           "Owner Module: %s\n"
+           "Client: %s\n"
+           "Source: %u\n"
+           "Sample Specification: %s\n"
+           "Channel Map: %s\n"
+           "Buffer Latency: %0.0f usec\n"
+           "Source Latency: %0.0f usec\n"
+           "Resample method: %s\n",
+           i->index,
+           i->name,
+           i->driver,
+           i->owner_module != PA_INVALID_INDEX ? t : "n/a",
+           i->client != PA_INVALID_INDEX ? k : "n/a",
+           i->source,
+           pa_sample_spec_snprint(s, sizeof(s), &i->sample_spec),
+           pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map),
+           (double) i->buffer_usec,
+           (double) i->source_usec,
+           i->resample_method ? i->resample_method : "n/a");
+}
+
+static void get_sample_info_callback(pa_context *c, const pa_sample_info *i, int is_last, void *userdata) {
+    char t[32], s[PA_SAMPLE_SPEC_SNPRINT_MAX], cv[PA_CVOLUME_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
+
+    if (is_last < 0) {
+        fprintf(stderr, "Failed to get sample information: %s\n", pa_strerror(pa_context_errno(c)));
+        quit(1);
+        return;
+    }
+
+    if (is_last) {
+        complete_action();
+        return;
+    }
+    
+    assert(i);
+
+    if (nl)
+        printf("\n");
+    nl = 1;
+
+    
+    pa_bytes_snprint(t, sizeof(t), i->bytes);
+    
+    printf("*** Sample #%u ***\n"
+           "Name: %s\n"
+           "Volume: %s\n"
+           "Sample Specification: %s\n"
+           "Channel Map: %s\n"
+           "Duration: %0.1fs\n"
+           "Size: %s\n"
+           "Lazy: %s\n"
+           "Filename: %s\n",
+           i->index,
+           i->name,
+           pa_cvolume_snprint(cv, sizeof(cv), &i->volume),
+           pa_sample_spec_valid(&i->sample_spec) ? pa_sample_spec_snprint(s, sizeof(s), &i->sample_spec) : "n/a",
+           pa_sample_spec_valid(&i->sample_spec) ? pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map) : "n/a",
+           (double) i->duration/1000000,
+           t,
+           i->lazy ? "yes" : "no",
+           i->filename ? i->filename : "n/a");
+}
+
+static void get_autoload_info_callback(pa_context *c, const pa_autoload_info *i, int is_last, void *userdata) {
+    if (is_last < 0) {
+        fprintf(stderr, "Failed to get autoload information: %s\n", pa_strerror(pa_context_errno(c)));
+        quit(1);
+        return;
+    }
+
+    if (is_last) {
+        complete_action();
+        return;
+    }
+    
+    assert(i);
+
+    if (nl)
+        printf("\n");
+    nl = 1;
+
+    printf("*** Autoload Entry #%u ***\n"
+           "Name: %s\n"
+           "Type: %s\n"
+           "Module: %s\n"
+           "Argument: %s\n",
+           i->index,
+           i->name,
+           i->type == PA_AUTOLOAD_SINK ? "sink" : "source",
+           i->module,
+           i->argument);
+}
+
+static void simple_callback(pa_context *c, int success, void *userdata) {
+    if (!success) {
+        fprintf(stderr, "Failure: %s\n", pa_strerror(pa_context_errno(c)));
+        quit(1);
+        return;
+    }
+
+    complete_action();
+}
+
+static void stream_state_callback(pa_stream *s, void *userdata) {
+    assert(s);
+
+    switch (pa_stream_get_state(s)) {
+        case PA_STREAM_CREATING:
+        case PA_STREAM_READY:
+            break;
+            
+        case PA_STREAM_TERMINATED:
+            drain();
+            break;
+            
+        case PA_STREAM_FAILED:
+        default:
+            fprintf(stderr, "Failed to upload sample: %s\n", pa_strerror(pa_context_errno(pa_stream_get_context(s))));
+            quit(1);
+    }
+}
+
+static void stream_write_callback(pa_stream *s, size_t length, void *userdata) {
+    sf_count_t l;
+    float *d;
+    assert(s && length && sndfile);
+
+    d = malloc(length);
+    assert(d);
+
+    assert(sample_length >= length);
+    l = length/pa_frame_size(&sample_spec);
+
+    if ((sf_readf_float(sndfile, d, l)) != l) {
+        free(d);
+        fprintf(stderr, "Premature end of file\n");
+        quit(1);
+    }
+    
+    pa_stream_write(s, d, length, free, 0);
+
+    sample_length -= length;
+
+    if (sample_length  <= 0) {
+        pa_stream_set_write_callback(sample_stream, NULL, NULL);
+        pa_stream_finish_upload(sample_stream);
+    }
+}
+
+static void context_state_callback(pa_context *c, void *userdata) {
+    assert(c);
+    switch (pa_context_get_state(c)) {
+        case PA_CONTEXT_CONNECTING:
+        case PA_CONTEXT_AUTHORIZING:
+        case PA_CONTEXT_SETTING_NAME:
+            break;
+
+        case PA_CONTEXT_READY:
+            switch (action) {
+                case STAT:
+                    actions = 2;
+                    pa_operation_unref(pa_context_stat(c, stat_callback, NULL));
+                    pa_operation_unref(pa_context_get_server_info(c, get_server_info_callback, NULL));
+                    break;
+
+                case PLAY_SAMPLE: 
+                    pa_operation_unref(pa_context_play_sample(c, sample_name, device, PA_VOLUME_NORM, simple_callback, NULL));
+                    break;
+
+                case REMOVE_SAMPLE:
+                    pa_operation_unref(pa_context_remove_sample(c, sample_name, simple_callback, NULL));
+                    break;
+
+                case UPLOAD_SAMPLE:
+                    sample_stream = pa_stream_new(c, sample_name, &sample_spec, NULL);
+                    assert(sample_stream);
+                    
+                    pa_stream_set_state_callback(sample_stream, stream_state_callback, NULL);
+                    pa_stream_set_write_callback(sample_stream, stream_write_callback, NULL);
+                    pa_stream_connect_upload(sample_stream, sample_length);
+                    break;
+                    
+                case EXIT:
+                    pa_context_exit_daemon(c);
+                    drain();
+
+                case LIST:
+                    actions = 8;
+                    pa_operation_unref(pa_context_get_module_info_list(c, get_module_info_callback, NULL));
+                    pa_operation_unref(pa_context_get_sink_info_list(c, get_sink_info_callback, NULL));
+                    pa_operation_unref(pa_context_get_source_info_list(c, get_source_info_callback, NULL));
+                    pa_operation_unref(pa_context_get_sink_input_info_list(c, get_sink_input_info_callback, NULL));
+                    pa_operation_unref(pa_context_get_source_output_info_list(c, get_source_output_info_callback, NULL)); 
+                    pa_operation_unref(pa_context_get_client_info_list(c, get_client_info_callback, NULL));
+                    pa_operation_unref(pa_context_get_sample_info_list(c, get_sample_info_callback, NULL));
+                    pa_operation_unref(pa_context_get_autoload_info_list(c, get_autoload_info_callback, NULL));
+                    break;
+
+                default:
+                    assert(0);
+            }
+            break;
+
+        case PA_CONTEXT_TERMINATED:
+            quit(0);
+            break;
+
+        case PA_CONTEXT_FAILED:
+        default:
+            fprintf(stderr, "Connection failure: %s\n", pa_strerror(pa_context_errno(c)));
+            quit(1);
+    }
+}
+
+static void exit_signal_callback(pa_mainloop_api *m, pa_signal_event *e, int sig, void *userdata) {
+    fprintf(stderr, "Got SIGINT, exiting.\n");
+    quit(0);
+}
+
+static void help(const char *argv0) {
+
+    printf("%s [options] stat\n"
+           "%s [options] list\n"
+           "%s [options] exit\n"
+           "%s [options] upload-sample FILENAME [NAME]\n"
+           "%s [options] play-sample NAME [SINK]\n"
+           "%s [options] remove-sample NAME\n\n"
+           "  -h, --help                            Show this help\n"
+           "      --version                         Show version\n\n"
+           "  -s, --server=SERVER                   The name of the server to connect to\n"
+           "  -n, --client-name=NAME                How to call this client on the server\n",
+           argv0, argv0, argv0, argv0, argv0, argv0);
+}
+
+enum { ARG_VERSION = 256 };
+
+int main(int argc, char *argv[]) {
+    pa_mainloop* m = NULL;
+    char tmp[PATH_MAX];
+    int ret = 1, r, c;
+    char *server = NULL, *client_name = NULL, *bn;
+
+    static const struct option long_options[] = {
+        {"server",      1, NULL, 's'},
+        {"client-name", 1, NULL, 'n'},
+        {"version",     0, NULL, ARG_VERSION},
+        {"help",        0, NULL, 'h'},
+        {NULL,          0, NULL, 0}
+    };
+
+    if (!(bn = strrchr(argv[0], '/')))
+        bn = argv[0];
+    else
+        bn++;
+    
+    while ((c = getopt_long(argc, argv, "s:n:h", long_options, NULL)) != -1) {
+        switch (c) {
+            case 'h' :
+                help(bn);
+                ret = 0;
+                goto quit;
+                
+            case ARG_VERSION:
+                printf("pactl "PACKAGE_VERSION"\nCompiled with libpolyp %s\nLinked with libpolyp %s\n", pa_get_headers_version(), pa_get_library_version());
+                ret = 0;
+                goto quit;
+
+            case 's':
+                free(server);
+                server = strdup(optarg);
+                break;
+
+            case 'n':
+                free(client_name);
+                client_name = strdup(optarg);
+                break;
+
+            default:
+                goto quit;
+        }
+    }
+
+    if (!client_name)
+        client_name = strdup(bn);
+    
+    if (optind < argc) {
+        if (!strcmp(argv[optind], "stat"))
+            action = STAT;
+        else if (!strcmp(argv[optind], "exit"))
+            action = EXIT;
+        else if (!strcmp(argv[optind], "list"))
+            action = LIST;
+        else if (!strcmp(argv[optind], "upload-sample")) {
+            struct SF_INFO sfinfo;
+            action = UPLOAD_SAMPLE;
+
+            if (optind+1 >= argc) {
+                fprintf(stderr, "Please specify a sample file to load\n");
+                goto quit;
+            }
+
+            if (optind+2 < argc)
+                sample_name = strdup(argv[optind+2]);
+            else {
+                char *f = strrchr(argv[optind+1], '/');
+                size_t n;
+                if (f)
+                    f++;
+                else
+                    f = argv[optind];
+
+                n = strcspn(f, ".");
+                strncpy(tmp, f, n);
+                tmp[n] = 0;
+                sample_name = strdup(tmp);
+            }
+            
+            memset(&sfinfo, 0, sizeof(sfinfo));
+            if (!(sndfile = sf_open(argv[optind+1], SFM_READ, &sfinfo))) {
+                fprintf(stderr, "Failed to open sound file.\n");
+                goto quit;
+            }
+            
+            sample_spec.format =  PA_SAMPLE_FLOAT32;
+            sample_spec.rate = sfinfo.samplerate;
+            sample_spec.channels = sfinfo.channels;
+
+            sample_length = sfinfo.frames*pa_frame_size(&sample_spec);
+        } else if (!strcmp(argv[optind], "play-sample")) {
+            action = PLAY_SAMPLE;
+            if (optind+1 >= argc) {
+                fprintf(stderr, "You have to specify a sample name to play\n");
+                goto quit;
+            }
+
+            sample_name = strdup(argv[optind+1]);
+
+            if (optind+2 < argc)
+                device = strdup(argv[optind+2]);
+            
+        } else if (!strcmp(argv[optind], "remove-sample")) {
+            action = REMOVE_SAMPLE;
+            if (optind+1 >= argc) {
+                fprintf(stderr, "You have to specify a sample name to remove\n");
+                goto quit;
+            }
+
+            sample_name = strdup(argv[optind+1]);
+        }
+    }
+
+    if (action == NONE) {
+        fprintf(stderr, "No valid command specified.\n");
+        goto quit;
+    }
+
+    if (!(m = pa_mainloop_new())) {
+        fprintf(stderr, "pa_mainloop_new() failed.\n");
+        goto quit;
+    }
+
+    mainloop_api = pa_mainloop_get_api(m);
+
+    r = pa_signal_init(mainloop_api);
+    assert(r == 0);
+    pa_signal_new(SIGINT, exit_signal_callback, NULL);
+#ifdef SIGPIPE
+    signal(SIGPIPE, SIG_IGN);
+#endif
+    
+    if (!(context = pa_context_new(mainloop_api, client_name))) {
+        fprintf(stderr, "pa_context_new() failed.\n");
+        goto quit;
+    }
+
+    pa_context_set_state_callback(context, context_state_callback, NULL);
+    pa_context_connect(context, server, 1, NULL);
+
+    if (pa_mainloop_run(m, &ret) < 0) {
+        fprintf(stderr, "pa_mainloop_run() failed.\n");
+        goto quit;
+    }
+
+quit:
+    if (sample_stream)
+        pa_stream_unref(sample_stream);
+
+    if (context)
+        pa_context_unref(context);
+
+    if (m) {
+        pa_signal_done();
+        pa_mainloop_free(m);
+    }
+    
+    if (sndfile)
+        sf_close(sndfile);
+
+    free(server);
+    free(device);
+    free(sample_name);
+
+    return ret;
+}
diff --git a/src/utils/paplay.c b/src/utils/paplay.c
new file mode 100644
index 000000000..ddc1cbc16
--- /dev/null
+++ b/src/utils/paplay.c
@@ -0,0 +1,386 @@
+/* $Id$ */
+
+/***
+  This file is part of polypaudio.
+ 
+  polypaudio 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.
+ 
+  polypaudio 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 polypaudio; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.
+***/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <signal.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <getopt.h>
+
+#include <sndfile.h>
+
+#include <polyp/polyplib.h>
+#include <polyp/polyplib-error.h>
+#include <polyp/mainloop.h>
+#include <polyp/mainloop-signal.h>
+#include <polyp/polyplib-version.h>
+
+#if PA_API_VERSION != 8
+#error Invalid Polypaudio API version
+#endif
+
+static pa_context *context = NULL;
+static pa_stream *stream = NULL;
+static pa_mainloop_api *mainloop_api = NULL;
+
+static char *stream_name = NULL, *client_name = NULL, *device = NULL;
+
+static int verbose = 0;
+static pa_volume_t volume = PA_VOLUME_NORM;
+
+static SNDFILE* sndfile = NULL;
+
+static pa_sample_spec sample_spec = { 0, 0, 0 }; 
+
+static sf_count_t (*readf_function)(SNDFILE *_sndfile, void *ptr, sf_count_t frames);
+
+/* A shortcut for terminating the application */
+static void quit(int ret) {
+    assert(mainloop_api);
+    mainloop_api->quit(mainloop_api, ret);
+}
+
+/* Connection draining complete */
+static void context_drain_complete(pa_context*c, void *userdata) {
+    pa_context_disconnect(c);
+}
+
+/* Stream draining complete */
+static void stream_drain_complete(pa_stream*s, int success, void *userdata) {
+    pa_operation *o;
+
+    if (!success) {
+        fprintf(stderr, "Failed to drain stream: %s\n", pa_strerror(pa_context_errno(context)));
+        quit(1);
+    }
+    
+    if (verbose)    
+        fprintf(stderr, "Playback stream drained.\n");
+
+    pa_stream_disconnect(stream);
+    pa_stream_unref(stream);
+    stream = NULL;
+    
+    if (!(o = pa_context_drain(context, context_drain_complete, NULL)))
+        pa_context_disconnect(context);
+    else {
+        pa_operation_unref(o);
+
+        if (verbose)
+            fprintf(stderr, "Draining connection to server.\n");
+    }
+}
+
+/* This is called whenever new data may be written to the stream */
+static void stream_write_callback(pa_stream *s, size_t length, void *userdata) {
+    size_t k;
+    sf_count_t f, n;
+    void *data;
+    assert(s && length);
+
+    if (!sndfile)
+        return;
+    
+    k = pa_frame_size(&sample_spec);
+
+    data = malloc(length);
+
+    n = length/k;
+    
+    f = readf_function(sndfile, data, n);
+
+    if (f > 0)
+        pa_stream_write(s, data, f*k, free, 0);
+
+    if (f < n) {
+        sf_close(sndfile);
+        sndfile = NULL;
+        pa_operation_unref(pa_stream_drain(s, stream_drain_complete, NULL));
+    }
+}
+
+/* This routine is called whenever the stream state changes */
+static void stream_state_callback(pa_stream *s, void *userdata) {
+    assert(s);
+
+    switch (pa_stream_get_state(s)) {
+        case PA_STREAM_CREATING:
+        case PA_STREAM_TERMINATED:
+            break;
+
+        case PA_STREAM_READY:
+            if (verbose)
+                fprintf(stderr, "Stream successfully created\n");
+            break;
+            
+        case PA_STREAM_FAILED:
+        default:
+            fprintf(stderr, "Stream errror: %s\n", pa_strerror(pa_context_errno(pa_stream_get_context(s))));
+            quit(1);
+    }
+}
+
+/* This is called whenever the context status changes */
+static void context_state_callback(pa_context *c, void *userdata) {
+    assert(c);
+
+    switch (pa_context_get_state(c)) {
+        case PA_CONTEXT_CONNECTING:
+        case PA_CONTEXT_AUTHORIZING:
+        case PA_CONTEXT_SETTING_NAME:
+            break;
+        
+        case PA_CONTEXT_READY: {
+            pa_cvolume cv;
+            
+            assert(c && !stream);
+
+            if (verbose)
+                fprintf(stderr, "Connection established.\n");
+
+            stream = pa_stream_new(c, stream_name, &sample_spec, NULL);
+            assert(stream);
+
+            pa_stream_set_state_callback(stream, stream_state_callback, NULL);
+            pa_stream_set_write_callback(stream, stream_write_callback, NULL);
+            pa_stream_connect_playback(stream, device, NULL, 0, pa_cvolume_set(&cv, PA_CHANNELS_MAX, volume));
+                
+            break;
+        }
+            
+        case PA_CONTEXT_TERMINATED:
+            quit(0);
+            break;
+
+        case PA_CONTEXT_FAILED:
+        default:
+            fprintf(stderr, "Connection failure: %s\n", pa_strerror(pa_context_errno(c)));
+            quit(1);
+    }
+}
+
+/* UNIX signal to quit recieved */
+static void exit_signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
+    if (verbose)
+        fprintf(stderr, "Got SIGINT, exiting.\n");
+    quit(0);
+    
+}
+
+static void help(const char *argv0) {
+
+    printf("%s [options] [FILE]\n\n"
+           "  -h, --help                            Show this help\n"
+           "      --version                         Show version\n\n"
+           "  -v, --verbose                         Enable verbose operations\n\n"
+           "  -s, --server=SERVER                   The name of the server to connect to\n"
+           "  -d, --device=DEVICE                   The name of the sink/source to connect to\n"
+           "  -n, --client-name=NAME                How to call this client on the server\n"
+           "      --stream-name=NAME                How to call this stream on the server\n"
+           "      --volume=VOLUME                   Specify the initial (linear) volume in range 0...256\n",
+           argv0);
+}
+
+enum {
+    ARG_VERSION = 256,
+    ARG_STREAM_NAME,
+    ARG_VOLUME
+};
+
+int main(int argc, char *argv[]) {
+    pa_mainloop* m = NULL;
+    int ret = 1, r, c;
+    char *bn, *server = NULL;
+    const char *filename;
+    SF_INFO sfinfo;
+
+    static const struct option long_options[] = {
+        {"device",      1, NULL, 'd'},
+        {"server",      1, NULL, 's'},
+        {"client-name", 1, NULL, 'n'},
+        {"stream-name", 1, NULL, ARG_STREAM_NAME},
+        {"version",     0, NULL, ARG_VERSION},
+        {"help",        0, NULL, 'h'},
+        {"verbose",     0, NULL, 'v'},
+        {"volume",      1, NULL, ARG_VOLUME},
+        {NULL,          0, NULL, 0}
+    };
+
+    if (!(bn = strrchr(argv[0], '/')))
+        bn = argv[0];
+    else
+        bn++;
+
+    while ((c = getopt_long(argc, argv, "d:s:n:hv", long_options, NULL)) != -1) {
+
+        switch (c) {
+            case 'h' :
+                help(bn);
+                ret = 0;
+                goto quit;
+                
+            case ARG_VERSION:
+                printf("paplay "PACKAGE_VERSION"\nCompiled with libpolyp %s\nLinked with libpolyp %s\n", pa_get_headers_version(), pa_get_library_version());
+                ret = 0;
+                goto quit;
+
+            case 'd':
+                free(device);
+                device = strdup(optarg);
+                break;
+
+            case 's':
+                free(server);
+                server = strdup(optarg);
+                break;
+
+            case 'n':
+                free(client_name);
+                client_name = strdup(optarg);
+                break;
+
+            case ARG_STREAM_NAME:
+                free(stream_name);
+                stream_name = strdup(optarg);
+                break;
+
+            case 'v':
+                verbose = 1;
+                break;
+
+            case ARG_VOLUME: {
+                int v = atoi(optarg);
+                volume = v < 0 ? 0 : v;
+                break;
+            }
+
+            default:
+                goto quit;
+        }
+    }
+
+
+    filename = optind < argc ? argv[optind] : "STDIN";
+    
+    
+    if (!client_name)
+        client_name = strdup(bn);
+
+    if (!stream_name)
+        stream_name = strdup(filename);
+
+    memset(&sfinfo, 0, sizeof(sfinfo));
+
+    if (optind < argc)
+        sndfile = sf_open(filename, SFM_READ, &sfinfo);
+    else
+        sndfile = sf_open_fd(STDIN_FILENO, SFM_READ, &sfinfo, 0);
+
+    if (!sndfile) {
+        fprintf(stderr, "Failed to open file '%s'\n", filename);
+        goto quit;
+    }
+              
+    sample_spec.rate = sfinfo.samplerate;
+    sample_spec.channels = sfinfo.channels;
+    
+    switch (sfinfo.format & 0xFF) {
+        case SF_FORMAT_PCM_16:
+        case SF_FORMAT_PCM_U8:
+        case SF_FORMAT_ULAW:
+        case SF_FORMAT_ALAW:
+            sample_spec.format = PA_SAMPLE_S16NE;
+            readf_function = (sf_count_t (*)(SNDFILE *_sndfile, void *ptr, sf_count_t frames)) sf_readf_short;
+            break;
+        case SF_FORMAT_FLOAT:
+        default:
+            sample_spec.format = PA_SAMPLE_FLOAT32NE;
+            readf_function = (sf_count_t (*)(SNDFILE *_sndfile, void *ptr, sf_count_t frames)) sf_readf_float;
+            break;
+    }
+
+    if (verbose) {
+        char t[PA_SAMPLE_SPEC_SNPRINT_MAX];
+        pa_sample_spec_snprint(t, sizeof(t), &sample_spec);
+        fprintf(stderr, "Using sample spec '%s'\n", t);
+    }
+    
+    /* Set up a new main loop */
+    if (!(m = pa_mainloop_new())) {
+        fprintf(stderr, "pa_mainloop_new() failed.\n");
+        goto quit;
+    }
+
+    mainloop_api = pa_mainloop_get_api(m);
+
+    r = pa_signal_init(mainloop_api);
+    assert(r == 0);
+    pa_signal_new(SIGINT, exit_signal_callback, NULL);
+#ifdef SIGPIPE
+    signal(SIGPIPE, SIG_IGN);
+#endif
+    
+    /* Create a new connection context */
+    if (!(context = pa_context_new(mainloop_api, client_name))) {
+        fprintf(stderr, "pa_context_new() failed.\n");
+        goto quit;
+    }
+
+    pa_context_set_state_callback(context, context_state_callback, NULL);
+
+    /* Connect the context */
+    pa_context_connect(context, server, 1, NULL);
+
+    /* Run the main loop */
+    if (pa_mainloop_run(m, &ret) < 0) {
+        fprintf(stderr, "pa_mainloop_run() failed.\n");
+        goto quit;
+    }
+    
+quit:
+    if (stream)
+        pa_stream_unref(stream);
+
+    if (context)
+        pa_context_unref(context);
+
+    if (m) {
+        pa_signal_done();
+        pa_mainloop_free(m);
+    }
+
+    free(server);
+    free(device);
+    free(client_name);
+    free(stream_name);
+
+    if (sndfile)
+        sf_close(sndfile);
+    
+    return ret;
+}
diff --git a/src/utils/pax11publish.c b/src/utils/pax11publish.c
new file mode 100644
index 000000000..63ee48212
--- /dev/null
+++ b/src/utils/pax11publish.c
@@ -0,0 +1,217 @@
+/* $Id$ */
+
+/***
+  This file is part of polypaudio.
+ 
+  polypaudio 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.
+ 
+  polypaudio 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 polypaudio; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.
+***/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <getopt.h>
+#include <string.h>
+#include <assert.h>
+
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+
+#include <polypcore/util.h>
+#include <polypcore/log.h>
+#include <polypcore/authkey.h>
+#include <polypcore/native-common.h>
+#include <polyp/client-conf.h>
+#include <polypcore/x11prop.h>
+
+int main(int argc, char *argv[]) {
+    const char *dname = NULL, *sink = NULL, *source = NULL, *server = NULL, *cookie_file = PA_NATIVE_COOKIE_FILE;
+    int c, ret = 1;
+    Display *d = NULL;
+    enum { DUMP, EXPORT, IMPORT, REMOVE } mode = DUMP;
+
+    while ((c = getopt(argc, argv, "deiD:S:O:I:c:hr")) != -1) {
+        switch (c) {
+            case 'D' :
+                dname = optarg;
+                break;
+            case 'h':
+                printf("%s [-D display] [-S server] [-O sink] [-I source] [-c file]  [-d|-e|-i|-r]\n\n"
+                       " -d    Show current Polypaudio data attached to X11 display (default)\n"
+                       " -e    Export local Polypaudio data to X11 display\n"
+                       " -i    Import Polypaudio data from X11 display to local environment variables and cookie file.\n"
+                       " -r    Remove Polypaudio data from X11 display\n",
+                       pa_path_get_filename(argv[0]));
+                ret = 0;
+                goto finish;
+            case 'd':
+                mode = DUMP;
+                break;
+            case 'e':
+                mode = EXPORT;
+                break;
+            case 'i':
+                mode = IMPORT;
+                break;
+            case 'r':
+                mode = REMOVE;
+                break;
+            case 'c':
+                cookie_file = optarg;
+                break;
+            case 'I':
+                source = optarg;
+                break;
+            case 'O':
+                sink = optarg;
+                break;
+            case 'S':
+                server = optarg;
+                break;
+            default:
+                fprintf(stderr, "Failed to parse command line.\n");
+                goto finish;
+        }
+    }
+
+    if (!(d = XOpenDisplay(dname))) {
+        pa_log(__FILE__": XOpenDisplay() failed\n");
+        goto finish;
+    }
+
+    switch (mode) {
+        case DUMP: {
+            char t[1024];
+            if (pa_x11_get_prop(d, "POLYP_SERVER", t, sizeof(t))) 
+                printf("Server: %s\n", t);
+            if (pa_x11_get_prop(d, "POLYP_SOURCE", t, sizeof(t)))
+                printf("Source: %s\n", t);
+            if (pa_x11_get_prop(d, "POLYP_SINK", t, sizeof(t)))
+                printf("Sink: %s\n", t);
+            if (pa_x11_get_prop(d, "POLYP_COOKIE", t, sizeof(t)))
+                printf("Cookie: %s\n", t);
+
+            break;
+        }
+            
+        case IMPORT: {
+            char t[1024];
+            if (pa_x11_get_prop(d, "POLYP_SERVER", t, sizeof(t))) 
+                printf("POLYP_SERVER='%s'\nexport POLYP_SERVER\n", t);
+            if (pa_x11_get_prop(d, "POLYP_SOURCE", t, sizeof(t)))
+                printf("POLYP_SOURCE='%s'\nexport POLYP_SOURCE\n", t);
+            if (pa_x11_get_prop(d, "POLYP_SINK", t, sizeof(t)))
+                printf("POLYP_SINK='%s'\nexport POLYP_SINK\n", t);
+
+            if (pa_x11_get_prop(d, "POLYP_COOKIE", t, sizeof(t))) {
+                uint8_t cookie[PA_NATIVE_COOKIE_LENGTH];
+                size_t l;
+                if ((l = pa_parsehex(t, cookie, sizeof(cookie))) != sizeof(cookie)) {
+                    fprintf(stderr, "Failed to parse cookie data\n");
+                    goto finish;
+                }
+
+                if (pa_authkey_save(cookie_file, cookie, l) < 0) {
+                    fprintf(stderr, "Failed to save cookie data\n");
+                    goto finish;
+                }
+            }
+
+            break;
+        }
+
+        case EXPORT: {
+            pa_client_conf *conf = pa_client_conf_new();
+            uint8_t cookie[PA_NATIVE_COOKIE_LENGTH];
+            char hx[PA_NATIVE_COOKIE_LENGTH*2+1];
+            assert(conf);
+
+            if (pa_client_conf_load(conf, NULL) < 0) {
+                fprintf(stderr, "Failed to load client configuration file.\n");
+                goto finish;
+            }
+
+            if (pa_client_conf_env(conf) < 0) {
+                fprintf(stderr, "Failed to read environment configuration data.\n");
+                goto finish;
+            }
+
+            pa_x11_del_prop(d, "POLYP_SERVER");
+            pa_x11_del_prop(d, "POLYP_SINK");
+            pa_x11_del_prop(d, "POLYP_SOURCE");
+            pa_x11_del_prop(d, "POLYP_ID");
+            pa_x11_del_prop(d, "POLYP_COOKIE");
+            
+            if (server)
+                pa_x11_set_prop(d, "POLYP_SERVER", server);
+            else if (conf->default_server)
+                pa_x11_set_prop(d, "POLYP_SERVER", conf->default_server);
+            else {
+                char hn[256];
+                if (!pa_get_fqdn(hn, sizeof(hn))) {
+                    fprintf(stderr, "Failed to get FQDN.\n");
+                    goto finish;
+                }
+                    
+                pa_x11_set_prop(d, "POLYP_SERVER", hn);
+            }
+
+            if (sink)
+                pa_x11_set_prop(d, "POLYP_SINK", sink);
+            else if (conf->default_sink)
+                pa_x11_set_prop(d, "POLYP_SINK", conf->default_sink);
+
+            if (source)
+                pa_x11_set_prop(d, "POLYP_SOURCE", source);
+            if (conf->default_source)
+                pa_x11_set_prop(d, "POLYP_SOURCE", conf->default_source);
+
+            pa_client_conf_free(conf);
+            
+            if (pa_authkey_load_auto(cookie_file, cookie, sizeof(cookie)) < 0) {
+                fprintf(stderr, "Failed to load cookie data\n");
+                goto finish;
+            }
+
+            pa_x11_set_prop(d, "POLYP_COOKIE", pa_hexstr(cookie, sizeof(cookie), hx, sizeof(hx)));
+            break;
+        }
+
+        case REMOVE:
+            pa_x11_del_prop(d, "POLYP_SERVER");
+            pa_x11_del_prop(d, "POLYP_SINK");
+            pa_x11_del_prop(d, "POLYP_SOURCE");
+            pa_x11_del_prop(d, "POLYP_ID");
+            pa_x11_del_prop(d, "POLYP_COOKIE");
+            break;
+            
+        default:
+            fprintf(stderr, "No yet implemented.\n");
+            goto finish;
+    }
+
+    ret = 0;
+    
+finish:
+
+    if (d) {
+        XSync(d, False);
+        XCloseDisplay(d);
+    }
+    
+    return ret;
+}