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