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