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