code.delx.au - pulseaudio/blob - src/pulsecore/protocol-native.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2004-2006 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 <string.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <unistd.h>
  31
  32 #include <pulse/rtclock.h>
  33 #include <pulse/timeval.h>
  34 #include <pulse/version.h>
  35 #include <pulse/utf8.h>
  36 #include <pulse/util.h>
  37 #include <pulse/xmalloc.h>
  38 #include <pulse/internal.h>
  39
  40 #include <pulsecore/native-common.h>
  41 #include <pulsecore/packet.h>
  42 #include <pulsecore/client.h>
  43 #include <pulsecore/source-output.h>
  44 #include <pulsecore/sink-input.h>
  45 #include <pulsecore/pstream.h>
  46 #include <pulsecore/tagstruct.h>
  47 #include <pulsecore/pdispatch.h>
  48 #include <pulsecore/pstream-util.h>
  49 #include <pulsecore/namereg.h>
  50 #include <pulsecore/core-scache.h>
  51 #include <pulsecore/core-subscribe.h>
  52 #include <pulsecore/log.h>
  53 #include <pulsecore/strlist.h>
  54 #include <pulsecore/shared.h>
  55 #include <pulsecore/sample-util.h>
  56 #include <pulsecore/creds.h>
  57 #include <pulsecore/core-util.h>
  58 #include <pulsecore/ipacl.h>
  59 #include <pulsecore/thread-mq.h>
  60
  61 #include "protocol-native.h"
  62
  63 /* #define PROTOCOL_NATIVE_DEBUG */
  64
  65 /* Kick a client if it doesn't authenticate within this time */
  66 #define AUTH_TIMEOUT (60 * PA_USEC_PER_SEC)
  67
  68 /* Don't accept more connection than this */
  69 #define MAX_CONNECTIONS 64
  70
  71 #define MAX_MEMBLOCKQ_LENGTH (4*1024*1024) /* 4MB */
  72 #define DEFAULT_TLENGTH_MSEC 2000 /* 2s */
  73 #define DEFAULT_PROCESS_MSEC 20   /* 20ms */
  74 #define DEFAULT_FRAGSIZE_MSEC DEFAULT_TLENGTH_MSEC
  75
  76 struct pa_native_protocol;
  77
  78 typedef struct record_stream {
  79     pa_msgobject parent;
  80
  81     pa_native_connection *connection;
  82     uint32_t index;
  83
  84     pa_source_output *source_output;
  85     pa_memblockq *memblockq;
  86
  87     pa_bool_t adjust_latency:1;
  88     pa_bool_t early_requests:1;
  89
  90     /* Requested buffer attributes */
  91     pa_buffer_attr buffer_attr_req;
  92     /* Fixed-up and adjusted buffer attributes */
  93     pa_buffer_attr buffer_attr;
  94
  95     pa_atomic_t on_the_fly;
  96     pa_usec_t configured_source_latency;
  97     size_t drop_initial;
  98
  99     /* Only updated after SOURCE_OUTPUT_MESSAGE_UPDATE_LATENCY */
 100     size_t on_the_fly_snapshot;
 101     pa_usec_t current_monitor_latency;
 102     pa_usec_t current_source_latency;
 103 } record_stream;
 104
 105 #define RECORD_STREAM(o) (record_stream_cast(o))
 106 PA_DEFINE_PRIVATE_CLASS(record_stream, pa_msgobject);
 107
 108 typedef struct output_stream {
 109     pa_msgobject parent;
 110 } output_stream;
 111
 112 #define OUTPUT_STREAM(o) (output_stream_cast(o))
 113 PA_DEFINE_PRIVATE_CLASS(output_stream, pa_msgobject);
 114
 115 typedef struct playback_stream {
 116     output_stream parent;
 117
 118     pa_native_connection *connection;
 119     uint32_t index;
 120
 121     pa_sink_input *sink_input;
 122     pa_memblockq *memblockq;
 123
 124     pa_bool_t adjust_latency:1;
 125     pa_bool_t early_requests:1;
 126
 127     pa_bool_t is_underrun:1;
 128     pa_bool_t drain_request:1;
 129     uint32_t drain_tag;
 130     uint32_t syncid;
 131
 132     /* Optimization to avoid too many rewinds with a lot of small blocks */
 133     pa_atomic_t seek_or_post_in_queue;
 134     int64_t seek_windex;
 135
 136     pa_atomic_t missing;
 137     pa_usec_t configured_sink_latency;
 138     /* Requested buffer attributes */
 139     pa_buffer_attr buffer_attr_req;
 140     /* Fixed-up and adjusted buffer attributes */
 141     pa_buffer_attr buffer_attr;
 142
 143     /* Only updated after SINK_INPUT_MESSAGE_UPDATE_LATENCY */
 144     int64_t read_index, write_index;
 145     size_t render_memblockq_length;
 146     pa_usec_t current_sink_latency;
 147     uint64_t playing_for, underrun_for;
 148 } playback_stream;
 149
 150 #define PLAYBACK_STREAM(o) (playback_stream_cast(o))
 151 PA_DEFINE_PRIVATE_CLASS(playback_stream, output_stream);
 152
 153 typedef struct upload_stream {
 154     output_stream parent;
 155
 156     pa_native_connection *connection;
 157     uint32_t index;
 158
 159     pa_memchunk memchunk;
 160     size_t length;
 161     char *name;
 162     pa_sample_spec sample_spec;
 163     pa_channel_map channel_map;
 164     pa_proplist *proplist;
 165 } upload_stream;
 166
 167 #define UPLOAD_STREAM(o) (upload_stream_cast(o))
 168 PA_DEFINE_PRIVATE_CLASS(upload_stream, output_stream);
 169
 170 struct pa_native_connection {
 171     pa_msgobject parent;
 172     pa_native_protocol *protocol;
 173     pa_native_options *options;
 174     pa_bool_t authorized:1;
 175     pa_bool_t is_local:1;
 176     uint32_t version;
 177     pa_client *client;
 178     pa_pstream *pstream;
 179     pa_pdispatch *pdispatch;
 180     pa_idxset *record_streams, *output_streams;
 181     uint32_t rrobin_index;
 182     pa_subscription *subscription;
 183     pa_time_event *auth_timeout_event;
 184 };
 185
 186 #define PA_NATIVE_CONNECTION(o) (pa_native_connection_cast(o))
 187 PA_DEFINE_PRIVATE_CLASS(pa_native_connection, pa_msgobject);
 188
 189 struct pa_native_protocol {
 190     PA_REFCNT_DECLARE;
 191
 192     pa_core *core;
 193     pa_idxset *connections;
 194
 195     pa_strlist *servers;
 196     pa_hook hooks[PA_NATIVE_HOOK_MAX];
 197
 198     pa_hashmap *extensions;
 199 };
 200
 201 enum {
 202     SOURCE_OUTPUT_MESSAGE_UPDATE_LATENCY = PA_SOURCE_OUTPUT_MESSAGE_MAX
 203 };
 204
 205 enum {
 206     SINK_INPUT_MESSAGE_POST_DATA = PA_SINK_INPUT_MESSAGE_MAX, /* data from main loop to sink input */
 207     SINK_INPUT_MESSAGE_DRAIN, /* disabled prebuf, get playback started. */
 208     SINK_INPUT_MESSAGE_FLUSH,
 209     SINK_INPUT_MESSAGE_TRIGGER,
 210     SINK_INPUT_MESSAGE_SEEK,
 211     SINK_INPUT_MESSAGE_PREBUF_FORCE,
 212     SINK_INPUT_MESSAGE_UPDATE_LATENCY,
 213     SINK_INPUT_MESSAGE_UPDATE_BUFFER_ATTR
 214 };
 215
 216 enum {
 217     PLAYBACK_STREAM_MESSAGE_REQUEST_DATA,      /* data requested from sink input from the main loop */
 218     PLAYBACK_STREAM_MESSAGE_UNDERFLOW,
 219     PLAYBACK_STREAM_MESSAGE_OVERFLOW,
 220     PLAYBACK_STREAM_MESSAGE_DRAIN_ACK,
 221     PLAYBACK_STREAM_MESSAGE_STARTED,
 222     PLAYBACK_STREAM_MESSAGE_UPDATE_TLENGTH
 223 };
 224
 225 enum {
 226     RECORD_STREAM_MESSAGE_POST_DATA         /* data from source output to main loop */
 227 };
 228
 229 enum {
 230     CONNECTION_MESSAGE_RELEASE,
 231     CONNECTION_MESSAGE_REVOKE
 232 };
 233
 234 static int sink_input_pop_cb(pa_sink_input *i, size_t length, pa_memchunk *chunk);
 235 static void sink_input_kill_cb(pa_sink_input *i);
 236 static void sink_input_suspend_cb(pa_sink_input *i, pa_bool_t suspend);
 237 static void sink_input_moving_cb(pa_sink_input *i, pa_sink *dest);
 238 static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes);
 239 static void sink_input_update_max_rewind_cb(pa_sink_input *i, size_t nbytes);
 240 static void sink_input_update_max_request_cb(pa_sink_input *i, size_t nbytes);
 241 static void sink_input_send_event_cb(pa_sink_input *i, const char *event, pa_proplist *pl);
 242
 243 static void native_connection_send_memblock(pa_native_connection *c);
 244 static void playback_stream_request_bytes(struct playback_stream*s);
 245
 246 static void source_output_kill_cb(pa_source_output *o);
 247 static void source_output_push_cb(pa_source_output *o, const pa_memchunk *chunk);
 248 static void source_output_suspend_cb(pa_source_output *o, pa_bool_t suspend);
 249 static void source_output_moving_cb(pa_source_output *o, pa_source *dest);
 250 static pa_usec_t source_output_get_latency_cb(pa_source_output *o);
 251 static void source_output_send_event_cb(pa_source_output *o, const char *event, pa_proplist *pl);
 252
 253 static int sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk);
 254 static int source_output_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk);
 255
 256 static void command_exit(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 257 static void command_create_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 258 static void command_drain_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 259 static void command_create_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 260 static void command_delete_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 261 static void command_auth(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 262 static void command_set_client_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 263 static void command_lookup(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 264 static void command_stat(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 265 static void command_get_playback_latency(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 266 static void command_get_record_latency(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 267 static void command_create_upload_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 268 static void command_finish_upload_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 269 static void command_play_sample(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 270 static void command_remove_sample(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 271 static void command_get_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 272 static void command_get_info_list(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 273 static void command_get_server_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 274 static void command_subscribe(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 275 static void command_set_volume(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 276 static void command_set_mute(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 277 static void command_cork_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 278 static void command_trigger_or_flush_or_prebuf_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 279 static void command_set_default_sink_or_source(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 280 static void command_set_stream_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 281 static void command_kill(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 282 static void command_load_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 283 static void command_unload_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 284 static void command_cork_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 285 static void command_flush_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 286 static void command_move_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 287 static void command_suspend(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 288 static void command_set_stream_buffer_attr(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 289 static void command_update_stream_sample_rate(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 290 static void command_update_proplist(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 291 static void command_remove_proplist(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 292 static void command_extension(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 293 static void command_set_card_profile(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 294 static void command_set_sink_or_source_port(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
 295
 296 static const pa_pdispatch_cb_t command_table[PA_COMMAND_MAX] = {
 297     [PA_COMMAND_ERROR] = NULL,
 298     [PA_COMMAND_TIMEOUT] = NULL,
 299     [PA_COMMAND_REPLY] = NULL,
 300     [PA_COMMAND_CREATE_PLAYBACK_STREAM] = command_create_playback_stream,
 301     [PA_COMMAND_DELETE_PLAYBACK_STREAM] = command_delete_stream,
 302     [PA_COMMAND_DRAIN_PLAYBACK_STREAM] = command_drain_playback_stream,
 303     [PA_COMMAND_CREATE_RECORD_STREAM] = command_create_record_stream,
 304     [PA_COMMAND_DELETE_RECORD_STREAM] = command_delete_stream,
 305     [PA_COMMAND_AUTH] = command_auth,
 306     [PA_COMMAND_REQUEST] = NULL,
 307     [PA_COMMAND_EXIT] = command_exit,
 308     [PA_COMMAND_SET_CLIENT_NAME] = command_set_client_name,
 309     [PA_COMMAND_LOOKUP_SINK] = command_lookup,
 310     [PA_COMMAND_LOOKUP_SOURCE] = command_lookup,
 311     [PA_COMMAND_STAT] = command_stat,
 312     [PA_COMMAND_GET_PLAYBACK_LATENCY] = command_get_playback_latency,
 313     [PA_COMMAND_GET_RECORD_LATENCY] = command_get_record_latency,
 314     [PA_COMMAND_CREATE_UPLOAD_STREAM] = command_create_upload_stream,
 315     [PA_COMMAND_DELETE_UPLOAD_STREAM] = command_delete_stream,
 316     [PA_COMMAND_FINISH_UPLOAD_STREAM] = command_finish_upload_stream,
 317     [PA_COMMAND_PLAY_SAMPLE] = command_play_sample,
 318     [PA_COMMAND_REMOVE_SAMPLE] = command_remove_sample,
 319     [PA_COMMAND_GET_SINK_INFO] = command_get_info,
 320     [PA_COMMAND_GET_SOURCE_INFO] = command_get_info,
 321     [PA_COMMAND_GET_CLIENT_INFO] = command_get_info,
 322     [PA_COMMAND_GET_CARD_INFO] = command_get_info,
 323     [PA_COMMAND_GET_MODULE_INFO] = command_get_info,
 324     [PA_COMMAND_GET_SINK_INPUT_INFO] = command_get_info,
 325     [PA_COMMAND_GET_SOURCE_OUTPUT_INFO] = command_get_info,
 326     [PA_COMMAND_GET_SAMPLE_INFO] = command_get_info,
 327     [PA_COMMAND_GET_SINK_INFO_LIST] = command_get_info_list,
 328     [PA_COMMAND_GET_SOURCE_INFO_LIST] = command_get_info_list,
 329     [PA_COMMAND_GET_MODULE_INFO_LIST] = command_get_info_list,
 330     [PA_COMMAND_GET_CLIENT_INFO_LIST] = command_get_info_list,
 331     [PA_COMMAND_GET_CARD_INFO_LIST] = command_get_info_list,
 332     [PA_COMMAND_GET_SINK_INPUT_INFO_LIST] = command_get_info_list,
 333     [PA_COMMAND_GET_SOURCE_OUTPUT_INFO_LIST] = command_get_info_list,
 334     [PA_COMMAND_GET_SAMPLE_INFO_LIST] = command_get_info_list,
 335     [PA_COMMAND_GET_SERVER_INFO] = command_get_server_info,
 336     [PA_COMMAND_SUBSCRIBE] = command_subscribe,
 337
 338     [PA_COMMAND_SET_SINK_VOLUME] = command_set_volume,
 339     [PA_COMMAND_SET_SINK_INPUT_VOLUME] = command_set_volume,
 340     [PA_COMMAND_SET_SOURCE_VOLUME] = command_set_volume,
 341     [PA_COMMAND_SET_SOURCE_OUTPUT_VOLUME] = command_set_volume,
 342
 343     [PA_COMMAND_SET_SINK_MUTE] = command_set_mute,
 344     [PA_COMMAND_SET_SINK_INPUT_MUTE] = command_set_mute,
 345     [PA_COMMAND_SET_SOURCE_MUTE] = command_set_mute,
 346     [PA_COMMAND_SET_SOURCE_OUTPUT_MUTE] = command_set_mute,
 347
 348     [PA_COMMAND_SUSPEND_SINK] = command_suspend,
 349     [PA_COMMAND_SUSPEND_SOURCE] = command_suspend,
 350
 351     [PA_COMMAND_CORK_PLAYBACK_STREAM] = command_cork_playback_stream,
 352     [PA_COMMAND_FLUSH_PLAYBACK_STREAM] = command_trigger_or_flush_or_prebuf_playback_stream,
 353     [PA_COMMAND_TRIGGER_PLAYBACK_STREAM] = command_trigger_or_flush_or_prebuf_playback_stream,
 354     [PA_COMMAND_PREBUF_PLAYBACK_STREAM] = command_trigger_or_flush_or_prebuf_playback_stream,
 355
 356     [PA_COMMAND_CORK_RECORD_STREAM] = command_cork_record_stream,
 357     [PA_COMMAND_FLUSH_RECORD_STREAM] = command_flush_record_stream,
 358
 359     [PA_COMMAND_SET_DEFAULT_SINK] = command_set_default_sink_or_source,
 360     [PA_COMMAND_SET_DEFAULT_SOURCE] = command_set_default_sink_or_source,
 361     [PA_COMMAND_SET_PLAYBACK_STREAM_NAME] = command_set_stream_name,
 362     [PA_COMMAND_SET_RECORD_STREAM_NAME] = command_set_stream_name,
 363     [PA_COMMAND_KILL_CLIENT] = command_kill,
 364     [PA_COMMAND_KILL_SINK_INPUT] = command_kill,
 365     [PA_COMMAND_KILL_SOURCE_OUTPUT] = command_kill,
 366     [PA_COMMAND_LOAD_MODULE] = command_load_module,
 367     [PA_COMMAND_UNLOAD_MODULE] = command_unload_module,
 368
 369     [PA_COMMAND_GET_AUTOLOAD_INFO___OBSOLETE] = NULL,
 370     [PA_COMMAND_GET_AUTOLOAD_INFO_LIST___OBSOLETE] = NULL,
 371     [PA_COMMAND_ADD_AUTOLOAD___OBSOLETE] = NULL,
 372     [PA_COMMAND_REMOVE_AUTOLOAD___OBSOLETE] = NULL,
 373
 374     [PA_COMMAND_MOVE_SINK_INPUT] = command_move_stream,
 375     [PA_COMMAND_MOVE_SOURCE_OUTPUT] = command_move_stream,
 376
 377     [PA_COMMAND_SET_PLAYBACK_STREAM_BUFFER_ATTR] = command_set_stream_buffer_attr,
 378     [PA_COMMAND_SET_RECORD_STREAM_BUFFER_ATTR] = command_set_stream_buffer_attr,
 379
 380     [PA_COMMAND_UPDATE_PLAYBACK_STREAM_SAMPLE_RATE] = command_update_stream_sample_rate,
 381     [PA_COMMAND_UPDATE_RECORD_STREAM_SAMPLE_RATE] = command_update_stream_sample_rate,
 382
 383     [PA_COMMAND_UPDATE_RECORD_STREAM_PROPLIST] = command_update_proplist,
 384     [PA_COMMAND_UPDATE_PLAYBACK_STREAM_PROPLIST] = command_update_proplist,
 385     [PA_COMMAND_UPDATE_CLIENT_PROPLIST] = command_update_proplist,
 386
 387     [PA_COMMAND_REMOVE_RECORD_STREAM_PROPLIST] = command_remove_proplist,
 388     [PA_COMMAND_REMOVE_PLAYBACK_STREAM_PROPLIST] = command_remove_proplist,
 389     [PA_COMMAND_REMOVE_CLIENT_PROPLIST] = command_remove_proplist,
 390
 391     [PA_COMMAND_SET_CARD_PROFILE] = command_set_card_profile,
 392
 393     [PA_COMMAND_SET_SINK_PORT] = command_set_sink_or_source_port,
 394     [PA_COMMAND_SET_SOURCE_PORT] = command_set_sink_or_source_port,
 395
 396     [PA_COMMAND_EXTENSION] = command_extension
 397 };
 398
 399 /* structure management */
 400
 401 /* Called from main context */
 402 static void upload_stream_unlink(upload_stream *s) {
 403     pa_assert(s);
 404
 405     if (!s->connection)
 406         return;
 407
 408     pa_assert_se(pa_idxset_remove_by_data(s->connection->output_streams, s, NULL) == s);
 409     s->connection = NULL;
 410     upload_stream_unref(s);
 411 }
 412
 413 /* Called from main context */
 414 static void upload_stream_free(pa_object *o) {
 415     upload_stream *s = UPLOAD_STREAM(o);
 416     pa_assert(s);
 417
 418     upload_stream_unlink(s);
 419
 420     pa_xfree(s->name);
 421
 422     if (s->proplist)
 423         pa_proplist_free(s->proplist);
 424
 425     if (s->memchunk.memblock)
 426         pa_memblock_unref(s->memchunk.memblock);
 427
 428     pa_xfree(s);
 429 }
 430
 431 /* Called from main context */
 432 static upload_stream* upload_stream_new(
 433         pa_native_connection *c,
 434         const pa_sample_spec *ss,
 435         const pa_channel_map *map,
 436         const char *name,
 437         size_t length,
 438         pa_proplist *p) {
 439
 440     upload_stream *s;
 441
 442     pa_assert(c);
 443     pa_assert(ss);
 444     pa_assert(name);
 445     pa_assert(length > 0);
 446     pa_assert(p);
 447
 448     s = pa_msgobject_new(upload_stream);
 449     s->parent.parent.parent.free = upload_stream_free;
 450     s->connection = c;
 451     s->sample_spec = *ss;
 452     s->channel_map = *map;
 453     s->name = pa_xstrdup(name);
 454     pa_memchunk_reset(&s->memchunk);
 455     s->length = length;
 456     s->proplist = pa_proplist_copy(p);
 457     pa_proplist_update(s->proplist, PA_UPDATE_MERGE, c->client->proplist);
 458
 459     pa_idxset_put(c->output_streams, s, &s->index);
 460
 461     return s;
 462 }
 463
 464 /* Called from main context */
 465 static void record_stream_unlink(record_stream *s) {
 466     pa_assert(s);
 467
 468     if (!s->connection)
 469         return;
 470
 471     if (s->source_output) {
 472         pa_source_output_unlink(s->source_output);
 473         pa_source_output_unref(s->source_output);
 474         s->source_output = NULL;
 475     }
 476
 477     pa_assert_se(pa_idxset_remove_by_data(s->connection->record_streams, s, NULL) == s);
 478     s->connection = NULL;
 479     record_stream_unref(s);
 480 }
 481
 482 /* Called from main context */
 483 static void record_stream_free(pa_object *o) {
 484     record_stream *s = RECORD_STREAM(o);
 485     pa_assert(s);
 486
 487     record_stream_unlink(s);
 488
 489     pa_memblockq_free(s->memblockq);
 490     pa_xfree(s);
 491 }
 492
 493 /* Called from main context */
 494 static int record_stream_process_msg(pa_msgobject *o, int code, void*userdata, int64_t offset, pa_memchunk *chunk) {
 495     record_stream *s = RECORD_STREAM(o);
 496     record_stream_assert_ref(s);
 497
 498     if (!s->connection)
 499         return -1;
 500
 501     switch (code) {
 502
 503         case RECORD_STREAM_MESSAGE_POST_DATA:
 504
 505             /* We try to keep up to date with how many bytes are
 506              * currently on the fly */
 507             pa_atomic_sub(&s->on_the_fly, chunk->length);
 508
 509             if (pa_memblockq_push_align(s->memblockq, chunk) < 0) {
 510 /*                 pa_log_warn("Failed to push data into output queue."); */
 511                 return -1;
 512             }
 513
 514             if (!pa_pstream_is_pending(s->connection->pstream))
 515                 native_connection_send_memblock(s->connection);
 516
 517             break;
 518     }
 519
 520     return 0;
 521 }
 522
 523 /* Called from main context */
 524 static void fix_record_buffer_attr_pre(record_stream *s) {
 525
 526     size_t frame_size;
 527     pa_usec_t orig_fragsize_usec, fragsize_usec, source_usec;
 528
 529     pa_assert(s);
 530
 531     /* This function will be called from the main thread, before as
 532      * well as after the source output has been activated using
 533      * pa_source_output_put()! That means it may not touch any
 534      * ->thread_info data! */
 535
 536     frame_size = pa_frame_size(&s->source_output->sample_spec);
 537     s->buffer_attr = s->buffer_attr_req;
 538
 539     if (s->buffer_attr.maxlength == (uint32_t) -1 || s->buffer_attr.maxlength > MAX_MEMBLOCKQ_LENGTH)
 540         s->buffer_attr.maxlength = MAX_MEMBLOCKQ_LENGTH;
 541     if (s->buffer_attr.maxlength <= 0)
 542         s->buffer_attr.maxlength = (uint32_t) frame_size;
 543
 544     if (s->buffer_attr.fragsize == (uint32_t) -1)
 545         s->buffer_attr.fragsize = (uint32_t) pa_usec_to_bytes(DEFAULT_FRAGSIZE_MSEC*PA_USEC_PER_MSEC, &s->source_output->sample_spec);
 546     if (s->buffer_attr.fragsize <= 0)
 547         s->buffer_attr.fragsize = (uint32_t) frame_size;
 548
 549     orig_fragsize_usec = fragsize_usec = pa_bytes_to_usec(s->buffer_attr.fragsize, &s->source_output->sample_spec);
 550
 551     if (s->early_requests) {
 552
 553         /* In early request mode we need to emulate the classic
 554          * fragment-based playback model. We do this setting the source
 555          * latency to the fragment size. */
 556
 557         source_usec = fragsize_usec;
 558
 559     } else if (s->adjust_latency) {
 560
 561         /* So, the user asked us to adjust the latency according to
 562          * what the source can provide. Half the latency will be
 563          * spent on the hw buffer, half of it in the async buffer
 564          * queue we maintain for each client. */
 565
 566         source_usec = fragsize_usec/2;
 567
 568     } else {
 569
 570         /* Ok, the user didn't ask us to adjust the latency, hence we
 571          * don't */
 572
 573         source_usec = (pa_usec_t) -1;
 574     }
 575
 576     if (source_usec != (pa_usec_t) -1)
 577         s->configured_source_latency = pa_source_output_set_requested_latency(s->source_output, source_usec);
 578     else
 579         s->configured_source_latency = 0;
 580
 581     if (s->early_requests) {
 582
 583         /* Ok, we didn't necessarily get what we were asking for, so
 584          * let's tell the user */
 585
 586         fragsize_usec = s->configured_source_latency;
 587
 588     } else if (s->adjust_latency) {
 589
 590         /* Now subtract what we actually got */
 591
 592         if (fragsize_usec >= s->configured_source_latency*2)
 593             fragsize_usec -= s->configured_source_latency;
 594         else
 595             fragsize_usec = s->configured_source_latency;
 596     }
 597
 598     if (pa_usec_to_bytes(orig_fragsize_usec, &s->source_output->sample_spec) !=
 599         pa_usec_to_bytes(fragsize_usec, &s->source_output->sample_spec))
 600
 601         s->buffer_attr.fragsize = (uint32_t) pa_usec_to_bytes(fragsize_usec, &s->source_output->sample_spec);
 602
 603     if (s->buffer_attr.fragsize <= 0)
 604         s->buffer_attr.fragsize = (uint32_t) frame_size;
 605 }
 606
 607 /* Called from main context */
 608 static void fix_record_buffer_attr_post(record_stream *s) {
 609     size_t base;
 610
 611     pa_assert(s);
 612
 613     /* This function will be called from the main thread, before as
 614      * well as after the source output has been activated using
 615      * pa_source_output_put()! That means it may not touch and
 616      * ->thread_info data! */
 617
 618     base = pa_frame_size(&s->source_output->sample_spec);
 619
 620     s->buffer_attr.fragsize = (s->buffer_attr.fragsize/base)*base;
 621     if (s->buffer_attr.fragsize <= 0)
 622         s->buffer_attr.fragsize = base;
 623
 624     if (s->buffer_attr.fragsize > s->buffer_attr.maxlength)
 625         s->buffer_attr.fragsize = s->buffer_attr.maxlength;
 626 }
 627
 628 /* Called from main context */
 629 static record_stream* record_stream_new(
 630         pa_native_connection *c,
 631         pa_source *source,
 632         pa_sample_spec *ss,
 633         pa_channel_map *map,
 634         pa_idxset *formats,
 635         pa_buffer_attr *attr,
 636         pa_cvolume *volume,
 637         pa_bool_t muted,
 638         pa_bool_t muted_set,
 639         pa_source_output_flags_t flags,
 640         pa_proplist *p,
 641         pa_bool_t adjust_latency,
 642         pa_bool_t early_requests,
 643         pa_bool_t relative_volume,
 644         pa_bool_t peak_detect,
 645         pa_sink_input *direct_on_input,
 646         int *ret) {
 647
 648     record_stream *s;
 649     pa_source_output *source_output = NULL;
 650     pa_source_output_new_data data;
 651     char *memblockq_name;
 652
 653     pa_assert(c);
 654     pa_assert(ss);
 655     pa_assert(p);
 656     pa_assert(ret);
 657
 658     pa_source_output_new_data_init(&data);
 659
 660     pa_proplist_update(data.proplist, PA_UPDATE_REPLACE, p);
 661     data.driver = __FILE__;
 662     data.module = c->options->module;
 663     data.client = c->client;
 664     if (source)
 665         pa_source_output_new_data_set_source(&data, source, FALSE);
 666     if (pa_sample_spec_valid(ss))
 667         pa_source_output_new_data_set_sample_spec(&data, ss);
 668     if (pa_channel_map_valid(map))
 669         pa_source_output_new_data_set_channel_map(&data, map);
 670     if (formats)
 671         pa_source_output_new_data_set_formats(&data, formats);
 672     data.direct_on_input = direct_on_input;
 673     if (volume) {
 674         pa_source_output_new_data_set_volume(&data, volume);
 675         data.volume_is_absolute = !relative_volume;
 676         data.save_volume = FALSE;
 677     }
 678     if (muted_set) {
 679         pa_source_output_new_data_set_muted(&data, muted);
 680         data.save_muted = FALSE;
 681     }
 682     if (peak_detect)
 683         data.resample_method = PA_RESAMPLER_PEAKS;
 684     data.flags = flags;
 685
 686     *ret = -pa_source_output_new(&source_output, c->protocol->core, &data);
 687
 688     pa_source_output_new_data_done(&data);
 689
 690     if (!source_output)
 691         return NULL;
 692
 693     s = pa_msgobject_new(record_stream);
 694     s->parent.parent.free = record_stream_free;
 695     s->parent.process_msg = record_stream_process_msg;
 696     s->connection = c;
 697     s->source_output = source_output;
 698     s->buffer_attr_req = *attr;
 699     s->adjust_latency = adjust_latency;
 700     s->early_requests = early_requests;
 701     pa_atomic_store(&s->on_the_fly, 0);
 702
 703     s->source_output->parent.process_msg = source_output_process_msg;
 704     s->source_output->push = source_output_push_cb;
 705     s->source_output->kill = source_output_kill_cb;
 706     s->source_output->get_latency = source_output_get_latency_cb;
 707     s->source_output->moving = source_output_moving_cb;
 708     s->source_output->suspend = source_output_suspend_cb;
 709     s->source_output->send_event = source_output_send_event_cb;
 710     s->source_output->userdata = s;
 711
 712     fix_record_buffer_attr_pre(s);
 713
 714     memblockq_name = pa_sprintf_malloc("native protocol record stream memblockq [%u]", s->source_output->index);
 715     s->memblockq = pa_memblockq_new(
 716             memblockq_name,
 717             0,
 718             s->buffer_attr.maxlength,
 719             0,
 720             &source_output->sample_spec,
 721             1,
 722             0,
 723             0,
 724             NULL);
 725     pa_xfree(memblockq_name);
 726
 727     pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
 728     fix_record_buffer_attr_post(s);
 729
 730     *ss = s->source_output->sample_spec;
 731     *map = s->source_output->channel_map;
 732
 733     pa_idxset_put(c->record_streams, s, &s->index);
 734
 735     pa_log_info("Final latency %0.2f ms = %0.2f ms + %0.2f ms",
 736                 ((double) pa_bytes_to_usec(s->buffer_attr.fragsize, &source_output->sample_spec) + (double) s->configured_source_latency) / PA_USEC_PER_MSEC,
 737                 (double) pa_bytes_to_usec(s->buffer_attr.fragsize, &source_output->sample_spec) / PA_USEC_PER_MSEC,
 738                 (double) s->configured_source_latency / PA_USEC_PER_MSEC);
 739
 740     pa_source_output_put(s->source_output);
 741     return s;
 742 }
 743
 744 /* Called from main context */
 745 static void record_stream_send_killed(record_stream *r) {
 746     pa_tagstruct *t;
 747     record_stream_assert_ref(r);
 748
 749     t = pa_tagstruct_new(NULL, 0);
 750     pa_tagstruct_putu32(t, PA_COMMAND_RECORD_STREAM_KILLED);
 751     pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
 752     pa_tagstruct_putu32(t, r->index);
 753     pa_pstream_send_tagstruct(r->connection->pstream, t);
 754 }
 755
 756 /* Called from main context */
 757 static void playback_stream_unlink(playback_stream *s) {
 758     pa_assert(s);
 759
 760     if (!s->connection)
 761         return;
 762
 763     if (s->sink_input) {
 764         pa_sink_input_unlink(s->sink_input);
 765         pa_sink_input_unref(s->sink_input);
 766         s->sink_input = NULL;
 767     }
 768
 769     if (s->drain_request)
 770         pa_pstream_send_error(s->connection->pstream, s->drain_tag, PA_ERR_NOENTITY);
 771
 772     pa_assert_se(pa_idxset_remove_by_data(s->connection->output_streams, s, NULL) == s);
 773     s->connection = NULL;
 774     playback_stream_unref(s);
 775 }
 776
 777 /* Called from main context */
 778 static void playback_stream_free(pa_object* o) {
 779     playback_stream *s = PLAYBACK_STREAM(o);
 780     pa_assert(s);
 781
 782     playback_stream_unlink(s);
 783
 784     pa_memblockq_free(s->memblockq);
 785     pa_xfree(s);
 786 }
 787
 788 /* Called from main context */
 789 static int playback_stream_process_msg(pa_msgobject *o, int code, void*userdata, int64_t offset, pa_memchunk *chunk) {
 790     playback_stream *s = PLAYBACK_STREAM(o);
 791     playback_stream_assert_ref(s);
 792
 793     if (!s->connection)
 794         return -1;
 795
 796     switch (code) {
 797
 798         case PLAYBACK_STREAM_MESSAGE_REQUEST_DATA: {
 799             pa_tagstruct *t;
 800             int l = 0;
 801
 802             for (;;) {
 803                 if ((l = pa_atomic_load(&s->missing)) <= 0)
 804                     return 0;
 805
 806                 if (pa_atomic_cmpxchg(&s->missing, l, 0))
 807                     break;
 808             }
 809
 810             t = pa_tagstruct_new(NULL, 0);
 811             pa_tagstruct_putu32(t, PA_COMMAND_REQUEST);
 812             pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
 813             pa_tagstruct_putu32(t, s->index);
 814             pa_tagstruct_putu32(t, (uint32_t) l);
 815             pa_pstream_send_tagstruct(s->connection->pstream, t);
 816
 817 #ifdef PROTOCOL_NATIVE_DEBUG
 818             pa_log("Requesting %lu bytes", (unsigned long) l);
 819 #endif
 820             break;
 821         }
 822
 823         case PLAYBACK_STREAM_MESSAGE_UNDERFLOW: {
 824             pa_tagstruct *t;
 825
 826 #ifdef PROTOCOL_NATIVE_DEBUG
 827             pa_log("signalling underflow");
 828 #endif
 829
 830             /* Report that we're empty */
 831             t = pa_tagstruct_new(NULL, 0);
 832             pa_tagstruct_putu32(t, PA_COMMAND_UNDERFLOW);
 833             pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
 834             pa_tagstruct_putu32(t, s->index);
 835             if (s->connection->version >= 23)
 836                 pa_tagstruct_puts64(t, offset);
 837             pa_pstream_send_tagstruct(s->connection->pstream, t);
 838             break;
 839         }
 840
 841         case PLAYBACK_STREAM_MESSAGE_OVERFLOW: {
 842             pa_tagstruct *t;
 843
 844             /* Notify the user we're overflowed*/
 845             t = pa_tagstruct_new(NULL, 0);
 846             pa_tagstruct_putu32(t, PA_COMMAND_OVERFLOW);
 847             pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
 848             pa_tagstruct_putu32(t, s->index);
 849             pa_pstream_send_tagstruct(s->connection->pstream, t);
 850             break;
 851         }
 852
 853         case PLAYBACK_STREAM_MESSAGE_STARTED:
 854
 855             if (s->connection->version >= 13) {
 856                 pa_tagstruct *t;
 857
 858                 /* Notify the user we started playback */
 859                 t = pa_tagstruct_new(NULL, 0);
 860                 pa_tagstruct_putu32(t, PA_COMMAND_STARTED);
 861                 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
 862                 pa_tagstruct_putu32(t, s->index);
 863                 pa_pstream_send_tagstruct(s->connection->pstream, t);
 864             }
 865
 866             break;
 867
 868         case PLAYBACK_STREAM_MESSAGE_DRAIN_ACK:
 869             pa_pstream_send_simple_ack(s->connection->pstream, PA_PTR_TO_UINT(userdata));
 870             break;
 871
 872         case PLAYBACK_STREAM_MESSAGE_UPDATE_TLENGTH:
 873
 874             s->buffer_attr.tlength = (uint32_t) offset;
 875
 876             if (s->connection->version >= 15) {
 877                 pa_tagstruct *t;
 878
 879                 t = pa_tagstruct_new(NULL, 0);
 880                 pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_BUFFER_ATTR_CHANGED);
 881                 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
 882                 pa_tagstruct_putu32(t, s->index);
 883                 pa_tagstruct_putu32(t, s->buffer_attr.maxlength);
 884                 pa_tagstruct_putu32(t, s->buffer_attr.tlength);
 885                 pa_tagstruct_putu32(t, s->buffer_attr.prebuf);
 886                 pa_tagstruct_putu32(t, s->buffer_attr.minreq);
 887                 pa_tagstruct_put_usec(t, s->configured_sink_latency);
 888                 pa_pstream_send_tagstruct(s->connection->pstream, t);
 889             }
 890
 891             break;
 892     }
 893
 894     return 0;
 895 }
 896
 897 /* Called from main context */
 898 static void fix_playback_buffer_attr(playback_stream *s) {
 899     size_t frame_size, max_prebuf;
 900     pa_usec_t orig_tlength_usec, tlength_usec, orig_minreq_usec, minreq_usec, sink_usec;
 901
 902     pa_assert(s);
 903
 904 #ifdef PROTOCOL_NATIVE_DEBUG
 905     pa_log("Client requested: maxlength=%li bytes tlength=%li bytes minreq=%li bytes prebuf=%li bytes",
 906            (long) s->buffer_attr.maxlength,
 907            (long) s->buffer_attr.tlength,
 908            (long) s->buffer_attr.minreq,
 909            (long) s->buffer_attr.prebuf);
 910
 911     pa_log("Client requested: maxlength=%lu ms tlength=%lu ms minreq=%lu ms prebuf=%lu ms",
 912            (unsigned long) (pa_bytes_to_usec(s->buffer_attr.maxlength, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC),
 913            (unsigned long) (pa_bytes_to_usec(s->buffer_attr.tlength, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC),
 914            (unsigned long) (pa_bytes_to_usec(s->buffer_attr.minreq, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC),
 915            (unsigned long) (pa_bytes_to_usec(s->buffer_attr.prebuf, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC));
 916 #endif
 917
 918     /* This function will be called from the main thread, before as
 919      * well as after the sink input has been activated using
 920      * pa_sink_input_put()! That means it may not touch any
 921      * ->thread_info data, such as the memblockq! */
 922
 923     frame_size = pa_frame_size(&s->sink_input->sample_spec);
 924     s->buffer_attr = s->buffer_attr_req;
 925
 926     if (s->buffer_attr.maxlength == (uint32_t) -1 || s->buffer_attr.maxlength > MAX_MEMBLOCKQ_LENGTH)
 927         s->buffer_attr.maxlength = MAX_MEMBLOCKQ_LENGTH;
 928     if (s->buffer_attr.maxlength <= 0)
 929         s->buffer_attr.maxlength = (uint32_t) frame_size;
 930
 931     if (s->buffer_attr.tlength == (uint32_t) -1)
 932         s->buffer_attr.tlength = (uint32_t) pa_usec_to_bytes_round_up(DEFAULT_TLENGTH_MSEC*PA_USEC_PER_MSEC, &s->sink_input->sample_spec);
 933     if (s->buffer_attr.tlength <= 0)
 934         s->buffer_attr.tlength = (uint32_t) frame_size;
 935
 936     if (s->buffer_attr.minreq == (uint32_t) -1)
 937         s->buffer_attr.minreq = (uint32_t) pa_usec_to_bytes_round_up(DEFAULT_PROCESS_MSEC*PA_USEC_PER_MSEC, &s->sink_input->sample_spec);
 938     if (s->buffer_attr.minreq <= 0)
 939         s->buffer_attr.minreq = (uint32_t) frame_size;
 940
 941     if (s->buffer_attr.tlength < s->buffer_attr.minreq+frame_size)
 942         s->buffer_attr.tlength = s->buffer_attr.minreq+(uint32_t) frame_size;
 943
 944     orig_tlength_usec = tlength_usec = pa_bytes_to_usec(s->buffer_attr.tlength, &s->sink_input->sample_spec);
 945     orig_minreq_usec = minreq_usec = pa_bytes_to_usec(s->buffer_attr.minreq, &s->sink_input->sample_spec);
 946
 947     pa_log_info("Requested tlength=%0.2f ms, minreq=%0.2f ms",
 948                 (double) tlength_usec / PA_USEC_PER_MSEC,
 949                 (double) minreq_usec / PA_USEC_PER_MSEC);
 950
 951     if (s->early_requests) {
 952
 953         /* In early request mode we need to emulate the classic
 954          * fragment-based playback model. We do this setting the sink
 955          * latency to the fragment size. */
 956
 957         sink_usec = minreq_usec;
 958         pa_log_debug("Early requests mode enabled, configuring sink latency to minreq.");
 959
 960     } else if (s->adjust_latency) {
 961
 962         /* So, the user asked us to adjust the latency of the stream
 963          * buffer according to the what the sink can provide. The
 964          * tlength passed in shall be the overall latency. Roughly
 965          * half the latency will be spent on the hw buffer, the other
 966          * half of it in the async buffer queue we maintain for each
 967          * client. In between we'll have a safety space of size
 968          * 2*minreq. Why the 2*minreq? When the hw buffer is completely
 969          * empty and needs to be filled, then our buffer must have
 970          * enough data to fulfill this request immediately and thus
 971          * have at least the same tlength as the size of the hw
 972          * buffer. It additionally needs space for 2 times minreq
 973          * because if the buffer ran empty and a partial fillup
 974          * happens immediately on the next iteration we need to be
 975          * able to fulfill it and give the application also minreq
 976          * time to fill it up again for the next request Makes 2 times
 977          * minreq in plus.. */
 978
 979         if (tlength_usec > minreq_usec*2)
 980             sink_usec = (tlength_usec - minreq_usec*2)/2;
 981         else
 982             sink_usec = 0;
 983
 984         pa_log_debug("Adjust latency mode enabled, configuring sink latency to half of overall latency.");
 985
 986     } else {
 987
 988         /* Ok, the user didn't ask us to adjust the latency, but we
 989          * still need to make sure that the parameters from the user
 990          * do make sense. */
 991
 992         if (tlength_usec > minreq_usec*2)
 993             sink_usec = (tlength_usec - minreq_usec*2);
 994         else
 995             sink_usec = 0;
 996
 997         pa_log_debug("Traditional mode enabled, modifying sink usec only for compat with minreq.");
 998     }
 999
1000     s->configured_sink_latency = pa_sink_input_set_requested_latency(s->sink_input, sink_usec);
1001
1002     if (s->early_requests) {
1003
1004         /* Ok, we didn't necessarily get what we were asking for, so
1005          * let's tell the user */
1006
1007         minreq_usec = s->configured_sink_latency;
1008
1009     } else if (s->adjust_latency) {
1010
1011         /* Ok, we didn't necessarily get what we were asking for, so
1012          * let's subtract from what we asked for for the remaining
1013          * buffer space */
1014
1015         if (tlength_usec >= s->configured_sink_latency)
1016             tlength_usec -= s->configured_sink_latency;
1017     }
1018
1019     pa_log_debug("Requested latency=%0.2f ms, Received latency=%0.2f ms",
1020                  (double) sink_usec / PA_USEC_PER_MSEC,
1021                  (double) s->configured_sink_latency / PA_USEC_PER_MSEC);
1022
1023     /* FIXME: This is actually larger than necessary, since not all of
1024      * the sink latency is actually rewritable. */
1025     if (tlength_usec < s->configured_sink_latency + 2*minreq_usec)
1026         tlength_usec = s->configured_sink_latency + 2*minreq_usec;
1027
1028     if (pa_usec_to_bytes_round_up(orig_tlength_usec, &s->sink_input->sample_spec) !=
1029         pa_usec_to_bytes_round_up(tlength_usec, &s->sink_input->sample_spec))
1030         s->buffer_attr.tlength = (uint32_t) pa_usec_to_bytes_round_up(tlength_usec, &s->sink_input->sample_spec);
1031
1032     if (pa_usec_to_bytes(orig_minreq_usec, &s->sink_input->sample_spec) !=
1033         pa_usec_to_bytes(minreq_usec, &s->sink_input->sample_spec))
1034         s->buffer_attr.minreq = (uint32_t) pa_usec_to_bytes(minreq_usec, &s->sink_input->sample_spec);
1035
1036     if (s->buffer_attr.minreq <= 0) {
1037         s->buffer_attr.minreq = (uint32_t) frame_size;
1038         s->buffer_attr.tlength += (uint32_t) frame_size*2;
1039     }
1040
1041     if (s->buffer_attr.tlength <= s->buffer_attr.minreq)
1042         s->buffer_attr.tlength = s->buffer_attr.minreq*2 + (uint32_t) frame_size;
1043
1044     max_prebuf = s->buffer_attr.tlength + (uint32_t)frame_size - s->buffer_attr.minreq;
1045
1046     if (s->buffer_attr.prebuf == (uint32_t) -1 ||
1047         s->buffer_attr.prebuf > max_prebuf)
1048         s->buffer_attr.prebuf = max_prebuf;
1049
1050 #ifdef PROTOCOL_NATIVE_DEBUG
1051     pa_log("Client accepted: maxlength=%lu ms tlength=%lu ms minreq=%lu ms prebuf=%lu ms",
1052            (unsigned long) (pa_bytes_to_usec(s->buffer_attr.maxlength, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC),
1053            (unsigned long) (pa_bytes_to_usec(s->buffer_attr.tlength, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC),
1054            (unsigned long) (pa_bytes_to_usec(s->buffer_attr.minreq, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC),
1055            (unsigned long) (pa_bytes_to_usec(s->buffer_attr.prebuf, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC));
1056 #endif
1057 }
1058
1059 /* Called from main context */
1060 static playback_stream* playback_stream_new(
1061         pa_native_connection *c,
1062         pa_sink *sink,
1063         pa_sample_spec *ss,
1064         pa_channel_map *map,
1065         pa_idxset *formats,
1066         pa_buffer_attr *a,
1067         pa_cvolume *volume,
1068         pa_bool_t muted,
1069         pa_bool_t muted_set,
1070         pa_sink_input_flags_t flags,
1071         pa_proplist *p,
1072         pa_bool_t adjust_latency,
1073         pa_bool_t early_requests,
1074         pa_bool_t relative_volume,
1075         uint32_t syncid,
1076         uint32_t *missing,
1077         int *ret) {
1078
1079     /* Note: This function takes ownership of the 'formats' param, so we need
1080      * to take extra care to not leak it */
1081
1082     playback_stream *ssync;
1083     playback_stream *s = NULL;
1084     pa_sink_input *sink_input = NULL;
1085     pa_memchunk silence;
1086     uint32_t idx;
1087     int64_t start_index;
1088     pa_sink_input_new_data data;
1089     char *memblockq_name;
1090
1091     pa_assert(c);
1092     pa_assert(ss);
1093     pa_assert(missing);
1094     pa_assert(p);
1095     pa_assert(ret);
1096
1097     /* Find syncid group */
1098     PA_IDXSET_FOREACH(ssync, c->output_streams, idx) {
1099
1100         if (!playback_stream_isinstance(ssync))
1101             continue;
1102
1103         if (ssync->syncid == syncid)
1104             break;
1105     }
1106
1107     /* Synced streams must connect to the same sink */
1108     if (ssync) {
1109
1110         if (!sink)
1111             sink = ssync->sink_input->sink;
1112         else if (sink != ssync->sink_input->sink) {
1113             *ret = PA_ERR_INVALID;
1114             goto out;
1115         }
1116     }
1117
1118     pa_sink_input_new_data_init(&data);
1119
1120     pa_proplist_update(data.proplist, PA_UPDATE_REPLACE, p);
1121     data.driver = __FILE__;
1122     data.module = c->options->module;
1123     data.client = c->client;
1124     if (sink)
1125         pa_sink_input_new_data_set_sink(&data, sink, FALSE);
1126     if (pa_sample_spec_valid(ss))
1127         pa_sink_input_new_data_set_sample_spec(&data, ss);
1128     if (pa_channel_map_valid(map))
1129         pa_sink_input_new_data_set_channel_map(&data, map);
1130     if (formats) {
1131         pa_sink_input_new_data_set_formats(&data, formats);
1132         /* Ownership transferred to new_data, so we don't free it ourselves */
1133         formats = NULL;
1134     }
1135     if (volume) {
1136         pa_sink_input_new_data_set_volume(&data, volume);
1137         data.volume_is_absolute = !relative_volume;
1138         data.save_volume = FALSE;
1139     }
1140     if (muted_set) {
1141         pa_sink_input_new_data_set_muted(&data, muted);
1142         data.save_muted = FALSE;
1143     }
1144     data.sync_base = ssync ? ssync->sink_input : NULL;
1145     data.flags = flags;
1146
1147     *ret = -pa_sink_input_new(&sink_input, c->protocol->core, &data);
1148
1149     pa_sink_input_new_data_done(&data);
1150
1151     if (!sink_input)
1152         goto out;
1153
1154     s = pa_msgobject_new(playback_stream);
1155     s->parent.parent.parent.free = playback_stream_free;
1156     s->parent.parent.process_msg = playback_stream_process_msg;
1157     s->connection = c;
1158     s->syncid = syncid;
1159     s->sink_input = sink_input;
1160     s->is_underrun = TRUE;
1161     s->drain_request = FALSE;
1162     pa_atomic_store(&s->missing, 0);
1163     s->buffer_attr_req = *a;
1164     s->adjust_latency = adjust_latency;
1165     s->early_requests = early_requests;
1166     pa_atomic_store(&s->seek_or_post_in_queue, 0);
1167     s->seek_windex = -1;
1168
1169     s->sink_input->parent.process_msg = sink_input_process_msg;
1170     s->sink_input->pop = sink_input_pop_cb;
1171     s->sink_input->process_rewind = sink_input_process_rewind_cb;
1172     s->sink_input->update_max_rewind = sink_input_update_max_rewind_cb;
1173     s->sink_input->update_max_request = sink_input_update_max_request_cb;
1174     s->sink_input->kill = sink_input_kill_cb;
1175     s->sink_input->moving = sink_input_moving_cb;
1176     s->sink_input->suspend = sink_input_suspend_cb;
1177     s->sink_input->send_event = sink_input_send_event_cb;
1178     s->sink_input->userdata = s;
1179
1180     start_index = ssync ? pa_memblockq_get_read_index(ssync->memblockq) : 0;
1181
1182     fix_playback_buffer_attr(s);
1183
1184     pa_sink_input_get_silence(sink_input, &silence);
1185     memblockq_name = pa_sprintf_malloc("native protocol playback stream memblockq [%u]", s->sink_input->index);
1186     s->memblockq = pa_memblockq_new(
1187             memblockq_name,
1188             start_index,
1189             s->buffer_attr.maxlength,
1190             s->buffer_attr.tlength,
1191             &sink_input->sample_spec,
1192             s->buffer_attr.prebuf,
1193             s->buffer_attr.minreq,
1194             0,
1195             &silence);
1196     pa_xfree(memblockq_name);
1197     pa_memblock_unref(silence.memblock);
1198
1199     pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
1200
1201     *missing = (uint32_t) pa_memblockq_pop_missing(s->memblockq);
1202
1203 #ifdef PROTOCOL_NATIVE_DEBUG
1204     pa_log("missing original: %li", (long int) *missing);
1205 #endif
1206
1207     *ss = s->sink_input->sample_spec;
1208     *map = s->sink_input->channel_map;
1209
1210     pa_idxset_put(c->output_streams, s, &s->index);
1211
1212     pa_log_info("Final latency %0.2f ms = %0.2f ms + 2*%0.2f ms + %0.2f ms",
1213                 ((double) pa_bytes_to_usec(s->buffer_attr.tlength, &sink_input->sample_spec) + (double) s->configured_sink_latency) / PA_USEC_PER_MSEC,
1214                 (double) pa_bytes_to_usec(s->buffer_attr.tlength-s->buffer_attr.minreq*2, &sink_input->sample_spec) / PA_USEC_PER_MSEC,
1215                 (double) pa_bytes_to_usec(s->buffer_attr.minreq, &sink_input->sample_spec) / PA_USEC_PER_MSEC,
1216                 (double) s->configured_sink_latency / PA_USEC_PER_MSEC);
1217
1218     pa_sink_input_put(s->sink_input);
1219
1220 out:
1221     if (formats)
1222         pa_idxset_free(formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
1223
1224     return s;
1225 }
1226
1227 /* Called from IO context */
1228 static void playback_stream_request_bytes(playback_stream *s) {
1229     size_t m, minreq;
1230     int previous_missing;
1231
1232     playback_stream_assert_ref(s);
1233
1234     m = pa_memblockq_pop_missing(s->memblockq);
1235
1236     /* pa_log("request_bytes(%lu) (tlength=%lu minreq=%lu length=%lu really missing=%lli)", */
1237     /*        (unsigned long) m, */
1238     /*        pa_memblockq_get_tlength(s->memblockq), */
1239     /*        pa_memblockq_get_minreq(s->memblockq), */
1240     /*        pa_memblockq_get_length(s->memblockq), */
1241     /*        (long long) pa_memblockq_get_tlength(s->memblockq) - (long long) pa_memblockq_get_length(s->memblockq)); */
1242
1243     if (m <= 0)
1244         return;
1245
1246 #ifdef PROTOCOL_NATIVE_DEBUG
1247     pa_log("request_bytes(%lu)", (unsigned long) m);
1248 #endif
1249
1250     previous_missing = pa_atomic_add(&s->missing, (int) m);
1251     minreq = pa_memblockq_get_minreq(s->memblockq);
1252
1253     if (pa_memblockq_prebuf_active(s->memblockq) ||
1254         (previous_missing < (int) minreq && previous_missing + (int) m >= (int) minreq))
1255         pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_REQUEST_DATA, NULL, 0, NULL, NULL);
1256 }
1257
1258 /* Called from main context */
1259 static void playback_stream_send_killed(playback_stream *p) {
1260     pa_tagstruct *t;
1261     playback_stream_assert_ref(p);
1262
1263     t = pa_tagstruct_new(NULL, 0);
1264     pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_STREAM_KILLED);
1265     pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1266     pa_tagstruct_putu32(t, p->index);
1267     pa_pstream_send_tagstruct(p->connection->pstream, t);
1268 }
1269
1270 /* Called from main context */
1271 static int native_connection_process_msg(pa_msgobject *o, int code, void*userdata, int64_t offset, pa_memchunk *chunk) {
1272     pa_native_connection *c = PA_NATIVE_CONNECTION(o);
1273     pa_native_connection_assert_ref(c);
1274
1275     if (!c->protocol)
1276         return -1;
1277
1278     switch (code) {
1279
1280         case CONNECTION_MESSAGE_REVOKE:
1281             pa_pstream_send_revoke(c->pstream, PA_PTR_TO_UINT(userdata));
1282             break;
1283
1284         case CONNECTION_MESSAGE_RELEASE:
1285             pa_pstream_send_release(c->pstream, PA_PTR_TO_UINT(userdata));
1286             break;
1287     }
1288
1289     return 0;
1290 }
1291
1292 /* Called from main context */
1293 static void native_connection_unlink(pa_native_connection *c) {
1294     record_stream *r;
1295     output_stream *o;
1296
1297     pa_assert(c);
1298
1299     if (!c->protocol)
1300         return;
1301
1302     pa_hook_fire(&c->protocol->hooks[PA_NATIVE_HOOK_CONNECTION_UNLINK], c);
1303
1304     if (c->options)
1305         pa_native_options_unref(c->options);
1306
1307     while ((r = pa_idxset_first(c->record_streams, NULL)))
1308         record_stream_unlink(r);
1309
1310     while ((o = pa_idxset_first(c->output_streams, NULL)))
1311         if (playback_stream_isinstance(o))
1312             playback_stream_unlink(PLAYBACK_STREAM(o));
1313         else
1314             upload_stream_unlink(UPLOAD_STREAM(o));
1315
1316     if (c->subscription)
1317         pa_subscription_free(c->subscription);
1318
1319     if (c->pstream)
1320         pa_pstream_unlink(c->pstream);
1321
1322     if (c->auth_timeout_event) {
1323         c->protocol->core->mainloop->time_free(c->auth_timeout_event);
1324         c->auth_timeout_event = NULL;
1325     }
1326
1327     pa_assert_se(pa_idxset_remove_by_data(c->protocol->connections, c, NULL) == c);
1328     c->protocol = NULL;
1329     pa_native_connection_unref(c);
1330 }
1331
1332 /* Called from main context */
1333 static void native_connection_free(pa_object *o) {
1334     pa_native_connection *c = PA_NATIVE_CONNECTION(o);
1335
1336     pa_assert(c);
1337
1338     native_connection_unlink(c);
1339
1340     pa_idxset_free(c->record_streams, NULL, NULL);
1341     pa_idxset_free(c->output_streams, NULL, NULL);
1342
1343     pa_pdispatch_unref(c->pdispatch);
1344     pa_pstream_unref(c->pstream);
1345     pa_client_free(c->client);
1346
1347     pa_xfree(c);
1348 }
1349
1350 /* Called from main context */
1351 static void native_connection_send_memblock(pa_native_connection *c) {
1352     uint32_t start;
1353     record_stream *r;
1354
1355     start = PA_IDXSET_INVALID;
1356     for (;;) {
1357         pa_memchunk chunk;
1358
1359         if (!(r = RECORD_STREAM(pa_idxset_rrobin(c->record_streams, &c->rrobin_index))))
1360             return;
1361
1362         if (start == PA_IDXSET_INVALID)
1363             start = c->rrobin_index;
1364         else if (start == c->rrobin_index)
1365             return;
1366
1367         if (pa_memblockq_peek(r->memblockq, &chunk) >= 0) {
1368             pa_memchunk schunk = chunk;
1369
1370             if (schunk.length > r->buffer_attr.fragsize)
1371                 schunk.length = r->buffer_attr.fragsize;
1372
1373             pa_pstream_send_memblock(c->pstream, r->index, 0, PA_SEEK_RELATIVE, &schunk);
1374
1375             pa_memblockq_drop(r->memblockq, schunk.length);
1376             pa_memblock_unref(schunk.memblock);
1377
1378             return;
1379         }
1380     }
1381 }
1382
1383 /*** sink input callbacks ***/
1384
1385 /* Called from thread context */
1386 static void handle_seek(playback_stream *s, int64_t indexw) {
1387     playback_stream_assert_ref(s);
1388
1389 /*     pa_log("handle_seek: %llu -- %i", (unsigned long long) s->sink_input->thread_info.underrun_for, pa_memblockq_is_readable(s->memblockq)); */
1390
1391     if (s->sink_input->thread_info.underrun_for > 0) {
1392
1393 /*         pa_log("%lu vs. %lu", (unsigned long) pa_memblockq_get_length(s->memblockq), (unsigned long) pa_memblockq_get_prebuf(s->memblockq)); */
1394
1395         if (pa_memblockq_is_readable(s->memblockq)) {
1396
1397             /* We just ended an underrun, let's ask the sink
1398              * for a complete rewind rewrite */
1399
1400             pa_log_debug("Requesting rewind due to end of underrun.");
1401             pa_sink_input_request_rewind(s->sink_input,
1402                                          (size_t) (s->sink_input->thread_info.underrun_for == (uint64_t) -1 ? 0 :
1403                                                    s->sink_input->thread_info.underrun_for),
1404                                          FALSE, TRUE, FALSE);
1405         }
1406
1407     } else {
1408         int64_t indexr;
1409
1410         indexr = pa_memblockq_get_read_index(s->memblockq);
1411
1412         if (indexw < indexr) {
1413             /* OK, the sink already asked for this data, so
1414              * let's have it ask us again */
1415
1416             pa_log_debug("Requesting rewind due to rewrite.");
1417             pa_sink_input_request_rewind(s->sink_input, (size_t) (indexr - indexw), TRUE, FALSE, FALSE);
1418         }
1419     }
1420
1421     playback_stream_request_bytes(s);
1422 }
1423
1424 static void flush_write_no_account(pa_memblockq *q) {
1425     pa_memblockq_flush_write(q, FALSE);
1426 }
1427
1428 /* Called from thread context */
1429 static int sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1430     pa_sink_input *i = PA_SINK_INPUT(o);
1431     playback_stream *s;
1432
1433     pa_sink_input_assert_ref(i);
1434     s = PLAYBACK_STREAM(i->userdata);
1435     playback_stream_assert_ref(s);
1436
1437     switch (code) {
1438
1439         case SINK_INPUT_MESSAGE_SEEK:
1440         case SINK_INPUT_MESSAGE_POST_DATA: {
1441             int64_t windex = pa_memblockq_get_write_index(s->memblockq);
1442
1443             if (code == SINK_INPUT_MESSAGE_SEEK) {
1444                 /* The client side is incapable of accounting correctly
1445                  * for seeks of a type != PA_SEEK_RELATIVE. We need to be
1446                  * able to deal with that. */
1447
1448                 pa_memblockq_seek(s->memblockq, offset, PA_PTR_TO_UINT(userdata), PA_PTR_TO_UINT(userdata) == PA_SEEK_RELATIVE);
1449                 windex = PA_MIN(windex, pa_memblockq_get_write_index(s->memblockq));
1450             }
1451
1452             if (chunk && pa_memblockq_push_align(s->memblockq, chunk) < 0) {
1453                 if (pa_log_ratelimit(PA_LOG_WARN))
1454                     pa_log_warn("Failed to push data into queue");
1455                 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_OVERFLOW, NULL, 0, NULL, NULL);
1456                 pa_memblockq_seek(s->memblockq, (int64_t) chunk->length, PA_SEEK_RELATIVE, TRUE);
1457             }
1458
1459             /* If more data is in queue, we rewind later instead. */
1460             if (s->seek_windex != -1)
1461                 windex = PA_MIN(windex, s->seek_windex);
1462             if (pa_atomic_dec(&s->seek_or_post_in_queue) > 1)
1463                 s->seek_windex = windex;
1464             else {
1465                 s->seek_windex = -1;
1466                 handle_seek(s, windex);
1467             }
1468             return 0;
1469         }
1470
1471         case SINK_INPUT_MESSAGE_DRAIN:
1472         case SINK_INPUT_MESSAGE_FLUSH:
1473         case SINK_INPUT_MESSAGE_PREBUF_FORCE:
1474         case SINK_INPUT_MESSAGE_TRIGGER: {
1475
1476             int64_t windex;
1477             pa_sink_input *isync;
1478             void (*func)(pa_memblockq *bq);
1479
1480             switch (code) {
1481                 case SINK_INPUT_MESSAGE_FLUSH:
1482                     func = flush_write_no_account;
1483                     break;
1484
1485                 case SINK_INPUT_MESSAGE_PREBUF_FORCE:
1486                     func = pa_memblockq_prebuf_force;
1487                     break;
1488
1489                 case SINK_INPUT_MESSAGE_DRAIN:
1490                 case SINK_INPUT_MESSAGE_TRIGGER:
1491                     func = pa_memblockq_prebuf_disable;
1492                     break;
1493
1494                 default:
1495                     pa_assert_not_reached();
1496             }
1497
1498             windex = pa_memblockq_get_write_index(s->memblockq);
1499             func(s->memblockq);
1500             handle_seek(s, windex);
1501
1502             /* Do the same for all other members in the sync group */
1503             for (isync = i->sync_prev; isync; isync = isync->sync_prev) {
1504                 playback_stream *ssync = PLAYBACK_STREAM(isync->userdata);
1505                 windex = pa_memblockq_get_write_index(ssync->memblockq);
1506                 func(ssync->memblockq);
1507                 handle_seek(ssync, windex);
1508             }
1509
1510             for (isync = i->sync_next; isync; isync = isync->sync_next) {
1511                 playback_stream *ssync = PLAYBACK_STREAM(isync->userdata);
1512                 windex = pa_memblockq_get_write_index(ssync->memblockq);
1513                 func(ssync->memblockq);
1514                 handle_seek(ssync, windex);
1515             }
1516
1517             if (code == SINK_INPUT_MESSAGE_DRAIN) {
1518                 if (!pa_memblockq_is_readable(s->memblockq))
1519                     pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_DRAIN_ACK, userdata, 0, NULL, NULL);
1520                 else {
1521                     s->drain_tag = PA_PTR_TO_UINT(userdata);
1522                     s->drain_request = TRUE;
1523                 }
1524             }
1525
1526             return 0;
1527         }
1528
1529         case SINK_INPUT_MESSAGE_UPDATE_LATENCY:
1530             /* Atomically get a snapshot of all timing parameters... */
1531             s->read_index = pa_memblockq_get_read_index(s->memblockq);
1532             s->write_index = pa_memblockq_get_write_index(s->memblockq);
1533             s->render_memblockq_length = pa_memblockq_get_length(s->sink_input->thread_info.render_memblockq);
1534             s->current_sink_latency = pa_sink_get_latency_within_thread(s->sink_input->sink);
1535             s->underrun_for = s->sink_input->thread_info.underrun_for;
1536             s->playing_for = s->sink_input->thread_info.playing_for;
1537
1538             return 0;
1539
1540         case PA_SINK_INPUT_MESSAGE_SET_STATE: {
1541             int64_t windex;
1542
1543             windex = pa_memblockq_get_write_index(s->memblockq);
1544
1545             pa_memblockq_prebuf_force(s->memblockq);
1546
1547             handle_seek(s, windex);
1548
1549             /* Fall through to the default handler */
1550             break;
1551         }
1552
1553         case PA_SINK_INPUT_MESSAGE_GET_LATENCY: {
1554             pa_usec_t *r = userdata;
1555
1556             *r = pa_bytes_to_usec(pa_memblockq_get_length(s->memblockq), &i->sample_spec);
1557
1558             /* Fall through, the default handler will add in the extra
1559              * latency added by the resampler */
1560             break;
1561         }
1562
1563         case SINK_INPUT_MESSAGE_UPDATE_BUFFER_ATTR: {
1564             pa_memblockq_apply_attr(s->memblockq, &s->buffer_attr);
1565             pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
1566             return 0;
1567         }
1568     }
1569
1570     return pa_sink_input_process_msg(o, code, userdata, offset, chunk);
1571 }
1572
1573 /* Called from thread context */
1574 static int sink_input_pop_cb(pa_sink_input *i, size_t nbytes, pa_memchunk *chunk) {
1575     playback_stream *s;
1576
1577     pa_sink_input_assert_ref(i);
1578     s = PLAYBACK_STREAM(i->userdata);
1579     playback_stream_assert_ref(s);
1580     pa_assert(chunk);
1581
1582 #ifdef PROTOCOL_NATIVE_DEBUG
1583     pa_log("%s, pop(): %lu", pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME), (unsigned long) pa_memblockq_get_length(s->memblockq));
1584 #endif
1585
1586     if (pa_memblockq_is_readable(s->memblockq))
1587         s->is_underrun = FALSE;
1588     else {
1589         if (!s->is_underrun)
1590             pa_log_debug("Underrun on '%s', %lu bytes in queue.", pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME)), (unsigned long) pa_memblockq_get_length(s->memblockq));
1591
1592         if (s->drain_request && pa_sink_input_safe_to_remove(i)) {
1593             s->drain_request = FALSE;
1594             pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_DRAIN_ACK, PA_UINT_TO_PTR(s->drain_tag), 0, NULL, NULL);
1595         } else if (!s->is_underrun)
1596             pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_UNDERFLOW, NULL, pa_memblockq_get_read_index(s->memblockq), NULL, NULL);
1597
1598         s->is_underrun = TRUE;
1599
1600         playback_stream_request_bytes(s);
1601     }
1602
1603     /* This call will not fail with prebuf=0, hence we check for
1604        underrun explicitly above */
1605     if (pa_memblockq_peek(s->memblockq, chunk) < 0)
1606         return -1;
1607
1608     chunk->length = PA_MIN(nbytes, chunk->length);
1609
1610     if (i->thread_info.underrun_for > 0)
1611         pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_STARTED, NULL, 0, NULL, NULL);
1612
1613     pa_memblockq_drop(s->memblockq, chunk->length);
1614     playback_stream_request_bytes(s);
1615
1616     return 0;
1617 }
1618
1619 /* Called from thread context */
1620 static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes) {
1621     playback_stream *s;
1622
1623     pa_sink_input_assert_ref(i);
1624     s = PLAYBACK_STREAM(i->userdata);
1625     playback_stream_assert_ref(s);
1626
1627     /* If we are in an underrun, then we don't rewind */
1628     if (i->thread_info.underrun_for > 0)
1629         return;
1630
1631     pa_memblockq_rewind(s->memblockq, nbytes);
1632 }
1633
1634 /* Called from thread context */
1635 static void sink_input_update_max_rewind_cb(pa_sink_input *i, size_t nbytes) {
1636     playback_stream *s;
1637
1638     pa_sink_input_assert_ref(i);
1639     s = PLAYBACK_STREAM(i->userdata);
1640     playback_stream_assert_ref(s);
1641
1642     pa_memblockq_set_maxrewind(s->memblockq, nbytes);
1643 }
1644
1645 /* Called from thread context */
1646 static void sink_input_update_max_request_cb(pa_sink_input *i, size_t nbytes) {
1647     playback_stream *s;
1648     size_t new_tlength, old_tlength;
1649
1650     pa_sink_input_assert_ref(i);
1651     s = PLAYBACK_STREAM(i->userdata);
1652     playback_stream_assert_ref(s);
1653
1654     old_tlength = pa_memblockq_get_tlength(s->memblockq);
1655     new_tlength = nbytes+2*pa_memblockq_get_minreq(s->memblockq);
1656
1657     if (old_tlength < new_tlength) {
1658         pa_log_debug("max_request changed, trying to update from %zu to %zu.", old_tlength, new_tlength);
1659         pa_memblockq_set_tlength(s->memblockq, new_tlength);
1660         new_tlength = pa_memblockq_get_tlength(s->memblockq);
1661
1662         if (new_tlength == old_tlength)
1663             pa_log_debug("Failed to increase tlength");
1664         else {
1665             pa_log_debug("Notifying client about increased tlength");
1666             pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_UPDATE_TLENGTH, NULL, pa_memblockq_get_tlength(s->memblockq), NULL, NULL);
1667         }
1668     }
1669 }
1670
1671 /* Called from main context */
1672 static void sink_input_kill_cb(pa_sink_input *i) {
1673     playback_stream *s;
1674
1675     pa_sink_input_assert_ref(i);
1676     s = PLAYBACK_STREAM(i->userdata);
1677     playback_stream_assert_ref(s);
1678
1679     playback_stream_send_killed(s);
1680     playback_stream_unlink(s);
1681 }
1682
1683 /* Called from main context */
1684 static void sink_input_send_event_cb(pa_sink_input *i, const char *event, pa_proplist *pl) {
1685     playback_stream *s;
1686     pa_tagstruct *t;
1687
1688     pa_sink_input_assert_ref(i);
1689     s = PLAYBACK_STREAM(i->userdata);
1690     playback_stream_assert_ref(s);
1691
1692     if (s->connection->version < 15)
1693       return;
1694
1695     t = pa_tagstruct_new(NULL, 0);
1696     pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_STREAM_EVENT);
1697     pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1698     pa_tagstruct_putu32(t, s->index);
1699     pa_tagstruct_puts(t, event);
1700     pa_tagstruct_put_proplist(t, pl);
1701     pa_pstream_send_tagstruct(s->connection->pstream, t);
1702 }
1703
1704 /* Called from main context */
1705 static void sink_input_suspend_cb(pa_sink_input *i, pa_bool_t suspend) {
1706     playback_stream *s;
1707     pa_tagstruct *t;
1708
1709     pa_sink_input_assert_ref(i);
1710     s = PLAYBACK_STREAM(i->userdata);
1711     playback_stream_assert_ref(s);
1712
1713     if (s->connection->version < 12)
1714       return;
1715
1716     t = pa_tagstruct_new(NULL, 0);
1717     pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_STREAM_SUSPENDED);
1718     pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1719     pa_tagstruct_putu32(t, s->index);
1720     pa_tagstruct_put_boolean(t, suspend);
1721     pa_pstream_send_tagstruct(s->connection->pstream, t);
1722 }
1723
1724 /* Called from main context */
1725 static void sink_input_moving_cb(pa_sink_input *i, pa_sink *dest) {
1726     playback_stream *s;
1727     pa_tagstruct *t;
1728
1729     pa_sink_input_assert_ref(i);
1730     s = PLAYBACK_STREAM(i->userdata);
1731     playback_stream_assert_ref(s);
1732
1733     if (!dest)
1734         return;
1735
1736     fix_playback_buffer_attr(s);
1737     pa_memblockq_apply_attr(s->memblockq, &s->buffer_attr);
1738     pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
1739
1740     if (s->connection->version < 12)
1741       return;
1742
1743     t = pa_tagstruct_new(NULL, 0);
1744     pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_STREAM_MOVED);
1745     pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1746     pa_tagstruct_putu32(t, s->index);
1747     pa_tagstruct_putu32(t, dest->index);
1748     pa_tagstruct_puts(t, dest->name);
1749     pa_tagstruct_put_boolean(t, pa_sink_get_state(dest) == PA_SINK_SUSPENDED);
1750
1751     if (s->connection->version >= 13) {
1752         pa_tagstruct_putu32(t, s->buffer_attr.maxlength);
1753         pa_tagstruct_putu32(t, s->buffer_attr.tlength);
1754         pa_tagstruct_putu32(t, s->buffer_attr.prebuf);
1755         pa_tagstruct_putu32(t, s->buffer_attr.minreq);
1756         pa_tagstruct_put_usec(t, s->configured_sink_latency);
1757     }
1758
1759     pa_pstream_send_tagstruct(s->connection->pstream, t);
1760 }
1761
1762 /*** source_output callbacks ***/
1763
1764 /* Called from thread context */
1765 static int source_output_process_msg(pa_msgobject *_o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1766     pa_source_output *o = PA_SOURCE_OUTPUT(_o);
1767     record_stream *s;
1768
1769     pa_source_output_assert_ref(o);
1770     s = RECORD_STREAM(o->userdata);
1771     record_stream_assert_ref(s);
1772
1773     switch (code) {
1774         case SOURCE_OUTPUT_MESSAGE_UPDATE_LATENCY:
1775             /* Atomically get a snapshot of all timing parameters... */
1776             s->current_monitor_latency = o->source->monitor_of ? pa_sink_get_latency_within_thread(o->source->monitor_of) : 0;
1777             s->current_source_latency = pa_source_get_latency_within_thread(o->source);
1778             s->on_the_fly_snapshot = pa_atomic_load(&s->on_the_fly);
1779             return 0;
1780     }
1781
1782     return pa_source_output_process_msg(_o, code, userdata, offset, chunk);
1783 }
1784
1785 /* Called from thread context */
1786 static void source_output_push_cb(pa_source_output *o, const pa_memchunk *chunk) {
1787     record_stream *s;
1788
1789     pa_source_output_assert_ref(o);
1790     s = RECORD_STREAM(o->userdata);
1791     record_stream_assert_ref(s);
1792     pa_assert(chunk);
1793
1794     pa_atomic_add(&s->on_the_fly, chunk->length);
1795     pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), RECORD_STREAM_MESSAGE_POST_DATA, NULL, 0, chunk, NULL);
1796 }
1797
1798 static void source_output_kill_cb(pa_source_output *o) {
1799     record_stream *s;
1800
1801     pa_source_output_assert_ref(o);
1802     s = RECORD_STREAM(o->userdata);
1803     record_stream_assert_ref(s);
1804
1805     record_stream_send_killed(s);
1806     record_stream_unlink(s);
1807 }
1808
1809 static pa_usec_t source_output_get_latency_cb(pa_source_output *o) {
1810     record_stream *s;
1811
1812     pa_source_output_assert_ref(o);
1813     s = RECORD_STREAM(o->userdata);
1814     record_stream_assert_ref(s);
1815
1816     /*pa_log("get_latency: %u", pa_memblockq_get_length(s->memblockq));*/
1817
1818     return pa_bytes_to_usec(pa_memblockq_get_length(s->memblockq), &o->sample_spec);
1819 }
1820
1821 /* Called from main context */
1822 static void source_output_send_event_cb(pa_source_output *o, const char *event, pa_proplist *pl) {
1823     record_stream *s;
1824     pa_tagstruct *t;
1825
1826     pa_source_output_assert_ref(o);
1827     s = RECORD_STREAM(o->userdata);
1828     record_stream_assert_ref(s);
1829
1830     if (s->connection->version < 15)
1831       return;
1832
1833     t = pa_tagstruct_new(NULL, 0);
1834     pa_tagstruct_putu32(t, PA_COMMAND_RECORD_STREAM_EVENT);
1835     pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1836     pa_tagstruct_putu32(t, s->index);
1837     pa_tagstruct_puts(t, event);
1838     pa_tagstruct_put_proplist(t, pl);
1839     pa_pstream_send_tagstruct(s->connection->pstream, t);
1840 }
1841
1842 /* Called from main context */
1843 static void source_output_suspend_cb(pa_source_output *o, pa_bool_t suspend) {
1844     record_stream *s;
1845     pa_tagstruct *t;
1846
1847     pa_source_output_assert_ref(o);
1848     s = RECORD_STREAM(o->userdata);
1849     record_stream_assert_ref(s);
1850
1851     if (s->connection->version < 12)
1852       return;
1853
1854     t = pa_tagstruct_new(NULL, 0);
1855     pa_tagstruct_putu32(t, PA_COMMAND_RECORD_STREAM_SUSPENDED);
1856     pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1857     pa_tagstruct_putu32(t, s->index);
1858     pa_tagstruct_put_boolean(t, suspend);
1859     pa_pstream_send_tagstruct(s->connection->pstream, t);
1860 }
1861
1862 /* Called from main context */
1863 static void source_output_moving_cb(pa_source_output *o, pa_source *dest) {
1864     record_stream *s;
1865     pa_tagstruct *t;
1866
1867     pa_source_output_assert_ref(o);
1868     s = RECORD_STREAM(o->userdata);
1869     record_stream_assert_ref(s);
1870
1871     if (!dest)
1872         return;
1873
1874     fix_record_buffer_attr_pre(s);
1875     pa_memblockq_set_maxlength(s->memblockq, s->buffer_attr.maxlength);
1876     pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
1877     fix_record_buffer_attr_post(s);
1878
1879     if (s->connection->version < 12)
1880       return;
1881
1882     t = pa_tagstruct_new(NULL, 0);
1883     pa_tagstruct_putu32(t, PA_COMMAND_RECORD_STREAM_MOVED);
1884     pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1885     pa_tagstruct_putu32(t, s->index);
1886     pa_tagstruct_putu32(t, dest->index);
1887     pa_tagstruct_puts(t, dest->name);
1888     pa_tagstruct_put_boolean(t, pa_source_get_state(dest) == PA_SOURCE_SUSPENDED);
1889
1890     if (s->connection->version >= 13) {
1891         pa_tagstruct_putu32(t, s->buffer_attr.maxlength);
1892         pa_tagstruct_putu32(t, s->buffer_attr.fragsize);
1893         pa_tagstruct_put_usec(t, s->configured_source_latency);
1894     }
1895
1896     pa_pstream_send_tagstruct(s->connection->pstream, t);
1897 }
1898
1899 /*** pdispatch callbacks ***/
1900
1901 static void protocol_error(pa_native_connection *c) {
1902     pa_log("protocol error, kicking client");
1903     native_connection_unlink(c);
1904 }
1905
1906 #define CHECK_VALIDITY(pstream, expression, tag, error) do { \
1907 if (!(expression)) { \
1908     pa_pstream_send_error((pstream), (tag), (error)); \
1909     return; \
1910 } \
1911 } while(0);
1912
1913 #define CHECK_VALIDITY_GOTO(pstream, expression, tag, error, label) do { \
1914 if (!(expression)) { \
1915     pa_pstream_send_error((pstream), (tag), (error)); \
1916     goto label; \
1917 } \
1918 } while(0);
1919
1920 static pa_tagstruct *reply_new(uint32_t tag) {
1921     pa_tagstruct *reply;
1922
1923     reply = pa_tagstruct_new(NULL, 0);
1924     pa_tagstruct_putu32(reply, PA_COMMAND_REPLY);
1925     pa_tagstruct_putu32(reply, tag);
1926     return reply;
1927 }
1928
1929 static void command_create_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
1930     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
1931     playback_stream *s;
1932     uint32_t sink_index, syncid, missing = 0;
1933     pa_buffer_attr attr;
1934     const char *name = NULL, *sink_name;
1935     pa_sample_spec ss;
1936     pa_channel_map map;
1937     pa_tagstruct *reply;
1938     pa_sink *sink = NULL;
1939     pa_cvolume volume;
1940     pa_bool_t
1941         corked = FALSE,
1942         no_remap = FALSE,
1943         no_remix = FALSE,
1944         fix_format = FALSE,
1945         fix_rate = FALSE,
1946         fix_channels = FALSE,
1947         no_move = FALSE,
1948         variable_rate = FALSE,
1949         muted = FALSE,
1950         adjust_latency = FALSE,
1951         early_requests = FALSE,
1952         dont_inhibit_auto_suspend = FALSE,
1953         volume_set = TRUE,
1954         muted_set = FALSE,
1955         fail_on_suspend = FALSE,
1956         relative_volume = FALSE,
1957         passthrough = FALSE;
1958
1959     pa_sink_input_flags_t flags = 0;
1960     pa_proplist *p = NULL;
1961     int ret = PA_ERR_INVALID;
1962     uint8_t n_formats = 0;
1963     pa_format_info *format;
1964     pa_idxset *formats = NULL;
1965     uint32_t i;
1966
1967     pa_native_connection_assert_ref(c);
1968     pa_assert(t);
1969     memset(&attr, 0, sizeof(attr));
1970
1971     if ((c->version < 13 && (pa_tagstruct_gets(t, &name) < 0 || !name)) ||
1972         pa_tagstruct_get(
1973                 t,
1974                 PA_TAG_SAMPLE_SPEC, &ss,
1975                 PA_TAG_CHANNEL_MAP, &map,
1976                 PA_TAG_U32, &sink_index,
1977                 PA_TAG_STRING, &sink_name,
1978                 PA_TAG_U32, &attr.maxlength,
1979                 PA_TAG_BOOLEAN, &corked,
1980                 PA_TAG_U32, &attr.tlength,
1981                 PA_TAG_U32, &attr.prebuf,
1982                 PA_TAG_U32, &attr.minreq,
1983                 PA_TAG_U32, &syncid,
1984                 PA_TAG_CVOLUME, &volume,
1985                 PA_TAG_INVALID) < 0) {
1986
1987         protocol_error(c);
1988         goto finish;
1989     }
1990
1991     CHECK_VALIDITY_GOTO(c->pstream, c->authorized, tag, PA_ERR_ACCESS, finish);
1992     CHECK_VALIDITY_GOTO(c->pstream, !sink_name || pa_namereg_is_valid_name_or_wildcard(sink_name, PA_NAMEREG_SINK), tag, PA_ERR_INVALID, finish);
1993     CHECK_VALIDITY_GOTO(c->pstream, sink_index == PA_INVALID_INDEX || !sink_name, tag, PA_ERR_INVALID, finish);
1994     CHECK_VALIDITY_GOTO(c->pstream, !sink_name || sink_index == PA_INVALID_INDEX, tag, PA_ERR_INVALID, finish);
1995     CHECK_VALIDITY_GOTO(c->pstream, pa_cvolume_valid(&volume), tag, PA_ERR_INVALID, finish);
1996
1997     p = pa_proplist_new();
1998
1999     if (name)
2000         pa_proplist_sets(p, PA_PROP_MEDIA_NAME, name);
2001
2002     if (c->version >= 12) {
2003         /* Since 0.9.8 the user can ask for a couple of additional flags */
2004
2005         if (pa_tagstruct_get_boolean(t, &no_remap) < 0 ||
2006             pa_tagstruct_get_boolean(t, &no_remix) < 0 ||
2007             pa_tagstruct_get_boolean(t, &fix_format) < 0 ||
2008             pa_tagstruct_get_boolean(t, &fix_rate) < 0 ||
2009             pa_tagstruct_get_boolean(t, &fix_channels) < 0 ||
2010             pa_tagstruct_get_boolean(t, &no_move) < 0 ||
2011             pa_tagstruct_get_boolean(t, &variable_rate) < 0) {
2012
2013             protocol_error(c);
2014             goto finish;
2015         }
2016     }
2017
2018     if (c->version >= 13) {
2019
2020         if (pa_tagstruct_get_boolean(t, &muted) < 0 ||
2021             pa_tagstruct_get_boolean(t, &adjust_latency) < 0 ||
2022             pa_tagstruct_get_proplist(t, p) < 0) {
2023
2024             protocol_error(c);
2025             goto finish;
2026         }
2027     }
2028
2029     if (c->version >= 14) {
2030
2031         if (pa_tagstruct_get_boolean(t, &volume_set) < 0 ||
2032             pa_tagstruct_get_boolean(t, &early_requests) < 0) {
2033
2034             protocol_error(c);
2035             goto finish;
2036         }
2037     }
2038
2039     if (c->version >= 15) {
2040
2041         if (pa_tagstruct_get_boolean(t, &muted_set) < 0 ||
2042             pa_tagstruct_get_boolean(t, &dont_inhibit_auto_suspend) < 0 ||
2043             pa_tagstruct_get_boolean(t, &fail_on_suspend) < 0) {
2044
2045             protocol_error(c);
2046             goto finish;
2047         }
2048     }
2049
2050     if (c->version >= 17) {
2051
2052         if (pa_tagstruct_get_boolean(t, &relative_volume) < 0) {
2053
2054             protocol_error(c);
2055             goto finish;
2056         }
2057     }
2058
2059     if (c->version >= 18) {
2060
2061         if (pa_tagstruct_get_boolean(t, &passthrough) < 0 ) {
2062             protocol_error(c);
2063             goto finish;
2064         }
2065     }
2066
2067     if (c->version >= 21) {
2068
2069         if (pa_tagstruct_getu8(t, &n_formats) < 0) {
2070             protocol_error(c);
2071             goto finish;
2072         }
2073
2074         if (n_formats)
2075             formats = pa_idxset_new(NULL, NULL);
2076
2077         for (i = 0; i < n_formats; i++) {
2078             format = pa_format_info_new();
2079             if (pa_tagstruct_get_format_info(t, format) < 0) {
2080                 protocol_error(c);
2081                 goto finish;
2082             }
2083             pa_idxset_put(formats, format, NULL);
2084         }
2085     }
2086
2087     if (n_formats == 0) {
2088         CHECK_VALIDITY_GOTO(c->pstream, pa_sample_spec_valid(&ss), tag, PA_ERR_INVALID, finish);
2089         CHECK_VALIDITY_GOTO(c->pstream, map.channels == ss.channels && volume.channels == ss.channels, tag, PA_ERR_INVALID, finish);
2090         CHECK_VALIDITY_GOTO(c->pstream, pa_channel_map_valid(&map), tag, PA_ERR_INVALID, finish);
2091     } else {
2092         PA_IDXSET_FOREACH(format, formats, i) {
2093             CHECK_VALIDITY_GOTO(c->pstream, pa_format_info_valid(format), tag, PA_ERR_INVALID, finish);
2094         }
2095     }
2096
2097     if (!pa_tagstruct_eof(t)) {
2098         protocol_error(c);
2099         goto finish;
2100     }
2101
2102     if (sink_index != PA_INVALID_INDEX) {
2103
2104         if (!(sink = pa_idxset_get_by_index(c->protocol->core->sinks, sink_index))) {
2105             pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2106             goto finish;
2107         }
2108
2109     } else if (sink_name) {
2110
2111         if (!(sink = pa_namereg_get(c->protocol->core, sink_name, PA_NAMEREG_SINK))) {
2112             pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2113             goto finish;
2114         }
2115     }
2116
2117     flags =
2118         (corked ? PA_SINK_INPUT_START_CORKED : 0) |
2119         (no_remap ? PA_SINK_INPUT_NO_REMAP : 0) |
2120         (no_remix ? PA_SINK_INPUT_NO_REMIX : 0) |
2121         (fix_format ? PA_SINK_INPUT_FIX_FORMAT : 0) |
2122         (fix_rate ? PA_SINK_INPUT_FIX_RATE : 0) |
2123         (fix_channels ? PA_SINK_INPUT_FIX_CHANNELS : 0) |
2124         (no_move ? PA_SINK_INPUT_DONT_MOVE : 0) |
2125         (variable_rate ? PA_SINK_INPUT_VARIABLE_RATE : 0) |
2126         (dont_inhibit_auto_suspend ? PA_SINK_INPUT_DONT_INHIBIT_AUTO_SUSPEND : 0) |
2127         (fail_on_suspend ? PA_SINK_INPUT_NO_CREATE_ON_SUSPEND|PA_SINK_INPUT_KILL_ON_SUSPEND : 0) |
2128         (passthrough ? PA_SINK_INPUT_PASSTHROUGH : 0);
2129
2130     /* Only since protocol version 15 there's a separate muted_set
2131      * flag. For older versions we synthesize it here */
2132     muted_set = muted_set || muted;
2133
2134     s = playback_stream_new(c, sink, &ss, &map, formats, &attr, volume_set ? &volume : NULL, muted, muted_set, flags, p, adjust_latency, early_requests, relative_volume, syncid, &missing, &ret);
2135     /* We no longer own the formats idxset */
2136     formats = NULL;
2137
2138     CHECK_VALIDITY_GOTO(c->pstream, s, tag, ret, finish);
2139
2140     reply = reply_new(tag);
2141     pa_tagstruct_putu32(reply, s->index);
2142     pa_assert(s->sink_input);
2143     pa_tagstruct_putu32(reply, s->sink_input->index);
2144     pa_tagstruct_putu32(reply, missing);
2145
2146 #ifdef PROTOCOL_NATIVE_DEBUG
2147     pa_log("initial request is %u", missing);
2148 #endif
2149
2150     if (c->version >= 9) {
2151         /* Since 0.9.0 we support sending the buffer metrics back to the client */
2152
2153         pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.maxlength);
2154         pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.tlength);
2155         pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.prebuf);
2156         pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.minreq);
2157     }
2158
2159     if (c->version >= 12) {
2160         /* Since 0.9.8 we support sending the chosen sample
2161          * spec/channel map/device/suspend status back to the
2162          * client */
2163
2164         pa_tagstruct_put_sample_spec(reply, &ss);
2165         pa_tagstruct_put_channel_map(reply, &map);
2166
2167         pa_tagstruct_putu32(reply, s->sink_input->sink->index);
2168         pa_tagstruct_puts(reply, s->sink_input->sink->name);
2169
2170         pa_tagstruct_put_boolean(reply, pa_sink_get_state(s->sink_input->sink) == PA_SINK_SUSPENDED);
2171     }
2172
2173     if (c->version >= 13)
2174         pa_tagstruct_put_usec(reply, s->configured_sink_latency);
2175
2176     if (c->version >= 21) {
2177         /* Send back the format we negotiated */
2178         if (s->sink_input->format)
2179             pa_tagstruct_put_format_info(reply, s->sink_input->format);
2180         else {
2181             pa_format_info *f = pa_format_info_new();
2182             pa_tagstruct_put_format_info(reply, f);
2183             pa_format_info_free(f);
2184         }
2185     }
2186
2187     pa_pstream_send_tagstruct(c->pstream, reply);
2188
2189 finish:
2190     if (p)
2191         pa_proplist_free(p);
2192     if (formats)
2193         pa_idxset_free(formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
2194 }
2195
2196 static void command_delete_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2197     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2198     uint32_t channel;
2199
2200     pa_native_connection_assert_ref(c);
2201     pa_assert(t);
2202
2203     if (pa_tagstruct_getu32(t, &channel) < 0 ||
2204         !pa_tagstruct_eof(t)) {
2205         protocol_error(c);
2206         return;
2207     }
2208
2209     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2210
2211     switch (command) {
2212
2213         case PA_COMMAND_DELETE_PLAYBACK_STREAM: {
2214             playback_stream *s;
2215             if (!(s = pa_idxset_get_by_index(c->output_streams, channel)) || !playback_stream_isinstance(s)) {
2216                 pa_pstream_send_error(c->pstream, tag, PA_ERR_EXIST);
2217                 return;
2218             }
2219
2220             playback_stream_unlink(s);
2221             break;
2222         }
2223
2224         case PA_COMMAND_DELETE_RECORD_STREAM: {
2225             record_stream *s;
2226             if (!(s = pa_idxset_get_by_index(c->record_streams, channel))) {
2227                 pa_pstream_send_error(c->pstream, tag, PA_ERR_EXIST);
2228                 return;
2229             }
2230
2231             record_stream_unlink(s);
2232             break;
2233         }
2234
2235         case PA_COMMAND_DELETE_UPLOAD_STREAM: {
2236             upload_stream *s;
2237
2238             if (!(s = pa_idxset_get_by_index(c->output_streams, channel)) || !upload_stream_isinstance(s)) {
2239                 pa_pstream_send_error(c->pstream, tag, PA_ERR_EXIST);
2240                 return;
2241             }
2242
2243             upload_stream_unlink(s);
2244             break;
2245         }
2246
2247         default:
2248             pa_assert_not_reached();
2249     }
2250
2251     pa_pstream_send_simple_ack(c->pstream, tag);
2252 }
2253
2254 static void command_create_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2255     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2256     record_stream *s;
2257     pa_buffer_attr attr;
2258     uint32_t source_index;
2259     const char *name = NULL, *source_name;
2260     pa_sample_spec ss;
2261     pa_channel_map map;
2262     pa_tagstruct *reply;
2263     pa_source *source = NULL;
2264     pa_cvolume volume;
2265     pa_bool_t
2266         corked = FALSE,
2267         no_remap = FALSE,
2268         no_remix = FALSE,
2269         fix_format = FALSE,
2270         fix_rate = FALSE,
2271         fix_channels = FALSE,
2272         no_move = FALSE,
2273         variable_rate = FALSE,
2274         muted = FALSE,
2275         adjust_latency = FALSE,
2276         peak_detect = FALSE,
2277         early_requests = FALSE,
2278         dont_inhibit_auto_suspend = FALSE,
2279         volume_set = FALSE,
2280         muted_set = FALSE,
2281         fail_on_suspend = FALSE,
2282         relative_volume = FALSE,
2283         passthrough = FALSE;
2284
2285     pa_source_output_flags_t flags = 0;
2286     pa_proplist *p = NULL;
2287     uint32_t direct_on_input_idx = PA_INVALID_INDEX;
2288     pa_sink_input *direct_on_input = NULL;
2289     int ret = PA_ERR_INVALID;
2290     uint8_t n_formats = 0;
2291     pa_format_info *format;
2292     pa_idxset *formats = NULL;
2293     uint32_t i;
2294
2295     pa_native_connection_assert_ref(c);
2296     pa_assert(t);
2297
2298     memset(&attr, 0, sizeof(attr));
2299
2300     if ((c->version < 13 && (pa_tagstruct_gets(t, &name) < 0 || !name)) ||
2301         pa_tagstruct_get_sample_spec(t, &ss) < 0 ||
2302         pa_tagstruct_get_channel_map(t, &map) < 0 ||
2303         pa_tagstruct_getu32(t, &source_index) < 0 ||
2304         pa_tagstruct_gets(t, &source_name) < 0 ||
2305         pa_tagstruct_getu32(t, &attr.maxlength) < 0 ||
2306         pa_tagstruct_get_boolean(t, &corked) < 0 ||
2307         pa_tagstruct_getu32(t, &attr.fragsize) < 0) {
2308
2309         protocol_error(c);
2310         goto finish;
2311     }
2312
2313     CHECK_VALIDITY_GOTO(c->pstream, c->authorized, tag, PA_ERR_ACCESS, finish);
2314     CHECK_VALIDITY_GOTO(c->pstream, !source_name || pa_namereg_is_valid_name_or_wildcard(source_name, PA_NAMEREG_SOURCE), tag, PA_ERR_INVALID, finish);
2315     CHECK_VALIDITY_GOTO(c->pstream, source_index == PA_INVALID_INDEX || !source_name, tag, PA_ERR_INVALID, finish);
2316     CHECK_VALIDITY_GOTO(c->pstream, !source_name || source_index == PA_INVALID_INDEX, tag, PA_ERR_INVALID, finish);
2317
2318     p = pa_proplist_new();
2319
2320     if (name)
2321         pa_proplist_sets(p, PA_PROP_MEDIA_NAME, name);
2322
2323     if (c->version >= 12) {
2324         /* Since 0.9.8 the user can ask for a couple of additional flags */
2325
2326         if (pa_tagstruct_get_boolean(t, &no_remap) < 0 ||
2327             pa_tagstruct_get_boolean(t, &no_remix) < 0 ||
2328             pa_tagstruct_get_boolean(t, &fix_format) < 0 ||
2329             pa_tagstruct_get_boolean(t, &fix_rate) < 0 ||
2330             pa_tagstruct_get_boolean(t, &fix_channels) < 0 ||
2331             pa_tagstruct_get_boolean(t, &no_move) < 0 ||
2332             pa_tagstruct_get_boolean(t, &variable_rate) < 0) {
2333
2334             protocol_error(c);
2335             goto finish;
2336         }
2337     }
2338
2339     if (c->version >= 13) {
2340
2341         if (pa_tagstruct_get_boolean(t, &peak_detect) < 0 ||
2342             pa_tagstruct_get_boolean(t, &adjust_latency) < 0 ||
2343             pa_tagstruct_get_proplist(t, p) < 0 ||
2344             pa_tagstruct_getu32(t, &direct_on_input_idx) < 0) {
2345
2346             protocol_error(c);
2347             goto finish;
2348         }
2349     }
2350
2351     if (c->version >= 14) {
2352
2353         if (pa_tagstruct_get_boolean(t, &early_requests) < 0) {
2354             protocol_error(c);
2355             goto finish;
2356         }
2357     }
2358
2359     if (c->version >= 15) {
2360
2361         if (pa_tagstruct_get_boolean(t, &dont_inhibit_auto_suspend) < 0 ||
2362             pa_tagstruct_get_boolean(t, &fail_on_suspend) < 0) {
2363
2364             protocol_error(c);
2365             goto finish;
2366         }
2367     }
2368
2369     if (c->version >= 22) {
2370         /* For newer client versions (with per-source-output volumes), we try
2371          * to make the behaviour for playback and record streams the same. */
2372         volume_set = TRUE;
2373
2374         if (pa_tagstruct_getu8(t, &n_formats) < 0) {
2375             protocol_error(c);
2376             goto finish;
2377         }
2378
2379         if (n_formats)
2380             formats = pa_idxset_new(NULL, NULL);
2381
2382         for (i = 0; i < n_formats; i++) {
2383             format = pa_format_info_new();
2384             if (pa_tagstruct_get_format_info(t, format) < 0) {
2385                 protocol_error(c);
2386                 goto finish;
2387             }
2388             pa_idxset_put(formats, format, NULL);
2389         }
2390
2391         if (pa_tagstruct_get_cvolume(t, &volume) < 0 ||
2392             pa_tagstruct_get_boolean(t, &muted) < 0 ||
2393             pa_tagstruct_get_boolean(t, &volume_set) < 0 ||
2394             pa_tagstruct_get_boolean(t, &muted_set) < 0 ||
2395             pa_tagstruct_get_boolean(t, &relative_volume) < 0 ||
2396             pa_tagstruct_get_boolean(t, &passthrough) < 0) {
2397
2398             protocol_error(c);
2399             goto finish;
2400         }
2401
2402         CHECK_VALIDITY_GOTO(c->pstream, pa_cvolume_valid(&volume), tag, PA_ERR_INVALID, finish);
2403     }
2404
2405     if (n_formats == 0) {
2406         CHECK_VALIDITY_GOTO(c->pstream, pa_sample_spec_valid(&ss), tag, PA_ERR_INVALID, finish);
2407         CHECK_VALIDITY_GOTO(c->pstream, map.channels == ss.channels, tag, PA_ERR_INVALID, finish);
2408         CHECK_VALIDITY_GOTO(c->pstream, c->version < 22 || (volume.channels == ss.channels), tag, PA_ERR_INVALID, finish);
2409         CHECK_VALIDITY_GOTO(c->pstream, pa_channel_map_valid(&map), tag, PA_ERR_INVALID, finish);
2410     } else {
2411         PA_IDXSET_FOREACH(format, formats, i) {
2412             CHECK_VALIDITY_GOTO(c->pstream, pa_format_info_valid(format), tag, PA_ERR_INVALID, finish);
2413         }
2414     }
2415
2416
2417     if (!pa_tagstruct_eof(t)) {
2418         protocol_error(c);
2419         goto finish;
2420     }
2421
2422     if (source_index != PA_INVALID_INDEX) {
2423
2424         if (!(source = pa_idxset_get_by_index(c->protocol->core->sources, source_index))) {
2425             pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2426             goto finish;
2427         }
2428
2429     } else if (source_name) {
2430
2431         if (!(source = pa_namereg_get(c->protocol->core, source_name, PA_NAMEREG_SOURCE))) {
2432             pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2433             goto finish;
2434         }
2435     }
2436
2437     if (direct_on_input_idx != PA_INVALID_INDEX) {
2438
2439         if (!(direct_on_input = pa_idxset_get_by_index(c->protocol->core->sink_inputs, direct_on_input_idx))) {
2440             pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2441             goto finish;
2442         }
2443     }
2444
2445     flags =
2446         (corked ? PA_SOURCE_OUTPUT_START_CORKED : 0) |
2447         (no_remap ? PA_SOURCE_OUTPUT_NO_REMAP : 0) |
2448         (no_remix ? PA_SOURCE_OUTPUT_NO_REMIX : 0) |
2449         (fix_format ? PA_SOURCE_OUTPUT_FIX_FORMAT : 0) |
2450         (fix_rate ? PA_SOURCE_OUTPUT_FIX_RATE : 0) |
2451         (fix_channels ? PA_SOURCE_OUTPUT_FIX_CHANNELS : 0) |
2452         (no_move ? PA_SOURCE_OUTPUT_DONT_MOVE : 0) |
2453         (variable_rate ? PA_SOURCE_OUTPUT_VARIABLE_RATE : 0) |
2454         (dont_inhibit_auto_suspend ? PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND : 0) |
2455         (fail_on_suspend ? PA_SOURCE_OUTPUT_NO_CREATE_ON_SUSPEND|PA_SOURCE_OUTPUT_KILL_ON_SUSPEND : 0) |
2456         (passthrough ? PA_SOURCE_OUTPUT_PASSTHROUGH : 0);
2457
2458     s = record_stream_new(c, source, &ss, &map, formats, &attr, volume_set ? &volume : NULL, muted, muted_set, flags, p, adjust_latency, early_requests, relative_volume, peak_detect, direct_on_input, &ret);
2459
2460     CHECK_VALIDITY_GOTO(c->pstream, s, tag, ret, finish);
2461
2462     reply = reply_new(tag);
2463     pa_tagstruct_putu32(reply, s->index);
2464     pa_assert(s->source_output);
2465     pa_tagstruct_putu32(reply, s->source_output->index);
2466
2467     if (c->version >= 9) {
2468         /* Since 0.9 we support sending the buffer metrics back to the client */
2469
2470         pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.maxlength);
2471         pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.fragsize);
2472     }
2473
2474     if (c->version >= 12) {
2475         /* Since 0.9.8 we support sending the chosen sample
2476          * spec/channel map/device/suspend status back to the
2477          * client */
2478
2479         pa_tagstruct_put_sample_spec(reply, &ss);
2480         pa_tagstruct_put_channel_map(reply, &map);
2481
2482         pa_tagstruct_putu32(reply, s->source_output->source->index);
2483         pa_tagstruct_puts(reply, s->source_output->source->name);
2484
2485         pa_tagstruct_put_boolean(reply, pa_source_get_state(s->source_output->source) == PA_SOURCE_SUSPENDED);
2486     }
2487
2488     if (c->version >= 13)
2489         pa_tagstruct_put_usec(reply, s->configured_source_latency);
2490
2491     if (c->version >= 22) {
2492         /* Send back the format we negotiated */
2493         if (s->source_output->format)
2494             pa_tagstruct_put_format_info(reply, s->source_output->format);
2495         else {
2496             pa_format_info *f = pa_format_info_new();
2497             pa_tagstruct_put_format_info(reply, f);
2498             pa_format_info_free(f);
2499         }
2500     }
2501
2502     pa_pstream_send_tagstruct(c->pstream, reply);
2503
2504 finish:
2505     if (p)
2506         pa_proplist_free(p);
2507     if (formats)
2508         pa_idxset_free(formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
2509 }
2510
2511 static void command_exit(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2512     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2513     int ret;
2514
2515     pa_native_connection_assert_ref(c);
2516     pa_assert(t);
2517
2518     if (!pa_tagstruct_eof(t)) {
2519         protocol_error(c);
2520         return;
2521     }
2522
2523     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2524     ret = pa_core_exit(c->protocol->core, FALSE, 0);
2525     CHECK_VALIDITY(c->pstream, ret >= 0, tag, PA_ERR_ACCESS);
2526
2527     pa_log_debug("Client %s asks us to terminate.", pa_strnull(pa_proplist_gets(c->client->proplist, PA_PROP_APPLICATION_PROCESS_BINARY)));
2528
2529     pa_pstream_send_simple_ack(c->pstream, tag); /* nonsense */
2530 }
2531
2532 static void command_auth(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2533     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2534     const void*cookie;
2535     pa_tagstruct *reply;
2536     pa_bool_t shm_on_remote = FALSE, do_shm;
2537
2538     pa_native_connection_assert_ref(c);
2539     pa_assert(t);
2540
2541     if (pa_tagstruct_getu32(t, &c->version) < 0 ||
2542         pa_tagstruct_get_arbitrary(t, &cookie, PA_NATIVE_COOKIE_LENGTH) < 0 ||
2543         !pa_tagstruct_eof(t)) {
2544         protocol_error(c);
2545         return;
2546     }
2547
2548     /* Minimum supported version */
2549     if (c->version < 8) {
2550         pa_pstream_send_error(c->pstream, tag, PA_ERR_VERSION);
2551         return;
2552     }
2553
2554     /* Starting with protocol version 13 the MSB of the version tag
2555        reflects if shm is available for this pa_native_connection or
2556        not. */
2557     if (c->version >= 13) {
2558         shm_on_remote = !!(c->version & 0x80000000U);
2559         c->version &= 0x7FFFFFFFU;
2560     }
2561
2562     pa_log_debug("Protocol version: remote %u, local %u", c->version, PA_PROTOCOL_VERSION);
2563
2564     pa_proplist_setf(c->client->proplist, "native-protocol.version", "%u", c->version);
2565
2566     if (!c->authorized) {
2567         pa_bool_t success = FALSE;
2568
2569 #ifdef HAVE_CREDS
2570         const pa_creds *creds;
2571
2572         if ((creds = pa_pdispatch_creds(pd))) {
2573             if (creds->uid == getuid())
2574                 success = TRUE;
2575             else if (c->options->auth_group) {
2576                 int r;
2577                 gid_t gid;
2578
2579                 if ((gid = pa_get_gid_of_group(c->options->auth_group)) == (gid_t) -1)
2580                     pa_log_warn("Failed to get GID of group '%s'", c->options->auth_group);
2581                 else if (gid == creds->gid)
2582                     success = TRUE;
2583
2584                 if (!success) {
2585                     if ((r = pa_uid_in_group(creds->uid, c->options->auth_group)) < 0)
2586                         pa_log_warn("Failed to check group membership.");
2587                     else if (r > 0)
2588                         success = TRUE;
2589                 }
2590             }
2591
2592             pa_log_info("Got credentials: uid=%lu gid=%lu success=%i",
2593                         (unsigned long) creds->uid,
2594                         (unsigned long) creds->gid,
2595                         (int) success);
2596         }
2597 #endif
2598
2599         if (!success && c->options->auth_cookie) {
2600             const uint8_t *ac;
2601
2602             if ((ac = pa_auth_cookie_read(c->options->auth_cookie, PA_NATIVE_COOKIE_LENGTH)))
2603                 if (memcmp(ac, cookie, PA_NATIVE_COOKIE_LENGTH) == 0)
2604                     success = TRUE;
2605         }
2606
2607         if (!success) {
2608             pa_log_warn("Denied access to client with invalid authorization data.");
2609             pa_pstream_send_error(c->pstream, tag, PA_ERR_ACCESS);
2610             return;
2611         }
2612
2613         c->authorized = TRUE;
2614         if (c->auth_timeout_event) {
2615             c->protocol->core->mainloop->time_free(c->auth_timeout_event);
2616             c->auth_timeout_event = NULL;
2617         }
2618     }
2619
2620     /* Enable shared memory support if possible */
2621     do_shm =
2622         pa_mempool_is_shared(c->protocol->core->mempool) &&
2623         c->is_local;
2624
2625     pa_log_debug("SHM possible: %s", pa_yes_no(do_shm));
2626
2627     if (do_shm)
2628         if (c->version < 10 || (c->version >= 13 && !shm_on_remote))
2629             do_shm = FALSE;
2630
2631 #ifdef HAVE_CREDS
2632     if (do_shm) {
2633         /* Only enable SHM if both sides are owned by the same
2634          * user. This is a security measure because otherwise data
2635          * private to the user might leak. */
2636
2637         const pa_creds *creds;
2638         if (!(creds = pa_pdispatch_creds(pd)) || getuid() != creds->uid)
2639             do_shm = FALSE;
2640     }
2641 #endif
2642
2643     pa_log_debug("Negotiated SHM: %s", pa_yes_no(do_shm));
2644     pa_pstream_enable_shm(c->pstream, do_shm);
2645
2646     reply = reply_new(tag);
2647     pa_tagstruct_putu32(reply, PA_PROTOCOL_VERSION | (do_shm ? 0x80000000 : 0));
2648
2649 #ifdef HAVE_CREDS
2650 {
2651     /* SHM support is only enabled after both sides made sure they are the same user. */
2652
2653     pa_creds ucred;
2654
2655     ucred.uid = getuid();
2656     ucred.gid = getgid();
2657
2658     pa_pstream_send_tagstruct_with_creds(c->pstream, reply, &ucred);
2659 }
2660 #else
2661     pa_pstream_send_tagstruct(c->pstream, reply);
2662 #endif
2663 }
2664
2665 static void command_set_client_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2666     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2667     const char *name = NULL;
2668     pa_proplist *p;
2669     pa_tagstruct *reply;
2670
2671     pa_native_connection_assert_ref(c);
2672     pa_assert(t);
2673
2674     p = pa_proplist_new();
2675
2676     if ((c->version < 13 && pa_tagstruct_gets(t, &name) < 0) ||
2677         (c->version >= 13 && pa_tagstruct_get_proplist(t, p) < 0) ||
2678         !pa_tagstruct_eof(t)) {
2679
2680         protocol_error(c);
2681         pa_proplist_free(p);
2682         return;
2683     }
2684
2685     if (name)
2686         if (pa_proplist_sets(p, PA_PROP_APPLICATION_NAME, name) < 0) {
2687             pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
2688             pa_proplist_free(p);
2689             return;
2690         }
2691
2692     pa_client_update_proplist(c->client, PA_UPDATE_REPLACE, p);
2693     pa_proplist_free(p);
2694
2695     reply = reply_new(tag);
2696
2697     if (c->version >= 13)
2698         pa_tagstruct_putu32(reply, c->client->index);
2699
2700     pa_pstream_send_tagstruct(c->pstream, reply);
2701 }
2702
2703 static void command_lookup(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2704     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2705     const char *name;
2706     uint32_t idx = PA_IDXSET_INVALID;
2707
2708     pa_native_connection_assert_ref(c);
2709     pa_assert(t);
2710
2711     if (pa_tagstruct_gets(t, &name) < 0 ||
2712         !pa_tagstruct_eof(t)) {
2713         protocol_error(c);
2714         return;
2715     }
2716
2717     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2718     CHECK_VALIDITY(c->pstream, name && pa_namereg_is_valid_name_or_wildcard(name, command == PA_COMMAND_LOOKUP_SINK ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE), tag, PA_ERR_INVALID);
2719
2720     if (command == PA_COMMAND_LOOKUP_SINK) {
2721         pa_sink *sink;
2722         if ((sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK)))
2723             idx = sink->index;
2724     } else {
2725         pa_source *source;
2726         pa_assert(command == PA_COMMAND_LOOKUP_SOURCE);
2727         if ((source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE)))
2728             idx = source->index;
2729     }
2730
2731     if (idx == PA_IDXSET_INVALID)
2732         pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2733     else {
2734         pa_tagstruct *reply;
2735         reply = reply_new(tag);
2736         pa_tagstruct_putu32(reply, idx);
2737         pa_pstream_send_tagstruct(c->pstream, reply);
2738     }
2739 }
2740
2741 static void command_drain_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2742     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2743     uint32_t idx;
2744     playback_stream *s;
2745
2746     pa_native_connection_assert_ref(c);
2747     pa_assert(t);
2748
2749     if (pa_tagstruct_getu32(t, &idx) < 0 ||
2750         !pa_tagstruct_eof(t)) {
2751         protocol_error(c);
2752         return;
2753     }
2754
2755     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2756     s = pa_idxset_get_by_index(c->output_streams, idx);
2757     CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
2758     CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
2759
2760     pa_asyncmsgq_post(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_DRAIN, PA_UINT_TO_PTR(tag), 0, NULL, NULL);
2761 }
2762
2763 static void command_stat(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2764     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2765     pa_tagstruct *reply;
2766     const pa_mempool_stat *stat;
2767
2768     pa_native_connection_assert_ref(c);
2769     pa_assert(t);
2770
2771     if (!pa_tagstruct_eof(t)) {
2772         protocol_error(c);
2773         return;
2774     }
2775
2776     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2777
2778     stat = pa_mempool_get_stat(c->protocol->core->mempool);
2779
2780     reply = reply_new(tag);
2781     pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->n_allocated));
2782     pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->allocated_size));
2783     pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->n_accumulated));
2784     pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->accumulated_size));
2785     pa_tagstruct_putu32(reply, (uint32_t) pa_scache_total_size(c->protocol->core));
2786     pa_pstream_send_tagstruct(c->pstream, reply);
2787 }
2788
2789 static void command_get_playback_latency(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2790     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2791     pa_tagstruct *reply;
2792     playback_stream *s;
2793     struct timeval tv, now;
2794     uint32_t idx;
2795
2796     pa_native_connection_assert_ref(c);
2797     pa_assert(t);
2798
2799     if (pa_tagstruct_getu32(t, &idx) < 0 ||
2800         pa_tagstruct_get_timeval(t, &tv) < 0 ||
2801         !pa_tagstruct_eof(t)) {
2802         protocol_error(c);
2803         return;
2804     }
2805
2806     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2807     s = pa_idxset_get_by_index(c->output_streams, idx);
2808     CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
2809     CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
2810
2811     /* Get an atomic snapshot of all timing parameters */
2812     pa_assert_se(pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_UPDATE_LATENCY, s, 0, NULL) == 0);
2813
2814     reply = reply_new(tag);
2815     pa_tagstruct_put_usec(reply,
2816                           s->current_sink_latency +
2817                           pa_bytes_to_usec(s->render_memblockq_length, &s->sink_input->sink->sample_spec));
2818     pa_tagstruct_put_usec(reply, 0);
2819     pa_tagstruct_put_boolean(reply,
2820                              s->playing_for > 0 &&
2821                              pa_sink_get_state(s->sink_input->sink) == PA_SINK_RUNNING &&
2822                              pa_sink_input_get_state(s->sink_input) == PA_SINK_INPUT_RUNNING);
2823     pa_tagstruct_put_timeval(reply, &tv);
2824     pa_tagstruct_put_timeval(reply, pa_gettimeofday(&now));
2825     pa_tagstruct_puts64(reply, s->write_index);
2826     pa_tagstruct_puts64(reply, s->read_index);
2827
2828     if (c->version >= 13) {
2829         pa_tagstruct_putu64(reply, s->underrun_for);
2830         pa_tagstruct_putu64(reply, s->playing_for);
2831     }
2832
2833     pa_pstream_send_tagstruct(c->pstream, reply);
2834 }
2835
2836 static void command_get_record_latency(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2837     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2838     pa_tagstruct *reply;
2839     record_stream *s;
2840     struct timeval tv, now;
2841     uint32_t idx;
2842
2843     pa_native_connection_assert_ref(c);
2844     pa_assert(t);
2845
2846     if (pa_tagstruct_getu32(t, &idx) < 0 ||
2847         pa_tagstruct_get_timeval(t, &tv) < 0 ||
2848         !pa_tagstruct_eof(t)) {
2849         protocol_error(c);
2850         return;
2851     }
2852
2853     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2854     s = pa_idxset_get_by_index(c->record_streams, idx);
2855     CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
2856
2857     /* Get an atomic snapshot of all timing parameters */
2858     pa_assert_se(pa_asyncmsgq_send(s->source_output->source->asyncmsgq, PA_MSGOBJECT(s->source_output), SOURCE_OUTPUT_MESSAGE_UPDATE_LATENCY, s, 0, NULL) == 0);
2859
2860     reply = reply_new(tag);
2861     pa_tagstruct_put_usec(reply, s->current_monitor_latency);
2862     pa_tagstruct_put_usec(reply,
2863                           s->current_source_latency +
2864                           pa_bytes_to_usec(s->on_the_fly_snapshot, &s->source_output->source->sample_spec));
2865     pa_tagstruct_put_boolean(reply,
2866                              pa_source_get_state(s->source_output->source) == PA_SOURCE_RUNNING &&
2867                              pa_source_output_get_state(s->source_output) == PA_SOURCE_OUTPUT_RUNNING);
2868     pa_tagstruct_put_timeval(reply, &tv);
2869     pa_tagstruct_put_timeval(reply, pa_gettimeofday(&now));
2870     pa_tagstruct_puts64(reply, pa_memblockq_get_write_index(s->memblockq));
2871     pa_tagstruct_puts64(reply, pa_memblockq_get_read_index(s->memblockq));
2872     pa_pstream_send_tagstruct(c->pstream, reply);
2873 }
2874
2875 static void command_create_upload_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2876     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2877     upload_stream *s;
2878     uint32_t length;
2879     const char *name = NULL;
2880     pa_sample_spec ss;
2881     pa_channel_map map;
2882     pa_tagstruct *reply;
2883     pa_proplist *p;
2884
2885     pa_native_connection_assert_ref(c);
2886     pa_assert(t);
2887
2888     if (pa_tagstruct_gets(t, &name) < 0 ||
2889         pa_tagstruct_get_sample_spec(t, &ss) < 0 ||
2890         pa_tagstruct_get_channel_map(t, &map) < 0 ||
2891         pa_tagstruct_getu32(t, &length) < 0) {
2892         protocol_error(c);
2893         return;
2894     }
2895
2896     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2897     CHECK_VALIDITY(c->pstream, pa_sample_spec_valid(&ss), tag, PA_ERR_INVALID);
2898     CHECK_VALIDITY(c->pstream, pa_channel_map_valid(&map), tag, PA_ERR_INVALID);
2899     CHECK_VALIDITY(c->pstream, map.channels == ss.channels, tag, PA_ERR_INVALID);
2900     CHECK_VALIDITY(c->pstream, (length % pa_frame_size(&ss)) == 0 && length > 0, tag, PA_ERR_INVALID);
2901     CHECK_VALIDITY(c->pstream, length <= PA_SCACHE_ENTRY_SIZE_MAX, tag, PA_ERR_TOOLARGE);
2902
2903     p = pa_proplist_new();
2904
2905     if ((c->version >= 13 && pa_tagstruct_get_proplist(t, p) < 0) ||
2906         !pa_tagstruct_eof(t)) {
2907
2908         protocol_error(c);
2909         pa_proplist_free(p);
2910         return;
2911     }
2912
2913     if (c->version < 13)
2914         pa_proplist_sets(p, PA_PROP_MEDIA_NAME, name);
2915     else if (!name)
2916         if (!(name = pa_proplist_gets(p, PA_PROP_EVENT_ID)))
2917             name = pa_proplist_gets(p, PA_PROP_MEDIA_NAME);
2918
2919     if (!name || !pa_namereg_is_valid_name(name)) {
2920         pa_proplist_free(p);
2921         CHECK_VALIDITY(c->pstream, FALSE, tag, PA_ERR_INVALID);
2922     }
2923
2924     s = upload_stream_new(c, &ss, &map, name, length, p);
2925     pa_proplist_free(p);
2926
2927     CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_INVALID);
2928
2929     reply = reply_new(tag);
2930     pa_tagstruct_putu32(reply, s->index);
2931     pa_tagstruct_putu32(reply, length);
2932     pa_pstream_send_tagstruct(c->pstream, reply);
2933 }
2934
2935 static void command_finish_upload_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2936     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2937     uint32_t channel;
2938     upload_stream *s;
2939     uint32_t idx;
2940
2941     pa_native_connection_assert_ref(c);
2942     pa_assert(t);
2943
2944     if (pa_tagstruct_getu32(t, &channel) < 0 ||
2945         !pa_tagstruct_eof(t)) {
2946         protocol_error(c);
2947         return;
2948     }
2949
2950     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2951
2952     s = pa_idxset_get_by_index(c->output_streams, channel);
2953     CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
2954     CHECK_VALIDITY(c->pstream, upload_stream_isinstance(s), tag, PA_ERR_NOENTITY);
2955
2956     if (!s->memchunk.memblock)
2957         pa_pstream_send_error(c->pstream, tag, PA_ERR_TOOLARGE);
2958     else if (pa_scache_add_item(c->protocol->core, s->name, &s->sample_spec, &s->channel_map, &s->memchunk, s->proplist, &idx) < 0)
2959         pa_pstream_send_error(c->pstream, tag, PA_ERR_INTERNAL);
2960     else
2961         pa_pstream_send_simple_ack(c->pstream, tag);
2962
2963     upload_stream_unlink(s);
2964 }
2965
2966 static void command_play_sample(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2967     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2968     uint32_t sink_index;
2969     pa_volume_t volume;
2970     pa_sink *sink;
2971     const char *name, *sink_name;
2972     uint32_t idx;
2973     pa_proplist *p;
2974     pa_tagstruct *reply;
2975
2976     pa_native_connection_assert_ref(c);
2977     pa_assert(t);
2978
2979     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2980
2981     if (pa_tagstruct_getu32(t, &sink_index) < 0 ||
2982         pa_tagstruct_gets(t, &sink_name) < 0 ||
2983         pa_tagstruct_getu32(t, &volume) < 0 ||
2984         pa_tagstruct_gets(t, &name) < 0) {
2985         protocol_error(c);
2986         return;
2987     }
2988
2989     CHECK_VALIDITY(c->pstream, !sink_name || pa_namereg_is_valid_name_or_wildcard(sink_name, PA_NAMEREG_SINK), tag, PA_ERR_INVALID);
2990     CHECK_VALIDITY(c->pstream, sink_index == PA_INVALID_INDEX || !sink_name, tag, PA_ERR_INVALID);
2991     CHECK_VALIDITY(c->pstream, !sink_name || sink_index == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
2992     CHECK_VALIDITY(c->pstream, name && pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
2993
2994     if (sink_index != PA_INVALID_INDEX)
2995         sink = pa_idxset_get_by_index(c->protocol->core->sinks, sink_index);
2996     else
2997         sink = pa_namereg_get(c->protocol->core, sink_name, PA_NAMEREG_SINK);
2998
2999     CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
3000
3001     p = pa_proplist_new();
3002
3003     if ((c->version >= 13 && pa_tagstruct_get_proplist(t, p) < 0) ||
3004         !pa_tagstruct_eof(t)) {
3005         protocol_error(c);
3006         pa_proplist_free(p);
3007         return;
3008     }
3009
3010     pa_proplist_update(p, PA_UPDATE_MERGE, c->client->proplist);
3011
3012     if (pa_scache_play_item(c->protocol->core, name, sink, volume, p, &idx) < 0) {
3013         pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
3014         pa_proplist_free(p);
3015         return;
3016     }
3017
3018     pa_proplist_free(p);
3019
3020     reply = reply_new(tag);
3021
3022     if (c->version >= 13)
3023         pa_tagstruct_putu32(reply, idx);
3024
3025     pa_pstream_send_tagstruct(c->pstream, reply);
3026 }
3027
3028 static void command_remove_sample(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3029     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3030     const char *name;
3031
3032     pa_native_connection_assert_ref(c);
3033     pa_assert(t);
3034
3035     if (pa_tagstruct_gets(t, &name) < 0 ||
3036         !pa_tagstruct_eof(t)) {
3037         protocol_error(c);
3038         return;
3039     }
3040
3041     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3042     CHECK_VALIDITY(c->pstream, name && pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
3043
3044     if (pa_scache_remove_item(c->protocol->core, name) < 0) {
3045         pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
3046         return;
3047     }
3048
3049     pa_pstream_send_simple_ack(c->pstream, tag);
3050 }
3051
3052 static void fixup_sample_spec(pa_native_connection *c, pa_sample_spec *fixed, const pa_sample_spec *original) {
3053     pa_assert(c);
3054     pa_assert(fixed);
3055     pa_assert(original);
3056
3057     *fixed = *original;
3058
3059     if (c->version < 12) {
3060         /* Before protocol version 12 we didn't support S32 samples,
3061          * so we need to lie about this to the client */
3062
3063         if (fixed->format == PA_SAMPLE_S32LE)
3064             fixed->format = PA_SAMPLE_FLOAT32LE;
3065         if (fixed->format == PA_SAMPLE_S32BE)
3066             fixed->format = PA_SAMPLE_FLOAT32BE;
3067     }
3068
3069     if (c->version < 15) {
3070         if (fixed->format == PA_SAMPLE_S24LE || fixed->format == PA_SAMPLE_S24_32LE)
3071             fixed->format = PA_SAMPLE_FLOAT32LE;
3072         if (fixed->format == PA_SAMPLE_S24BE || fixed->format == PA_SAMPLE_S24_32BE)
3073             fixed->format = PA_SAMPLE_FLOAT32BE;
3074     }
3075 }
3076
3077 static void sink_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_sink *sink) {
3078     pa_sample_spec fixed_ss;
3079
3080     pa_assert(t);
3081     pa_sink_assert_ref(sink);
3082
3083     fixup_sample_spec(c, &fixed_ss, &sink->sample_spec);
3084
3085     pa_tagstruct_put(
3086         t,
3087         PA_TAG_U32, sink->index,
3088         PA_TAG_STRING, sink->name,
3089         PA_TAG_STRING, pa_strnull(pa_proplist_gets(sink->proplist, PA_PROP_DEVICE_DESCRIPTION)),
3090         PA_TAG_SAMPLE_SPEC, &fixed_ss,
3091         PA_TAG_CHANNEL_MAP, &sink->channel_map,
3092         PA_TAG_U32, sink->module ? sink->module->index : PA_INVALID_INDEX,
3093         PA_TAG_CVOLUME, pa_sink_get_volume(sink, FALSE),
3094         PA_TAG_BOOLEAN, pa_sink_get_mute(sink, FALSE),
3095         PA_TAG_U32, sink->monitor_source ? sink->monitor_source->index : PA_INVALID_INDEX,
3096         PA_TAG_STRING, sink->monitor_source ? sink->monitor_source->name : NULL,
3097         PA_TAG_USEC, pa_sink_get_latency(sink),
3098         PA_TAG_STRING, sink->driver,
3099         PA_TAG_U32, sink->flags & PA_SINK_CLIENT_FLAGS_MASK,
3100         PA_TAG_INVALID);
3101
3102     if (c->version >= 13) {
3103         pa_tagstruct_put_proplist(t, sink->proplist);
3104         pa_tagstruct_put_usec(t, pa_sink_get_requested_latency(sink));
3105     }
3106
3107     if (c->version >= 15) {
3108         pa_tagstruct_put_volume(t, sink->base_volume);
3109         if (PA_UNLIKELY(pa_sink_get_state(sink) == PA_SINK_INVALID_STATE))
3110             pa_log_error("Internal sink state is invalid.");
3111         pa_tagstruct_putu32(t, pa_sink_get_state(sink));
3112         pa_tagstruct_putu32(t, sink->n_volume_steps);
3113         pa_tagstruct_putu32(t, sink->card ? sink->card->index : PA_INVALID_INDEX);
3114     }
3115
3116     if (c->version >= 16) {
3117         void *state;
3118         pa_device_port *p;
3119
3120         pa_tagstruct_putu32(t, pa_hashmap_size(sink->ports));
3121
3122         PA_HASHMAP_FOREACH(p, sink->ports, state) {
3123             pa_tagstruct_puts(t, p->name);
3124             pa_tagstruct_puts(t, p->description);
3125             pa_tagstruct_putu32(t, p->priority);
3126             if (c->version >= 24)
3127                 pa_tagstruct_putu32(t, p->available);
3128         }
3129
3130         pa_tagstruct_puts(t, sink->active_port ? sink->active_port->name : NULL);
3131     }
3132
3133     if (c->version >= 21) {
3134         uint32_t i;
3135         pa_format_info *f;
3136         pa_idxset *formats = pa_sink_get_formats(sink);
3137
3138         pa_tagstruct_putu8(t, (uint8_t) pa_idxset_size(formats));
3139         PA_IDXSET_FOREACH(f, formats, i) {
3140             pa_tagstruct_put_format_info(t, f);
3141         }
3142
3143         pa_idxset_free(formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
3144     }
3145 }
3146
3147 static void source_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_source *source) {
3148     pa_sample_spec fixed_ss;
3149
3150     pa_assert(t);
3151     pa_source_assert_ref(source);
3152
3153     fixup_sample_spec(c, &fixed_ss, &source->sample_spec);
3154
3155     pa_tagstruct_put(
3156         t,
3157         PA_TAG_U32, source->index,
3158         PA_TAG_STRING, source->name,
3159         PA_TAG_STRING, pa_strnull(pa_proplist_gets(source->proplist, PA_PROP_DEVICE_DESCRIPTION)),
3160         PA_TAG_SAMPLE_SPEC, &fixed_ss,
3161         PA_TAG_CHANNEL_MAP, &source->channel_map,
3162         PA_TAG_U32, source->module ? source->module->index : PA_INVALID_INDEX,
3163         PA_TAG_CVOLUME, pa_source_get_volume(source, FALSE),
3164         PA_TAG_BOOLEAN, pa_source_get_mute(source, FALSE),
3165         PA_TAG_U32, source->monitor_of ? source->monitor_of->index : PA_INVALID_INDEX,
3166         PA_TAG_STRING, source->monitor_of ? source->monitor_of->name : NULL,
3167         PA_TAG_USEC, pa_source_get_latency(source),
3168         PA_TAG_STRING, source->driver,
3169         PA_TAG_U32, source->flags & PA_SOURCE_CLIENT_FLAGS_MASK,
3170         PA_TAG_INVALID);
3171
3172     if (c->version >= 13) {
3173         pa_tagstruct_put_proplist(t, source->proplist);
3174         pa_tagstruct_put_usec(t, pa_source_get_requested_latency(source));
3175     }
3176
3177     if (c->version >= 15) {
3178         pa_tagstruct_put_volume(t, source->base_volume);
3179         if (PA_UNLIKELY(pa_source_get_state(source) == PA_SOURCE_INVALID_STATE))
3180             pa_log_error("Internal source state is invalid.");
3181         pa_tagstruct_putu32(t, pa_source_get_state(source));
3182         pa_tagstruct_putu32(t, source->n_volume_steps);
3183         pa_tagstruct_putu32(t, source->card ? source->card->index : PA_INVALID_INDEX);
3184     }
3185
3186     if (c->version >= 16) {
3187         void *state;
3188         pa_device_port *p;
3189
3190         pa_tagstruct_putu32(t, pa_hashmap_size(source->ports));
3191
3192         PA_HASHMAP_FOREACH(p, source->ports, state) {
3193             pa_tagstruct_puts(t, p->name);
3194             pa_tagstruct_puts(t, p->description);
3195             pa_tagstruct_putu32(t, p->priority);
3196             if (c->version >= 24)
3197                 pa_tagstruct_putu32(t, p->available);
3198         }
3199
3200         pa_tagstruct_puts(t, source->active_port ? source->active_port->name : NULL);
3201     }
3202
3203     if (c->version >= 22) {
3204         uint32_t i;
3205         pa_format_info *f;
3206         pa_idxset *formats = pa_source_get_formats(source);
3207
3208         pa_tagstruct_putu8(t, (uint8_t) pa_idxset_size(formats));
3209         PA_IDXSET_FOREACH(f, formats, i) {
3210             pa_tagstruct_put_format_info(t, f);
3211         }
3212
3213         pa_idxset_free(formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
3214     }
3215 }
3216
3217 static void client_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_client *client) {
3218     pa_assert(t);
3219     pa_assert(client);
3220
3221     pa_tagstruct_putu32(t, client->index);
3222     pa_tagstruct_puts(t, pa_strnull(pa_proplist_gets(client->proplist, PA_PROP_APPLICATION_NAME)));
3223     pa_tagstruct_putu32(t, client->module ? client->module->index : PA_INVALID_INDEX);
3224     pa_tagstruct_puts(t, client->driver);
3225
3226     if (c->version >= 13)
3227         pa_tagstruct_put_proplist(t, client->proplist);
3228 }
3229
3230 static void card_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_card *card) {
3231     void *state = NULL;
3232     pa_card_profile *p;
3233
3234     pa_assert(t);
3235     pa_assert(card);
3236
3237     pa_tagstruct_putu32(t, card->index);
3238     pa_tagstruct_puts(t, card->name);
3239     pa_tagstruct_putu32(t, card->module ? card->module->index : PA_INVALID_INDEX);
3240     pa_tagstruct_puts(t, card->driver);
3241
3242     pa_tagstruct_putu32(t, pa_hashmap_size(card->profiles));
3243
3244     PA_HASHMAP_FOREACH(p, card->profiles, state) {
3245         pa_tagstruct_puts(t, p->name);
3246         pa_tagstruct_puts(t, p->description);
3247         pa_tagstruct_putu32(t, p->n_sinks);
3248         pa_tagstruct_putu32(t, p->n_sources);
3249         pa_tagstruct_putu32(t, p->priority);
3250     }
3251
3252     pa_tagstruct_puts(t, card->active_profile->name);
3253     pa_tagstruct_put_proplist(t, card->proplist);
3254
3255     if (c->version < 26)
3256         return;
3257
3258     if (card->ports) {
3259         pa_device_port* port;
3260
3261         pa_tagstruct_putu32(t, pa_hashmap_size(card->ports));
3262
3263         PA_HASHMAP_FOREACH(port, card->ports, state) {
3264             void *state2;
3265
3266             pa_tagstruct_puts(t, port->name);
3267             pa_tagstruct_puts(t, port->description);
3268             pa_tagstruct_putu32(t, port->priority);
3269             pa_tagstruct_putu32(t, port->available);
3270             pa_tagstruct_putu8(t, /* FIXME: port->direction */ (port->is_input ? PA_DIRECTION_INPUT : 0) | (port->is_output ? PA_DIRECTION_OUTPUT : 0));
3271             pa_tagstruct_put_proplist(t, port->proplist);
3272
3273             pa_tagstruct_putu32(t, pa_hashmap_size(port->profiles));
3274
3275             PA_HASHMAP_FOREACH(p, port->profiles, state2)
3276                 pa_tagstruct_puts(t, p->name);
3277         }
3278
3279     } else
3280         pa_tagstruct_putu32(t, 0);
3281 }
3282
3283 static void module_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_module *module) {
3284     pa_assert(t);
3285     pa_assert(module);
3286
3287     pa_tagstruct_putu32(t, module->index);
3288     pa_tagstruct_puts(t, module->name);
3289     pa_tagstruct_puts(t, module->argument);
3290     pa_tagstruct_putu32(t, (uint32_t) pa_module_get_n_used(module));
3291
3292     if (c->version < 15)
3293         pa_tagstruct_put_boolean(t, FALSE); /* autoload is obsolete */
3294
3295     if (c->version >= 15)
3296         pa_tagstruct_put_proplist(t, module->proplist);
3297 }
3298
3299 static void sink_input_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_sink_input *s) {
3300     pa_sample_spec fixed_ss;
3301     pa_usec_t sink_latency;
3302     pa_cvolume v;
3303     pa_bool_t has_volume = FALSE;
3304
3305     pa_assert(t);
3306     pa_sink_input_assert_ref(s);
3307
3308     fixup_sample_spec(c, &fixed_ss, &s->sample_spec);
3309
3310     has_volume = pa_sink_input_is_volume_readable(s);
3311     if (has_volume)
3312         pa_sink_input_get_volume(s, &v, TRUE);
3313     else
3314         pa_cvolume_reset(&v, fixed_ss.channels);
3315
3316     pa_tagstruct_putu32(t, s->index);
3317     pa_tagstruct_puts(t, pa_strnull(pa_proplist_gets(s->proplist, PA_PROP_MEDIA_NAME)));
3318     pa_tagstruct_putu32(t, s->module ? s->module->index : PA_INVALID_INDEX);
3319     pa_tagstruct_putu32(t, s->client ? s->client->index : PA_INVALID_INDEX);
3320     pa_tagstruct_putu32(t, s->sink->index);
3321     pa_tagstruct_put_sample_spec(t, &fixed_ss);
3322     pa_tagstruct_put_channel_map(t, &s->channel_map);
3323     pa_tagstruct_put_cvolume(t, &v);
3324     pa_tagstruct_put_usec(t, pa_sink_input_get_latency(s, &sink_latency));
3325     pa_tagstruct_put_usec(t, sink_latency);
3326     pa_tagstruct_puts(t, pa_resample_method_to_string(pa_sink_input_get_resample_method(s)));
3327     pa_tagstruct_puts(t, s->driver);
3328     if (c->version >= 11)
3329         pa_tagstruct_put_boolean(t, pa_sink_input_get_mute(s));
3330     if (c->version >= 13)
3331         pa_tagstruct_put_proplist(t, s->proplist);
3332     if (c->version >= 19)
3333         pa_tagstruct_put_boolean(t, (pa_sink_input_get_state(s) == PA_SINK_INPUT_CORKED));
3334     if (c->version >= 20) {
3335         pa_tagstruct_put_boolean(t, has_volume);
3336         pa_tagstruct_put_boolean(t, s->volume_writable);
3337     }
3338     if (c->version >= 21)
3339         pa_tagstruct_put_format_info(t, s->format);
3340 }
3341
3342 static void source_output_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_source_output *s) {
3343     pa_sample_spec fixed_ss;
3344     pa_usec_t source_latency;
3345     pa_cvolume v;
3346     pa_bool_t has_volume = FALSE;
3347
3348     pa_assert(t);
3349     pa_source_output_assert_ref(s);
3350
3351     fixup_sample_spec(c, &fixed_ss, &s->sample_spec);
3352
3353     has_volume = pa_source_output_is_volume_readable(s);
3354     if (has_volume)
3355         pa_source_output_get_volume(s, &v, TRUE);
3356     else
3357         pa_cvolume_reset(&v, fixed_ss.channels);
3358
3359     pa_tagstruct_putu32(t, s->index);
3360     pa_tagstruct_puts(t, pa_strnull(pa_proplist_gets(s->proplist, PA_PROP_MEDIA_NAME)));
3361     pa_tagstruct_putu32(t, s->module ? s->module->index : PA_INVALID_INDEX);
3362     pa_tagstruct_putu32(t, s->client ? s->client->index : PA_INVALID_INDEX);
3363     pa_tagstruct_putu32(t, s->source->index);
3364     pa_tagstruct_put_sample_spec(t, &fixed_ss);
3365     pa_tagstruct_put_channel_map(t, &s->channel_map);
3366     pa_tagstruct_put_usec(t, pa_source_output_get_latency(s, &source_latency));
3367     pa_tagstruct_put_usec(t, source_latency);
3368     pa_tagstruct_puts(t, pa_resample_method_to_string(pa_source_output_get_resample_method(s)));
3369     pa_tagstruct_puts(t, s->driver);
3370     if (c->version >= 13)
3371         pa_tagstruct_put_proplist(t, s->proplist);
3372     if (c->version >= 19)
3373         pa_tagstruct_put_boolean(t, (pa_source_output_get_state(s) == PA_SOURCE_OUTPUT_CORKED));
3374     if (c->version >= 22) {
3375         pa_tagstruct_put_cvolume(t, &v);
3376         pa_tagstruct_put_boolean(t, pa_source_output_get_mute(s));
3377         pa_tagstruct_put_boolean(t, has_volume);
3378         pa_tagstruct_put_boolean(t, s->volume_writable);
3379         pa_tagstruct_put_format_info(t, s->format);
3380     }
3381 }
3382
3383 static void scache_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_scache_entry *e) {
3384     pa_sample_spec fixed_ss;
3385     pa_cvolume v;
3386
3387     pa_assert(t);
3388     pa_assert(e);
3389
3390     if (e->memchunk.memblock)
3391         fixup_sample_spec(c, &fixed_ss, &e->sample_spec);
3392     else
3393         memset(&fixed_ss, 0, sizeof(fixed_ss));
3394
3395     pa_tagstruct_putu32(t, e->index);
3396     pa_tagstruct_puts(t, e->name);
3397
3398     if (e->volume_is_set)
3399         v = e->volume;
3400     else
3401         pa_cvolume_init(&v);
3402
3403     pa_tagstruct_put_cvolume(t, &v);
3404     pa_tagstruct_put_usec(t, e->memchunk.memblock ? pa_bytes_to_usec(e->memchunk.length, &e->sample_spec) : 0);
3405     pa_tagstruct_put_sample_spec(t, &fixed_ss);
3406     pa_tagstruct_put_channel_map(t, &e->channel_map);
3407     pa_tagstruct_putu32(t, (uint32_t) e->memchunk.length);
3408     pa_tagstruct_put_boolean(t, e->lazy);
3409     pa_tagstruct_puts(t, e->filename);
3410
3411     if (c->version >= 13)
3412         pa_tagstruct_put_proplist(t, e->proplist);
3413 }
3414
3415 static void command_get_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3416     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3417     uint32_t idx;
3418     pa_sink *sink = NULL;
3419     pa_source *source = NULL;
3420     pa_client *client = NULL;
3421     pa_card *card = NULL;
3422     pa_module *module = NULL;
3423     pa_sink_input *si = NULL;
3424     pa_source_output *so = NULL;
3425     pa_scache_entry *sce = NULL;
3426     const char *name = NULL;
3427     pa_tagstruct *reply;
3428
3429     pa_native_connection_assert_ref(c);
3430     pa_assert(t);
3431
3432     if (pa_tagstruct_getu32(t, &idx) < 0 ||
3433         (command != PA_COMMAND_GET_CLIENT_INFO &&
3434          command != PA_COMMAND_GET_MODULE_INFO &&
3435          command != PA_COMMAND_GET_SINK_INPUT_INFO &&
3436          command != PA_COMMAND_GET_SOURCE_OUTPUT_INFO &&
3437          pa_tagstruct_gets(t, &name) < 0) ||
3438         !pa_tagstruct_eof(t)) {
3439         protocol_error(c);
3440         return;
3441     }
3442
3443     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3444     CHECK_VALIDITY(c->pstream, !name ||
3445                    (command == PA_COMMAND_GET_SINK_INFO &&
3446                     pa_namereg_is_valid_name_or_wildcard(name, PA_NAMEREG_SINK)) ||
3447                    (command == PA_COMMAND_GET_SOURCE_INFO &&
3448                     pa_namereg_is_valid_name_or_wildcard(name, PA_NAMEREG_SOURCE)) ||
3449                    pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
3450     CHECK_VALIDITY(c->pstream, command == PA_COMMAND_GET_SINK_INFO ||
3451                    command == PA_COMMAND_GET_SOURCE_INFO ||
3452                    (idx != PA_INVALID_INDEX || name), tag, PA_ERR_INVALID);
3453     CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
3454     CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3455
3456     if (command == PA_COMMAND_GET_SINK_INFO) {
3457         if (idx != PA_INVALID_INDEX)
3458             sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
3459         else
3460             sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
3461     } else if (command == PA_COMMAND_GET_SOURCE_INFO) {
3462         if (idx != PA_INVALID_INDEX)
3463             source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
3464         else
3465             source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
3466     } else if (command == PA_COMMAND_GET_CARD_INFO) {
3467         if (idx != PA_INVALID_INDEX)
3468             card = pa_idxset_get_by_index(c->protocol->core->cards, idx);
3469         else
3470             card = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_CARD);
3471     } else if (command == PA_COMMAND_GET_CLIENT_INFO)
3472         client = pa_idxset_get_by_index(c->protocol->core->clients, idx);
3473     else if (command == PA_COMMAND_GET_MODULE_INFO)
3474         module = pa_idxset_get_by_index(c->protocol->core->modules, idx);
3475     else if (command == PA_COMMAND_GET_SINK_INPUT_INFO)
3476         si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
3477     else if (command == PA_COMMAND_GET_SOURCE_OUTPUT_INFO)
3478         so = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
3479     else {
3480         pa_assert(command == PA_COMMAND_GET_SAMPLE_INFO);
3481         if (idx != PA_INVALID_INDEX)
3482             sce = pa_idxset_get_by_index(c->protocol->core->scache, idx);
3483         else
3484             sce = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SAMPLE);
3485     }
3486
3487     if (!sink && !source && !client && !card && !module && !si && !so && !sce) {
3488         pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
3489         return;
3490     }
3491
3492     reply = reply_new(tag);
3493     if (sink)
3494         sink_fill_tagstruct(c, reply, sink);
3495     else if (source)
3496         source_fill_tagstruct(c, reply, source);
3497     else if (client)
3498         client_fill_tagstruct(c, reply, client);
3499     else if (card)
3500         card_fill_tagstruct(c, reply, card);
3501     else if (module)
3502         module_fill_tagstruct(c, reply, module);
3503     else if (si)
3504         sink_input_fill_tagstruct(c, reply, si);
3505     else if (so)
3506         source_output_fill_tagstruct(c, reply, so);
3507     else
3508         scache_fill_tagstruct(c, reply, sce);
3509     pa_pstream_send_tagstruct(c->pstream, reply);
3510 }
3511
3512 static void command_get_info_list(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3513     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3514     pa_idxset *i;
3515     uint32_t idx;
3516     void *p;
3517     pa_tagstruct *reply;
3518
3519     pa_native_connection_assert_ref(c);
3520     pa_assert(t);
3521
3522     if (!pa_tagstruct_eof(t)) {
3523         protocol_error(c);
3524         return;
3525     }
3526
3527     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3528
3529     reply = reply_new(tag);
3530
3531     if (command == PA_COMMAND_GET_SINK_INFO_LIST)
3532         i = c->protocol->core->sinks;
3533     else if (command == PA_COMMAND_GET_SOURCE_INFO_LIST)
3534         i = c->protocol->core->sources;
3535     else if (command == PA_COMMAND_GET_CLIENT_INFO_LIST)
3536         i = c->protocol->core->clients;
3537     else if (command == PA_COMMAND_GET_CARD_INFO_LIST)
3538         i = c->protocol->core->cards;
3539     else if (command == PA_COMMAND_GET_MODULE_INFO_LIST)
3540         i = c->protocol->core->modules;
3541     else if (command == PA_COMMAND_GET_SINK_INPUT_INFO_LIST)
3542         i = c->protocol->core->sink_inputs;
3543     else if (command == PA_COMMAND_GET_SOURCE_OUTPUT_INFO_LIST)
3544         i = c->protocol->core->source_outputs;
3545     else {
3546         pa_assert(command == PA_COMMAND_GET_SAMPLE_INFO_LIST);
3547         i = c->protocol->core->scache;
3548     }
3549
3550     if (i) {
3551         PA_IDXSET_FOREACH(p, i, idx) {
3552             if (command == PA_COMMAND_GET_SINK_INFO_LIST)
3553                 sink_fill_tagstruct(c, reply, p);
3554             else if (command == PA_COMMAND_GET_SOURCE_INFO_LIST)
3555                 source_fill_tagstruct(c, reply, p);
3556             else if (command == PA_COMMAND_GET_CLIENT_INFO_LIST)
3557                 client_fill_tagstruct(c, reply, p);
3558             else if (command == PA_COMMAND_GET_CARD_INFO_LIST)
3559                 card_fill_tagstruct(c, reply, p);
3560             else if (command == PA_COMMAND_GET_MODULE_INFO_LIST)
3561                 module_fill_tagstruct(c, reply, p);
3562             else if (command == PA_COMMAND_GET_SINK_INPUT_INFO_LIST)
3563                 sink_input_fill_tagstruct(c, reply, p);
3564             else if (command == PA_COMMAND_GET_SOURCE_OUTPUT_INFO_LIST)
3565                 source_output_fill_tagstruct(c, reply, p);
3566             else {
3567                 pa_assert(command == PA_COMMAND_GET_SAMPLE_INFO_LIST);
3568                 scache_fill_tagstruct(c, reply, p);
3569             }
3570         }
3571     }
3572
3573     pa_pstream_send_tagstruct(c->pstream, reply);
3574 }
3575
3576 static void command_get_server_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3577     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3578     pa_tagstruct *reply;
3579     pa_sink *def_sink;
3580     pa_source *def_source;
3581     pa_sample_spec fixed_ss;
3582     char *h, *u;
3583
3584     pa_native_connection_assert_ref(c);
3585     pa_assert(t);
3586
3587     if (!pa_tagstruct_eof(t)) {
3588         protocol_error(c);
3589         return;
3590     }
3591
3592     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3593
3594     reply = reply_new(tag);
3595     pa_tagstruct_puts(reply, PACKAGE_NAME);
3596     pa_tagstruct_puts(reply, PACKAGE_VERSION);
3597
3598     u = pa_get_user_name_malloc();
3599     pa_tagstruct_puts(reply, u);
3600     pa_xfree(u);
3601
3602     h = pa_get_host_name_malloc();
3603     pa_tagstruct_puts(reply, h);
3604     pa_xfree(h);
3605
3606     fixup_sample_spec(c, &fixed_ss, &c->protocol->core->default_sample_spec);
3607     pa_tagstruct_put_sample_spec(reply, &fixed_ss);
3608
3609     def_sink = pa_namereg_get_default_sink(c->protocol->core);
3610     pa_tagstruct_puts(reply, def_sink ? def_sink->name : NULL);
3611     def_source = pa_namereg_get_default_source(c->protocol->core);
3612     pa_tagstruct_puts(reply, def_source ? def_source->name : NULL);
3613
3614     pa_tagstruct_putu32(reply, c->protocol->core->cookie);
3615
3616     if (c->version >= 15)
3617         pa_tagstruct_put_channel_map(reply, &c->protocol->core->default_channel_map);
3618
3619     pa_pstream_send_tagstruct(c->pstream, reply);
3620 }
3621
3622 static void subscription_cb(pa_core *core, pa_subscription_event_type_t e, uint32_t idx, void *userdata) {
3623     pa_tagstruct *t;
3624     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3625
3626     pa_native_connection_assert_ref(c);
3627
3628     t = pa_tagstruct_new(NULL, 0);
3629     pa_tagstruct_putu32(t, PA_COMMAND_SUBSCRIBE_EVENT);
3630     pa_tagstruct_putu32(t, (uint32_t) -1);
3631     pa_tagstruct_putu32(t, e);
3632     pa_tagstruct_putu32(t, idx);
3633     pa_pstream_send_tagstruct(c->pstream, t);
3634 }
3635
3636 static void command_subscribe(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3637     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3638     pa_subscription_mask_t m;
3639
3640     pa_native_connection_assert_ref(c);
3641     pa_assert(t);
3642
3643     if (pa_tagstruct_getu32(t, &m) < 0 ||
3644         !pa_tagstruct_eof(t)) {
3645         protocol_error(c);
3646         return;
3647     }
3648
3649     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3650     CHECK_VALIDITY(c->pstream, (m & ~PA_SUBSCRIPTION_MASK_ALL) == 0, tag, PA_ERR_INVALID);
3651
3652     if (c->subscription)
3653         pa_subscription_free(c->subscription);
3654
3655     if (m != 0) {
3656         c->subscription = pa_subscription_new(c->protocol->core, m, subscription_cb, c);
3657         pa_assert(c->subscription);
3658     } else
3659         c->subscription = NULL;
3660
3661     pa_pstream_send_simple_ack(c->pstream, tag);
3662 }
3663
3664 static void command_set_volume(
3665         pa_pdispatch *pd,
3666         uint32_t command,
3667         uint32_t tag,
3668         pa_tagstruct *t,
3669         void *userdata) {
3670
3671     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3672     uint32_t idx;
3673     pa_cvolume volume;
3674     pa_sink *sink = NULL;
3675     pa_source *source = NULL;
3676     pa_sink_input *si = NULL;
3677     pa_source_output *so = NULL;
3678     const char *name = NULL;
3679     const char *client_name;
3680
3681     pa_native_connection_assert_ref(c);
3682     pa_assert(t);
3683
3684     if (pa_tagstruct_getu32(t, &idx) < 0 ||
3685         (command == PA_COMMAND_SET_SINK_VOLUME && pa_tagstruct_gets(t, &name) < 0) ||
3686         (command == PA_COMMAND_SET_SOURCE_VOLUME && pa_tagstruct_gets(t, &name) < 0) ||
3687         pa_tagstruct_get_cvolume(t, &volume) ||
3688         !pa_tagstruct_eof(t)) {
3689         protocol_error(c);
3690         return;
3691     }
3692
3693     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3694     CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name_or_wildcard(name, command == PA_COMMAND_SET_SINK_VOLUME ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE), tag, PA_ERR_INVALID);
3695     CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
3696     CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
3697     CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3698     CHECK_VALIDITY(c->pstream, pa_cvolume_valid(&volume), tag, PA_ERR_INVALID);
3699
3700     switch (command) {
3701
3702         case PA_COMMAND_SET_SINK_VOLUME:
3703             if (idx != PA_INVALID_INDEX)
3704                 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
3705             else
3706                 sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
3707             break;
3708
3709         case PA_COMMAND_SET_SOURCE_VOLUME:
3710             if (idx != PA_INVALID_INDEX)
3711                 source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
3712             else
3713                 source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
3714             break;
3715
3716         case PA_COMMAND_SET_SINK_INPUT_VOLUME:
3717             si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
3718             break;
3719
3720         case PA_COMMAND_SET_SOURCE_OUTPUT_VOLUME:
3721             so = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
3722             break;
3723
3724         default:
3725             pa_assert_not_reached();
3726     }
3727
3728     CHECK_VALIDITY(c->pstream, si || so || sink || source, tag, PA_ERR_NOENTITY);
3729
3730     client_name = pa_strnull(pa_proplist_gets(c->client->proplist, PA_PROP_APPLICATION_PROCESS_BINARY));
3731
3732     if (sink) {
3733         CHECK_VALIDITY(c->pstream, volume.channels == 1 || pa_cvolume_compatible(&volume, &sink->sample_spec), tag, PA_ERR_INVALID);
3734
3735         pa_log_debug("Client %s changes volume of sink %s.", client_name, sink->name);
3736         pa_sink_set_volume(sink, &volume, TRUE, TRUE);
3737     } else if (source) {
3738         CHECK_VALIDITY(c->pstream, volume.channels == 1 || pa_cvolume_compatible(&volume, &source->sample_spec), tag, PA_ERR_INVALID);
3739
3740         pa_log_debug("Client %s changes volume of source %s.", client_name, source->name);
3741         pa_source_set_volume(source, &volume, TRUE, TRUE);
3742     } else if (si) {
3743         CHECK_VALIDITY(c->pstream, si->volume_writable, tag, PA_ERR_BADSTATE);
3744         CHECK_VALIDITY(c->pstream, volume.channels == 1 || pa_cvolume_compatible(&volume, &si->sample_spec), tag, PA_ERR_INVALID);
3745
3746         pa_log_debug("Client %s changes volume of sink input %s.",
3747                      client_name,
3748                      pa_strnull(pa_proplist_gets(si->proplist, PA_PROP_MEDIA_NAME)));
3749         pa_sink_input_set_volume(si, &volume, TRUE, TRUE);
3750     } else if (so) {
3751         CHECK_VALIDITY(c->pstream, volume.channels == 1 || pa_cvolume_compatible(&volume, &so->sample_spec), tag, PA_ERR_INVALID);
3752
3753         pa_log_debug("Client %s changes volume of source output %s.",
3754                      client_name,
3755                      pa_strnull(pa_proplist_gets(so->proplist, PA_PROP_MEDIA_NAME)));
3756         pa_source_output_set_volume(so, &volume, TRUE, TRUE);
3757     }
3758
3759     pa_pstream_send_simple_ack(c->pstream, tag);
3760 }
3761
3762 static void command_set_mute(
3763         pa_pdispatch *pd,
3764         uint32_t command,
3765         uint32_t tag,
3766         pa_tagstruct *t,
3767         void *userdata) {
3768
3769     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3770     uint32_t idx;
3771     pa_bool_t mute;
3772     pa_sink *sink = NULL;
3773     pa_source *source = NULL;
3774     pa_sink_input *si = NULL;
3775     pa_source_output *so = NULL;
3776     const char *name = NULL, *client_name;
3777
3778     pa_native_connection_assert_ref(c);
3779     pa_assert(t);
3780
3781     if (pa_tagstruct_getu32(t, &idx) < 0 ||
3782         (command == PA_COMMAND_SET_SINK_MUTE && pa_tagstruct_gets(t, &name) < 0) ||
3783         (command == PA_COMMAND_SET_SOURCE_MUTE && pa_tagstruct_gets(t, &name) < 0) ||
3784         pa_tagstruct_get_boolean(t, &mute) ||
3785         !pa_tagstruct_eof(t)) {
3786         protocol_error(c);
3787         return;
3788     }
3789
3790     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3791     CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name_or_wildcard(name, command == PA_COMMAND_SET_SINK_MUTE ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE), tag, PA_ERR_INVALID);
3792     CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
3793     CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
3794     CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3795
3796     switch (command) {
3797
3798         case PA_COMMAND_SET_SINK_MUTE:
3799             if (idx != PA_INVALID_INDEX)
3800                 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
3801             else
3802                 sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
3803
3804             break;
3805
3806         case PA_COMMAND_SET_SOURCE_MUTE:
3807             if (idx != PA_INVALID_INDEX)
3808                 source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
3809             else
3810                 source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
3811
3812             break;
3813
3814         case PA_COMMAND_SET_SINK_INPUT_MUTE:
3815             si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
3816             break;
3817
3818         case PA_COMMAND_SET_SOURCE_OUTPUT_MUTE:
3819             so = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
3820             break;
3821
3822         default:
3823             pa_assert_not_reached();
3824     }
3825
3826     CHECK_VALIDITY(c->pstream, si || so || sink || source, tag, PA_ERR_NOENTITY);
3827
3828     client_name = pa_strnull(pa_proplist_gets(c->client->proplist, PA_PROP_APPLICATION_PROCESS_BINARY));
3829
3830     if (sink) {
3831         pa_log_debug("Client %s changes mute of sink %s.", client_name, sink->name);
3832         pa_sink_set_mute(sink, mute, TRUE);
3833     } else if (source) {
3834         pa_log_debug("Client %s changes mute of source %s.", client_name, source->name);
3835         pa_source_set_mute(source, mute, TRUE);
3836     } else if (si) {
3837         pa_log_debug("Client %s changes mute of sink input %s.",
3838                      client_name,
3839                      pa_strnull(pa_proplist_gets(si->proplist, PA_PROP_MEDIA_NAME)));
3840         pa_sink_input_set_mute(si, mute, TRUE);
3841     } else if (so) {
3842         pa_log_debug("Client %s changes mute of source output %s.",
3843                      client_name,
3844                      pa_strnull(pa_proplist_gets(so->proplist, PA_PROP_MEDIA_NAME)));
3845         pa_source_output_set_mute(so, mute, TRUE);
3846     }
3847
3848     pa_pstream_send_simple_ack(c->pstream, tag);
3849 }
3850
3851 static void command_cork_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3852     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3853     uint32_t idx;
3854     pa_bool_t b;
3855     playback_stream *s;
3856
3857     pa_native_connection_assert_ref(c);
3858     pa_assert(t);
3859
3860     if (pa_tagstruct_getu32(t, &idx) < 0 ||
3861         pa_tagstruct_get_boolean(t, &b) < 0 ||
3862         !pa_tagstruct_eof(t)) {
3863         protocol_error(c);
3864         return;
3865     }
3866
3867     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3868     CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3869     s = pa_idxset_get_by_index(c->output_streams, idx);
3870     CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3871     CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3872
3873     pa_sink_input_cork(s->sink_input, b);
3874
3875     if (b)
3876         s->is_underrun = TRUE;
3877
3878     pa_pstream_send_simple_ack(c->pstream, tag);
3879 }
3880
3881 static void command_trigger_or_flush_or_prebuf_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3882     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3883     uint32_t idx;
3884     playback_stream *s;
3885
3886     pa_native_connection_assert_ref(c);
3887     pa_assert(t);
3888
3889     if (pa_tagstruct_getu32(t, &idx) < 0 ||
3890         !pa_tagstruct_eof(t)) {
3891         protocol_error(c);
3892         return;
3893     }
3894
3895     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3896     CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3897     s = pa_idxset_get_by_index(c->output_streams, idx);
3898     CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3899     CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3900
3901     switch (command) {
3902         case PA_COMMAND_FLUSH_PLAYBACK_STREAM:
3903             pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_FLUSH, NULL, 0, NULL);
3904             break;
3905
3906         case PA_COMMAND_PREBUF_PLAYBACK_STREAM:
3907             pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_PREBUF_FORCE, NULL, 0, NULL);
3908             break;
3909
3910         case PA_COMMAND_TRIGGER_PLAYBACK_STREAM:
3911             pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_TRIGGER, NULL, 0, NULL);
3912             break;
3913
3914         default:
3915             pa_assert_not_reached();
3916     }
3917
3918     pa_pstream_send_simple_ack(c->pstream, tag);
3919 }
3920
3921 static void command_cork_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3922     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3923     uint32_t idx;
3924     record_stream *s;
3925     pa_bool_t b;
3926
3927     pa_native_connection_assert_ref(c);
3928     pa_assert(t);
3929
3930     if (pa_tagstruct_getu32(t, &idx) < 0 ||
3931         pa_tagstruct_get_boolean(t, &b) < 0 ||
3932         !pa_tagstruct_eof(t)) {
3933         protocol_error(c);
3934         return;
3935     }
3936
3937     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3938     s = pa_idxset_get_by_index(c->record_streams, idx);
3939     CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3940
3941     pa_source_output_cork(s->source_output, b);
3942     pa_memblockq_prebuf_force(s->memblockq);
3943     pa_pstream_send_simple_ack(c->pstream, tag);
3944 }
3945
3946 static void command_flush_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3947     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3948     uint32_t idx;
3949     record_stream *s;
3950
3951     pa_native_connection_assert_ref(c);
3952     pa_assert(t);
3953
3954     if (pa_tagstruct_getu32(t, &idx) < 0 ||
3955         !pa_tagstruct_eof(t)) {
3956         protocol_error(c);
3957         return;
3958     }
3959
3960     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3961     s = pa_idxset_get_by_index(c->record_streams, idx);
3962     CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3963
3964     pa_memblockq_flush_read(s->memblockq);
3965     pa_pstream_send_simple_ack(c->pstream, tag);
3966 }
3967
3968 static void command_set_stream_buffer_attr(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3969     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3970     uint32_t idx;
3971     pa_buffer_attr a;
3972     pa_tagstruct *reply;
3973
3974     pa_native_connection_assert_ref(c);
3975     pa_assert(t);
3976
3977     memset(&a, 0, sizeof(a));
3978
3979     if (pa_tagstruct_getu32(t, &idx) < 0) {
3980         protocol_error(c);
3981         return;
3982     }
3983
3984     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3985
3986     if (command == PA_COMMAND_SET_PLAYBACK_STREAM_BUFFER_ATTR) {
3987         playback_stream *s;
3988         pa_bool_t adjust_latency = FALSE, early_requests = FALSE;
3989
3990         s = pa_idxset_get_by_index(c->output_streams, idx);
3991         CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3992         CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3993
3994         if (pa_tagstruct_get(
3995                     t,
3996                     PA_TAG_U32, &a.maxlength,
3997                     PA_TAG_U32, &a.tlength,
3998                     PA_TAG_U32, &a.prebuf,
3999                     PA_TAG_U32, &a.minreq,
4000                     PA_TAG_INVALID) < 0 ||
4001             (c->version >= 13 && pa_tagstruct_get_boolean(t, &adjust_latency) < 0) ||
4002             (c->version >= 14 && pa_tagstruct_get_boolean(t, &early_requests) < 0) ||
4003             !pa_tagstruct_eof(t)) {
4004             protocol_error(c);
4005             return;
4006         }
4007
4008         s->adjust_latency = adjust_latency;
4009         s->early_requests = early_requests;
4010         s->buffer_attr_req = a;
4011
4012         fix_playback_buffer_attr(s);
4013         pa_assert_se(pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_UPDATE_BUFFER_ATTR, NULL, 0, NULL) == 0);
4014
4015         reply = reply_new(tag);
4016         pa_tagstruct_putu32(reply, s->buffer_attr.maxlength);
4017         pa_tagstruct_putu32(reply, s->buffer_attr.tlength);
4018         pa_tagstruct_putu32(reply, s->buffer_attr.prebuf);
4019         pa_tagstruct_putu32(reply, s->buffer_attr.minreq);
4020
4021         if (c->version >= 13)
4022             pa_tagstruct_put_usec(reply, s->configured_sink_latency);
4023
4024     } else {
4025         record_stream *s;
4026         pa_bool_t adjust_latency = FALSE, early_requests = FALSE;
4027         pa_assert(command == PA_COMMAND_SET_RECORD_STREAM_BUFFER_ATTR);
4028
4029         s = pa_idxset_get_by_index(c->record_streams, idx);
4030         CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4031
4032         if (pa_tagstruct_get(
4033                     t,
4034                     PA_TAG_U32, &a.maxlength,
4035                     PA_TAG_U32, &a.fragsize,
4036                     PA_TAG_INVALID) < 0 ||
4037             (c->version >= 13 && pa_tagstruct_get_boolean(t, &adjust_latency) < 0) ||
4038             (c->version >= 14 && pa_tagstruct_get_boolean(t, &early_requests) < 0) ||
4039             !pa_tagstruct_eof(t)) {
4040             protocol_error(c);
4041             return;
4042         }
4043
4044         s->adjust_latency = adjust_latency;
4045         s->early_requests = early_requests;
4046         s->buffer_attr_req = a;
4047
4048         fix_record_buffer_attr_pre(s);
4049         pa_memblockq_set_maxlength(s->memblockq, s->buffer_attr.maxlength);
4050         pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
4051         fix_record_buffer_attr_post(s);
4052
4053         reply = reply_new(tag);
4054         pa_tagstruct_putu32(reply, s->buffer_attr.maxlength);
4055         pa_tagstruct_putu32(reply, s->buffer_attr.fragsize);
4056
4057         if (c->version >= 13)
4058             pa_tagstruct_put_usec(reply, s->configured_source_latency);
4059     }
4060
4061     pa_pstream_send_tagstruct(c->pstream, reply);
4062 }
4063
4064 static void command_update_stream_sample_rate(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4065     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4066     uint32_t idx;
4067     uint32_t rate;
4068
4069     pa_native_connection_assert_ref(c);
4070     pa_assert(t);
4071
4072     if (pa_tagstruct_getu32(t, &idx) < 0 ||
4073         pa_tagstruct_getu32(t, &rate) < 0 ||
4074         !pa_tagstruct_eof(t)) {
4075         protocol_error(c);
4076         return;
4077     }
4078
4079     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4080     CHECK_VALIDITY(c->pstream, rate > 0 && rate <= PA_RATE_MAX, tag, PA_ERR_INVALID);
4081
4082     if (command == PA_COMMAND_UPDATE_PLAYBACK_STREAM_SAMPLE_RATE) {
4083         playback_stream *s;
4084
4085         s = pa_idxset_get_by_index(c->output_streams, idx);
4086         CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4087         CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
4088
4089         pa_sink_input_set_rate(s->sink_input, rate);
4090
4091     } else {
4092         record_stream *s;
4093         pa_assert(command == PA_COMMAND_UPDATE_RECORD_STREAM_SAMPLE_RATE);
4094
4095         s = pa_idxset_get_by_index(c->record_streams, idx);
4096         CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4097
4098         pa_source_output_set_rate(s->source_output, rate);
4099     }
4100
4101     pa_pstream_send_simple_ack(c->pstream, tag);
4102 }
4103
4104 static void command_update_proplist(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4105     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4106     uint32_t idx;
4107     uint32_t mode;
4108     pa_proplist *p;
4109
4110     pa_native_connection_assert_ref(c);
4111     pa_assert(t);
4112
4113     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4114
4115     p = pa_proplist_new();
4116
4117     if (command == PA_COMMAND_UPDATE_CLIENT_PROPLIST) {
4118
4119         if (pa_tagstruct_getu32(t, &mode) < 0 ||
4120             pa_tagstruct_get_proplist(t, p) < 0 ||
4121             !pa_tagstruct_eof(t)) {
4122             protocol_error(c);
4123             pa_proplist_free(p);
4124             return;
4125         }
4126
4127     } else {
4128
4129         if (pa_tagstruct_getu32(t, &idx) < 0 ||
4130             pa_tagstruct_getu32(t, &mode) < 0 ||
4131             pa_tagstruct_get_proplist(t, p) < 0 ||
4132             !pa_tagstruct_eof(t)) {
4133             protocol_error(c);
4134             pa_proplist_free(p);
4135             return;
4136         }
4137     }
4138
4139     if (!(mode == PA_UPDATE_SET || mode == PA_UPDATE_MERGE || mode == PA_UPDATE_REPLACE)) {
4140         pa_proplist_free(p);
4141         CHECK_VALIDITY(c->pstream, FALSE, tag, PA_ERR_INVALID);
4142     }
4143
4144     if (command == PA_COMMAND_UPDATE_PLAYBACK_STREAM_PROPLIST) {
4145         playback_stream *s;
4146
4147         s = pa_idxset_get_by_index(c->output_streams, idx);
4148         if (!s || !playback_stream_isinstance(s)) {
4149             pa_proplist_free(p);
4150             CHECK_VALIDITY(c->pstream, FALSE, tag, PA_ERR_NOENTITY);
4151         }
4152         pa_sink_input_update_proplist(s->sink_input, mode, p);
4153
4154     } else if (command == PA_COMMAND_UPDATE_RECORD_STREAM_PROPLIST) {
4155         record_stream *s;
4156
4157         if (!(s = pa_idxset_get_by_index(c->record_streams, idx))) {
4158             pa_proplist_free(p);
4159             CHECK_VALIDITY(c->pstream, FALSE, tag, PA_ERR_NOENTITY);
4160         }
4161         pa_source_output_update_proplist(s->source_output, mode, p);
4162
4163     } else {
4164         pa_assert(command == PA_COMMAND_UPDATE_CLIENT_PROPLIST);
4165
4166         pa_client_update_proplist(c->client, mode, p);
4167     }
4168
4169     pa_pstream_send_simple_ack(c->pstream, tag);
4170     pa_proplist_free(p);
4171 }
4172
4173 static void command_remove_proplist(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4174     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4175     uint32_t idx;
4176     unsigned changed = 0;
4177     pa_proplist *p;
4178     pa_strlist *l = NULL;
4179
4180     pa_native_connection_assert_ref(c);
4181     pa_assert(t);
4182
4183     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4184
4185     if (command != PA_COMMAND_REMOVE_CLIENT_PROPLIST) {
4186
4187         if (pa_tagstruct_getu32(t, &idx) < 0) {
4188             protocol_error(c);
4189             return;
4190         }
4191     }
4192
4193     if (command == PA_COMMAND_REMOVE_PLAYBACK_STREAM_PROPLIST) {
4194         playback_stream *s;
4195
4196         s = pa_idxset_get_by_index(c->output_streams, idx);
4197         CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4198         CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
4199
4200         p = s->sink_input->proplist;
4201
4202     } else if (command == PA_COMMAND_REMOVE_RECORD_STREAM_PROPLIST) {
4203         record_stream *s;
4204
4205         s = pa_idxset_get_by_index(c->record_streams, idx);
4206         CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4207
4208         p = s->source_output->proplist;
4209     } else {
4210         pa_assert(command == PA_COMMAND_REMOVE_CLIENT_PROPLIST);
4211
4212         p = c->client->proplist;
4213     }
4214
4215     for (;;) {
4216         const char *k;
4217
4218         if (pa_tagstruct_gets(t, &k) < 0) {
4219             protocol_error(c);
4220             pa_strlist_free(l);
4221             return;
4222         }
4223
4224         if (!k)
4225             break;
4226
4227         l = pa_strlist_prepend(l, k);
4228     }
4229
4230     if (!pa_tagstruct_eof(t)) {
4231         protocol_error(c);
4232         pa_strlist_free(l);
4233         return;
4234     }
4235
4236     for (;;) {
4237         char *z;
4238
4239         l = pa_strlist_pop(l, &z);
4240
4241         if (!z)
4242             break;
4243
4244         changed += (unsigned) (pa_proplist_unset(p, z) >= 0);
4245         pa_xfree(z);
4246     }
4247
4248     pa_pstream_send_simple_ack(c->pstream, tag);
4249
4250     if (changed) {
4251         if (command == PA_COMMAND_REMOVE_PLAYBACK_STREAM_PROPLIST) {
4252             playback_stream *s;
4253
4254             s = pa_idxset_get_by_index(c->output_streams, idx);
4255             pa_subscription_post(c->protocol->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, s->sink_input->index);
4256
4257         } else if (command == PA_COMMAND_REMOVE_RECORD_STREAM_PROPLIST) {
4258             record_stream *s;
4259
4260             s = pa_idxset_get_by_index(c->record_streams, idx);
4261             pa_subscription_post(c->protocol->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, s->source_output->index);
4262
4263         } else {
4264             pa_assert(command == PA_COMMAND_REMOVE_CLIENT_PROPLIST);
4265             pa_subscription_post(c->protocol->core, PA_SUBSCRIPTION_EVENT_CLIENT|PA_SUBSCRIPTION_EVENT_CHANGE, c->client->index);
4266         }
4267     }
4268 }
4269
4270 static void command_set_default_sink_or_source(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4271     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4272     const char *s;
4273
4274     pa_native_connection_assert_ref(c);
4275     pa_assert(t);
4276
4277     if (pa_tagstruct_gets(t, &s) < 0 ||
4278         !pa_tagstruct_eof(t)) {
4279         protocol_error(c);
4280         return;
4281     }
4282
4283     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4284     CHECK_VALIDITY(c->pstream, !s || pa_namereg_is_valid_name(s), tag, PA_ERR_INVALID);
4285
4286     if (command == PA_COMMAND_SET_DEFAULT_SOURCE) {
4287         pa_source *source;
4288
4289         source = pa_namereg_get(c->protocol->core, s, PA_NAMEREG_SOURCE);
4290         CHECK_VALIDITY(c->pstream, source, tag, PA_ERR_NOENTITY);
4291
4292         pa_namereg_set_default_source(c->protocol->core, source);
4293     } else {
4294         pa_sink *sink;
4295         pa_assert(command == PA_COMMAND_SET_DEFAULT_SINK);
4296
4297         sink = pa_namereg_get(c->protocol->core, s, PA_NAMEREG_SINK);
4298         CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
4299
4300         pa_namereg_set_default_sink(c->protocol->core, sink);
4301     }
4302
4303     pa_pstream_send_simple_ack(c->pstream, tag);
4304 }
4305
4306 static void command_set_stream_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4307     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4308     uint32_t idx;
4309     const char *name;
4310
4311     pa_native_connection_assert_ref(c);
4312     pa_assert(t);
4313
4314     if (pa_tagstruct_getu32(t, &idx) < 0 ||
4315         pa_tagstruct_gets(t, &name) < 0 ||
4316         !pa_tagstruct_eof(t)) {
4317         protocol_error(c);
4318         return;
4319     }
4320
4321     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4322     CHECK_VALIDITY(c->pstream, name && pa_utf8_valid(name), tag, PA_ERR_INVALID);
4323
4324     if (command == PA_COMMAND_SET_PLAYBACK_STREAM_NAME) {
4325         playback_stream *s;
4326
4327         s = pa_idxset_get_by_index(c->output_streams, idx);
4328         CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4329         CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
4330
4331         pa_sink_input_set_name(s->sink_input, name);
4332
4333     } else {
4334         record_stream *s;
4335         pa_assert(command == PA_COMMAND_SET_RECORD_STREAM_NAME);
4336
4337         s = pa_idxset_get_by_index(c->record_streams, idx);
4338         CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4339
4340         pa_source_output_set_name(s->source_output, name);
4341     }
4342
4343     pa_pstream_send_simple_ack(c->pstream, tag);
4344 }
4345
4346 static void command_kill(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4347     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4348     uint32_t idx;
4349
4350     pa_native_connection_assert_ref(c);
4351     pa_assert(t);
4352
4353     if (pa_tagstruct_getu32(t, &idx) < 0 ||
4354         !pa_tagstruct_eof(t)) {
4355         protocol_error(c);
4356         return;
4357     }
4358
4359     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4360
4361     if (command == PA_COMMAND_KILL_CLIENT) {
4362         pa_client *client;
4363
4364         client = pa_idxset_get_by_index(c->protocol->core->clients, idx);
4365         CHECK_VALIDITY(c->pstream, client, tag, PA_ERR_NOENTITY);
4366
4367         pa_native_connection_ref(c);
4368         pa_client_kill(client);
4369
4370     } else if (command == PA_COMMAND_KILL_SINK_INPUT) {
4371         pa_sink_input *s;
4372
4373         s = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
4374         CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4375
4376         pa_native_connection_ref(c);
4377         pa_sink_input_kill(s);
4378     } else {
4379         pa_source_output *s;
4380
4381         pa_assert(command == PA_COMMAND_KILL_SOURCE_OUTPUT);
4382
4383         s = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
4384         CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4385
4386         pa_native_connection_ref(c);
4387         pa_source_output_kill(s);
4388     }
4389
4390     pa_pstream_send_simple_ack(c->pstream, tag);
4391     pa_native_connection_unref(c);
4392 }
4393
4394 static void command_load_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4395     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4396     pa_module *m;
4397     const char *name, *argument;
4398     pa_tagstruct *reply;
4399
4400     pa_native_connection_assert_ref(c);
4401     pa_assert(t);
4402
4403     if (pa_tagstruct_gets(t, &name) < 0 ||
4404         pa_tagstruct_gets(t, &argument) < 0 ||
4405         !pa_tagstruct_eof(t)) {
4406         protocol_error(c);
4407         return;
4408     }
4409
4410     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4411     CHECK_VALIDITY(c->pstream, name && *name && pa_utf8_valid(name) && !strchr(name, '/'), tag, PA_ERR_INVALID);
4412     CHECK_VALIDITY(c->pstream, !argument || pa_utf8_valid(argument), tag, PA_ERR_INVALID);
4413
4414     if (!(m = pa_module_load(c->protocol->core, name, argument))) {
4415         pa_pstream_send_error(c->pstream, tag, PA_ERR_MODINITFAILED);
4416         return;
4417     }
4418
4419     reply = reply_new(tag);
4420     pa_tagstruct_putu32(reply, m->index);
4421     pa_pstream_send_tagstruct(c->pstream, reply);
4422 }
4423
4424 static void command_unload_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4425     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4426     uint32_t idx;
4427     pa_module *m;
4428
4429     pa_native_connection_assert_ref(c);
4430     pa_assert(t);
4431
4432     if (pa_tagstruct_getu32(t, &idx) < 0 ||
4433         !pa_tagstruct_eof(t)) {
4434         protocol_error(c);
4435         return;
4436     }
4437
4438     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4439     m = pa_idxset_get_by_index(c->protocol->core->modules, idx);
4440     CHECK_VALIDITY(c->pstream, m, tag, PA_ERR_NOENTITY);
4441
4442     pa_module_unload_request(m, FALSE);
4443     pa_pstream_send_simple_ack(c->pstream, tag);
4444 }
4445
4446 static void command_move_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4447     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4448     uint32_t idx = PA_INVALID_INDEX, idx_device = PA_INVALID_INDEX;
4449     const char *name_device = NULL;
4450
4451     pa_native_connection_assert_ref(c);
4452     pa_assert(t);
4453
4454     if (pa_tagstruct_getu32(t, &idx) < 0 ||
4455         pa_tagstruct_getu32(t, &idx_device) < 0 ||
4456         pa_tagstruct_gets(t, &name_device) < 0 ||
4457         !pa_tagstruct_eof(t)) {
4458         protocol_error(c);
4459         return;
4460     }
4461
4462     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4463     CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4464
4465     CHECK_VALIDITY(c->pstream, !name_device || pa_namereg_is_valid_name_or_wildcard(name_device, command == PA_COMMAND_MOVE_SINK_INPUT ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE), tag, PA_ERR_INVALID);
4466     CHECK_VALIDITY(c->pstream, idx_device != PA_INVALID_INDEX || name_device, tag, PA_ERR_INVALID);
4467     CHECK_VALIDITY(c->pstream, idx_device == PA_INVALID_INDEX || !name_device, tag, PA_ERR_INVALID);
4468     CHECK_VALIDITY(c->pstream, !name_device || idx_device == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4469
4470     if (command == PA_COMMAND_MOVE_SINK_INPUT) {
4471         pa_sink_input *si = NULL;
4472         pa_sink *sink = NULL;
4473
4474         si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
4475
4476         if (idx_device != PA_INVALID_INDEX)
4477             sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx_device);
4478         else
4479             sink = pa_namereg_get(c->protocol->core, name_device, PA_NAMEREG_SINK);
4480
4481         CHECK_VALIDITY(c->pstream, si && sink, tag, PA_ERR_NOENTITY);
4482
4483         if (pa_sink_input_move_to(si, sink, TRUE) < 0) {
4484             pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4485             return;
4486         }
4487     } else {
4488         pa_source_output *so = NULL;
4489         pa_source *source;
4490
4491         pa_assert(command == PA_COMMAND_MOVE_SOURCE_OUTPUT);
4492
4493         so = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
4494
4495         if (idx_device != PA_INVALID_INDEX)
4496             source = pa_idxset_get_by_index(c->protocol->core->sources, idx_device);
4497         else
4498             source = pa_namereg_get(c->protocol->core, name_device, PA_NAMEREG_SOURCE);
4499
4500         CHECK_VALIDITY(c->pstream, so && source, tag, PA_ERR_NOENTITY);
4501
4502         if (pa_source_output_move_to(so, source, TRUE) < 0) {
4503             pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4504             return;
4505         }
4506     }
4507
4508     pa_pstream_send_simple_ack(c->pstream, tag);
4509 }
4510
4511 static void command_suspend(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4512     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4513     uint32_t idx = PA_INVALID_INDEX;
4514     const char *name = NULL;
4515     pa_bool_t b;
4516
4517     pa_native_connection_assert_ref(c);
4518     pa_assert(t);
4519
4520     if (pa_tagstruct_getu32(t, &idx) < 0 ||
4521         pa_tagstruct_gets(t, &name) < 0 ||
4522         pa_tagstruct_get_boolean(t, &b) < 0 ||
4523         !pa_tagstruct_eof(t)) {
4524         protocol_error(c);
4525         return;
4526     }
4527
4528     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4529     CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name_or_wildcard(name, command == PA_COMMAND_SUSPEND_SINK ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE) || *name == 0, tag, PA_ERR_INVALID);
4530     CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
4531     CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
4532     CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4533
4534     if (command == PA_COMMAND_SUSPEND_SINK) {
4535
4536         if (idx == PA_INVALID_INDEX && name && !*name) {
4537
4538             pa_log_debug("%s all sinks", b ? "Suspending" : "Resuming");
4539
4540             if (pa_sink_suspend_all(c->protocol->core, b, PA_SUSPEND_USER) < 0) {
4541                 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4542                 return;
4543             }
4544         } else {
4545             pa_sink *sink = NULL;
4546
4547             if (idx != PA_INVALID_INDEX)
4548                 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
4549             else
4550                 sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
4551
4552             CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
4553
4554             if (pa_sink_suspend(sink, b, PA_SUSPEND_USER) < 0) {
4555                 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4556                 return;
4557             }
4558         }
4559     } else {
4560
4561         pa_assert(command == PA_COMMAND_SUSPEND_SOURCE);
4562
4563         if (idx == PA_INVALID_INDEX && name && !*name) {
4564
4565             pa_log_debug("%s all sources", b ? "Suspending" : "Resuming");
4566
4567             if (pa_source_suspend_all(c->protocol->core, b, PA_SUSPEND_USER) < 0) {
4568                 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4569                 return;
4570             }
4571
4572         } else {
4573             pa_source *source;
4574
4575             if (idx != PA_INVALID_INDEX)
4576                 source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
4577             else
4578                 source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
4579
4580             CHECK_VALIDITY(c->pstream, source, tag, PA_ERR_NOENTITY);
4581
4582             if (pa_source_suspend(source, b, PA_SUSPEND_USER) < 0) {
4583                 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4584                 return;
4585             }
4586         }
4587     }
4588
4589     pa_pstream_send_simple_ack(c->pstream, tag);
4590 }
4591
4592 static void command_extension(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4593     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4594     uint32_t idx = PA_INVALID_INDEX;
4595     const char *name = NULL;
4596     pa_module *m;
4597     pa_native_protocol_ext_cb_t cb;
4598
4599     pa_native_connection_assert_ref(c);
4600     pa_assert(t);
4601
4602     if (pa_tagstruct_getu32(t, &idx) < 0 ||
4603         pa_tagstruct_gets(t, &name) < 0) {
4604         protocol_error(c);
4605         return;
4606     }
4607
4608     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4609     CHECK_VALIDITY(c->pstream, !name || pa_utf8_valid(name), tag, PA_ERR_INVALID);
4610     CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
4611     CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
4612     CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4613
4614     if (idx != PA_INVALID_INDEX)
4615         m = pa_idxset_get_by_index(c->protocol->core->modules, idx);
4616     else
4617         PA_IDXSET_FOREACH(m, c->protocol->core->modules, idx)
4618             if (pa_streq(name, m->name))
4619                 break;
4620
4621     CHECK_VALIDITY(c->pstream, m, tag, PA_ERR_NOEXTENSION);
4622     CHECK_VALIDITY(c->pstream, m->load_once || idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4623
4624     cb = (pa_native_protocol_ext_cb_t) (unsigned long) pa_hashmap_get(c->protocol->extensions, m);
4625     CHECK_VALIDITY(c->pstream, cb, tag, PA_ERR_NOEXTENSION);
4626
4627     if (cb(c->protocol, m, c, tag, t) < 0)
4628         protocol_error(c);
4629 }
4630
4631 static void command_set_card_profile(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4632     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4633     uint32_t idx = PA_INVALID_INDEX;
4634     const char *name = NULL, *profile = NULL;
4635     pa_card *card = NULL;
4636     int ret;
4637
4638     pa_native_connection_assert_ref(c);
4639     pa_assert(t);
4640
4641     if (pa_tagstruct_getu32(t, &idx) < 0 ||
4642         pa_tagstruct_gets(t, &name) < 0 ||
4643         pa_tagstruct_gets(t, &profile) < 0 ||
4644         !pa_tagstruct_eof(t)) {
4645         protocol_error(c);
4646         return;
4647     }
4648
4649     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4650     CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
4651     CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
4652     CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
4653     CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4654
4655     if (idx != PA_INVALID_INDEX)
4656         card = pa_idxset_get_by_index(c->protocol->core->cards, idx);
4657     else
4658         card = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_CARD);
4659
4660     CHECK_VALIDITY(c->pstream, card, tag, PA_ERR_NOENTITY);
4661
4662     if ((ret = pa_card_set_profile(card, profile, TRUE)) < 0) {
4663         pa_pstream_send_error(c->pstream, tag, -ret);
4664         return;
4665     }
4666
4667     pa_pstream_send_simple_ack(c->pstream, tag);
4668 }
4669
4670 static void command_set_sink_or_source_port(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4671     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4672     uint32_t idx = PA_INVALID_INDEX;
4673     const char *name = NULL, *port = NULL;
4674     int ret;
4675
4676     pa_native_connection_assert_ref(c);
4677     pa_assert(t);
4678
4679     if (pa_tagstruct_getu32(t, &idx) < 0 ||
4680         pa_tagstruct_gets(t, &name) < 0 ||
4681         pa_tagstruct_gets(t, &port) < 0 ||
4682         !pa_tagstruct_eof(t)) {
4683         protocol_error(c);
4684         return;
4685     }
4686
4687     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4688     CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name_or_wildcard(name, command == PA_COMMAND_SET_SINK_PORT ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE), tag, PA_ERR_INVALID);
4689     CHECK_VALIDITY(c->pstream, (idx != PA_INVALID_INDEX) ^ (name != NULL), tag, PA_ERR_INVALID);
4690     CHECK_VALIDITY(c->pstream, port, tag, PA_ERR_INVALID);
4691
4692     if (command == PA_COMMAND_SET_SINK_PORT) {
4693         pa_sink *sink;
4694
4695         if (idx != PA_INVALID_INDEX)
4696             sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
4697         else
4698             sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
4699
4700         CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
4701
4702         if ((ret = pa_sink_set_port(sink, port, TRUE)) < 0) {
4703             pa_pstream_send_error(c->pstream, tag, -ret);
4704             return;
4705         }
4706     } else {
4707         pa_source *source;
4708
4709         pa_assert(command = PA_COMMAND_SET_SOURCE_PORT);
4710
4711         if (idx != PA_INVALID_INDEX)
4712             source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
4713         else
4714             source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
4715
4716         CHECK_VALIDITY(c->pstream, source, tag, PA_ERR_NOENTITY);
4717
4718         if ((ret = pa_source_set_port(source, port, TRUE)) < 0) {
4719             pa_pstream_send_error(c->pstream, tag, -ret);
4720             return;
4721         }
4722     }
4723
4724     pa_pstream_send_simple_ack(c->pstream, tag);
4725 }
4726
4727 /*** pstream callbacks ***/
4728
4729 static void pstream_packet_callback(pa_pstream *p, pa_packet *packet, const pa_creds *creds, void *userdata) {
4730     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4731
4732     pa_assert(p);
4733     pa_assert(packet);
4734     pa_native_connection_assert_ref(c);
4735
4736     if (pa_pdispatch_run(c->pdispatch, packet, creds, c) < 0) {
4737         pa_log("invalid packet.");
4738         native_connection_unlink(c);
4739     }
4740 }
4741
4742 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) {
4743     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4744     output_stream *stream;
4745
4746     pa_assert(p);
4747     pa_assert(chunk);
4748     pa_native_connection_assert_ref(c);
4749
4750     if (!(stream = OUTPUT_STREAM(pa_idxset_get_by_index(c->output_streams, channel)))) {
4751         pa_log_debug("Client sent block for invalid stream.");
4752         /* Ignoring */
4753         return;
4754     }
4755
4756 #ifdef PROTOCOL_NATIVE_DEBUG
4757     pa_log("got %lu bytes from client", (unsigned long) chunk->length);
4758 #endif
4759
4760     if (playback_stream_isinstance(stream)) {
4761         playback_stream *ps = PLAYBACK_STREAM(stream);
4762
4763         pa_atomic_inc(&ps->seek_or_post_in_queue);
4764         if (chunk->memblock) {
4765             if (seek != PA_SEEK_RELATIVE || offset != 0)
4766                 pa_asyncmsgq_post(ps->sink_input->sink->asyncmsgq, PA_MSGOBJECT(ps->sink_input), SINK_INPUT_MESSAGE_SEEK, PA_UINT_TO_PTR(seek), offset, chunk, NULL);
4767             else
4768                 pa_asyncmsgq_post(ps->sink_input->sink->asyncmsgq, PA_MSGOBJECT(ps->sink_input), SINK_INPUT_MESSAGE_POST_DATA, NULL, 0, chunk, NULL);
4769         } else
4770             pa_asyncmsgq_post(ps->sink_input->sink->asyncmsgq, PA_MSGOBJECT(ps->sink_input), SINK_INPUT_MESSAGE_SEEK, PA_UINT_TO_PTR(seek), offset+chunk->length, NULL, NULL);
4771
4772     } else {
4773         upload_stream *u = UPLOAD_STREAM(stream);
4774         size_t l;
4775
4776         if (!u->memchunk.memblock) {
4777             if (u->length == chunk->length && chunk->memblock) {
4778                 u->memchunk = *chunk;
4779                 pa_memblock_ref(u->memchunk.memblock);
4780                 u->length = 0;
4781             } else {
4782                 u->memchunk.memblock = pa_memblock_new(c->protocol->core->mempool, u->length);
4783                 u->memchunk.index = u->memchunk.length = 0;
4784             }
4785         }
4786
4787         pa_assert(u->memchunk.memblock);
4788
4789         l = u->length;
4790         if (l > chunk->length)
4791             l = chunk->length;
4792
4793         if (l > 0) {
4794             void *dst;
4795             dst = pa_memblock_acquire(u->memchunk.memblock);
4796
4797             if (chunk->memblock) {
4798                 void *src;
4799                 src = pa_memblock_acquire(chunk->memblock);
4800
4801                 memcpy((uint8_t*) dst + u->memchunk.index + u->memchunk.length,
4802                        (uint8_t*) src + chunk->index, l);
4803
4804                 pa_memblock_release(chunk->memblock);
4805             } else
4806                 pa_silence_memory((uint8_t*) dst + u->memchunk.index + u->memchunk.length, l, &u->sample_spec);
4807
4808             pa_memblock_release(u->memchunk.memblock);
4809
4810             u->memchunk.length += l;
4811             u->length -= l;
4812         }
4813     }
4814 }
4815
4816 static void pstream_die_callback(pa_pstream *p, void *userdata) {
4817     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4818
4819     pa_assert(p);
4820     pa_native_connection_assert_ref(c);
4821
4822     native_connection_unlink(c);
4823     pa_log_info("Connection died.");
4824 }
4825
4826 static void pstream_drain_callback(pa_pstream *p, void *userdata) {
4827     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4828
4829     pa_assert(p);
4830     pa_native_connection_assert_ref(c);
4831
4832     native_connection_send_memblock(c);
4833 }
4834
4835 static void pstream_revoke_callback(pa_pstream *p, uint32_t block_id, void *userdata) {
4836     pa_thread_mq *q;
4837
4838     if (!(q = pa_thread_mq_get()))
4839         pa_pstream_send_revoke(p, block_id);
4840     else
4841         pa_asyncmsgq_post(q->outq, PA_MSGOBJECT(userdata), CONNECTION_MESSAGE_REVOKE, PA_UINT_TO_PTR(block_id), 0, NULL, NULL);
4842 }
4843
4844 static void pstream_release_callback(pa_pstream *p, uint32_t block_id, void *userdata) {
4845     pa_thread_mq *q;
4846
4847     if (!(q = pa_thread_mq_get()))
4848         pa_pstream_send_release(p, block_id);
4849     else
4850         pa_asyncmsgq_post(q->outq, PA_MSGOBJECT(userdata), CONNECTION_MESSAGE_RELEASE, PA_UINT_TO_PTR(block_id), 0, NULL, NULL);
4851 }
4852
4853 /*** client callbacks ***/
4854
4855 static void client_kill_cb(pa_client *c) {
4856     pa_assert(c);
4857
4858     native_connection_unlink(PA_NATIVE_CONNECTION(c->userdata));
4859     pa_log_info("Connection killed.");
4860 }
4861
4862 static void client_send_event_cb(pa_client *client, const char*event, pa_proplist *pl) {
4863     pa_tagstruct *t;
4864     pa_native_connection *c;
4865
4866     pa_assert(client);
4867     c = PA_NATIVE_CONNECTION(client->userdata);
4868     pa_native_connection_assert_ref(c);
4869
4870     if (c->version < 15)
4871       return;
4872
4873     t = pa_tagstruct_new(NULL, 0);
4874     pa_tagstruct_putu32(t, PA_COMMAND_CLIENT_EVENT);
4875     pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
4876     pa_tagstruct_puts(t, event);
4877     pa_tagstruct_put_proplist(t, pl);
4878     pa_pstream_send_tagstruct(c->pstream, t);
4879 }
4880
4881 /*** module entry points ***/
4882
4883 static void auth_timeout(pa_mainloop_api*m, pa_time_event *e, const struct timeval *t, void *userdata) {
4884     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4885
4886     pa_assert(m);
4887     pa_native_connection_assert_ref(c);
4888     pa_assert(c->auth_timeout_event == e);
4889
4890     if (!c->authorized) {
4891         native_connection_unlink(c);
4892         pa_log_info("Connection terminated due to authentication timeout.");
4893     }
4894 }
4895
4896 void pa_native_protocol_connect(pa_native_protocol *p, pa_iochannel *io, pa_native_options *o) {
4897     pa_native_connection *c;
4898     char pname[128];
4899     pa_client *client;
4900     pa_client_new_data data;
4901
4902     pa_assert(p);
4903     pa_assert(io);
4904     pa_assert(o);
4905
4906     if (pa_idxset_size(p->connections)+1 > MAX_CONNECTIONS) {
4907         pa_log_warn("Warning! Too many connections (%u), dropping incoming connection.", MAX_CONNECTIONS);
4908         pa_iochannel_free(io);
4909         return;
4910     }
4911
4912     pa_client_new_data_init(&data);
4913     data.module = o->module;
4914     data.driver = __FILE__;
4915     pa_iochannel_socket_peer_to_string(io, pname, sizeof(pname));
4916     pa_proplist_setf(data.proplist, PA_PROP_APPLICATION_NAME, "Native client (%s)", pname);
4917     pa_proplist_sets(data.proplist, "native-protocol.peer", pname);
4918     client = pa_client_new(p->core, &data);
4919     pa_client_new_data_done(&data);
4920
4921     if (!client)
4922         return;
4923
4924     c = pa_msgobject_new(pa_native_connection);
4925     c->parent.parent.free = native_connection_free;
4926     c->parent.process_msg = native_connection_process_msg;
4927     c->protocol = p;
4928     c->options = pa_native_options_ref(o);
4929     c->authorized = FALSE;
4930
4931     if (o->auth_anonymous) {
4932         pa_log_info("Client authenticated anonymously.");
4933         c->authorized = TRUE;
4934     }
4935
4936     if (!c->authorized &&
4937         o->auth_ip_acl &&
4938         pa_ip_acl_check(o->auth_ip_acl, pa_iochannel_get_recv_fd(io)) > 0) {
4939
4940         pa_log_info("Client authenticated by IP ACL.");
4941         c->authorized = TRUE;
4942     }
4943
4944     if (!c->authorized)
4945         c->auth_timeout_event = pa_core_rttime_new(p->core, pa_rtclock_now() + AUTH_TIMEOUT, auth_timeout, c);
4946     else
4947         c->auth_timeout_event = NULL;
4948
4949     c->is_local = pa_iochannel_socket_is_local(io);
4950     c->version = 8;
4951
4952     c->client = client;
4953     c->client->kill = client_kill_cb;
4954     c->client->send_event = client_send_event_cb;
4955     c->client->userdata = c;
4956
4957     c->pstream = pa_pstream_new(p->core->mainloop, io, p->core->mempool);
4958     pa_pstream_set_receive_packet_callback(c->pstream, pstream_packet_callback, c);
4959     pa_pstream_set_receive_memblock_callback(c->pstream, pstream_memblock_callback, c);
4960     pa_pstream_set_die_callback(c->pstream, pstream_die_callback, c);
4961     pa_pstream_set_drain_callback(c->pstream, pstream_drain_callback, c);
4962     pa_pstream_set_revoke_callback(c->pstream, pstream_revoke_callback, c);
4963     pa_pstream_set_release_callback(c->pstream, pstream_release_callback, c);
4964
4965     c->pdispatch = pa_pdispatch_new(p->core->mainloop, TRUE, command_table, PA_COMMAND_MAX);
4966
4967     c->record_streams = pa_idxset_new(NULL, NULL);
4968     c->output_streams = pa_idxset_new(NULL, NULL);
4969
4970     c->rrobin_index = PA_IDXSET_INVALID;
4971     c->subscription = NULL;
4972
4973     pa_idxset_put(p->connections, c, NULL);
4974
4975 #ifdef HAVE_CREDS
4976     if (pa_iochannel_creds_supported(io))
4977         pa_iochannel_creds_enable(io);
4978 #endif
4979
4980     pa_hook_fire(&p->hooks[PA_NATIVE_HOOK_CONNECTION_PUT], c);
4981 }
4982
4983 void pa_native_protocol_disconnect(pa_native_protocol *p, pa_module *m) {
4984     pa_native_connection *c;
4985     void *state = NULL;
4986
4987     pa_assert(p);
4988     pa_assert(m);
4989
4990     while ((c = pa_idxset_iterate(p->connections, &state, NULL)))
4991         if (c->options->module == m)
4992             native_connection_unlink(c);
4993 }
4994
4995 static pa_native_protocol* native_protocol_new(pa_core *c) {
4996     pa_native_protocol *p;
4997     pa_native_hook_t h;
4998
4999     pa_assert(c);
5000
5001     p = pa_xnew(pa_native_protocol, 1);
5002     PA_REFCNT_INIT(p);
5003     p->core = c;
5004     p->connections = pa_idxset_new(NULL, NULL);
5005
5006     p->servers = NULL;
5007
5008     p->extensions = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
5009
5010     for (h = 0; h < PA_NATIVE_HOOK_MAX; h++)
5011         pa_hook_init(&p->hooks[h], p);
5012
5013     pa_assert_se(pa_shared_set(c, "native-protocol", p) >= 0);
5014
5015     return p;
5016 }
5017
5018 pa_native_protocol* pa_native_protocol_get(pa_core *c) {
5019     pa_native_protocol *p;
5020
5021     if ((p = pa_shared_get(c, "native-protocol")))
5022         return pa_native_protocol_ref(p);
5023
5024     return native_protocol_new(c);
5025 }
5026
5027 pa_native_protocol* pa_native_protocol_ref(pa_native_protocol *p) {
5028     pa_assert(p);
5029     pa_assert(PA_REFCNT_VALUE(p) >= 1);
5030
5031     PA_REFCNT_INC(p);
5032
5033     return p;
5034 }
5035
5036 void pa_native_protocol_unref(pa_native_protocol *p) {
5037     pa_native_connection *c;
5038     pa_native_hook_t h;
5039
5040     pa_assert(p);
5041     pa_assert(PA_REFCNT_VALUE(p) >= 1);
5042
5043     if (PA_REFCNT_DEC(p) > 0)
5044         return;
5045
5046     while ((c = pa_idxset_first(p->connections, NULL)))
5047         native_connection_unlink(c);
5048
5049     pa_idxset_free(p->connections, NULL, NULL);
5050
5051     pa_strlist_free(p->servers);
5052
5053     for (h = 0; h < PA_NATIVE_HOOK_MAX; h++)
5054         pa_hook_done(&p->hooks[h]);
5055
5056     pa_hashmap_free(p->extensions, NULL, NULL);
5057
5058     pa_assert_se(pa_shared_remove(p->core, "native-protocol") >= 0);
5059
5060     pa_xfree(p);
5061 }
5062
5063 void pa_native_protocol_add_server_string(pa_native_protocol *p, const char *name) {
5064     pa_assert(p);
5065     pa_assert(PA_REFCNT_VALUE(p) >= 1);
5066     pa_assert(name);
5067
5068     p->servers = pa_strlist_prepend(p->servers, name);
5069
5070     pa_hook_fire(&p->hooks[PA_NATIVE_HOOK_SERVERS_CHANGED], p->servers);
5071 }
5072
5073 void pa_native_protocol_remove_server_string(pa_native_protocol *p, const char *name) {
5074     pa_assert(p);
5075     pa_assert(PA_REFCNT_VALUE(p) >= 1);
5076     pa_assert(name);
5077
5078     p->servers = pa_strlist_remove(p->servers, name);
5079
5080     pa_hook_fire(&p->hooks[PA_NATIVE_HOOK_SERVERS_CHANGED], p->servers);
5081 }
5082
5083 pa_hook *pa_native_protocol_hooks(pa_native_protocol *p) {
5084     pa_assert(p);
5085     pa_assert(PA_REFCNT_VALUE(p) >= 1);
5086
5087     return p->hooks;
5088 }
5089
5090 pa_strlist *pa_native_protocol_servers(pa_native_protocol *p) {
5091     pa_assert(p);
5092     pa_assert(PA_REFCNT_VALUE(p) >= 1);
5093
5094     return p->servers;
5095 }
5096
5097 int pa_native_protocol_install_ext(pa_native_protocol *p, pa_module *m, pa_native_protocol_ext_cb_t cb) {
5098     pa_assert(p);
5099     pa_assert(PA_REFCNT_VALUE(p) >= 1);
5100     pa_assert(m);
5101     pa_assert(cb);
5102     pa_assert(!pa_hashmap_get(p->extensions, m));
5103
5104     pa_assert_se(pa_hashmap_put(p->extensions, m, (void*) (unsigned long) cb) == 0);
5105     return 0;
5106 }
5107
5108 void pa_native_protocol_remove_ext(pa_native_protocol *p, pa_module *m) {
5109     pa_assert(p);
5110     pa_assert(PA_REFCNT_VALUE(p) >= 1);
5111     pa_assert(m);
5112
5113     pa_assert_se(pa_hashmap_remove(p->extensions, m));
5114 }
5115
5116 pa_native_options* pa_native_options_new(void) {
5117     pa_native_options *o;
5118
5119     o = pa_xnew0(pa_native_options, 1);
5120     PA_REFCNT_INIT(o);
5121
5122     return o;
5123 }
5124
5125 pa_native_options* pa_native_options_ref(pa_native_options *o) {
5126     pa_assert(o);
5127     pa_assert(PA_REFCNT_VALUE(o) >= 1);
5128
5129     PA_REFCNT_INC(o);
5130
5131     return o;
5132 }
5133
5134 void pa_native_options_unref(pa_native_options *o) {
5135     pa_assert(o);
5136     pa_assert(PA_REFCNT_VALUE(o) >= 1);
5137
5138     if (PA_REFCNT_DEC(o) > 0)
5139         return;
5140
5141     pa_xfree(o->auth_group);
5142
5143     if (o->auth_ip_acl)
5144         pa_ip_acl_free(o->auth_ip_acl);
5145
5146     if (o->auth_cookie)
5147         pa_auth_cookie_unref(o->auth_cookie);
5148
5149     pa_xfree(o);
5150 }
5151
5152 int pa_native_options_parse(pa_native_options *o, pa_core *c, pa_modargs *ma) {
5153     pa_bool_t enabled;
5154     const char *acl;
5155
5156     pa_assert(o);
5157     pa_assert(PA_REFCNT_VALUE(o) >= 1);
5158     pa_assert(ma);
5159
5160     if (pa_modargs_get_value_boolean(ma, "auth-anonymous", &o->auth_anonymous) < 0) {
5161         pa_log("auth-anonymous= expects a boolean argument.");
5162         return -1;
5163     }
5164
5165     enabled = TRUE;
5166     if (pa_modargs_get_value_boolean(ma, "auth-group-enable", &enabled) < 0) {
5167         pa_log("auth-group-enable= expects a boolean argument.");
5168         return -1;
5169     }
5170
5171     pa_xfree(o->auth_group);
5172     o->auth_group = enabled ? pa_xstrdup(pa_modargs_get_value(ma, "auth-group", pa_in_system_mode() ? PA_ACCESS_GROUP : NULL)) : NULL;
5173
5174 #ifndef HAVE_CREDS
5175     if (o->auth_group)
5176         pa_log_warn("Authentication group configured, but not available on local system. Ignoring.");
5177 #endif
5178
5179     if ((acl = pa_modargs_get_value(ma, "auth-ip-acl", NULL))) {
5180         pa_ip_acl *ipa;
5181
5182         if (!(ipa = pa_ip_acl_new(acl))) {
5183             pa_log("Failed to parse IP ACL '%s'", acl);
5184             return -1;
5185         }
5186
5187         if (o->auth_ip_acl)
5188             pa_ip_acl_free(o->auth_ip_acl);
5189
5190         o->auth_ip_acl = ipa;
5191     }
5192
5193     enabled = TRUE;
5194     if (pa_modargs_get_value_boolean(ma, "auth-cookie-enabled", &enabled) < 0) {
5195         pa_log("auth-cookie-enabled= expects a boolean argument.");
5196         return -1;
5197     }
5198
5199     if (o->auth_cookie)
5200         pa_auth_cookie_unref(o->auth_cookie);
5201
5202     if (enabled) {
5203         const char *cn;
5204
5205         /* The new name for this is 'auth-cookie', for compat reasons
5206          * we check the old name too */
5207         cn = pa_modargs_get_value(ma, "auth-cookie", NULL);
5208         if (!cn)
5209             cn = pa_modargs_get_value(ma, "cookie", NULL);
5210
5211         if (cn)
5212             o->auth_cookie = pa_auth_cookie_get(c, cn, TRUE, PA_NATIVE_COOKIE_LENGTH);
5213         else {
5214             o->auth_cookie = pa_auth_cookie_get(c, PA_NATIVE_COOKIE_FILE, FALSE, PA_NATIVE_COOKIE_LENGTH);
5215             if (!o->auth_cookie) {
5216                 o->auth_cookie = pa_auth_cookie_get(c, PA_NATIVE_COOKIE_FILE_FALLBACK, FALSE, PA_NATIVE_COOKIE_LENGTH);
5217
5218                 if (!o->auth_cookie)
5219                     o->auth_cookie = pa_auth_cookie_get(c, PA_NATIVE_COOKIE_FILE, TRUE, PA_NATIVE_COOKIE_LENGTH);
5220             }
5221         }
5222
5223         if (!o->auth_cookie)
5224             return -1;
5225
5226     } else
5227           o->auth_cookie = NULL;
5228
5229     return 0;
5230 }
5231
5232 pa_pstream* pa_native_connection_get_pstream(pa_native_connection *c) {
5233     pa_native_connection_assert_ref(c);
5234
5235     return c->pstream;
5236 }
5237
5238 pa_client* pa_native_connection_get_client(pa_native_connection *c) {
5239     pa_native_connection_assert_ref(c);
5240
5241     return c->client;
5242 }