src/pulse/context.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2004-2008 Lennart Poettering
   5   Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
   6
   7   PulseAudio is free software; you can redistribute it and/or modify
   8   it under the terms of the GNU Lesser General Public License as published
   9   by the Free Software Foundation; either version 2.1 of the License,
  10   or (at your option) any later version.
  11
  12   PulseAudio is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with PulseAudio; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20   USA.
  21 ***/
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <sys/types.h>
  31 #include <unistd.h>
  32 #include <sys/stat.h>
  33 #include <errno.h>
  34 #include <signal.h>
  35 #include <limits.h>
  36 #include <locale.h>
  37
  38 #ifdef HAVE_SYS_WAIT_H
  39 #include <sys/wait.h>
  40 #endif
  41
  42 #ifdef HAVE_SYS_SOCKET_H
  43 #include <sys/socket.h>
  44 #endif
  45 #ifdef HAVE_SYS_UN_H
  46 #include <sys/un.h>
  47 #endif
  48 #ifdef HAVE_NETDB_H
  49 #include <netdb.h>
  50 #endif
  51
  52 #include <pulse/version.h>
  53 #include <pulse/xmalloc.h>
  54 #include <pulse/utf8.h>
  55 #include <pulse/util.h>
  56 #include <pulse/i18n.h>
  57
  58 #include <pulsecore/winsock.h>
  59 #include <pulsecore/core-error.h>
  60
  61 #include <pulsecore/native-common.h>
  62 #include <pulsecore/pdispatch.h>
  63 #include <pulsecore/pstream.h>
  64 #include <pulsecore/dynarray.h>
  65 #include <pulsecore/socket-client.h>
  66 #include <pulsecore/pstream-util.h>
  67 #include <pulsecore/core-util.h>
  68 #include <pulsecore/log.h>
  69 #include <pulsecore/socket-util.h>
  70 #include <pulsecore/creds.h>
  71 #include <pulsecore/macro.h>
  72 #include <pulsecore/proplist-util.h>
  73
  74 #include "internal.h"
  75
  76 #include "client-conf.h"
  77 #include "fork-detect.h"
  78
  79 #ifdef HAVE_X11
  80 #include "client-conf-x11.h"
  81 #endif
  82
  83 #include "context.h"
  84
  85 void pa_command_extension(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
  86
  87 static const pa_pdispatch_cb_t command_table[PA_COMMAND_MAX] = {
  88     [PA_COMMAND_REQUEST] = pa_command_request,
  89     [PA_COMMAND_OVERFLOW] = pa_command_overflow_or_underflow,
  90     [PA_COMMAND_UNDERFLOW] = pa_command_overflow_or_underflow,
  91     [PA_COMMAND_PLAYBACK_STREAM_KILLED] = pa_command_stream_killed,
  92     [PA_COMMAND_RECORD_STREAM_KILLED] = pa_command_stream_killed,
  93     [PA_COMMAND_PLAYBACK_STREAM_MOVED] = pa_command_stream_moved,
  94     [PA_COMMAND_RECORD_STREAM_MOVED] = pa_command_stream_moved,
  95     [PA_COMMAND_PLAYBACK_STREAM_SUSPENDED] = pa_command_stream_suspended,
  96     [PA_COMMAND_RECORD_STREAM_SUSPENDED] = pa_command_stream_suspended,
  97     [PA_COMMAND_STARTED] = pa_command_stream_started,
  98     [PA_COMMAND_SUBSCRIBE_EVENT] = pa_command_subscribe_event,
  99     [PA_COMMAND_EXTENSION] = pa_command_extension,
 100     [PA_COMMAND_PLAYBACK_STREAM_EVENT] = pa_command_stream_event,
 101     [PA_COMMAND_RECORD_STREAM_EVENT] = pa_command_stream_event,
 102     [PA_COMMAND_CLIENT_EVENT] = pa_command_client_event
 103 };
 104 static void context_free(pa_context *c);
 105
 106 pa_context *pa_context_new(pa_mainloop_api *mainloop, const char *name) {
 107     return pa_context_new_with_proplist(mainloop, name, NULL);
 108 }
 109
 110 static void reset_callbacks(pa_context *c) {
 111     pa_assert(c);
 112
 113     c->state_callback = NULL;
 114     c->state_userdata = NULL;
 115
 116     c->subscribe_callback = NULL;
 117     c->subscribe_userdata = NULL;
 118
 119     c->event_callback = NULL;
 120     c->event_userdata = NULL;
 121
 122     c->ext_stream_restore.callback = NULL;
 123     c->ext_stream_restore.userdata = NULL;
 124 }
 125
 126 pa_context *pa_context_new_with_proplist(pa_mainloop_api *mainloop, const char *name, pa_proplist *p) {
 127     pa_context *c;
 128
 129     pa_assert(mainloop);
 130
 131     if (pa_detect_fork())
 132         return NULL;
 133
 134     pa_init_i18n();
 135
 136     c = pa_xnew(pa_context, 1);
 137     PA_REFCNT_INIT(c);
 138
 139     c->proplist = p ? pa_proplist_copy(p) : pa_proplist_new();
 140
 141     if (name)
 142         pa_proplist_sets(c->proplist, PA_PROP_APPLICATION_NAME, name);
 143
 144     c->mainloop = mainloop;
 145     c->client = NULL;
 146     c->pstream = NULL;
 147     c->pdispatch = NULL;
 148     c->playback_streams = pa_dynarray_new();
 149     c->record_streams = pa_dynarray_new();
 150     c->client_index = PA_INVALID_INDEX;
 151
 152     PA_LLIST_HEAD_INIT(pa_stream, c->streams);
 153     PA_LLIST_HEAD_INIT(pa_operation, c->operations);
 154
 155     c->error = PA_OK;
 156     c->state = PA_CONTEXT_UNCONNECTED;
 157     c->ctag = 0;
 158     c->csyncid = 0;
 159
 160     reset_callbacks(c);
 161
 162     c->is_local = FALSE;
 163     c->server_list = NULL;
 164     c->server = NULL;
 165
 166     c->do_shm = FALSE;
 167
 168     c->do_autospawn = FALSE;
 169     memset(&c->spawn_api, 0, sizeof(c->spawn_api));
 170
 171 #ifndef MSG_NOSIGNAL
 172 #ifdef SIGPIPE
 173     pa_check_signal_is_blocked(SIGPIPE);
 174 #endif
 175 #endif
 176
 177     c->conf = pa_client_conf_new();
 178 #ifdef HAVE_X11
 179     pa_client_conf_from_x11(c->conf, NULL);
 180 #endif
 181     pa_client_conf_load(c->conf, NULL);
 182     pa_client_conf_env(c->conf);
 183
 184     if (!(c->mempool = pa_mempool_new(!c->conf->disable_shm, c->conf->shm_size))) {
 185
 186         if (!c->conf->disable_shm)
 187             c->mempool = pa_mempool_new(FALSE, c->conf->shm_size);
 188
 189         if (!c->mempool) {
 190             context_free(c);
 191             return NULL;
 192         }
 193     }
 194
 195     return c;
 196 }
 197
 198 static void context_unlink(pa_context *c) {
 199     pa_stream *s;
 200
 201     pa_assert(c);
 202
 203     s = c->streams ? pa_stream_ref(c->streams) : NULL;
 204     while (s) {
 205         pa_stream *n = s->next ? pa_stream_ref(s->next) : NULL;
 206         pa_stream_set_state(s, c->state == PA_CONTEXT_FAILED ? PA_STREAM_FAILED : PA_STREAM_TERMINATED);
 207         pa_stream_unref(s);
 208         s = n;
 209     }
 210
 211     while (c->operations)
 212         pa_operation_cancel(c->operations);
 213
 214     if (c->pdispatch) {
 215         pa_pdispatch_unref(c->pdispatch);
 216         c->pdispatch = NULL;
 217     }
 218
 219     if (c->pstream) {
 220         pa_pstream_unlink(c->pstream);
 221         pa_pstream_unref(c->pstream);
 222         c->pstream = NULL;
 223     }
 224
 225     if (c->client) {
 226         pa_socket_client_unref(c->client);
 227         c->client = NULL;
 228     }
 229
 230     reset_callbacks(c);
 231 }
 232
 233 static void context_free(pa_context *c) {
 234     pa_assert(c);
 235
 236     context_unlink(c);
 237
 238     if (c->record_streams)
 239         pa_dynarray_free(c->record_streams, NULL, NULL);
 240     if (c->playback_streams)
 241         pa_dynarray_free(c->playback_streams, NULL, NULL);
 242
 243     if (c->mempool)
 244         pa_mempool_free(c->mempool);
 245
 246     if (c->conf)
 247         pa_client_conf_free(c->conf);
 248
 249     pa_strlist_free(c->server_list);
 250
 251     if (c->proplist)
 252         pa_proplist_free(c->proplist);
 253
 254     pa_xfree(c->server);
 255     pa_xfree(c);
 256 }
 257
 258 pa_context* pa_context_ref(pa_context *c) {
 259     pa_assert(c);
 260     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 261
 262     PA_REFCNT_INC(c);
 263     return c;
 264 }
 265
 266 void pa_context_unref(pa_context *c) {
 267     pa_assert(c);
 268     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 269
 270     if (PA_REFCNT_DEC(c) <= 0)
 271         context_free(c);
 272 }
 273
 274 void pa_context_set_state(pa_context *c, pa_context_state_t st) {
 275     pa_assert(c);
 276     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 277
 278     if (c->state == st)
 279         return;
 280
 281     pa_context_ref(c);
 282
 283     c->state = st;
 284
 285     if (c->state_callback)
 286         c->state_callback(c, c->state_userdata);
 287
 288     if (st == PA_CONTEXT_FAILED || st == PA_CONTEXT_TERMINATED)
 289         context_unlink(c);
 290
 291     pa_context_unref(c);
 292 }
 293
 294 int pa_context_set_error(pa_context *c, int error) {
 295     pa_assert(error >= 0);
 296     pa_assert(error < PA_ERR_MAX);
 297
 298     if (c)
 299         c->error = error;
 300
 301     return error;
 302 }
 303
 304 void pa_context_fail(pa_context *c, int error) {
 305     pa_assert(c);
 306     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 307
 308     pa_context_set_error(c, error);
 309     pa_context_set_state(c, PA_CONTEXT_FAILED);
 310 }
 311
 312 static void pstream_die_callback(pa_pstream *p, void *userdata) {
 313     pa_context *c = userdata;
 314
 315     pa_assert(p);
 316     pa_assert(c);
 317
 318     pa_context_fail(c, PA_ERR_CONNECTIONTERMINATED);
 319 }
 320
 321 static void pstream_packet_callback(pa_pstream *p, pa_packet *packet, const pa_creds *creds, void *userdata) {
 322     pa_context *c = userdata;
 323
 324     pa_assert(p);
 325     pa_assert(packet);
 326     pa_assert(c);
 327
 328     pa_context_ref(c);
 329
 330     if (pa_pdispatch_run(c->pdispatch, packet, creds, c) < 0)
 331         pa_context_fail(c, PA_ERR_PROTOCOL);
 332
 333     pa_context_unref(c);
 334 }
 335
 336 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) {
 337     pa_context *c = userdata;
 338     pa_stream *s;
 339
 340     pa_assert(p);
 341     pa_assert(chunk);
 342     pa_assert(chunk->length > 0);
 343     pa_assert(c);
 344     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 345
 346     pa_context_ref(c);
 347
 348     if ((s = pa_dynarray_get(c->record_streams, channel))) {
 349
 350         if (chunk->memblock) {
 351             pa_memblockq_seek(s->record_memblockq, offset, seek);
 352             pa_memblockq_push_align(s->record_memblockq, chunk);
 353         } else
 354             pa_memblockq_seek(s->record_memblockq, offset+chunk->length, seek);
 355
 356         if (s->read_callback) {
 357             size_t l;
 358
 359             if ((l = pa_memblockq_get_length(s->record_memblockq)) > 0)
 360                 s->read_callback(s, l, s->read_userdata);
 361         }
 362     }
 363
 364     pa_context_unref(c);
 365 }
 366
 367 int pa_context_handle_error(pa_context *c, uint32_t command, pa_tagstruct *t, pa_bool_t fail) {
 368     uint32_t err;
 369     pa_assert(c);
 370     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 371
 372     if (command == PA_COMMAND_ERROR) {
 373         pa_assert(t);
 374
 375         if (pa_tagstruct_getu32(t, &err) < 0 ||
 376             !pa_tagstruct_eof(t)) {
 377             pa_context_fail(c, PA_ERR_PROTOCOL);
 378             return -1;
 379         }
 380
 381     } else if (command == PA_COMMAND_TIMEOUT)
 382         err = PA_ERR_TIMEOUT;
 383     else {
 384         pa_context_fail(c, PA_ERR_PROTOCOL);
 385         return -1;
 386     }
 387
 388     if (err == PA_OK) {
 389         pa_context_fail(c, PA_ERR_PROTOCOL);
 390         return -1;
 391     }
 392
 393     if (err >= PA_ERR_MAX)
 394         err = PA_ERR_UNKNOWN;
 395
 396     if (fail) {
 397         pa_context_fail(c, (int) err);
 398         return -1;
 399     }
 400
 401     pa_context_set_error(c, (int) err);
 402
 403     return 0;
 404 }
 405
 406 static void setup_complete_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
 407     pa_context *c = userdata;
 408
 409     pa_assert(pd);
 410     pa_assert(c);
 411     pa_assert(c->state == PA_CONTEXT_AUTHORIZING || c->state == PA_CONTEXT_SETTING_NAME);
 412
 413     pa_context_ref(c);
 414
 415     if (command != PA_COMMAND_REPLY) {
 416         pa_context_handle_error(c, command, t, TRUE);
 417         goto finish;
 418     }
 419
 420     switch(c->state) {
 421         case PA_CONTEXT_AUTHORIZING: {
 422             pa_tagstruct *reply;
 423             pa_bool_t shm_on_remote = FALSE;
 424
 425             if (pa_tagstruct_getu32(t, &c->version) < 0 ||
 426                 !pa_tagstruct_eof(t)) {
 427                 pa_context_fail(c, PA_ERR_PROTOCOL);
 428                 goto finish;
 429             }
 430
 431             /* Minimum supported version */
 432             if (c->version < 8) {
 433                 pa_context_fail(c, PA_ERR_VERSION);
 434                 goto finish;
 435             }
 436
 437             /* Starting with protocol version 13 the MSB of the version
 438                tag reflects if shm is available for this connection or
 439                not. */
 440             if (c->version >= 13) {
 441                 shm_on_remote = !!(c->version & 0x80000000U);
 442                 c->version &= 0x7FFFFFFFU;
 443             }
 444
 445             pa_log_debug("Protocol version: remote %u, local %u", c->version, PA_PROTOCOL_VERSION);
 446
 447             /* Enable shared memory support if possible */
 448             if (c->do_shm)
 449                 if (c->version < 10 || (c->version >= 13 && !shm_on_remote))
 450                     c->do_shm = FALSE;
 451
 452             if (c->do_shm) {
 453
 454                 /* Only enable SHM if both sides are owned by the same
 455                  * user. This is a security measure because otherwise
 456                  * data private to the user might leak. */
 457
 458 #ifdef HAVE_CREDS
 459                 const pa_creds *creds;
 460                 if (!(creds = pa_pdispatch_creds(pd)) || getuid() != creds->uid)
 461                     c->do_shm = FALSE;
 462 #endif
 463             }
 464
 465             pa_log_debug("Negotiated SHM: %s", pa_yes_no(c->do_shm));
 466             pa_pstream_enable_shm(c->pstream, c->do_shm);
 467
 468             reply = pa_tagstruct_command(c, PA_COMMAND_SET_CLIENT_NAME, &tag);
 469
 470             if (c->version >= 13) {
 471                 pa_init_proplist(c->proplist);
 472                 pa_tagstruct_put_proplist(reply, c->proplist);
 473             } else
 474                 pa_tagstruct_puts(reply, pa_proplist_gets(c->proplist, PA_PROP_APPLICATION_NAME));
 475
 476             pa_pstream_send_tagstruct(c->pstream, reply);
 477             pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, setup_complete_callback, c, NULL);
 478
 479             pa_context_set_state(c, PA_CONTEXT_SETTING_NAME);
 480             break;
 481         }
 482
 483         case PA_CONTEXT_SETTING_NAME :
 484
 485             if ((c->version >= 13 && (pa_tagstruct_getu32(t, &c->client_index) < 0 ||
 486                                       c->client_index == PA_INVALID_INDEX)) ||
 487                 !pa_tagstruct_eof(t)) {
 488                 pa_context_fail(c, PA_ERR_PROTOCOL);
 489                 goto finish;
 490             }
 491
 492             pa_context_set_state(c, PA_CONTEXT_READY);
 493             break;
 494
 495         default:
 496             pa_assert_not_reached();
 497     }
 498
 499 finish:
 500     pa_context_unref(c);
 501 }
 502
 503 static void setup_context(pa_context *c, pa_iochannel *io) {
 504     pa_tagstruct *t;
 505     uint32_t tag;
 506
 507     pa_assert(c);
 508     pa_assert(io);
 509
 510     pa_context_ref(c);
 511
 512     pa_assert(!c->pstream);
 513     c->pstream = pa_pstream_new(c->mainloop, io, c->mempool);
 514
 515     pa_pstream_set_die_callback(c->pstream, pstream_die_callback, c);
 516     pa_pstream_set_recieve_packet_callback(c->pstream, pstream_packet_callback, c);
 517     pa_pstream_set_recieve_memblock_callback(c->pstream, pstream_memblock_callback, c);
 518
 519     pa_assert(!c->pdispatch);
 520     c->pdispatch = pa_pdispatch_new(c->mainloop, command_table, PA_COMMAND_MAX);
 521
 522     if (!c->conf->cookie_valid)
 523         pa_log_info(_("No cookie loaded. Attempting to connect without."));
 524
 525     t = pa_tagstruct_command(c, PA_COMMAND_AUTH, &tag);
 526
 527     c->do_shm =
 528         pa_mempool_is_shared(c->mempool) &&
 529         c->is_local;
 530
 531     pa_log_debug("SHM possible: %s", pa_yes_no(c->do_shm));
 532
 533     /* Starting with protocol version 13 we use the MSB of the version
 534      * tag for informing the other side if we could do SHM or not */
 535     pa_tagstruct_putu32(t, PA_PROTOCOL_VERSION | (c->do_shm ? 0x80000000U : 0));
 536     pa_tagstruct_put_arbitrary(t, c->conf->cookie, sizeof(c->conf->cookie));
 537
 538 #ifdef HAVE_CREDS
 539 {
 540     pa_creds ucred;
 541
 542     if (pa_iochannel_creds_supported(io))
 543         pa_iochannel_creds_enable(io);
 544
 545     ucred.uid = getuid();
 546     ucred.gid = getgid();
 547
 548     pa_pstream_send_tagstruct_with_creds(c->pstream, t, &ucred);
 549 }
 550 #else
 551     pa_pstream_send_tagstruct(c->pstream, t);
 552 #endif
 553
 554     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, setup_complete_callback, c, NULL);
 555
 556     pa_context_set_state(c, PA_CONTEXT_AUTHORIZING);
 557
 558     pa_context_unref(c);
 559 }
 560
 561 #ifdef ENABLE_LEGACY_RUNTIME_DIR
 562 static char *get_old_legacy_runtime_dir(void) {
 563     char *p, u[128];
 564     struct stat st;
 565
 566     if (!pa_get_user_name(u, sizeof(u)))
 567         return NULL;
 568
 569     p = pa_sprintf_malloc("/tmp/pulse-%s", u);
 570
 571     if (stat(p, &st) < 0) {
 572         pa_xfree(p);
 573         return NULL;
 574     }
 575
 576     if (st.st_uid != getuid()) {
 577         pa_xfree(p);
 578         return NULL;
 579     }
 580
 581     return p;
 582 }
 583
 584 static char *get_very_old_legacy_runtime_dir(void) {
 585     char *p, h[128];
 586     struct stat st;
 587
 588     if (!pa_get_home_dir(h, sizeof(h)))
 589         return NULL;
 590
 591     p = pa_sprintf_malloc("%s/.pulse", h);
 592
 593     if (stat(p, &st) < 0) {
 594         pa_xfree(p);
 595         return NULL;
 596     }
 597
 598     if (st.st_uid != getuid()) {
 599         pa_xfree(p);
 600         return NULL;
 601     }
 602
 603     return p;
 604 }
 605 #endif
 606
 607 static pa_strlist *prepend_per_user(pa_strlist *l) {
 608     char *ufn;
 609
 610 #ifdef ENABLE_LEGACY_RUNTIME_DIR
 611     static char *legacy_dir;
 612
 613     /* The very old per-user instance path (< 0.9.11). This is supported only to ease upgrades */
 614     if ((legacy_dir = get_very_old_legacy_runtime_dir())) {
 615         char *p = pa_sprintf_malloc("%s" PA_PATH_SEP PA_NATIVE_DEFAULT_UNIX_SOCKET, legacy_dir);
 616         l = pa_strlist_prepend(l, p);
 617         pa_xfree(p);
 618         pa_xfree(legacy_dir);
 619     }
 620
 621     /* The old per-user instance path (< 0.9.12). This is supported only to ease upgrades */
 622     if ((legacy_dir = get_old_legacy_runtime_dir())) {
 623         char *p = pa_sprintf_malloc("%s" PA_PATH_SEP PA_NATIVE_DEFAULT_UNIX_SOCKET, legacy_dir);
 624         l = pa_strlist_prepend(l, p);
 625         pa_xfree(p);
 626         pa_xfree(legacy_dir);
 627     }
 628 #endif
 629
 630     /* The per-user instance */
 631     if ((ufn = pa_runtime_path(PA_NATIVE_DEFAULT_UNIX_SOCKET))) {
 632         l = pa_strlist_prepend(l, ufn);
 633         pa_xfree(ufn);
 634     }
 635
 636     return l;
 637 }
 638
 639 #ifndef OS_IS_WIN32
 640
 641 static int context_autospawn(pa_context *c) {
 642     pid_t pid;
 643     int status, r;
 644
 645     pa_log_debug("Trying to autospawn...");
 646
 647     pa_context_ref(c);
 648
 649     if (c->spawn_api.prefork)
 650         c->spawn_api.prefork();
 651
 652     if ((pid = fork()) < 0) {
 653         pa_log_error(_("fork(): %s"), pa_cstrerror(errno));
 654         pa_context_fail(c, PA_ERR_INTERNAL);
 655
 656         if (c->spawn_api.postfork)
 657             c->spawn_api.postfork();
 658
 659         goto fail;
 660     } else if (!pid) {
 661         /* Child */
 662
 663         const char *state = NULL;
 664 #define MAX_ARGS 64
 665         const char * argv[MAX_ARGS+1];
 666         int n;
 667
 668         if (c->spawn_api.atfork)
 669             c->spawn_api.atfork();
 670
 671         pa_close_all(-1);
 672
 673         /* Setup argv */
 674
 675         n = 0;
 676
 677         argv[n++] = c->conf->daemon_binary;
 678         argv[n++] = "--start";
 679
 680         while (n < MAX_ARGS) {
 681             char *a;
 682
 683             if (!(a = pa_split_spaces(c->conf->extra_arguments, &state)))
 684                 break;
 685
 686             argv[n++] = a;
 687         }
 688
 689         argv[n++] = NULL;
 690
 691         execv(argv[0], (char * const *) argv);
 692         _exit(1);
 693 #undef MAX_ARGS
 694     }
 695
 696     /* Parent */
 697
 698     if (c->spawn_api.postfork)
 699         c->spawn_api.postfork();
 700
 701     do {
 702         r = waitpid(pid, &status, 0);
 703     } while (r < 0 && errno == EINTR);
 704
 705     if (r < 0) {
 706         pa_log(_("waitpid(): %s"), pa_cstrerror(errno));
 707         pa_context_fail(c, PA_ERR_INTERNAL);
 708         goto fail;
 709     } else if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
 710         pa_context_fail(c, PA_ERR_CONNECTIONREFUSED);
 711         goto fail;
 712     }
 713
 714     pa_context_unref(c);
 715
 716     return 0;
 717
 718 fail:
 719
 720     pa_context_unref(c);
 721
 722     return -1;
 723 }
 724
 725 #endif /* OS_IS_WIN32 */
 726
 727 static void on_connection(pa_socket_client *client, pa_iochannel*io, void *userdata);
 728
 729 static int try_next_connection(pa_context *c) {
 730     char *u = NULL;
 731     int r = -1;
 732
 733     pa_assert(c);
 734     pa_assert(!c->client);
 735
 736     for (;;) {
 737         pa_xfree(u);
 738         u = NULL;
 739
 740         c->server_list = pa_strlist_pop(c->server_list, &u);
 741
 742         if (!u) {
 743
 744 #ifndef OS_IS_WIN32
 745             if (c->do_autospawn) {
 746
 747                 if ((r = context_autospawn(c)) < 0)
 748                     goto finish;
 749
 750                 /* Autospawn only once */
 751                 c->do_autospawn = FALSE;
 752
 753                 /* Connect only to per-user sockets this time */
 754                 c->server_list = prepend_per_user(c->server_list);
 755
 756                 /* Retry connection */
 757                 continue;
 758             }
 759 #endif
 760
 761             pa_context_fail(c, PA_ERR_CONNECTIONREFUSED);
 762             goto finish;
 763         }
 764
 765         pa_log_debug("Trying to connect to %s...", u);
 766
 767         pa_xfree(c->server);
 768         c->server = pa_xstrdup(u);
 769
 770         if (!(c->client = pa_socket_client_new_string(c->mainloop, u, PA_NATIVE_DEFAULT_PORT)))
 771             continue;
 772
 773         c->is_local = !!pa_socket_client_is_local(c->client);
 774         pa_socket_client_set_callback(c->client, on_connection, c);
 775         break;
 776     }
 777
 778     r = 0;
 779
 780 finish:
 781     pa_xfree(u);
 782
 783     return r;
 784 }
 785
 786 static void on_connection(pa_socket_client *client, pa_iochannel*io, void *userdata) {
 787     pa_context *c = userdata;
 788     int saved_errno = errno;
 789
 790     pa_assert(client);
 791     pa_assert(c);
 792     pa_assert(c->state == PA_CONTEXT_CONNECTING);
 793
 794     pa_context_ref(c);
 795
 796     pa_socket_client_unref(client);
 797     c->client = NULL;
 798
 799     if (!io) {
 800         /* Try the item in the list */
 801         if (saved_errno == ECONNREFUSED ||
 802             saved_errno == ETIMEDOUT ||
 803             saved_errno == EHOSTUNREACH) {
 804             try_next_connection(c);
 805             goto finish;
 806         }
 807
 808         pa_context_fail(c, PA_ERR_CONNECTIONREFUSED);
 809         goto finish;
 810     }
 811
 812     setup_context(c, io);
 813
 814 finish:
 815     pa_context_unref(c);
 816 }
 817
 818 int pa_context_connect(
 819         pa_context *c,
 820         const char *server,
 821         pa_context_flags_t flags,
 822         const pa_spawn_api *api) {
 823
 824     int r = -1;
 825
 826     pa_assert(c);
 827     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 828
 829     PA_CHECK_VALIDITY(c, !pa_detect_fork(), PA_ERR_FORKED);
 830     PA_CHECK_VALIDITY(c, c->state == PA_CONTEXT_UNCONNECTED, PA_ERR_BADSTATE);
 831     PA_CHECK_VALIDITY(c, !(flags & ~PA_CONTEXT_NOAUTOSPAWN), PA_ERR_INVALID);
 832     PA_CHECK_VALIDITY(c, !server || *server, PA_ERR_INVALID);
 833
 834     if (!server)
 835         server = c->conf->default_server;
 836
 837     pa_context_ref(c);
 838
 839     pa_assert(!c->server_list);
 840
 841     if (server) {
 842         if (!(c->server_list = pa_strlist_parse(server))) {
 843             pa_context_fail(c, PA_ERR_INVALIDSERVER);
 844             goto finish;
 845         }
 846
 847     } else {
 848         char *d;
 849
 850         /* Prepend in reverse order */
 851
 852         /* Follow the X display */
 853         if ((d = getenv("DISPLAY"))) {
 854             char *e;
 855             d = pa_xstrdup(d);
 856             if ((e = strchr(d, ':')))
 857                 *e = 0;
 858
 859             if (*d)
 860                 c->server_list = pa_strlist_prepend(c->server_list, d);
 861
 862             pa_xfree(d);
 863         }
 864
 865         /* Add TCP/IP on the localhost */
 866         c->server_list = pa_strlist_prepend(c->server_list, "tcp6:[::1]");
 867         c->server_list = pa_strlist_prepend(c->server_list, "tcp4:127.0.0.1");
 868
 869         /* The system wide instance via PF_LOCAL */
 870         c->server_list = pa_strlist_prepend(c->server_list, PA_SYSTEM_RUNTIME_PATH PA_PATH_SEP PA_NATIVE_DEFAULT_UNIX_SOCKET);
 871
 872         /* The user instance via PF_LOCAL */
 873         c->server_list = prepend_per_user(c->server_list);
 874
 875         /* Set up autospawning */
 876         if (!(flags & PA_CONTEXT_NOAUTOSPAWN) && c->conf->autospawn) {
 877
 878             if (getuid() == 0)
 879                 pa_log_debug("Not doing autospawn since we are root.");
 880             else {
 881                 c->do_autospawn = TRUE;
 882
 883                 if (api)
 884                     c->spawn_api = *api;
 885             }
 886         }
 887     }
 888
 889     pa_context_set_state(c, PA_CONTEXT_CONNECTING);
 890     r = try_next_connection(c);
 891
 892 finish:
 893     pa_context_unref(c);
 894
 895     return r;
 896 }
 897
 898 void pa_context_disconnect(pa_context *c) {
 899     pa_assert(c);
 900     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 901
 902     if (pa_detect_fork())
 903         return;
 904
 905     if (PA_CONTEXT_IS_GOOD(c->state))
 906         pa_context_set_state(c, PA_CONTEXT_TERMINATED);
 907 }
 908
 909 pa_context_state_t pa_context_get_state(pa_context *c) {
 910     pa_assert(c);
 911     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 912
 913     return c->state;
 914 }
 915
 916 int pa_context_errno(pa_context *c) {
 917     pa_assert(c);
 918     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 919
 920     return c->error;
 921 }
 922
 923 void pa_context_set_state_callback(pa_context *c, pa_context_notify_cb_t cb, void *userdata) {
 924     pa_assert(c);
 925     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 926
 927     if (pa_detect_fork())
 928         return;
 929
 930     if (c->state == PA_CONTEXT_TERMINATED || c->state == PA_CONTEXT_FAILED)
 931         return;
 932
 933     c->state_callback = cb;
 934     c->state_userdata = userdata;
 935 }
 936
 937 void pa_context_set_event_callback(pa_context *c, pa_context_event_cb_t cb, void *userdata) {
 938     pa_assert(c);
 939     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 940
 941     if (pa_detect_fork())
 942         return;
 943
 944     if (c->state == PA_CONTEXT_TERMINATED || c->state == PA_CONTEXT_FAILED)
 945         return;
 946
 947     c->event_callback = cb;
 948     c->event_userdata = userdata;
 949 }
 950
 951 int pa_context_is_pending(pa_context *c) {
 952     pa_assert(c);
 953     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 954
 955     PA_CHECK_VALIDITY(c, !pa_detect_fork(), PA_ERR_FORKED);
 956     PA_CHECK_VALIDITY(c, PA_CONTEXT_IS_GOOD(c->state), PA_ERR_BADSTATE);
 957
 958     return (c->pstream && pa_pstream_is_pending(c->pstream)) ||
 959         (c->pdispatch && pa_pdispatch_is_pending(c->pdispatch)) ||
 960         c->client;
 961 }
 962
 963 static void set_dispatch_callbacks(pa_operation *o);
 964
 965 static void pdispatch_drain_callback(pa_pdispatch*pd, void *userdata) {
 966     set_dispatch_callbacks(userdata);
 967 }
 968
 969 static void pstream_drain_callback(pa_pstream *s, void *userdata) {
 970     set_dispatch_callbacks(userdata);
 971 }
 972
 973 static void set_dispatch_callbacks(pa_operation *o) {
 974     int done = 1;
 975
 976     pa_assert(o);
 977     pa_assert(PA_REFCNT_VALUE(o) >= 1);
 978     pa_assert(o->context);
 979     pa_assert(PA_REFCNT_VALUE(o->context) >= 1);
 980     pa_assert(o->context->state == PA_CONTEXT_READY);
 981
 982     pa_pstream_set_drain_callback(o->context->pstream, NULL, NULL);
 983     pa_pdispatch_set_drain_callback(o->context->pdispatch, NULL, NULL);
 984
 985     if (pa_pdispatch_is_pending(o->context->pdispatch)) {
 986         pa_pdispatch_set_drain_callback(o->context->pdispatch, pdispatch_drain_callback, o);
 987         done = 0;
 988     }
 989
 990     if (pa_pstream_is_pending(o->context->pstream)) {
 991         pa_pstream_set_drain_callback(o->context->pstream, pstream_drain_callback, o);
 992         done = 0;
 993     }
 994
 995     if (done) {
 996         if (o->callback) {
 997             pa_context_notify_cb_t cb = (pa_context_notify_cb_t) o->callback;
 998             cb(o->context, o->userdata);
 999         }
1000
1001         pa_operation_done(o);
1002         pa_operation_unref(o);
1003     }
1004 }
1005
1006 pa_operation* pa_context_drain(pa_context *c, pa_context_notify_cb_t cb, void *userdata) {
1007     pa_operation *o;
1008
1009     pa_assert(c);
1010     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1011
1012     PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1013     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1014     PA_CHECK_VALIDITY_RETURN_NULL(c, pa_context_is_pending(c), PA_ERR_BADSTATE);
1015
1016     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1017     set_dispatch_callbacks(pa_operation_ref(o));
1018
1019     return o;
1020 }
1021
1022 void pa_context_simple_ack_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
1023     pa_operation *o = userdata;
1024     int success = 1;
1025
1026     pa_assert(pd);
1027     pa_assert(o);
1028     pa_assert(PA_REFCNT_VALUE(o) >= 1);
1029
1030     if (!o->context)
1031         goto finish;
1032
1033     if (command != PA_COMMAND_REPLY) {
1034         if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
1035             goto finish;
1036
1037         success = 0;
1038     } else if (!pa_tagstruct_eof(t)) {
1039         pa_context_fail(o->context, PA_ERR_PROTOCOL);
1040         goto finish;
1041     }
1042
1043     if (o->callback) {
1044         pa_context_success_cb_t cb = (pa_context_success_cb_t) o->callback;
1045         cb(o->context, success, o->userdata);
1046     }
1047
1048 finish:
1049     pa_operation_done(o);
1050     pa_operation_unref(o);
1051 }
1052
1053 pa_operation* pa_context_send_simple_command(pa_context *c, uint32_t command, pa_pdispatch_cb_t internal_cb, pa_operation_cb_t cb, void *userdata) {
1054     pa_tagstruct *t;
1055     pa_operation *o;
1056     uint32_t tag;
1057
1058     pa_assert(c);
1059     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1060
1061     PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1062     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1063
1064     o = pa_operation_new(c, NULL, cb, userdata);
1065
1066     t = pa_tagstruct_command(c, command, &tag);
1067     pa_pstream_send_tagstruct(c->pstream, t);
1068     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, internal_cb, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1069
1070     return o;
1071 }
1072
1073 pa_operation* pa_context_exit_daemon(pa_context *c, pa_context_success_cb_t cb, void *userdata) {
1074     pa_assert(c);
1075     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1076
1077     return pa_context_send_simple_command(c, PA_COMMAND_EXIT, pa_context_simple_ack_callback, (pa_operation_cb_t) cb, userdata);
1078 }
1079
1080 pa_operation* pa_context_set_default_sink(pa_context *c, const char *name, pa_context_success_cb_t cb, void *userdata) {
1081     pa_tagstruct *t;
1082     pa_operation *o;
1083     uint32_t tag;
1084
1085     pa_assert(c);
1086     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1087
1088     PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1089     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1090
1091     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1092     t = pa_tagstruct_command(c, PA_COMMAND_SET_DEFAULT_SINK, &tag);
1093     pa_tagstruct_puts(t, name);
1094     pa_pstream_send_tagstruct(c->pstream, t);
1095     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT,  pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1096
1097     return o;
1098 }
1099
1100 pa_operation* pa_context_set_default_source(pa_context *c, const char *name, pa_context_success_cb_t cb, void *userdata) {
1101     pa_tagstruct *t;
1102     pa_operation *o;
1103     uint32_t tag;
1104
1105     pa_assert(c);
1106     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1107
1108     PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1109     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1110
1111     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1112     t = pa_tagstruct_command(c, PA_COMMAND_SET_DEFAULT_SOURCE, &tag);
1113     pa_tagstruct_puts(t, name);
1114     pa_pstream_send_tagstruct(c->pstream, t);
1115     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT,  pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1116
1117     return o;
1118 }
1119
1120 int pa_context_is_local(pa_context *c) {
1121     pa_assert(c);
1122     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1123
1124     PA_CHECK_VALIDITY_RETURN_ANY(c, !pa_detect_fork(), PA_ERR_FORKED, -1);
1125     PA_CHECK_VALIDITY_RETURN_ANY(c, PA_CONTEXT_IS_GOOD(c->state), PA_ERR_BADSTATE, -1);
1126
1127     return !!c->is_local;
1128 }
1129
1130 pa_operation* pa_context_set_name(pa_context *c, const char *name, pa_context_success_cb_t cb, void *userdata) {
1131     pa_operation *o;
1132
1133     pa_assert(c);
1134     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1135     pa_assert(name);
1136
1137     PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1138     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1139
1140     if (c->version >= 13) {
1141         pa_proplist *p = pa_proplist_new();
1142
1143         pa_proplist_sets(p, PA_PROP_APPLICATION_NAME, name);
1144         o = pa_context_proplist_update(c, PA_UPDATE_REPLACE, p, cb, userdata);
1145         pa_proplist_free(p);
1146     } else {
1147         pa_tagstruct *t;
1148         uint32_t tag;
1149
1150         o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1151         t = pa_tagstruct_command(c, PA_COMMAND_SET_CLIENT_NAME, &tag);
1152         pa_tagstruct_puts(t, name);
1153         pa_pstream_send_tagstruct(c->pstream, t);
1154         pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT,  pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1155     }
1156
1157     return o;
1158 }
1159
1160 const char* pa_get_library_version(void) {
1161     return PACKAGE_VERSION;
1162 }
1163
1164 const char* pa_context_get_server(pa_context *c) {
1165     pa_assert(c);
1166     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1167
1168     PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1169     PA_CHECK_VALIDITY_RETURN_NULL(c, c->server, PA_ERR_NOENTITY);
1170
1171     if (*c->server == '{') {
1172         char *e = strchr(c->server+1, '}');
1173         return e ? e+1 : c->server;
1174     }
1175
1176     return c->server;
1177 }
1178
1179 uint32_t pa_context_get_protocol_version(pa_context *c) {
1180     return PA_PROTOCOL_VERSION;
1181 }
1182
1183 uint32_t pa_context_get_server_protocol_version(pa_context *c) {
1184     pa_assert(c);
1185     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1186
1187     PA_CHECK_VALIDITY_RETURN_ANY(c, !pa_detect_fork(), PA_ERR_FORKED, PA_INVALID_INDEX);
1188     PA_CHECK_VALIDITY_RETURN_ANY(c, PA_CONTEXT_IS_GOOD(c->state), PA_ERR_BADSTATE, PA_INVALID_INDEX);
1189
1190     return c->version;
1191 }
1192
1193 pa_tagstruct *pa_tagstruct_command(pa_context *c, uint32_t command, uint32_t *tag) {
1194     pa_tagstruct *t;
1195
1196     pa_assert(c);
1197     pa_assert(tag);
1198
1199     t = pa_tagstruct_new(NULL, 0);
1200     pa_tagstruct_putu32(t, command);
1201     pa_tagstruct_putu32(t, *tag = c->ctag++);
1202
1203     return t;
1204 }
1205
1206 uint32_t pa_context_get_index(pa_context *c) {
1207     pa_assert(c);
1208     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1209
1210     PA_CHECK_VALIDITY_RETURN_ANY(c, !pa_detect_fork(), PA_ERR_FORKED, PA_INVALID_INDEX);
1211     PA_CHECK_VALIDITY_RETURN_ANY(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE, PA_INVALID_INDEX);
1212     PA_CHECK_VALIDITY_RETURN_ANY(c, c->version >= 13, PA_ERR_NOTSUPPORTED, PA_INVALID_INDEX);
1213
1214     return c->client_index;
1215 }
1216
1217 pa_operation *pa_context_proplist_update(pa_context *c, pa_update_mode_t mode, pa_proplist *p, pa_context_success_cb_t cb, void *userdata) {
1218     pa_operation *o;
1219     pa_tagstruct *t;
1220     uint32_t tag;
1221
1222     pa_assert(c);
1223     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1224
1225     PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1226     PA_CHECK_VALIDITY_RETURN_NULL(c, mode == PA_UPDATE_SET || mode == PA_UPDATE_MERGE || mode == PA_UPDATE_REPLACE, PA_ERR_INVALID);
1227     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1228     PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 13, PA_ERR_NOTSUPPORTED);
1229
1230     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1231
1232     t = pa_tagstruct_command(c, PA_COMMAND_UPDATE_CLIENT_PROPLIST, &tag);
1233     pa_tagstruct_putu32(t, (uint32_t) mode);
1234     pa_tagstruct_put_proplist(t, p);
1235
1236     pa_pstream_send_tagstruct(c->pstream, t);
1237     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1238
1239     /* Please note that we don't update c->proplist here, because we
1240      * don't export that field */
1241
1242     return o;
1243 }
1244
1245 pa_operation *pa_context_proplist_remove(pa_context *c, const char *const keys[], pa_context_success_cb_t cb, void *userdata) {
1246     pa_operation *o;
1247     pa_tagstruct *t;
1248     uint32_t tag;
1249     const char * const *k;
1250
1251     pa_assert(c);
1252     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1253
1254     PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1255     PA_CHECK_VALIDITY_RETURN_NULL(c, keys && keys[0], PA_ERR_INVALID);
1256     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1257     PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 13, PA_ERR_NOTSUPPORTED);
1258
1259     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1260
1261     t = pa_tagstruct_command(c, PA_COMMAND_REMOVE_CLIENT_PROPLIST, &tag);
1262
1263     for (k = keys; *k; k++)
1264         pa_tagstruct_puts(t, *k);
1265
1266     pa_tagstruct_puts(t, NULL);
1267
1268     pa_pstream_send_tagstruct(c->pstream, t);
1269     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1270
1271     /* Please note that we don't update c->proplist here, because we
1272      * don't export that field */
1273
1274     return o;
1275 }
1276
1277 void pa_command_extension(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
1278     pa_context *c = userdata;
1279     uint32_t idx;
1280     const char *name;
1281
1282     pa_assert(pd);
1283     pa_assert(command == PA_COMMAND_EXTENSION);
1284     pa_assert(t);
1285     pa_assert(c);
1286     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1287
1288     pa_context_ref(c);
1289
1290     if (c->version < 15) {
1291         pa_context_fail(c, PA_ERR_PROTOCOL);
1292         goto finish;
1293     }
1294
1295     if (pa_tagstruct_getu32(t, &idx) < 0 ||
1296         pa_tagstruct_gets(t, &name) < 0) {
1297         pa_context_fail(c, PA_ERR_PROTOCOL);
1298         goto finish;
1299     }
1300
1301     if (!strcmp(name, "module-stream-restore"))
1302         pa_ext_stream_restore_command(c, tag, t);
1303     else
1304         pa_log(_("Received message for unknown extension '%s'"), name);
1305
1306 finish:
1307     pa_context_unref(c);
1308 }
1309
1310
1311 void pa_command_client_event(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
1312     pa_context *c = userdata;
1313     pa_proplist *pl = NULL;
1314     const char *event;
1315
1316     pa_assert(pd);
1317     pa_assert(command == PA_COMMAND_CLIENT_EVENT);
1318     pa_assert(t);
1319     pa_assert(c);
1320     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1321
1322     pa_context_ref(c);
1323
1324     if (c->version < 15) {
1325         pa_context_fail(c, PA_ERR_PROTOCOL);
1326         goto finish;
1327     }
1328
1329     pl = pa_proplist_new();
1330
1331     if (pa_tagstruct_gets(t, &event) < 0 ||
1332         pa_tagstruct_get_proplist(t, pl) < 0 ||
1333         !pa_tagstruct_eof(t) || !event) {
1334         pa_context_fail(c, PA_ERR_PROTOCOL);
1335         goto finish;
1336     }
1337
1338     if (c->event_callback)
1339         c->event_callback(c, event, pl, c->event_userdata);
1340
1341 finish:
1342     pa_context_unref(c);
1343
1344     if (pl)
1345         pa_proplist_free(pl);
1346 }