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, card->profiles ? pa_hashmap_size(card->profiles) : 0);
3243
3244     if (card->profiles) {
3245         while ((p = pa_hashmap_iterate(card->profiles, &state, NULL))) {
3246             pa_tagstruct_puts(t, p->name);
3247             pa_tagstruct_puts(t, p->description);
3248             pa_tagstruct_putu32(t, p->n_sinks);
3249             pa_tagstruct_putu32(t, p->n_sources);
3250             pa_tagstruct_putu32(t, p->priority);
3251         }
3252     }
3253
3254     pa_tagstruct_puts(t, card->active_profile ? card->active_profile->name : NULL);
3255     pa_tagstruct_put_proplist(t, card->proplist);
3256
3257     if (c->version < 26)
3258         return;
3259
3260     if (card->ports) {
3261         pa_device_port* port;
3262
3263         pa_tagstruct_putu32(t, pa_hashmap_size(card->ports));
3264
3265         PA_HASHMAP_FOREACH(port, card->ports, state) {
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             if (port->profiles) {
3274                 void* state2;
3275                 pa_tagstruct_putu32(t, pa_hashmap_size(port->profiles));
3276                 PA_HASHMAP_FOREACH(p, port->profiles, state2)
3277                     pa_tagstruct_puts(t, p->name);
3278             } else
3279                 pa_tagstruct_putu32(t, 0);
3280         }
3281
3282     } else
3283         pa_tagstruct_putu32(t, 0);
3284 }
3285
3286 static void module_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_module *module) {
3287     pa_assert(t);
3288     pa_assert(module);
3289
3290     pa_tagstruct_putu32(t, module->index);
3291     pa_tagstruct_puts(t, module->name);
3292     pa_tagstruct_puts(t, module->argument);
3293     pa_tagstruct_putu32(t, (uint32_t) pa_module_get_n_used(module));
3294
3295     if (c->version < 15)
3296         pa_tagstruct_put_boolean(t, FALSE); /* autoload is obsolete */
3297
3298     if (c->version >= 15)
3299         pa_tagstruct_put_proplist(t, module->proplist);
3300 }
3301
3302 static void sink_input_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_sink_input *s) {
3303     pa_sample_spec fixed_ss;
3304     pa_usec_t sink_latency;
3305     pa_cvolume v;
3306     pa_bool_t has_volume = FALSE;
3307
3308     pa_assert(t);
3309     pa_sink_input_assert_ref(s);
3310
3311     fixup_sample_spec(c, &fixed_ss, &s->sample_spec);
3312
3313     has_volume = pa_sink_input_is_volume_readable(s);
3314     if (has_volume)
3315         pa_sink_input_get_volume(s, &v, TRUE);
3316     else
3317         pa_cvolume_reset(&v, fixed_ss.channels);
3318
3319     pa_tagstruct_putu32(t, s->index);
3320     pa_tagstruct_puts(t, pa_strnull(pa_proplist_gets(s->proplist, PA_PROP_MEDIA_NAME)));
3321     pa_tagstruct_putu32(t, s->module ? s->module->index : PA_INVALID_INDEX);
3322     pa_tagstruct_putu32(t, s->client ? s->client->index : PA_INVALID_INDEX);
3323     pa_tagstruct_putu32(t, s->sink->index);
3324     pa_tagstruct_put_sample_spec(t, &fixed_ss);
3325     pa_tagstruct_put_channel_map(t, &s->channel_map);
3326     pa_tagstruct_put_cvolume(t, &v);
3327     pa_tagstruct_put_usec(t, pa_sink_input_get_latency(s, &sink_latency));
3328     pa_tagstruct_put_usec(t, sink_latency);
3329     pa_tagstruct_puts(t, pa_resample_method_to_string(pa_sink_input_get_resample_method(s)));
3330     pa_tagstruct_puts(t, s->driver);
3331     if (c->version >= 11)
3332         pa_tagstruct_put_boolean(t, pa_sink_input_get_mute(s));
3333     if (c->version >= 13)
3334         pa_tagstruct_put_proplist(t, s->proplist);
3335     if (c->version >= 19)
3336         pa_tagstruct_put_boolean(t, (pa_sink_input_get_state(s) == PA_SINK_INPUT_CORKED));
3337     if (c->version >= 20) {
3338         pa_tagstruct_put_boolean(t, has_volume);
3339         pa_tagstruct_put_boolean(t, s->volume_writable);
3340     }
3341     if (c->version >= 21)
3342         pa_tagstruct_put_format_info(t, s->format);
3343 }
3344
3345 static void source_output_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_source_output *s) {
3346     pa_sample_spec fixed_ss;
3347     pa_usec_t source_latency;
3348     pa_cvolume v;
3349     pa_bool_t has_volume = FALSE;
3350
3351     pa_assert(t);
3352     pa_source_output_assert_ref(s);
3353
3354     fixup_sample_spec(c, &fixed_ss, &s->sample_spec);
3355
3356     has_volume = pa_source_output_is_volume_readable(s);
3357     if (has_volume)
3358         pa_source_output_get_volume(s, &v, TRUE);
3359     else
3360         pa_cvolume_reset(&v, fixed_ss.channels);
3361
3362     pa_tagstruct_putu32(t, s->index);
3363     pa_tagstruct_puts(t, pa_strnull(pa_proplist_gets(s->proplist, PA_PROP_MEDIA_NAME)));
3364     pa_tagstruct_putu32(t, s->module ? s->module->index : PA_INVALID_INDEX);
3365     pa_tagstruct_putu32(t, s->client ? s->client->index : PA_INVALID_INDEX);
3366     pa_tagstruct_putu32(t, s->source->index);
3367     pa_tagstruct_put_sample_spec(t, &fixed_ss);
3368     pa_tagstruct_put_channel_map(t, &s->channel_map);
3369     pa_tagstruct_put_usec(t, pa_source_output_get_latency(s, &source_latency));
3370     pa_tagstruct_put_usec(t, source_latency);
3371     pa_tagstruct_puts(t, pa_resample_method_to_string(pa_source_output_get_resample_method(s)));
3372     pa_tagstruct_puts(t, s->driver);
3373     if (c->version >= 13)
3374         pa_tagstruct_put_proplist(t, s->proplist);
3375     if (c->version >= 19)
3376         pa_tagstruct_put_boolean(t, (pa_source_output_get_state(s) == PA_SOURCE_OUTPUT_CORKED));
3377     if (c->version >= 22) {
3378         pa_tagstruct_put_cvolume(t, &v);
3379         pa_tagstruct_put_boolean(t, pa_source_output_get_mute(s));
3380         pa_tagstruct_put_boolean(t, has_volume);
3381         pa_tagstruct_put_boolean(t, s->volume_writable);
3382         pa_tagstruct_put_format_info(t, s->format);
3383     }
3384 }
3385
3386 static void scache_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_scache_entry *e) {
3387     pa_sample_spec fixed_ss;
3388     pa_cvolume v;
3389
3390     pa_assert(t);
3391     pa_assert(e);
3392
3393     if (e->memchunk.memblock)
3394         fixup_sample_spec(c, &fixed_ss, &e->sample_spec);
3395     else
3396         memset(&fixed_ss, 0, sizeof(fixed_ss));
3397
3398     pa_tagstruct_putu32(t, e->index);
3399     pa_tagstruct_puts(t, e->name);
3400
3401     if (e->volume_is_set)
3402         v = e->volume;
3403     else
3404         pa_cvolume_init(&v);
3405
3406     pa_tagstruct_put_cvolume(t, &v);
3407     pa_tagstruct_put_usec(t, e->memchunk.memblock ? pa_bytes_to_usec(e->memchunk.length, &e->sample_spec) : 0);
3408     pa_tagstruct_put_sample_spec(t, &fixed_ss);
3409     pa_tagstruct_put_channel_map(t, &e->channel_map);
3410     pa_tagstruct_putu32(t, (uint32_t) e->memchunk.length);
3411     pa_tagstruct_put_boolean(t, e->lazy);
3412     pa_tagstruct_puts(t, e->filename);
3413
3414     if (c->version >= 13)
3415         pa_tagstruct_put_proplist(t, e->proplist);
3416 }
3417
3418 static void command_get_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3419     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3420     uint32_t idx;
3421     pa_sink *sink = NULL;
3422     pa_source *source = NULL;
3423     pa_client *client = NULL;
3424     pa_card *card = NULL;
3425     pa_module *module = NULL;
3426     pa_sink_input *si = NULL;
3427     pa_source_output *so = NULL;
3428     pa_scache_entry *sce = NULL;
3429     const char *name = NULL;
3430     pa_tagstruct *reply;
3431
3432     pa_native_connection_assert_ref(c);
3433     pa_assert(t);
3434
3435     if (pa_tagstruct_getu32(t, &idx) < 0 ||
3436         (command != PA_COMMAND_GET_CLIENT_INFO &&
3437          command != PA_COMMAND_GET_MODULE_INFO &&
3438          command != PA_COMMAND_GET_SINK_INPUT_INFO &&
3439          command != PA_COMMAND_GET_SOURCE_OUTPUT_INFO &&
3440          pa_tagstruct_gets(t, &name) < 0) ||
3441         !pa_tagstruct_eof(t)) {
3442         protocol_error(c);
3443         return;
3444     }
3445
3446     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3447     CHECK_VALIDITY(c->pstream, !name ||
3448                    (command == PA_COMMAND_GET_SINK_INFO &&
3449                     pa_namereg_is_valid_name_or_wildcard(name, PA_NAMEREG_SINK)) ||
3450                    (command == PA_COMMAND_GET_SOURCE_INFO &&
3451                     pa_namereg_is_valid_name_or_wildcard(name, PA_NAMEREG_SOURCE)) ||
3452                    pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
3453     CHECK_VALIDITY(c->pstream, command == PA_COMMAND_GET_SINK_INFO ||
3454                    command == PA_COMMAND_GET_SOURCE_INFO ||
3455                    (idx != PA_INVALID_INDEX || name), tag, PA_ERR_INVALID);
3456     CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
3457     CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3458
3459     if (command == PA_COMMAND_GET_SINK_INFO) {
3460         if (idx != PA_INVALID_INDEX)
3461             sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
3462         else
3463             sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
3464     } else if (command == PA_COMMAND_GET_SOURCE_INFO) {
3465         if (idx != PA_INVALID_INDEX)
3466             source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
3467         else
3468             source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
3469     } else if (command == PA_COMMAND_GET_CARD_INFO) {
3470         if (idx != PA_INVALID_INDEX)
3471             card = pa_idxset_get_by_index(c->protocol->core->cards, idx);
3472         else
3473             card = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_CARD);
3474     } else if (command == PA_COMMAND_GET_CLIENT_INFO)
3475         client = pa_idxset_get_by_index(c->protocol->core->clients, idx);
3476     else if (command == PA_COMMAND_GET_MODULE_INFO)
3477         module = pa_idxset_get_by_index(c->protocol->core->modules, idx);
3478     else if (command == PA_COMMAND_GET_SINK_INPUT_INFO)
3479         si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
3480     else if (command == PA_COMMAND_GET_SOURCE_OUTPUT_INFO)
3481         so = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
3482     else {
3483         pa_assert(command == PA_COMMAND_GET_SAMPLE_INFO);
3484         if (idx != PA_INVALID_INDEX)
3485             sce = pa_idxset_get_by_index(c->protocol->core->scache, idx);
3486         else
3487             sce = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SAMPLE);
3488     }
3489
3490     if (!sink && !source && !client && !card && !module && !si && !so && !sce) {
3491         pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
3492         return;
3493     }
3494
3495     reply = reply_new(tag);
3496     if (sink)
3497         sink_fill_tagstruct(c, reply, sink);
3498     else if (source)
3499         source_fill_tagstruct(c, reply, source);
3500     else if (client)
3501         client_fill_tagstruct(c, reply, client);
3502     else if (card)
3503         card_fill_tagstruct(c, reply, card);
3504     else if (module)
3505         module_fill_tagstruct(c, reply, module);
3506     else if (si)
3507         sink_input_fill_tagstruct(c, reply, si);
3508     else if (so)
3509         source_output_fill_tagstruct(c, reply, so);
3510     else
3511         scache_fill_tagstruct(c, reply, sce);
3512     pa_pstream_send_tagstruct(c->pstream, reply);
3513 }
3514
3515 static void command_get_info_list(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3516     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3517     pa_idxset *i;
3518     uint32_t idx;
3519     void *p;
3520     pa_tagstruct *reply;
3521
3522     pa_native_connection_assert_ref(c);
3523     pa_assert(t);
3524
3525     if (!pa_tagstruct_eof(t)) {
3526         protocol_error(c);
3527         return;
3528     }
3529
3530     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3531
3532     reply = reply_new(tag);
3533
3534     if (command == PA_COMMAND_GET_SINK_INFO_LIST)
3535         i = c->protocol->core->sinks;
3536     else if (command == PA_COMMAND_GET_SOURCE_INFO_LIST)
3537         i = c->protocol->core->sources;
3538     else if (command == PA_COMMAND_GET_CLIENT_INFO_LIST)
3539         i = c->protocol->core->clients;
3540     else if (command == PA_COMMAND_GET_CARD_INFO_LIST)
3541         i = c->protocol->core->cards;
3542     else if (command == PA_COMMAND_GET_MODULE_INFO_LIST)
3543         i = c->protocol->core->modules;
3544     else if (command == PA_COMMAND_GET_SINK_INPUT_INFO_LIST)
3545         i = c->protocol->core->sink_inputs;
3546     else if (command == PA_COMMAND_GET_SOURCE_OUTPUT_INFO_LIST)
3547         i = c->protocol->core->source_outputs;
3548     else {
3549         pa_assert(command == PA_COMMAND_GET_SAMPLE_INFO_LIST);
3550         i = c->protocol->core->scache;
3551     }
3552
3553     if (i) {
3554         PA_IDXSET_FOREACH(p, i, idx) {
3555             if (command == PA_COMMAND_GET_SINK_INFO_LIST)
3556                 sink_fill_tagstruct(c, reply, p);
3557             else if (command == PA_COMMAND_GET_SOURCE_INFO_LIST)
3558                 source_fill_tagstruct(c, reply, p);
3559             else if (command == PA_COMMAND_GET_CLIENT_INFO_LIST)
3560                 client_fill_tagstruct(c, reply, p);
3561             else if (command == PA_COMMAND_GET_CARD_INFO_LIST)
3562                 card_fill_tagstruct(c, reply, p);
3563             else if (command == PA_COMMAND_GET_MODULE_INFO_LIST)
3564                 module_fill_tagstruct(c, reply, p);
3565             else if (command == PA_COMMAND_GET_SINK_INPUT_INFO_LIST)
3566                 sink_input_fill_tagstruct(c, reply, p);
3567             else if (command == PA_COMMAND_GET_SOURCE_OUTPUT_INFO_LIST)
3568                 source_output_fill_tagstruct(c, reply, p);
3569             else {
3570                 pa_assert(command == PA_COMMAND_GET_SAMPLE_INFO_LIST);
3571                 scache_fill_tagstruct(c, reply, p);
3572             }
3573         }
3574     }
3575
3576     pa_pstream_send_tagstruct(c->pstream, reply);
3577 }
3578
3579 static void command_get_server_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3580     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3581     pa_tagstruct *reply;
3582     pa_sink *def_sink;
3583     pa_source *def_source;
3584     pa_sample_spec fixed_ss;
3585     char *h, *u;
3586
3587     pa_native_connection_assert_ref(c);
3588     pa_assert(t);
3589
3590     if (!pa_tagstruct_eof(t)) {
3591         protocol_error(c);
3592         return;
3593     }
3594
3595     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3596
3597     reply = reply_new(tag);
3598     pa_tagstruct_puts(reply, PACKAGE_NAME);
3599     pa_tagstruct_puts(reply, PACKAGE_VERSION);
3600
3601     u = pa_get_user_name_malloc();
3602     pa_tagstruct_puts(reply, u);
3603     pa_xfree(u);
3604
3605     h = pa_get_host_name_malloc();
3606     pa_tagstruct_puts(reply, h);
3607     pa_xfree(h);
3608
3609     fixup_sample_spec(c, &fixed_ss, &c->protocol->core->default_sample_spec);
3610     pa_tagstruct_put_sample_spec(reply, &fixed_ss);
3611
3612     def_sink = pa_namereg_get_default_sink(c->protocol->core);
3613     pa_tagstruct_puts(reply, def_sink ? def_sink->name : NULL);
3614     def_source = pa_namereg_get_default_source(c->protocol->core);
3615     pa_tagstruct_puts(reply, def_source ? def_source->name : NULL);
3616
3617     pa_tagstruct_putu32(reply, c->protocol->core->cookie);
3618
3619     if (c->version >= 15)
3620         pa_tagstruct_put_channel_map(reply, &c->protocol->core->default_channel_map);
3621
3622     pa_pstream_send_tagstruct(c->pstream, reply);
3623 }
3624
3625 static void subscription_cb(pa_core *core, pa_subscription_event_type_t e, uint32_t idx, void *userdata) {
3626     pa_tagstruct *t;
3627     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3628
3629     pa_native_connection_assert_ref(c);
3630
3631     t = pa_tagstruct_new(NULL, 0);
3632     pa_tagstruct_putu32(t, PA_COMMAND_SUBSCRIBE_EVENT);
3633     pa_tagstruct_putu32(t, (uint32_t) -1);
3634     pa_tagstruct_putu32(t, e);
3635     pa_tagstruct_putu32(t, idx);
3636     pa_pstream_send_tagstruct(c->pstream, t);
3637 }
3638
3639 static void command_subscribe(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3640     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3641     pa_subscription_mask_t m;
3642
3643     pa_native_connection_assert_ref(c);
3644     pa_assert(t);
3645
3646     if (pa_tagstruct_getu32(t, &m) < 0 ||
3647         !pa_tagstruct_eof(t)) {
3648         protocol_error(c);
3649         return;
3650     }
3651
3652     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3653     CHECK_VALIDITY(c->pstream, (m & ~PA_SUBSCRIPTION_MASK_ALL) == 0, tag, PA_ERR_INVALID);
3654
3655     if (c->subscription)
3656         pa_subscription_free(c->subscription);
3657
3658     if (m != 0) {
3659         c->subscription = pa_subscription_new(c->protocol->core, m, subscription_cb, c);
3660         pa_assert(c->subscription);
3661     } else
3662         c->subscription = NULL;
3663
3664     pa_pstream_send_simple_ack(c->pstream, tag);
3665 }
3666
3667 static void command_set_volume(
3668         pa_pdispatch *pd,
3669         uint32_t command,
3670         uint32_t tag,
3671         pa_tagstruct *t,
3672         void *userdata) {
3673
3674     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3675     uint32_t idx;
3676     pa_cvolume volume;
3677     pa_sink *sink = NULL;
3678     pa_source *source = NULL;
3679     pa_sink_input *si = NULL;
3680     pa_source_output *so = NULL;
3681     const char *name = NULL;
3682     const char *client_name;
3683
3684     pa_native_connection_assert_ref(c);
3685     pa_assert(t);
3686
3687     if (pa_tagstruct_getu32(t, &idx) < 0 ||
3688         (command == PA_COMMAND_SET_SINK_VOLUME && pa_tagstruct_gets(t, &name) < 0) ||
3689         (command == PA_COMMAND_SET_SOURCE_VOLUME && pa_tagstruct_gets(t, &name) < 0) ||
3690         pa_tagstruct_get_cvolume(t, &volume) ||
3691         !pa_tagstruct_eof(t)) {
3692         protocol_error(c);
3693         return;
3694     }
3695
3696     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3697     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);
3698     CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
3699     CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
3700     CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3701     CHECK_VALIDITY(c->pstream, pa_cvolume_valid(&volume), tag, PA_ERR_INVALID);
3702
3703     switch (command) {
3704
3705         case PA_COMMAND_SET_SINK_VOLUME:
3706             if (idx != PA_INVALID_INDEX)
3707                 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
3708             else
3709                 sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
3710             break;
3711
3712         case PA_COMMAND_SET_SOURCE_VOLUME:
3713             if (idx != PA_INVALID_INDEX)
3714                 source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
3715             else
3716                 source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
3717             break;
3718
3719         case PA_COMMAND_SET_SINK_INPUT_VOLUME:
3720             si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
3721             break;
3722
3723         case PA_COMMAND_SET_SOURCE_OUTPUT_VOLUME:
3724             so = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
3725             break;
3726
3727         default:
3728             pa_assert_not_reached();
3729     }
3730
3731     CHECK_VALIDITY(c->pstream, si || so || sink || source, tag, PA_ERR_NOENTITY);
3732
3733     client_name = pa_strnull(pa_proplist_gets(c->client->proplist, PA_PROP_APPLICATION_PROCESS_BINARY));
3734
3735     if (sink) {
3736         CHECK_VALIDITY(c->pstream, volume.channels == 1 || pa_cvolume_compatible(&volume, &sink->sample_spec), tag, PA_ERR_INVALID);
3737
3738         pa_log_debug("Client %s changes volume of sink %s.", client_name, sink->name);
3739         pa_sink_set_volume(sink, &volume, TRUE, TRUE);
3740     } else if (source) {
3741         CHECK_VALIDITY(c->pstream, volume.channels == 1 || pa_cvolume_compatible(&volume, &source->sample_spec), tag, PA_ERR_INVALID);
3742
3743         pa_log_debug("Client %s changes volume of source %s.", client_name, source->name);
3744         pa_source_set_volume(source, &volume, TRUE, TRUE);
3745     } else if (si) {
3746         CHECK_VALIDITY(c->pstream, si->volume_writable, tag, PA_ERR_BADSTATE);
3747         CHECK_VALIDITY(c->pstream, volume.channels == 1 || pa_cvolume_compatible(&volume, &si->sample_spec), tag, PA_ERR_INVALID);
3748
3749         pa_log_debug("Client %s changes volume of sink input %s.",
3750                      client_name,
3751                      pa_strnull(pa_proplist_gets(si->proplist, PA_PROP_MEDIA_NAME)));
3752         pa_sink_input_set_volume(si, &volume, TRUE, TRUE);
3753     } else if (so) {
3754         CHECK_VALIDITY(c->pstream, volume.channels == 1 || pa_cvolume_compatible(&volume, &so->sample_spec), tag, PA_ERR_INVALID);
3755
3756         pa_log_debug("Client %s changes volume of source output %s.",
3757                      client_name,
3758                      pa_strnull(pa_proplist_gets(so->proplist, PA_PROP_MEDIA_NAME)));
3759         pa_source_output_set_volume(so, &volume, TRUE, TRUE);
3760     }
3761
3762     pa_pstream_send_simple_ack(c->pstream, tag);
3763 }
3764
3765 static void command_set_mute(
3766         pa_pdispatch *pd,
3767         uint32_t command,
3768         uint32_t tag,
3769         pa_tagstruct *t,
3770         void *userdata) {
3771
3772     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3773     uint32_t idx;
3774     pa_bool_t mute;
3775     pa_sink *sink = NULL;
3776     pa_source *source = NULL;
3777     pa_sink_input *si = NULL;
3778     pa_source_output *so = NULL;
3779     const char *name = NULL, *client_name;
3780
3781     pa_native_connection_assert_ref(c);
3782     pa_assert(t);
3783
3784     if (pa_tagstruct_getu32(t, &idx) < 0 ||
3785         (command == PA_COMMAND_SET_SINK_MUTE && pa_tagstruct_gets(t, &name) < 0) ||
3786         (command == PA_COMMAND_SET_SOURCE_MUTE && pa_tagstruct_gets(t, &name) < 0) ||
3787         pa_tagstruct_get_boolean(t, &mute) ||
3788         !pa_tagstruct_eof(t)) {
3789         protocol_error(c);
3790         return;
3791     }
3792
3793     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3794     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);
3795     CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
3796     CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
3797     CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3798
3799     switch (command) {
3800
3801         case PA_COMMAND_SET_SINK_MUTE:
3802             if (idx != PA_INVALID_INDEX)
3803                 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
3804             else
3805                 sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
3806
3807             break;
3808
3809         case PA_COMMAND_SET_SOURCE_MUTE:
3810             if (idx != PA_INVALID_INDEX)
3811                 source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
3812             else
3813                 source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
3814
3815             break;
3816
3817         case PA_COMMAND_SET_SINK_INPUT_MUTE:
3818             si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
3819             break;
3820
3821         case PA_COMMAND_SET_SOURCE_OUTPUT_MUTE:
3822             so = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
3823             break;
3824
3825         default:
3826             pa_assert_not_reached();
3827     }
3828
3829     CHECK_VALIDITY(c->pstream, si || so || sink || source, tag, PA_ERR_NOENTITY);
3830
3831     client_name = pa_strnull(pa_proplist_gets(c->client->proplist, PA_PROP_APPLICATION_PROCESS_BINARY));
3832
3833     if (sink) {
3834         pa_log_debug("Client %s changes mute of sink %s.", client_name, sink->name);
3835         pa_sink_set_mute(sink, mute, TRUE);
3836     } else if (source) {
3837         pa_log_debug("Client %s changes mute of source %s.", client_name, source->name);
3838         pa_source_set_mute(source, mute, TRUE);
3839     } else if (si) {
3840         pa_log_debug("Client %s changes mute of sink input %s.",
3841                      client_name,
3842                      pa_strnull(pa_proplist_gets(si->proplist, PA_PROP_MEDIA_NAME)));
3843         pa_sink_input_set_mute(si, mute, TRUE);
3844     } else if (so) {
3845         pa_log_debug("Client %s changes mute of source output %s.",
3846                      client_name,
3847                      pa_strnull(pa_proplist_gets(so->proplist, PA_PROP_MEDIA_NAME)));
3848         pa_source_output_set_mute(so, mute, TRUE);
3849     }
3850
3851     pa_pstream_send_simple_ack(c->pstream, tag);
3852 }
3853
3854 static void command_cork_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3855     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3856     uint32_t idx;
3857     pa_bool_t b;
3858     playback_stream *s;
3859
3860     pa_native_connection_assert_ref(c);
3861     pa_assert(t);
3862
3863     if (pa_tagstruct_getu32(t, &idx) < 0 ||
3864         pa_tagstruct_get_boolean(t, &b) < 0 ||
3865         !pa_tagstruct_eof(t)) {
3866         protocol_error(c);
3867         return;
3868     }
3869
3870     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3871     CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3872     s = pa_idxset_get_by_index(c->output_streams, idx);
3873     CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3874     CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3875
3876     pa_sink_input_cork(s->sink_input, b);
3877
3878     if (b)
3879         s->is_underrun = TRUE;
3880
3881     pa_pstream_send_simple_ack(c->pstream, tag);
3882 }
3883
3884 static void command_trigger_or_flush_or_prebuf_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3885     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3886     uint32_t idx;
3887     playback_stream *s;
3888
3889     pa_native_connection_assert_ref(c);
3890     pa_assert(t);
3891
3892     if (pa_tagstruct_getu32(t, &idx) < 0 ||
3893         !pa_tagstruct_eof(t)) {
3894         protocol_error(c);
3895         return;
3896     }
3897
3898     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3899     CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3900     s = pa_idxset_get_by_index(c->output_streams, idx);
3901     CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3902     CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3903
3904     switch (command) {
3905         case PA_COMMAND_FLUSH_PLAYBACK_STREAM:
3906             pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_FLUSH, NULL, 0, NULL);
3907             break;
3908
3909         case PA_COMMAND_PREBUF_PLAYBACK_STREAM:
3910             pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_PREBUF_FORCE, NULL, 0, NULL);
3911             break;
3912
3913         case PA_COMMAND_TRIGGER_PLAYBACK_STREAM:
3914             pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_TRIGGER, NULL, 0, NULL);
3915             break;
3916
3917         default:
3918             pa_assert_not_reached();
3919     }
3920
3921     pa_pstream_send_simple_ack(c->pstream, tag);
3922 }
3923
3924 static void command_cork_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3925     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3926     uint32_t idx;
3927     record_stream *s;
3928     pa_bool_t b;
3929
3930     pa_native_connection_assert_ref(c);
3931     pa_assert(t);
3932
3933     if (pa_tagstruct_getu32(t, &idx) < 0 ||
3934         pa_tagstruct_get_boolean(t, &b) < 0 ||
3935         !pa_tagstruct_eof(t)) {
3936         protocol_error(c);
3937         return;
3938     }
3939
3940     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3941     s = pa_idxset_get_by_index(c->record_streams, idx);
3942     CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3943
3944     pa_source_output_cork(s->source_output, b);
3945     pa_memblockq_prebuf_force(s->memblockq);
3946     pa_pstream_send_simple_ack(c->pstream, tag);
3947 }
3948
3949 static void command_flush_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3950     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3951     uint32_t idx;
3952     record_stream *s;
3953
3954     pa_native_connection_assert_ref(c);
3955     pa_assert(t);
3956
3957     if (pa_tagstruct_getu32(t, &idx) < 0 ||
3958         !pa_tagstruct_eof(t)) {
3959         protocol_error(c);
3960         return;
3961     }
3962
3963     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3964     s = pa_idxset_get_by_index(c->record_streams, idx);
3965     CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3966
3967     pa_memblockq_flush_read(s->memblockq);
3968     pa_pstream_send_simple_ack(c->pstream, tag);
3969 }
3970
3971 static void command_set_stream_buffer_attr(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3972     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3973     uint32_t idx;
3974     pa_buffer_attr a;
3975     pa_tagstruct *reply;
3976
3977     pa_native_connection_assert_ref(c);
3978     pa_assert(t);
3979
3980     memset(&a, 0, sizeof(a));
3981
3982     if (pa_tagstruct_getu32(t, &idx) < 0) {
3983         protocol_error(c);
3984         return;
3985     }
3986
3987     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3988
3989     if (command == PA_COMMAND_SET_PLAYBACK_STREAM_BUFFER_ATTR) {
3990         playback_stream *s;
3991         pa_bool_t adjust_latency = FALSE, early_requests = FALSE;
3992
3993         s = pa_idxset_get_by_index(c->output_streams, idx);
3994         CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3995         CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3996
3997         if (pa_tagstruct_get(
3998                     t,
3999                     PA_TAG_U32, &a.maxlength,
4000                     PA_TAG_U32, &a.tlength,
4001                     PA_TAG_U32, &a.prebuf,
4002                     PA_TAG_U32, &a.minreq,
4003                     PA_TAG_INVALID) < 0 ||
4004             (c->version >= 13 && pa_tagstruct_get_boolean(t, &adjust_latency) < 0) ||
4005             (c->version >= 14 && pa_tagstruct_get_boolean(t, &early_requests) < 0) ||
4006             !pa_tagstruct_eof(t)) {
4007             protocol_error(c);
4008             return;
4009         }
4010
4011         s->adjust_latency = adjust_latency;
4012         s->early_requests = early_requests;
4013         s->buffer_attr_req = a;
4014
4015         fix_playback_buffer_attr(s);
4016         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);
4017
4018         reply = reply_new(tag);
4019         pa_tagstruct_putu32(reply, s->buffer_attr.maxlength);
4020         pa_tagstruct_putu32(reply, s->buffer_attr.tlength);
4021         pa_tagstruct_putu32(reply, s->buffer_attr.prebuf);
4022         pa_tagstruct_putu32(reply, s->buffer_attr.minreq);
4023
4024         if (c->version >= 13)
4025             pa_tagstruct_put_usec(reply, s->configured_sink_latency);
4026
4027     } else {
4028         record_stream *s;
4029         pa_bool_t adjust_latency = FALSE, early_requests = FALSE;
4030         pa_assert(command == PA_COMMAND_SET_RECORD_STREAM_BUFFER_ATTR);
4031
4032         s = pa_idxset_get_by_index(c->record_streams, idx);
4033         CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4034
4035         if (pa_tagstruct_get(
4036                     t,
4037                     PA_TAG_U32, &a.maxlength,
4038                     PA_TAG_U32, &a.fragsize,
4039                     PA_TAG_INVALID) < 0 ||
4040             (c->version >= 13 && pa_tagstruct_get_boolean(t, &adjust_latency) < 0) ||
4041             (c->version >= 14 && pa_tagstruct_get_boolean(t, &early_requests) < 0) ||
4042             !pa_tagstruct_eof(t)) {
4043             protocol_error(c);
4044             return;
4045         }
4046
4047         s->adjust_latency = adjust_latency;
4048         s->early_requests = early_requests;
4049         s->buffer_attr_req = a;
4050
4051         fix_record_buffer_attr_pre(s);
4052         pa_memblockq_set_maxlength(s->memblockq, s->buffer_attr.maxlength);
4053         pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
4054         fix_record_buffer_attr_post(s);
4055
4056         reply = reply_new(tag);
4057         pa_tagstruct_putu32(reply, s->buffer_attr.maxlength);
4058         pa_tagstruct_putu32(reply, s->buffer_attr.fragsize);
4059
4060         if (c->version >= 13)
4061             pa_tagstruct_put_usec(reply, s->configured_source_latency);
4062     }
4063
4064     pa_pstream_send_tagstruct(c->pstream, reply);
4065 }
4066
4067 static void command_update_stream_sample_rate(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4068     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4069     uint32_t idx;
4070     uint32_t rate;
4071
4072     pa_native_connection_assert_ref(c);
4073     pa_assert(t);
4074
4075     if (pa_tagstruct_getu32(t, &idx) < 0 ||
4076         pa_tagstruct_getu32(t, &rate) < 0 ||
4077         !pa_tagstruct_eof(t)) {
4078         protocol_error(c);
4079         return;
4080     }
4081
4082     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4083     CHECK_VALIDITY(c->pstream, rate > 0 && rate <= PA_RATE_MAX, tag, PA_ERR_INVALID);
4084
4085     if (command == PA_COMMAND_UPDATE_PLAYBACK_STREAM_SAMPLE_RATE) {
4086         playback_stream *s;
4087
4088         s = pa_idxset_get_by_index(c->output_streams, idx);
4089         CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4090         CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
4091
4092         pa_sink_input_set_rate(s->sink_input, rate);
4093
4094     } else {
4095         record_stream *s;
4096         pa_assert(command == PA_COMMAND_UPDATE_RECORD_STREAM_SAMPLE_RATE);
4097
4098         s = pa_idxset_get_by_index(c->record_streams, idx);
4099         CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4100
4101         pa_source_output_set_rate(s->source_output, rate);
4102     }
4103
4104     pa_pstream_send_simple_ack(c->pstream, tag);
4105 }
4106
4107 static void command_update_proplist(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4108     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4109     uint32_t idx;
4110     uint32_t mode;
4111     pa_proplist *p;
4112
4113     pa_native_connection_assert_ref(c);
4114     pa_assert(t);
4115
4116     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4117
4118     p = pa_proplist_new();
4119
4120     if (command == PA_COMMAND_UPDATE_CLIENT_PROPLIST) {
4121
4122         if (pa_tagstruct_getu32(t, &mode) < 0 ||
4123             pa_tagstruct_get_proplist(t, p) < 0 ||
4124             !pa_tagstruct_eof(t)) {
4125             protocol_error(c);
4126             pa_proplist_free(p);
4127             return;
4128         }
4129
4130     } else {
4131
4132         if (pa_tagstruct_getu32(t, &idx) < 0 ||
4133             pa_tagstruct_getu32(t, &mode) < 0 ||
4134             pa_tagstruct_get_proplist(t, p) < 0 ||
4135             !pa_tagstruct_eof(t)) {
4136             protocol_error(c);
4137             pa_proplist_free(p);
4138             return;
4139         }
4140     }
4141
4142     if (!(mode == PA_UPDATE_SET || mode == PA_UPDATE_MERGE || mode == PA_UPDATE_REPLACE)) {
4143         pa_proplist_free(p);
4144         CHECK_VALIDITY(c->pstream, FALSE, tag, PA_ERR_INVALID);
4145     }
4146
4147     if (command == PA_COMMAND_UPDATE_PLAYBACK_STREAM_PROPLIST) {
4148         playback_stream *s;
4149
4150         s = pa_idxset_get_by_index(c->output_streams, idx);
4151         if (!s || !playback_stream_isinstance(s)) {
4152             pa_proplist_free(p);
4153             CHECK_VALIDITY(c->pstream, FALSE, tag, PA_ERR_NOENTITY);
4154         }
4155         pa_sink_input_update_proplist(s->sink_input, mode, p);
4156
4157     } else if (command == PA_COMMAND_UPDATE_RECORD_STREAM_PROPLIST) {
4158         record_stream *s;
4159
4160         if (!(s = pa_idxset_get_by_index(c->record_streams, idx))) {
4161             pa_proplist_free(p);
4162             CHECK_VALIDITY(c->pstream, FALSE, tag, PA_ERR_NOENTITY);
4163         }
4164         pa_source_output_update_proplist(s->source_output, mode, p);
4165
4166     } else {
4167         pa_assert(command == PA_COMMAND_UPDATE_CLIENT_PROPLIST);
4168
4169         pa_client_update_proplist(c->client, mode, p);
4170     }
4171
4172     pa_pstream_send_simple_ack(c->pstream, tag);
4173     pa_proplist_free(p);
4174 }
4175
4176 static void command_remove_proplist(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4177     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4178     uint32_t idx;
4179     unsigned changed = 0;
4180     pa_proplist *p;
4181     pa_strlist *l = NULL;
4182
4183     pa_native_connection_assert_ref(c);
4184     pa_assert(t);
4185
4186     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4187
4188     if (command != PA_COMMAND_REMOVE_CLIENT_PROPLIST) {
4189
4190         if (pa_tagstruct_getu32(t, &idx) < 0) {
4191             protocol_error(c);
4192             return;
4193         }
4194     }
4195
4196     if (command == PA_COMMAND_REMOVE_PLAYBACK_STREAM_PROPLIST) {
4197         playback_stream *s;
4198
4199         s = pa_idxset_get_by_index(c->output_streams, idx);
4200         CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4201         CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
4202
4203         p = s->sink_input->proplist;
4204
4205     } else if (command == PA_COMMAND_REMOVE_RECORD_STREAM_PROPLIST) {
4206         record_stream *s;
4207
4208         s = pa_idxset_get_by_index(c->record_streams, idx);
4209         CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4210
4211         p = s->source_output->proplist;
4212     } else {
4213         pa_assert(command == PA_COMMAND_REMOVE_CLIENT_PROPLIST);
4214
4215         p = c->client->proplist;
4216     }
4217
4218     for (;;) {
4219         const char *k;
4220
4221         if (pa_tagstruct_gets(t, &k) < 0) {
4222             protocol_error(c);
4223             pa_strlist_free(l);
4224             return;
4225         }
4226
4227         if (!k)
4228             break;
4229
4230         l = pa_strlist_prepend(l, k);
4231     }
4232
4233     if (!pa_tagstruct_eof(t)) {
4234         protocol_error(c);
4235         pa_strlist_free(l);
4236         return;
4237     }
4238
4239     for (;;) {
4240         char *z;
4241
4242         l = pa_strlist_pop(l, &z);
4243
4244         if (!z)
4245             break;
4246
4247         changed += (unsigned) (pa_proplist_unset(p, z) >= 0);
4248         pa_xfree(z);
4249     }
4250
4251     pa_pstream_send_simple_ack(c->pstream, tag);
4252
4253     if (changed) {
4254         if (command == PA_COMMAND_REMOVE_PLAYBACK_STREAM_PROPLIST) {
4255             playback_stream *s;
4256
4257             s = pa_idxset_get_by_index(c->output_streams, idx);
4258             pa_subscription_post(c->protocol->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, s->sink_input->index);
4259
4260         } else if (command == PA_COMMAND_REMOVE_RECORD_STREAM_PROPLIST) {
4261             record_stream *s;
4262
4263             s = pa_idxset_get_by_index(c->record_streams, idx);
4264             pa_subscription_post(c->protocol->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, s->source_output->index);
4265
4266         } else {
4267             pa_assert(command == PA_COMMAND_REMOVE_CLIENT_PROPLIST);
4268             pa_subscription_post(c->protocol->core, PA_SUBSCRIPTION_EVENT_CLIENT|PA_SUBSCRIPTION_EVENT_CHANGE, c->client->index);
4269         }
4270     }
4271 }
4272
4273 static void command_set_default_sink_or_source(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4274     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4275     const char *s;
4276
4277     pa_native_connection_assert_ref(c);
4278     pa_assert(t);
4279
4280     if (pa_tagstruct_gets(t, &s) < 0 ||
4281         !pa_tagstruct_eof(t)) {
4282         protocol_error(c);
4283         return;
4284     }
4285
4286     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4287     CHECK_VALIDITY(c->pstream, !s || pa_namereg_is_valid_name(s), tag, PA_ERR_INVALID);
4288
4289     if (command == PA_COMMAND_SET_DEFAULT_SOURCE) {
4290         pa_source *source;
4291
4292         source = pa_namereg_get(c->protocol->core, s, PA_NAMEREG_SOURCE);
4293         CHECK_VALIDITY(c->pstream, source, tag, PA_ERR_NOENTITY);
4294
4295         pa_namereg_set_default_source(c->protocol->core, source);
4296     } else {
4297         pa_sink *sink;
4298         pa_assert(command == PA_COMMAND_SET_DEFAULT_SINK);
4299
4300         sink = pa_namereg_get(c->protocol->core, s, PA_NAMEREG_SINK);
4301         CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
4302
4303         pa_namereg_set_default_sink(c->protocol->core, sink);
4304     }
4305
4306     pa_pstream_send_simple_ack(c->pstream, tag);
4307 }
4308
4309 static void command_set_stream_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4310     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4311     uint32_t idx;
4312     const char *name;
4313
4314     pa_native_connection_assert_ref(c);
4315     pa_assert(t);
4316
4317     if (pa_tagstruct_getu32(t, &idx) < 0 ||
4318         pa_tagstruct_gets(t, &name) < 0 ||
4319         !pa_tagstruct_eof(t)) {
4320         protocol_error(c);
4321         return;
4322     }
4323
4324     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4325     CHECK_VALIDITY(c->pstream, name && pa_utf8_valid(name), tag, PA_ERR_INVALID);
4326
4327     if (command == PA_COMMAND_SET_PLAYBACK_STREAM_NAME) {
4328         playback_stream *s;
4329
4330         s = pa_idxset_get_by_index(c->output_streams, idx);
4331         CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4332         CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
4333
4334         pa_sink_input_set_name(s->sink_input, name);
4335
4336     } else {
4337         record_stream *s;
4338         pa_assert(command == PA_COMMAND_SET_RECORD_STREAM_NAME);
4339
4340         s = pa_idxset_get_by_index(c->record_streams, idx);
4341         CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4342
4343         pa_source_output_set_name(s->source_output, name);
4344     }
4345
4346     pa_pstream_send_simple_ack(c->pstream, tag);
4347 }
4348
4349 static void command_kill(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4350     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4351     uint32_t idx;
4352
4353     pa_native_connection_assert_ref(c);
4354     pa_assert(t);
4355
4356     if (pa_tagstruct_getu32(t, &idx) < 0 ||
4357         !pa_tagstruct_eof(t)) {
4358         protocol_error(c);
4359         return;
4360     }
4361
4362     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4363
4364     if (command == PA_COMMAND_KILL_CLIENT) {
4365         pa_client *client;
4366
4367         client = pa_idxset_get_by_index(c->protocol->core->clients, idx);
4368         CHECK_VALIDITY(c->pstream, client, tag, PA_ERR_NOENTITY);
4369
4370         pa_native_connection_ref(c);
4371         pa_client_kill(client);
4372
4373     } else if (command == PA_COMMAND_KILL_SINK_INPUT) {
4374         pa_sink_input *s;
4375
4376         s = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
4377         CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4378
4379         pa_native_connection_ref(c);
4380         pa_sink_input_kill(s);
4381     } else {
4382         pa_source_output *s;
4383
4384         pa_assert(command == PA_COMMAND_KILL_SOURCE_OUTPUT);
4385
4386         s = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
4387         CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4388
4389         pa_native_connection_ref(c);
4390         pa_source_output_kill(s);
4391     }
4392
4393     pa_pstream_send_simple_ack(c->pstream, tag);
4394     pa_native_connection_unref(c);
4395 }
4396
4397 static void command_load_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4398     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4399     pa_module *m;
4400     const char *name, *argument;
4401     pa_tagstruct *reply;
4402
4403     pa_native_connection_assert_ref(c);
4404     pa_assert(t);
4405
4406     if (pa_tagstruct_gets(t, &name) < 0 ||
4407         pa_tagstruct_gets(t, &argument) < 0 ||
4408         !pa_tagstruct_eof(t)) {
4409         protocol_error(c);
4410         return;
4411     }
4412
4413     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4414     CHECK_VALIDITY(c->pstream, name && *name && pa_utf8_valid(name) && !strchr(name, '/'), tag, PA_ERR_INVALID);
4415     CHECK_VALIDITY(c->pstream, !argument || pa_utf8_valid(argument), tag, PA_ERR_INVALID);
4416
4417     if (!(m = pa_module_load(c->protocol->core, name, argument))) {
4418         pa_pstream_send_error(c->pstream, tag, PA_ERR_MODINITFAILED);
4419         return;
4420     }
4421
4422     reply = reply_new(tag);
4423     pa_tagstruct_putu32(reply, m->index);
4424     pa_pstream_send_tagstruct(c->pstream, reply);
4425 }
4426
4427 static void command_unload_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4428     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4429     uint32_t idx;
4430     pa_module *m;
4431
4432     pa_native_connection_assert_ref(c);
4433     pa_assert(t);
4434
4435     if (pa_tagstruct_getu32(t, &idx) < 0 ||
4436         !pa_tagstruct_eof(t)) {
4437         protocol_error(c);
4438         return;
4439     }
4440
4441     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4442     m = pa_idxset_get_by_index(c->protocol->core->modules, idx);
4443     CHECK_VALIDITY(c->pstream, m, tag, PA_ERR_NOENTITY);
4444
4445     pa_module_unload_request(m, FALSE);
4446     pa_pstream_send_simple_ack(c->pstream, tag);
4447 }
4448
4449 static void command_move_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4450     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4451     uint32_t idx = PA_INVALID_INDEX, idx_device = PA_INVALID_INDEX;
4452     const char *name_device = NULL;
4453
4454     pa_native_connection_assert_ref(c);
4455     pa_assert(t);
4456
4457     if (pa_tagstruct_getu32(t, &idx) < 0 ||
4458         pa_tagstruct_getu32(t, &idx_device) < 0 ||
4459         pa_tagstruct_gets(t, &name_device) < 0 ||
4460         !pa_tagstruct_eof(t)) {
4461         protocol_error(c);
4462         return;
4463     }
4464
4465     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4466     CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4467
4468     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);
4469     CHECK_VALIDITY(c->pstream, idx_device != PA_INVALID_INDEX || name_device, tag, PA_ERR_INVALID);
4470     CHECK_VALIDITY(c->pstream, idx_device == PA_INVALID_INDEX || !name_device, tag, PA_ERR_INVALID);
4471     CHECK_VALIDITY(c->pstream, !name_device || idx_device == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4472
4473     if (command == PA_COMMAND_MOVE_SINK_INPUT) {
4474         pa_sink_input *si = NULL;
4475         pa_sink *sink = NULL;
4476
4477         si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
4478
4479         if (idx_device != PA_INVALID_INDEX)
4480             sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx_device);
4481         else
4482             sink = pa_namereg_get(c->protocol->core, name_device, PA_NAMEREG_SINK);
4483
4484         CHECK_VALIDITY(c->pstream, si && sink, tag, PA_ERR_NOENTITY);
4485
4486         if (pa_sink_input_move_to(si, sink, TRUE) < 0) {
4487             pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4488             return;
4489         }
4490     } else {
4491         pa_source_output *so = NULL;
4492         pa_source *source;
4493
4494         pa_assert(command == PA_COMMAND_MOVE_SOURCE_OUTPUT);
4495
4496         so = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
4497
4498         if (idx_device != PA_INVALID_INDEX)
4499             source = pa_idxset_get_by_index(c->protocol->core->sources, idx_device);
4500         else
4501             source = pa_namereg_get(c->protocol->core, name_device, PA_NAMEREG_SOURCE);
4502
4503         CHECK_VALIDITY(c->pstream, so && source, tag, PA_ERR_NOENTITY);
4504
4505         if (pa_source_output_move_to(so, source, TRUE) < 0) {
4506             pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4507             return;
4508         }
4509     }
4510
4511     pa_pstream_send_simple_ack(c->pstream, tag);
4512 }
4513
4514 static void command_suspend(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4515     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4516     uint32_t idx = PA_INVALID_INDEX;
4517     const char *name = NULL;
4518     pa_bool_t b;
4519
4520     pa_native_connection_assert_ref(c);
4521     pa_assert(t);
4522
4523     if (pa_tagstruct_getu32(t, &idx) < 0 ||
4524         pa_tagstruct_gets(t, &name) < 0 ||
4525         pa_tagstruct_get_boolean(t, &b) < 0 ||
4526         !pa_tagstruct_eof(t)) {
4527         protocol_error(c);
4528         return;
4529     }
4530
4531     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4532     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);
4533     CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
4534     CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
4535     CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4536
4537     if (command == PA_COMMAND_SUSPEND_SINK) {
4538
4539         if (idx == PA_INVALID_INDEX && name && !*name) {
4540
4541             pa_log_debug("%s all sinks", b ? "Suspending" : "Resuming");
4542
4543             if (pa_sink_suspend_all(c->protocol->core, b, PA_SUSPEND_USER) < 0) {
4544                 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4545                 return;
4546             }
4547         } else {
4548             pa_sink *sink = NULL;
4549
4550             if (idx != PA_INVALID_INDEX)
4551                 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
4552             else
4553                 sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
4554
4555             CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
4556
4557             if (pa_sink_suspend(sink, b, PA_SUSPEND_USER) < 0) {
4558                 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4559                 return;
4560             }
4561         }
4562     } else {
4563
4564         pa_assert(command == PA_COMMAND_SUSPEND_SOURCE);
4565
4566         if (idx == PA_INVALID_INDEX && name && !*name) {
4567
4568             pa_log_debug("%s all sources", b ? "Suspending" : "Resuming");
4569
4570             if (pa_source_suspend_all(c->protocol->core, b, PA_SUSPEND_USER) < 0) {
4571                 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4572                 return;
4573             }
4574
4575         } else {
4576             pa_source *source;
4577
4578             if (idx != PA_INVALID_INDEX)
4579                 source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
4580             else
4581                 source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
4582
4583             CHECK_VALIDITY(c->pstream, source, tag, PA_ERR_NOENTITY);
4584
4585             if (pa_source_suspend(source, b, PA_SUSPEND_USER) < 0) {
4586                 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4587                 return;
4588             }
4589         }
4590     }
4591
4592     pa_pstream_send_simple_ack(c->pstream, tag);
4593 }
4594
4595 static void command_extension(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4596     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4597     uint32_t idx = PA_INVALID_INDEX;
4598     const char *name = NULL;
4599     pa_module *m;
4600     pa_native_protocol_ext_cb_t cb;
4601
4602     pa_native_connection_assert_ref(c);
4603     pa_assert(t);
4604
4605     if (pa_tagstruct_getu32(t, &idx) < 0 ||
4606         pa_tagstruct_gets(t, &name) < 0) {
4607         protocol_error(c);
4608         return;
4609     }
4610
4611     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4612     CHECK_VALIDITY(c->pstream, !name || pa_utf8_valid(name), tag, PA_ERR_INVALID);
4613     CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
4614     CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
4615     CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4616
4617     if (idx != PA_INVALID_INDEX)
4618         m = pa_idxset_get_by_index(c->protocol->core->modules, idx);
4619     else
4620         PA_IDXSET_FOREACH(m, c->protocol->core->modules, idx)
4621             if (pa_streq(name, m->name))
4622                 break;
4623
4624     CHECK_VALIDITY(c->pstream, m, tag, PA_ERR_NOEXTENSION);
4625     CHECK_VALIDITY(c->pstream, m->load_once || idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4626
4627     cb = (pa_native_protocol_ext_cb_t) (unsigned long) pa_hashmap_get(c->protocol->extensions, m);
4628     CHECK_VALIDITY(c->pstream, cb, tag, PA_ERR_NOEXTENSION);
4629
4630     if (cb(c->protocol, m, c, tag, t) < 0)
4631         protocol_error(c);
4632 }
4633
4634 static void command_set_card_profile(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4635     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4636     uint32_t idx = PA_INVALID_INDEX;
4637     const char *name = NULL, *profile = NULL;
4638     pa_card *card = NULL;
4639     int ret;
4640
4641     pa_native_connection_assert_ref(c);
4642     pa_assert(t);
4643
4644     if (pa_tagstruct_getu32(t, &idx) < 0 ||
4645         pa_tagstruct_gets(t, &name) < 0 ||
4646         pa_tagstruct_gets(t, &profile) < 0 ||
4647         !pa_tagstruct_eof(t)) {
4648         protocol_error(c);
4649         return;
4650     }
4651
4652     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4653     CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
4654     CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
4655     CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
4656     CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4657
4658     if (idx != PA_INVALID_INDEX)
4659         card = pa_idxset_get_by_index(c->protocol->core->cards, idx);
4660     else
4661         card = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_CARD);
4662
4663     CHECK_VALIDITY(c->pstream, card, tag, PA_ERR_NOENTITY);
4664
4665     if ((ret = pa_card_set_profile(card, profile, TRUE)) < 0) {
4666         pa_pstream_send_error(c->pstream, tag, -ret);
4667         return;
4668     }
4669
4670     pa_pstream_send_simple_ack(c->pstream, tag);
4671 }
4672
4673 static void command_set_sink_or_source_port(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4674     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4675     uint32_t idx = PA_INVALID_INDEX;
4676     const char *name = NULL, *port = NULL;
4677     int ret;
4678
4679     pa_native_connection_assert_ref(c);
4680     pa_assert(t);
4681
4682     if (pa_tagstruct_getu32(t, &idx) < 0 ||
4683         pa_tagstruct_gets(t, &name) < 0 ||
4684         pa_tagstruct_gets(t, &port) < 0 ||
4685         !pa_tagstruct_eof(t)) {
4686         protocol_error(c);
4687         return;
4688     }
4689
4690     CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4691     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);
4692     CHECK_VALIDITY(c->pstream, (idx != PA_INVALID_INDEX) ^ (name != NULL), tag, PA_ERR_INVALID);
4693     CHECK_VALIDITY(c->pstream, port, tag, PA_ERR_INVALID);
4694
4695     if (command == PA_COMMAND_SET_SINK_PORT) {
4696         pa_sink *sink;
4697
4698         if (idx != PA_INVALID_INDEX)
4699             sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
4700         else
4701             sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
4702
4703         CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
4704
4705         if ((ret = pa_sink_set_port(sink, port, TRUE)) < 0) {
4706             pa_pstream_send_error(c->pstream, tag, -ret);
4707             return;
4708         }
4709     } else {
4710         pa_source *source;
4711
4712         pa_assert(command = PA_COMMAND_SET_SOURCE_PORT);
4713
4714         if (idx != PA_INVALID_INDEX)
4715             source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
4716         else
4717             source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
4718
4719         CHECK_VALIDITY(c->pstream, source, tag, PA_ERR_NOENTITY);
4720
4721         if ((ret = pa_source_set_port(source, port, TRUE)) < 0) {
4722             pa_pstream_send_error(c->pstream, tag, -ret);
4723             return;
4724         }
4725     }
4726
4727     pa_pstream_send_simple_ack(c->pstream, tag);
4728 }
4729
4730 /*** pstream callbacks ***/
4731
4732 static void pstream_packet_callback(pa_pstream *p, pa_packet *packet, const pa_creds *creds, void *userdata) {
4733     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4734
4735     pa_assert(p);
4736     pa_assert(packet);
4737     pa_native_connection_assert_ref(c);
4738
4739     if (pa_pdispatch_run(c->pdispatch, packet, creds, c) < 0) {
4740         pa_log("invalid packet.");
4741         native_connection_unlink(c);
4742     }
4743 }
4744
4745 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) {
4746     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4747     output_stream *stream;
4748
4749     pa_assert(p);
4750     pa_assert(chunk);
4751     pa_native_connection_assert_ref(c);
4752
4753     if (!(stream = OUTPUT_STREAM(pa_idxset_get_by_index(c->output_streams, channel)))) {
4754         pa_log_debug("Client sent block for invalid stream.");
4755         /* Ignoring */
4756         return;
4757     }
4758
4759 #ifdef PROTOCOL_NATIVE_DEBUG
4760     pa_log("got %lu bytes from client", (unsigned long) chunk->length);
4761 #endif
4762
4763     if (playback_stream_isinstance(stream)) {
4764         playback_stream *ps = PLAYBACK_STREAM(stream);
4765
4766         pa_atomic_inc(&ps->seek_or_post_in_queue);
4767         if (chunk->memblock) {
4768             if (seek != PA_SEEK_RELATIVE || offset != 0)
4769                 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);
4770             else
4771                 pa_asyncmsgq_post(ps->sink_input->sink->asyncmsgq, PA_MSGOBJECT(ps->sink_input), SINK_INPUT_MESSAGE_POST_DATA, NULL, 0, chunk, NULL);
4772         } else
4773             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);
4774
4775     } else {
4776         upload_stream *u = UPLOAD_STREAM(stream);
4777         size_t l;
4778
4779         if (!u->memchunk.memblock) {
4780             if (u->length == chunk->length && chunk->memblock) {
4781                 u->memchunk = *chunk;
4782                 pa_memblock_ref(u->memchunk.memblock);
4783                 u->length = 0;
4784             } else {
4785                 u->memchunk.memblock = pa_memblock_new(c->protocol->core->mempool, u->length);
4786                 u->memchunk.index = u->memchunk.length = 0;
4787             }
4788         }
4789
4790         pa_assert(u->memchunk.memblock);
4791
4792         l = u->length;
4793         if (l > chunk->length)
4794             l = chunk->length;
4795
4796         if (l > 0) {
4797             void *dst;
4798             dst = pa_memblock_acquire(u->memchunk.memblock);
4799
4800             if (chunk->memblock) {
4801                 void *src;
4802                 src = pa_memblock_acquire(chunk->memblock);
4803
4804                 memcpy((uint8_t*) dst + u->memchunk.index + u->memchunk.length,
4805                        (uint8_t*) src + chunk->index, l);
4806
4807                 pa_memblock_release(chunk->memblock);
4808             } else
4809                 pa_silence_memory((uint8_t*) dst + u->memchunk.index + u->memchunk.length, l, &u->sample_spec);
4810
4811             pa_memblock_release(u->memchunk.memblock);
4812
4813             u->memchunk.length += l;
4814             u->length -= l;
4815         }
4816     }
4817 }
4818
4819 static void pstream_die_callback(pa_pstream *p, void *userdata) {
4820     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4821
4822     pa_assert(p);
4823     pa_native_connection_assert_ref(c);
4824
4825     native_connection_unlink(c);
4826     pa_log_info("Connection died.");
4827 }
4828
4829 static void pstream_drain_callback(pa_pstream *p, void *userdata) {
4830     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4831
4832     pa_assert(p);
4833     pa_native_connection_assert_ref(c);
4834
4835     native_connection_send_memblock(c);
4836 }
4837
4838 static void pstream_revoke_callback(pa_pstream *p, uint32_t block_id, void *userdata) {
4839     pa_thread_mq *q;
4840
4841     if (!(q = pa_thread_mq_get()))
4842         pa_pstream_send_revoke(p, block_id);
4843     else
4844         pa_asyncmsgq_post(q->outq, PA_MSGOBJECT(userdata), CONNECTION_MESSAGE_REVOKE, PA_UINT_TO_PTR(block_id), 0, NULL, NULL);
4845 }
4846
4847 static void pstream_release_callback(pa_pstream *p, uint32_t block_id, void *userdata) {
4848     pa_thread_mq *q;
4849
4850     if (!(q = pa_thread_mq_get()))
4851         pa_pstream_send_release(p, block_id);
4852     else
4853         pa_asyncmsgq_post(q->outq, PA_MSGOBJECT(userdata), CONNECTION_MESSAGE_RELEASE, PA_UINT_TO_PTR(block_id), 0, NULL, NULL);
4854 }
4855
4856 /*** client callbacks ***/
4857
4858 static void client_kill_cb(pa_client *c) {
4859     pa_assert(c);
4860
4861     native_connection_unlink(PA_NATIVE_CONNECTION(c->userdata));
4862     pa_log_info("Connection killed.");
4863 }
4864
4865 static void client_send_event_cb(pa_client *client, const char*event, pa_proplist *pl) {
4866     pa_tagstruct *t;
4867     pa_native_connection *c;
4868
4869     pa_assert(client);
4870     c = PA_NATIVE_CONNECTION(client->userdata);
4871     pa_native_connection_assert_ref(c);
4872
4873     if (c->version < 15)
4874       return;
4875
4876     t = pa_tagstruct_new(NULL, 0);
4877     pa_tagstruct_putu32(t, PA_COMMAND_CLIENT_EVENT);
4878     pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
4879     pa_tagstruct_puts(t, event);
4880     pa_tagstruct_put_proplist(t, pl);
4881     pa_pstream_send_tagstruct(c->pstream, t);
4882 }
4883
4884 /*** module entry points ***/
4885
4886 static void auth_timeout(pa_mainloop_api*m, pa_time_event *e, const struct timeval *t, void *userdata) {
4887     pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4888
4889     pa_assert(m);
4890     pa_native_connection_assert_ref(c);
4891     pa_assert(c->auth_timeout_event == e);
4892
4893     if (!c->authorized) {
4894         native_connection_unlink(c);
4895         pa_log_info("Connection terminated due to authentication timeout.");
4896     }
4897 }
4898
4899 void pa_native_protocol_connect(pa_native_protocol *p, pa_iochannel *io, pa_native_options *o) {
4900     pa_native_connection *c;
4901     char pname[128];
4902     pa_client *client;
4903     pa_client_new_data data;
4904
4905     pa_assert(p);
4906     pa_assert(io);
4907     pa_assert(o);
4908
4909     if (pa_idxset_size(p->connections)+1 > MAX_CONNECTIONS) {
4910         pa_log_warn("Warning! Too many connections (%u), dropping incoming connection.", MAX_CONNECTIONS);
4911         pa_iochannel_free(io);
4912         return;
4913     }
4914
4915     pa_client_new_data_init(&data);
4916     data.module = o->module;
4917     data.driver = __FILE__;
4918     pa_iochannel_socket_peer_to_string(io, pname, sizeof(pname));
4919     pa_proplist_setf(data.proplist, PA_PROP_APPLICATION_NAME, "Native client (%s)", pname);
4920     pa_proplist_sets(data.proplist, "native-protocol.peer", pname);
4921     client = pa_client_new(p->core, &data);
4922     pa_client_new_data_done(&data);
4923
4924     if (!client)
4925         return;
4926
4927     c = pa_msgobject_new(pa_native_connection);
4928     c->parent.parent.free = native_connection_free;
4929     c->parent.process_msg = native_connection_process_msg;
4930     c->protocol = p;
4931     c->options = pa_native_options_ref(o);
4932     c->authorized = FALSE;
4933
4934     if (o->auth_anonymous) {
4935         pa_log_info("Client authenticated anonymously.");
4936         c->authorized = TRUE;
4937     }
4938
4939     if (!c->authorized &&
4940         o->auth_ip_acl &&
4941         pa_ip_acl_check(o->auth_ip_acl, pa_iochannel_get_recv_fd(io)) > 0) {
4942
4943         pa_log_info("Client authenticated by IP ACL.");
4944         c->authorized = TRUE;
4945     }
4946
4947     if (!c->authorized)
4948         c->auth_timeout_event = pa_core_rttime_new(p->core, pa_rtclock_now() + AUTH_TIMEOUT, auth_timeout, c);
4949     else
4950         c->auth_timeout_event = NULL;
4951
4952     c->is_local = pa_iochannel_socket_is_local(io);
4953     c->version = 8;
4954
4955     c->client = client;
4956     c->client->kill = client_kill_cb;
4957     c->client->send_event = client_send_event_cb;
4958     c->client->userdata = c;
4959
4960     c->pstream = pa_pstream_new(p->core->mainloop, io, p->core->mempool);
4961     pa_pstream_set_receive_packet_callback(c->pstream, pstream_packet_callback, c);
4962     pa_pstream_set_receive_memblock_callback(c->pstream, pstream_memblock_callback, c);
4963     pa_pstream_set_die_callback(c->pstream, pstream_die_callback, c);
4964     pa_pstream_set_drain_callback(c->pstream, pstream_drain_callback, c);
4965     pa_pstream_set_revoke_callback(c->pstream, pstream_revoke_callback, c);
4966     pa_pstream_set_release_callback(c->pstream, pstream_release_callback, c);
4967
4968     c->pdispatch = pa_pdispatch_new(p->core->mainloop, TRUE, command_table, PA_COMMAND_MAX);
4969
4970     c->record_streams = pa_idxset_new(NULL, NULL);
4971     c->output_streams = pa_idxset_new(NULL, NULL);
4972
4973     c->rrobin_index = PA_IDXSET_INVALID;
4974     c->subscription = NULL;
4975
4976     pa_idxset_put(p->connections, c, NULL);
4977
4978 #ifdef HAVE_CREDS
4979     if (pa_iochannel_creds_supported(io))
4980         pa_iochannel_creds_enable(io);
4981 #endif
4982
4983     pa_hook_fire(&p->hooks[PA_NATIVE_HOOK_CONNECTION_PUT], c);
4984 }
4985
4986 void pa_native_protocol_disconnect(pa_native_protocol *p, pa_module *m) {
4987     pa_native_connection *c;
4988     void *state = NULL;
4989
4990     pa_assert(p);
4991     pa_assert(m);
4992
4993     while ((c = pa_idxset_iterate(p->connections, &state, NULL)))
4994         if (c->options->module == m)
4995             native_connection_unlink(c);
4996 }
4997
4998 static pa_native_protocol* native_protocol_new(pa_core *c) {
4999     pa_native_protocol *p;
5000     pa_native_hook_t h;
5001
5002     pa_assert(c);
5003
5004     p = pa_xnew(pa_native_protocol, 1);
5005     PA_REFCNT_INIT(p);
5006     p->core = c;
5007     p->connections = pa_idxset_new(NULL, NULL);
5008
5009     p->servers = NULL;
5010
5011     p->extensions = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
5012
5013     for (h = 0; h < PA_NATIVE_HOOK_MAX; h++)
5014         pa_hook_init(&p->hooks[h], p);
5015
5016     pa_assert_se(pa_shared_set(c, "native-protocol", p) >= 0);
5017
5018     return p;
5019 }
5020
5021 pa_native_protocol* pa_native_protocol_get(pa_core *c) {
5022     pa_native_protocol *p;
5023
5024     if ((p = pa_shared_get(c, "native-protocol")))
5025         return pa_native_protocol_ref(p);
5026
5027     return native_protocol_new(c);
5028 }
5029
5030 pa_native_protocol* pa_native_protocol_ref(pa_native_protocol *p) {
5031     pa_assert(p);
5032     pa_assert(PA_REFCNT_VALUE(p) >= 1);
5033
5034     PA_REFCNT_INC(p);
5035
5036     return p;
5037 }
5038
5039 void pa_native_protocol_unref(pa_native_protocol *p) {
5040     pa_native_connection *c;
5041     pa_native_hook_t h;
5042
5043     pa_assert(p);
5044     pa_assert(PA_REFCNT_VALUE(p) >= 1);
5045
5046     if (PA_REFCNT_DEC(p) > 0)
5047         return;
5048
5049     while ((c = pa_idxset_first(p->connections, NULL)))
5050         native_connection_unlink(c);
5051
5052     pa_idxset_free(p->connections, NULL, NULL);
5053
5054     pa_strlist_free(p->servers);
5055
5056     for (h = 0; h < PA_NATIVE_HOOK_MAX; h++)
5057         pa_hook_done(&p->hooks[h]);
5058
5059     pa_hashmap_free(p->extensions, NULL, NULL);
5060
5061     pa_assert_se(pa_shared_remove(p->core, "native-protocol") >= 0);
5062
5063     pa_xfree(p);
5064 }
5065
5066 void pa_native_protocol_add_server_string(pa_native_protocol *p, const char *name) {
5067     pa_assert(p);
5068     pa_assert(PA_REFCNT_VALUE(p) >= 1);
5069     pa_assert(name);
5070
5071     p->servers = pa_strlist_prepend(p->servers, name);
5072
5073     pa_hook_fire(&p->hooks[PA_NATIVE_HOOK_SERVERS_CHANGED], p->servers);
5074 }
5075
5076 void pa_native_protocol_remove_server_string(pa_native_protocol *p, const char *name) {
5077     pa_assert(p);
5078     pa_assert(PA_REFCNT_VALUE(p) >= 1);
5079     pa_assert(name);
5080
5081     p->servers = pa_strlist_remove(p->servers, name);
5082
5083     pa_hook_fire(&p->hooks[PA_NATIVE_HOOK_SERVERS_CHANGED], p->servers);
5084 }
5085
5086 pa_hook *pa_native_protocol_hooks(pa_native_protocol *p) {
5087     pa_assert(p);
5088     pa_assert(PA_REFCNT_VALUE(p) >= 1);
5089
5090     return p->hooks;
5091 }
5092
5093 pa_strlist *pa_native_protocol_servers(pa_native_protocol *p) {
5094     pa_assert(p);
5095     pa_assert(PA_REFCNT_VALUE(p) >= 1);
5096
5097     return p->servers;
5098 }
5099
5100 int pa_native_protocol_install_ext(pa_native_protocol *p, pa_module *m, pa_native_protocol_ext_cb_t cb) {
5101     pa_assert(p);
5102     pa_assert(PA_REFCNT_VALUE(p) >= 1);
5103     pa_assert(m);
5104     pa_assert(cb);
5105     pa_assert(!pa_hashmap_get(p->extensions, m));
5106
5107     pa_assert_se(pa_hashmap_put(p->extensions, m, (void*) (unsigned long) cb) == 0);
5108     return 0;
5109 }
5110
5111 void pa_native_protocol_remove_ext(pa_native_protocol *p, pa_module *m) {
5112     pa_assert(p);
5113     pa_assert(PA_REFCNT_VALUE(p) >= 1);
5114     pa_assert(m);
5115
5116     pa_assert_se(pa_hashmap_remove(p->extensions, m));
5117 }
5118
5119 pa_native_options* pa_native_options_new(void) {
5120     pa_native_options *o;
5121
5122     o = pa_xnew0(pa_native_options, 1);
5123     PA_REFCNT_INIT(o);
5124
5125     return o;
5126 }
5127
5128 pa_native_options* pa_native_options_ref(pa_native_options *o) {
5129     pa_assert(o);
5130     pa_assert(PA_REFCNT_VALUE(o) >= 1);
5131
5132     PA_REFCNT_INC(o);
5133
5134     return o;
5135 }
5136
5137 void pa_native_options_unref(pa_native_options *o) {
5138     pa_assert(o);
5139     pa_assert(PA_REFCNT_VALUE(o) >= 1);
5140
5141     if (PA_REFCNT_DEC(o) > 0)
5142         return;
5143
5144     pa_xfree(o->auth_group);
5145
5146     if (o->auth_ip_acl)
5147         pa_ip_acl_free(o->auth_ip_acl);
5148
5149     if (o->auth_cookie)
5150         pa_auth_cookie_unref(o->auth_cookie);
5151
5152     pa_xfree(o);
5153 }
5154
5155 int pa_native_options_parse(pa_native_options *o, pa_core *c, pa_modargs *ma) {
5156     pa_bool_t enabled;
5157     const char *acl;
5158
5159     pa_assert(o);
5160     pa_assert(PA_REFCNT_VALUE(o) >= 1);
5161     pa_assert(ma);
5162
5163     if (pa_modargs_get_value_boolean(ma, "auth-anonymous", &o->auth_anonymous) < 0) {
5164         pa_log("auth-anonymous= expects a boolean argument.");
5165         return -1;
5166     }
5167
5168     enabled = TRUE;
5169     if (pa_modargs_get_value_boolean(ma, "auth-group-enable", &enabled) < 0) {
5170         pa_log("auth-group-enable= expects a boolean argument.");
5171         return -1;
5172     }
5173
5174     pa_xfree(o->auth_group);
5175     o->auth_group = enabled ? pa_xstrdup(pa_modargs_get_value(ma, "auth-group", pa_in_system_mode() ? PA_ACCESS_GROUP : NULL)) : NULL;
5176
5177 #ifndef HAVE_CREDS
5178     if (o->auth_group)
5179         pa_log_warn("Authentication group configured, but not available on local system. Ignoring.");
5180 #endif
5181
5182     if ((acl = pa_modargs_get_value(ma, "auth-ip-acl", NULL))) {
5183         pa_ip_acl *ipa;
5184
5185         if (!(ipa = pa_ip_acl_new(acl))) {
5186             pa_log("Failed to parse IP ACL '%s'", acl);
5187             return -1;
5188         }
5189
5190         if (o->auth_ip_acl)
5191             pa_ip_acl_free(o->auth_ip_acl);
5192
5193         o->auth_ip_acl = ipa;
5194     }
5195
5196     enabled = TRUE;
5197     if (pa_modargs_get_value_boolean(ma, "auth-cookie-enabled", &enabled) < 0) {
5198         pa_log("auth-cookie-enabled= expects a boolean argument.");
5199         return -1;
5200     }
5201
5202     if (o->auth_cookie)
5203         pa_auth_cookie_unref(o->auth_cookie);
5204
5205     if (enabled) {
5206         const char *cn;
5207
5208         /* The new name for this is 'auth-cookie', for compat reasons
5209          * we check the old name too */
5210         cn = pa_modargs_get_value(ma, "auth-cookie", NULL);
5211         if (!cn)
5212             cn = pa_modargs_get_value(ma, "cookie", NULL);
5213
5214         if (cn)
5215             o->auth_cookie = pa_auth_cookie_get(c, cn, TRUE, PA_NATIVE_COOKIE_LENGTH);
5216         else {
5217             o->auth_cookie = pa_auth_cookie_get(c, PA_NATIVE_COOKIE_FILE, FALSE, PA_NATIVE_COOKIE_LENGTH);
5218             if (!o->auth_cookie) {
5219                 o->auth_cookie = pa_auth_cookie_get(c, PA_NATIVE_COOKIE_FILE_FALLBACK, FALSE, PA_NATIVE_COOKIE_LENGTH);
5220
5221                 if (!o->auth_cookie)
5222                     o->auth_cookie = pa_auth_cookie_get(c, PA_NATIVE_COOKIE_FILE, TRUE, PA_NATIVE_COOKIE_LENGTH);
5223             }
5224         }
5225
5226         if (!o->auth_cookie)
5227             return -1;
5228
5229     } else
5230           o->auth_cookie = NULL;
5231
5232     return 0;
5233 }
5234
5235 pa_pstream* pa_native_connection_get_pstream(pa_native_connection *c) {
5236     pa_native_connection_assert_ref(c);
5237
5238     return c->pstream;
5239 }
5240
5241 pa_client* pa_native_connection_get_client(pa_native_connection *c) {
5242     pa_native_connection_assert_ref(c);
5243
5244     return c->client;
5245 }