X-Git-Url: https://code.delx.au/pulseaudio/blobdiff_plain/34fe8bd893ed9c7531bc4898b934ef9d4cdf3e68..ee452b0f06c82dd870de82fb3e6bdd4e14d29f3c:/polyp/protocol-native.c diff --git a/polyp/protocol-native.c b/polyp/protocol-native.c index 9c6996be..31ab4ab8 100644 --- a/polyp/protocol-native.c +++ b/polyp/protocol-native.c @@ -44,6 +44,8 @@ #include "xmalloc.h" #include "util.h" #include "subscribe.h" +#include "log.h" +#include "autoload.h" struct connection; struct pa_protocol_native; @@ -109,12 +111,13 @@ struct pa_protocol_native { static int sink_input_peek_cb(struct pa_sink_input *i, struct pa_memchunk *chunk); static void sink_input_drop_cb(struct pa_sink_input *i, const struct pa_memchunk *chunk, size_t length); static void sink_input_kill_cb(struct pa_sink_input *i); -static uint32_t sink_input_get_latency_cb(struct pa_sink_input *i); +static pa_usec_t sink_input_get_latency_cb(struct pa_sink_input *i); static void request_bytes(struct playback_stream*s); static void source_output_kill_cb(struct pa_source_output *o); static void source_output_push_cb(struct pa_source_output *o, const struct pa_memchunk *chunk); +static pa_usec_t source_output_get_latency_cb(struct pa_source_output *o); static void command_exit(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); static void command_create_playback_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); @@ -122,10 +125,11 @@ static void command_drain_playback_stream(struct pa_pdispatch *pd, uint32_t comm static void command_create_record_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); static void command_delete_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); static void command_auth(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); -static void command_set_name(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); +static void command_set_client_name(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); static void command_lookup(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); static void command_stat(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); static void command_get_playback_latency(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); +static void command_get_record_latency(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); static void command_create_upload_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); static void command_finish_upload_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); static void command_play_sample(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); @@ -137,6 +141,17 @@ static void command_subscribe(struct pa_pdispatch *pd, uint32_t command, uint32_ static void command_set_volume(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); static void command_cork_playback_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); static void command_flush_or_trigger_playback_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); +static void command_set_default_sink_or_source(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); +static void command_set_stream_name(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); +static void command_kill(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); +static void command_load_module(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); +static void command_unload_module(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); +static void command_add_autoload(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); +static void command_remove_autoload(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); +static void command_get_autoload_info(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); +static void command_get_autoload_info_list(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); +static void command_cork_record_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); +static void command_flush_record_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata); static const struct pa_pdispatch_command command_table[PA_COMMAND_MAX] = { [PA_COMMAND_ERROR] = { NULL }, @@ -150,11 +165,12 @@ static const struct pa_pdispatch_command command_table[PA_COMMAND_MAX] = { [PA_COMMAND_AUTH] = { command_auth }, [PA_COMMAND_REQUEST] = { NULL }, [PA_COMMAND_EXIT] = { command_exit }, - [PA_COMMAND_SET_NAME] = { command_set_name }, + [PA_COMMAND_SET_CLIENT_NAME] = { command_set_client_name }, [PA_COMMAND_LOOKUP_SINK] = { command_lookup }, [PA_COMMAND_LOOKUP_SOURCE] = { command_lookup }, [PA_COMMAND_STAT] = { command_stat }, [PA_COMMAND_GET_PLAYBACK_LATENCY] = { command_get_playback_latency }, + [PA_COMMAND_GET_RECORD_LATENCY] = { command_get_record_latency }, [PA_COMMAND_CREATE_UPLOAD_STREAM] = { command_create_upload_stream }, [PA_COMMAND_DELETE_UPLOAD_STREAM] = { command_delete_stream }, [PA_COMMAND_FINISH_UPLOAD_STREAM] = { command_finish_upload_stream }, @@ -176,11 +192,32 @@ static const struct pa_pdispatch_command command_table[PA_COMMAND_MAX] = { [PA_COMMAND_GET_SAMPLE_INFO_LIST] = { command_get_info_list }, [PA_COMMAND_GET_SERVER_INFO] = { command_get_server_info }, [PA_COMMAND_SUBSCRIBE] = { command_subscribe }, + [PA_COMMAND_SET_SINK_VOLUME] = { command_set_volume }, [PA_COMMAND_SET_SINK_INPUT_VOLUME] = { command_set_volume }, + [PA_COMMAND_CORK_PLAYBACK_STREAM] = { command_cork_playback_stream }, [PA_COMMAND_FLUSH_PLAYBACK_STREAM] = { command_flush_or_trigger_playback_stream }, [PA_COMMAND_TRIGGER_PLAYBACK_STREAM] = { command_flush_or_trigger_playback_stream }, + [PA_COMMAND_PREBUF_PLAYBACK_STREAM] = { command_flush_or_trigger_playback_stream }, + + [PA_COMMAND_CORK_RECORD_STREAM] = { command_cork_record_stream }, + [PA_COMMAND_FLUSH_RECORD_STREAM] = { command_flush_record_stream }, + + [PA_COMMAND_SET_DEFAULT_SINK] = { command_set_default_sink_or_source }, + [PA_COMMAND_SET_DEFAULT_SOURCE] = { command_set_default_sink_or_source }, + [PA_COMMAND_SET_PLAYBACK_STREAM_NAME] = { command_set_stream_name }, + [PA_COMMAND_SET_RECORD_STREAM_NAME] = { command_set_stream_name }, + [PA_COMMAND_KILL_CLIENT] = { command_kill }, + [PA_COMMAND_KILL_SINK_INPUT] = { command_kill }, + [PA_COMMAND_KILL_SOURCE_OUTPUT] = { command_kill }, + [PA_COMMAND_LOAD_MODULE] = { command_load_module }, + [PA_COMMAND_UNLOAD_MODULE] = { command_unload_module }, + [PA_COMMAND_GET_AUTOLOAD_INFO] = { command_get_autoload_info }, + [PA_COMMAND_GET_AUTOLOAD_INFO_LIST] = { command_get_autoload_info_list }, + [PA_COMMAND_ADD_AUTOLOAD] = { command_add_autoload }, + [PA_COMMAND_REMOVE_AUTOLOAD] = { command_remove_autoload }, + }; /* structure management */ @@ -224,7 +261,7 @@ static struct record_stream* record_stream_new(struct connection *c, struct pa_s size_t base; assert(c && source && ss && name && maxlength); - if (!(source_output = pa_source_output_new(source, name, ss))) + if (!(source_output = pa_source_output_new(source, name, ss, -1))) return NULL; s = pa_xmalloc(sizeof(struct record_stream)); @@ -232,6 +269,7 @@ static struct record_stream* record_stream_new(struct connection *c, struct pa_s s->source_output = source_output; s->source_output->push = source_output_push_cb; s->source_output->kill = source_output_kill_cb; + s->source_output->get_latency = source_output_get_latency_cb; s->source_output->userdata = s; s->source_output->owner = c->protocol->module; s->source_output->client = c->client; @@ -251,7 +289,8 @@ static void record_stream_free(struct record_stream* r) { assert(r && r->connection); pa_idxset_remove_by_data(r->connection->record_streams, r, NULL); - pa_source_output_free(r->source_output); + pa_source_output_disconnect(r->source_output); + pa_source_output_unref(r->source_output); pa_memblockq_free(r->memblockq); pa_xfree(r); } @@ -260,12 +299,13 @@ static struct playback_stream* playback_stream_new(struct connection *c, struct size_t maxlength, size_t tlength, size_t prebuf, - size_t minreq) { + size_t minreq, + pa_volume_t volume) { struct playback_stream *s; struct pa_sink_input *sink_input; assert(c && sink && ss && name && maxlength); - if (!(sink_input = pa_sink_input_new(sink, name, ss))) + if (!(sink_input = pa_sink_input_new(sink, name, ss, 0, -1))) return NULL; s = pa_xmalloc(sizeof(struct playback_stream)); @@ -286,6 +326,8 @@ static struct playback_stream* playback_stream_new(struct connection *c, struct s->requested_bytes = 0; s->drain_request = 0; + + s->sink_input->volume = volume; pa_idxset_put(c->output_streams, s, &s->index); return s; @@ -298,7 +340,8 @@ static void playback_stream_free(struct playback_stream* p) { pa_pstream_send_error(p->connection->pstream, p->drain_tag, PA_ERROR_NOENTITY); pa_idxset_remove_by_data(p->connection->output_streams, p, NULL); - pa_sink_input_free(p->sink_input); + pa_sink_input_disconnect(p->sink_input); + pa_sink_input_unref(p->sink_input); pa_memblockq_free(p->memblockq); pa_xfree(p); } @@ -338,7 +381,7 @@ static void request_bytes(struct playback_stream *s) { if (!(l = pa_memblockq_missing(s->memblockq))) return; - + if (l <= s->requested_bytes) return; @@ -357,7 +400,7 @@ static void request_bytes(struct playback_stream *s) { pa_tagstruct_putu32(t, l); pa_pstream_send_tagstruct(s->connection->pstream, t); - /*fprintf(stderr, "Requesting %u bytes\n", l);*/ +/* pa_log(__FILE__": Requesting %u bytes\n", l); */ } static void send_memblock(struct connection *c) { @@ -377,12 +420,14 @@ static void send_memblock(struct connection *c) { return; if (pa_memblockq_peek(r->memblockq, &chunk) >= 0) { - if (chunk.length > r->fragment_size) - chunk.length = r->fragment_size; + struct pa_memchunk schunk = chunk; + + if (schunk.length > r->fragment_size) + schunk.length = r->fragment_size; - pa_pstream_send_memblock(c->pstream, r->index, 0, &chunk); - pa_memblockq_drop(r->memblockq, &chunk, chunk.length); - pa_memblock_unref(chunk.memblock); + pa_pstream_send_memblock(c->pstream, r->index, 0, &schunk); + pa_memblockq_drop(r->memblockq, &chunk, schunk.length); + pa_memblock_unref(schunk.memblock); return; } @@ -413,7 +458,6 @@ static void send_record_stream_killed(struct record_stream *r) { pa_pstream_send_tagstruct(r->connection->pstream, t); } - /*** sinkinput callbacks ***/ static int sink_input_peek_cb(struct pa_sink_input *i, struct pa_memchunk *chunk) { @@ -421,8 +465,6 @@ static int sink_input_peek_cb(struct pa_sink_input *i, struct pa_memchunk *chunk assert(i && i->userdata && chunk); s = i->userdata; - /*fprintf(stderr, "%3.0f \r", (double) pa_memblockq_get_length(s->memblockq)/pa_memblockq_get_tlength(s->memblockq)*100);*/ - if (pa_memblockq_peek(s->memblockq, chunk) < 0) return -1; @@ -442,7 +484,7 @@ static void sink_input_drop_cb(struct pa_sink_input *i, const struct pa_memchunk s->drain_request = 0; } - /*fprintf(stderr, "after_drop: %u\n", pa_memblockq_get_length(s->memblockq));*/ +/* pa_log(__FILE__": after_drop: %u\n", pa_memblockq_get_length(s->memblockq)); */ } static void sink_input_kill_cb(struct pa_sink_input *i) { @@ -451,12 +493,12 @@ static void sink_input_kill_cb(struct pa_sink_input *i) { playback_stream_free((struct playback_stream *) i->userdata); } -static uint32_t sink_input_get_latency_cb(struct pa_sink_input *i) { +static pa_usec_t sink_input_get_latency_cb(struct pa_sink_input *i) { struct playback_stream *s; assert(i && i->userdata); s = i->userdata; - /*fprintf(stderr, "get_latency: %u\n", pa_memblockq_get_length(s->memblockq));*/ + /*pa_log(__FILE__": get_latency: %u\n", pa_memblockq_get_length(s->memblockq));*/ return pa_bytes_to_usec(pa_memblockq_get_length(s->memblockq), &s->sink_input->sample_spec); } @@ -468,7 +510,7 @@ static void source_output_push_cb(struct pa_source_output *o, const struct pa_me assert(o && o->userdata && chunk); s = o->userdata; - pa_memblockq_push(s->memblockq, chunk, 0); + pa_memblockq_push_align(s->memblockq, chunk, 0); if (!pa_pstream_is_pending(s->connection->pstream)) send_memblock(s->connection); } @@ -479,10 +521,20 @@ static void source_output_kill_cb(struct pa_source_output *o) { record_stream_free((struct record_stream *) o->userdata); } +static pa_usec_t source_output_get_latency_cb(struct pa_source_output *o) { + struct record_stream *s; + assert(o && o->userdata); + s = o->userdata; + + /*pa_log(__FILE__": get_latency: %u\n", pa_memblockq_get_length(s->memblockq));*/ + + return pa_bytes_to_usec(pa_memblockq_get_length(s->memblockq), &o->sample_spec); +} + /*** pdispatch callbacks ***/ static void protocol_error(struct connection *c) { - fprintf(stderr, __FILE__": protocol error, kicking client\n"); + pa_log(__FILE__": protocol error, kicking client\n"); connection_free(c); } @@ -495,21 +547,26 @@ static void command_create_playback_stream(struct pa_pdispatch *pd, uint32_t com struct pa_sample_spec ss; struct pa_tagstruct *reply; struct pa_sink *sink; + pa_volume_t volume; + int corked; assert(c && t && c->protocol && c->protocol->core); - if (pa_tagstruct_gets(t, &name) < 0 || + if (pa_tagstruct_gets(t, &name) < 0 || !name || pa_tagstruct_get_sample_spec(t, &ss) < 0 || pa_tagstruct_getu32(t, &sink_index) < 0 || pa_tagstruct_gets(t, &sink_name) < 0 || pa_tagstruct_getu32(t, &maxlength) < 0 || + pa_tagstruct_get_boolean(t, &corked) < 0 || pa_tagstruct_getu32(t, &tlength) < 0 || pa_tagstruct_getu32(t, &prebuf) < 0 || pa_tagstruct_getu32(t, &minreq) < 0 || + pa_tagstruct_getu32(t, &volume) < 0 || !pa_tagstruct_eof(t)) { protocol_error(c); return; } + if (!c->authorized) { pa_pstream_send_error(c->pstream, tag, PA_ERROR_ACCESS); return; @@ -518,17 +575,19 @@ static void command_create_playback_stream(struct pa_pdispatch *pd, uint32_t com if (sink_index != (uint32_t) -1) sink = pa_idxset_get_by_index(c->protocol->core->sinks, sink_index); else - sink = pa_namereg_get(c->protocol->core, *sink_name ? sink_name : NULL, PA_NAMEREG_SINK, 1); + sink = pa_namereg_get(c->protocol->core, sink_name, PA_NAMEREG_SINK, 1); if (!sink) { pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY); return; } - if (!(s = playback_stream_new(c, sink, &ss, name, maxlength, tlength, prebuf, minreq))) { + if (!(s = playback_stream_new(c, sink, &ss, name, maxlength, tlength, prebuf, minreq, volume))) { pa_pstream_send_error(c->pstream, tag, PA_ERROR_INVALID); return; } + + pa_sink_input_cork(s->sink_input, corked); reply = pa_tagstruct_new(NULL, 0); assert(reply); @@ -537,6 +596,7 @@ static void command_create_playback_stream(struct pa_pdispatch *pd, uint32_t com pa_tagstruct_putu32(reply, s->index); assert(s->sink_input); pa_tagstruct_putu32(reply, s->sink_input->index); + pa_tagstruct_putu32(reply, s->requested_bytes = pa_memblockq_missing(s->memblockq)); pa_pstream_send_tagstruct(c->pstream, reply); request_bytes(s); } @@ -596,13 +656,15 @@ static void command_create_record_stream(struct pa_pdispatch *pd, uint32_t comma struct pa_sample_spec ss; struct pa_tagstruct *reply; struct pa_source *source; + int corked; assert(c && t && c->protocol && c->protocol->core); - if (pa_tagstruct_gets(t, &name) < 0 || + if (pa_tagstruct_gets(t, &name) < 0 || !name || pa_tagstruct_get_sample_spec(t, &ss) < 0 || pa_tagstruct_getu32(t, &source_index) < 0 || pa_tagstruct_gets(t, &source_name) < 0 || pa_tagstruct_getu32(t, &maxlength) < 0 || + pa_tagstruct_get_boolean(t, &corked) < 0 || pa_tagstruct_getu32(t, &fragment_size) < 0 || !pa_tagstruct_eof(t)) { protocol_error(c); @@ -617,7 +679,7 @@ static void command_create_record_stream(struct pa_pdispatch *pd, uint32_t comma if (source_index != (uint32_t) -1) source = pa_idxset_get_by_index(c->protocol->core->sources, source_index); else - source = pa_namereg_get(c->protocol->core, *source_name ? source_name : NULL, PA_NAMEREG_SOURCE, 1); + source = pa_namereg_get(c->protocol->core, source_name, PA_NAMEREG_SOURCE, 1); if (!source) { pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY); @@ -628,6 +690,8 @@ static void command_create_record_stream(struct pa_pdispatch *pd, uint32_t comma pa_pstream_send_error(c->pstream, tag, PA_ERROR_INVALID); return; } + + pa_source_output_cork(s->source_output, corked); reply = pa_tagstruct_new(NULL, 0); assert(reply); @@ -669,30 +733,33 @@ static void command_auth(struct pa_pdispatch *pd, uint32_t command, uint32_t tag protocol_error(c); return; } + + if (!c->authorized) { + if (memcmp(c->protocol->auth_cookie, cookie, PA_NATIVE_COOKIE_LENGTH) != 0) { + pa_log(__FILE__": Denied access to client with invalid authorization key.\n"); + pa_pstream_send_error(c->pstream, tag, PA_ERROR_ACCESS); + return; + } - if (memcmp(c->protocol->auth_cookie, cookie, PA_NATIVE_COOKIE_LENGTH) != 0) { - fprintf(stderr, "protocol-native.c: Denied access to client with invalid authorization key.\n"); - pa_pstream_send_error(c->pstream, tag, PA_ERROR_ACCESS); - return; + c->authorized = 1; } - - c->authorized = 1; + pa_pstream_send_simple_ack(c->pstream, tag); return; } -static void command_set_name(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) { +static void command_set_client_name(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) { struct connection *c = userdata; const char *name; assert(c && t); - if (pa_tagstruct_gets(t, &name) < 0 || + if (pa_tagstruct_gets(t, &name) < 0 || !name || !pa_tagstruct_eof(t)) { protocol_error(c); return; } - pa_client_rename(c->client, name); + pa_client_set_name(c->client, name); pa_pstream_send_simple_ack(c->pstream, tag); return; } @@ -703,7 +770,7 @@ static void command_lookup(struct pa_pdispatch *pd, uint32_t command, uint32_t t uint32_t index = PA_IDXSET_INVALID; assert(c && t); - if (pa_tagstruct_gets(t, &name) < 0 || + if (pa_tagstruct_gets(t, &name) < 0 || !name || !pa_tagstruct_eof(t)) { protocol_error(c); return; @@ -764,9 +831,11 @@ static void command_drain_playback_stream(struct pa_pdispatch *pd, uint32_t comm pa_memblockq_prebuf_disable(s->memblockq); - if (!pa_memblockq_is_readable(s->memblockq)) + if (!pa_memblockq_is_readable(s->memblockq)) { +/* pa_log("immediate drain: %u\n", pa_memblockq_get_length(s->memblockq)); */ pa_pstream_send_simple_ack(c->pstream, tag); - else { + } else { +/* pa_log("slow drain triggered\n"); */ s->drain_request = 1; s->drain_tag = tag; @@ -797,6 +866,7 @@ static void command_stat(struct pa_pdispatch *pd, uint32_t command, uint32_t tag pa_tagstruct_putu32(reply, c->protocol->core->memblock_stat->total_size); pa_tagstruct_putu32(reply, c->protocol->core->memblock_stat->allocated); pa_tagstruct_putu32(reply, c->protocol->core->memblock_stat->allocated_size); + pa_tagstruct_putu32(reply, pa_scache_total_size(c->protocol->core)); pa_pstream_send_tagstruct(c->pstream, reply); } @@ -804,10 +874,14 @@ static void command_get_playback_latency(struct pa_pdispatch *pd, uint32_t comma struct connection *c = userdata; struct pa_tagstruct *reply; struct playback_stream *s; + struct timeval tv, now; + uint64_t counter; uint32_t index; assert(c && t); - + if (pa_tagstruct_getu32(t, &index) < 0 || + pa_tagstruct_get_timeval(t, &tv) < 0 || + pa_tagstruct_getu64(t, &counter) < 0 || !pa_tagstruct_eof(t)) { protocol_error(c); return; @@ -827,13 +901,62 @@ static void command_get_playback_latency(struct pa_pdispatch *pd, uint32_t comma assert(reply); pa_tagstruct_putu32(reply, PA_COMMAND_REPLY); pa_tagstruct_putu32(reply, tag); - pa_tagstruct_putu32(reply, pa_sink_input_get_latency(s->sink_input)); - pa_tagstruct_putu32(reply, pa_sink_get_latency(s->sink_input->sink)); - pa_tagstruct_putu32(reply, pa_memblockq_is_readable(s->memblockq)); + pa_tagstruct_put_usec(reply, pa_sink_input_get_latency(s->sink_input)); + pa_tagstruct_put_usec(reply, pa_sink_get_latency(s->sink_input->sink)); + pa_tagstruct_put_usec(reply, 0); + pa_tagstruct_put_boolean(reply, pa_memblockq_is_readable(s->memblockq)); + pa_tagstruct_putu32(reply, pa_memblockq_get_length(s->memblockq)); + pa_tagstruct_put_timeval(reply, &tv); + gettimeofday(&now, NULL); + pa_tagstruct_put_timeval(reply, &now); + pa_tagstruct_putu64(reply, counter); + pa_pstream_send_tagstruct(c->pstream, reply); +} + +static void command_get_record_latency(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) { + struct connection *c = userdata; + struct pa_tagstruct *reply; + struct record_stream *s; + struct timeval tv, now; + uint64_t counter; + uint32_t index; + assert(c && t); + + if (pa_tagstruct_getu32(t, &index) < 0 || + pa_tagstruct_get_timeval(t, &tv) < 0 || + pa_tagstruct_getu64(t, &counter) < 0 || + !pa_tagstruct_eof(t)) { + protocol_error(c); + return; + } + + if (!c->authorized) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_ACCESS); + return; + } + + if (!(s = pa_idxset_get_by_index(c->record_streams, index))) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY); + return; + } + + reply = pa_tagstruct_new(NULL, 0); + assert(reply); + pa_tagstruct_putu32(reply, PA_COMMAND_REPLY); + pa_tagstruct_putu32(reply, tag); + pa_tagstruct_put_usec(reply, pa_source_output_get_latency(s->source_output)); + pa_tagstruct_put_usec(reply, s->source_output->source->monitor_of ? pa_sink_get_latency(s->source_output->source->monitor_of) : 0); + pa_tagstruct_put_usec(reply, pa_source_get_latency(s->source_output->source)); + pa_tagstruct_put_boolean(reply, 0); pa_tagstruct_putu32(reply, pa_memblockq_get_length(s->memblockq)); + pa_tagstruct_put_timeval(reply, &tv); + gettimeofday(&now, NULL); + pa_tagstruct_put_timeval(reply, &now); + pa_tagstruct_putu64(reply, counter); pa_pstream_send_tagstruct(c->pstream, reply); } + static void command_create_upload_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) { struct connection *c = userdata; struct upload_stream *s; @@ -843,7 +966,7 @@ static void command_create_upload_stream(struct pa_pdispatch *pd, uint32_t comma struct pa_tagstruct *reply; assert(c && t && c->protocol && c->protocol->core); - if (pa_tagstruct_gets(t, &name) < 0 || + if (pa_tagstruct_gets(t, &name) < 0 || !name || pa_tagstruct_get_sample_spec(t, &ss) < 0 || pa_tagstruct_getu32(t, &length) < 0 || !pa_tagstruct_eof(t)) { @@ -871,13 +994,6 @@ static void command_create_upload_stream(struct pa_pdispatch *pd, uint32_t comma pa_tagstruct_putu32(reply, PA_COMMAND_REPLY); pa_tagstruct_putu32(reply, tag); pa_tagstruct_putu32(reply, s->index); - pa_pstream_send_tagstruct(c->pstream, reply); - - reply = pa_tagstruct_new(NULL, 0); - assert(reply); - pa_tagstruct_putu32(reply, PA_COMMAND_REQUEST); - pa_tagstruct_putu32(reply, (uint32_t) -1); /* tag */ - pa_tagstruct_putu32(reply, s->index); pa_tagstruct_putu32(reply, length); pa_pstream_send_tagstruct(c->pstream, reply); } @@ -920,7 +1036,7 @@ static void command_play_sample(struct pa_pdispatch *pd, uint32_t command, uint3 if (pa_tagstruct_getu32(t, &sink_index) < 0 || pa_tagstruct_gets(t, &sink_name) < 0 || pa_tagstruct_getu32(t, &volume) < 0 || - pa_tagstruct_gets(t, &name) < 0 || + pa_tagstruct_gets(t, &name) < 0 || !name || !pa_tagstruct_eof(t)) { protocol_error(c); return; @@ -934,7 +1050,7 @@ static void command_play_sample(struct pa_pdispatch *pd, uint32_t command, uint3 if (sink_index != (uint32_t) -1) sink = pa_idxset_get_by_index(c->protocol->core->sinks, sink_index); else - sink = pa_namereg_get(c->protocol->core, *sink_name ? sink_name : NULL, PA_NAMEREG_SINK, 1); + sink = pa_namereg_get(c->protocol->core, sink_name, PA_NAMEREG_SINK, 1); if (!sink) { pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY); @@ -954,7 +1070,7 @@ static void command_remove_sample(struct pa_pdispatch *pd, uint32_t command, uin const char *name; assert(c && t); - if (pa_tagstruct_gets(t, &name) < 0 || + if (pa_tagstruct_gets(t, &name) < 0 || !name || !pa_tagstruct_eof(t)) { protocol_error(c); return; @@ -977,24 +1093,25 @@ static void sink_fill_tagstruct(struct pa_tagstruct *t, struct pa_sink *sink) { assert(t && sink); pa_tagstruct_putu32(t, sink->index); pa_tagstruct_puts(t, sink->name); - pa_tagstruct_puts(t, sink->description ? sink->description : ""); + pa_tagstruct_puts(t, sink->description); pa_tagstruct_put_sample_spec(t, &sink->sample_spec); pa_tagstruct_putu32(t, sink->owner ? sink->owner->index : (uint32_t) -1); pa_tagstruct_putu32(t, sink->volume); pa_tagstruct_putu32(t, sink->monitor_source->index); pa_tagstruct_puts(t, sink->monitor_source->name); - pa_tagstruct_putu32(t, pa_sink_get_latency(sink)); + pa_tagstruct_put_usec(t, pa_sink_get_latency(sink)); } static void source_fill_tagstruct(struct pa_tagstruct *t, struct pa_source *source) { assert(t && source); pa_tagstruct_putu32(t, source->index); pa_tagstruct_puts(t, source->name); - pa_tagstruct_puts(t, source->description ? source->description : ""); + pa_tagstruct_puts(t, source->description); pa_tagstruct_put_sample_spec(t, &source->sample_spec); pa_tagstruct_putu32(t, source->owner ? source->owner->index : (uint32_t) -1); pa_tagstruct_putu32(t, source->monitor_of ? source->monitor_of->index : (uint32_t) -1); - pa_tagstruct_puts(t, source->monitor_of ? source->monitor_of->name : ""); + pa_tagstruct_puts(t, source->monitor_of ? source->monitor_of->name : NULL); + pa_tagstruct_put_usec(t, pa_source_get_latency(source)); } static void client_fill_tagstruct(struct pa_tagstruct *t, struct pa_client *client) { @@ -1009,32 +1126,34 @@ static void module_fill_tagstruct(struct pa_tagstruct *t, struct pa_module *modu assert(t && module); pa_tagstruct_putu32(t, module->index); pa_tagstruct_puts(t, module->name); - pa_tagstruct_puts(t, module->argument ? module->argument : ""); + pa_tagstruct_puts(t, module->argument); pa_tagstruct_putu32(t, module->n_used); - pa_tagstruct_putu32(t, module->auto_unload); + pa_tagstruct_put_boolean(t, module->auto_unload); } static void sink_input_fill_tagstruct(struct pa_tagstruct *t, struct pa_sink_input *s) { assert(t && s); pa_tagstruct_putu32(t, s->index); - pa_tagstruct_puts(t, s->name ? s->name : ""); + pa_tagstruct_puts(t, s->name); pa_tagstruct_putu32(t, s->owner ? s->owner->index : (uint32_t) -1); pa_tagstruct_putu32(t, s->client ? s->client->index : (uint32_t) -1); pa_tagstruct_putu32(t, s->sink->index); pa_tagstruct_put_sample_spec(t, &s->sample_spec); pa_tagstruct_putu32(t, s->volume); - pa_tagstruct_putu32(t, pa_sink_input_get_latency(s)); - pa_tagstruct_putu32(t, pa_sink_get_latency(s->sink)); + pa_tagstruct_put_usec(t, pa_sink_input_get_latency(s)); + pa_tagstruct_put_usec(t, pa_sink_get_latency(s->sink)); } static void source_output_fill_tagstruct(struct pa_tagstruct *t, struct pa_source_output *s) { assert(t && s); pa_tagstruct_putu32(t, s->index); - pa_tagstruct_puts(t, s->name ? s->name : ""); + pa_tagstruct_puts(t, s->name); pa_tagstruct_putu32(t, s->owner ? s->owner->index : (uint32_t) -1); pa_tagstruct_putu32(t, s->client ? s->client->index : (uint32_t) -1); pa_tagstruct_putu32(t, s->source->index); pa_tagstruct_put_sample_spec(t, &s->sample_spec); + pa_tagstruct_put_usec(t, pa_source_output_get_latency(s)); + pa_tagstruct_put_usec(t, pa_source_get_latency(s->source)); } static void scache_fill_tagstruct(struct pa_tagstruct *t, struct pa_scache_entry *e) { @@ -1042,8 +1161,11 @@ static void scache_fill_tagstruct(struct pa_tagstruct *t, struct pa_scache_entry pa_tagstruct_putu32(t, e->index); pa_tagstruct_puts(t, e->name); pa_tagstruct_putu32(t, e->volume); - pa_tagstruct_putu32(t, pa_bytes_to_usec(e->memchunk.length, &e->sample_spec)); + pa_tagstruct_put_usec(t, pa_bytes_to_usec(e->memchunk.length, &e->sample_spec)); pa_tagstruct_put_sample_spec(t, &e->sample_spec); + pa_tagstruct_putu32(t, e->memchunk.length); + pa_tagstruct_put_boolean(t, e->lazy); + pa_tagstruct_puts(t, e->filename); } static void command_get_info(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) { @@ -1081,12 +1203,12 @@ static void command_get_info(struct pa_pdispatch *pd, uint32_t command, uint32_t if (index != (uint32_t) -1) sink = pa_idxset_get_by_index(c->protocol->core->sinks, index); else - sink = pa_namereg_get(c->protocol->core, *name ? name : NULL, PA_NAMEREG_SINK, 1); + sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK, 1); } else if (command == PA_COMMAND_GET_SOURCE_INFO) { if (index != (uint32_t) -1) source = pa_idxset_get_by_index(c->protocol->core->sources, index); else - source = pa_namereg_get(c->protocol->core, *name ? name : NULL, PA_NAMEREG_SOURCE, 1); + source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE, 1); } else if (command == PA_COMMAND_GET_CLIENT_INFO) client = pa_idxset_get_by_index(c->protocol->core->clients, index); else if (command == PA_COMMAND_GET_MODULE_INFO) @@ -1096,7 +1218,7 @@ static void command_get_info(struct pa_pdispatch *pd, uint32_t command, uint32_t else if (command == PA_COMMAND_GET_SOURCE_OUTPUT_INFO) so = pa_idxset_get_by_index(c->protocol->core->source_outputs, index); else { - assert(command == PA_COMMAND_GET_SAMPLE_INFO && name); + assert(command == PA_COMMAND_GET_SAMPLE_INFO); if (index != (uint32_t) -1) sce = pa_idxset_get_by_index(c->protocol->core->scache, index); else @@ -1197,6 +1319,7 @@ static void command_get_server_info(struct pa_pdispatch *pd, uint32_t command, u struct connection *c = userdata; struct pa_tagstruct *reply; char txt[256]; + const char *n; assert(c && t); if (!pa_tagstruct_eof(t)) { @@ -1218,6 +1341,11 @@ static void command_get_server_info(struct pa_pdispatch *pd, uint32_t command, u pa_tagstruct_puts(reply, pa_get_user_name(txt, sizeof(txt))); pa_tagstruct_puts(reply, pa_get_host_name(txt, sizeof(txt))); pa_tagstruct_put_sample_spec(reply, &c->protocol->core->default_sample_spec); + + n = pa_namereg_get_default_sink_name(c->protocol->core); + pa_tagstruct_puts(reply, n); + n = pa_namereg_get_default_source_name(c->protocol->core); + pa_tagstruct_puts(reply, n); pa_pstream_send_tagstruct(c->pstream, reply); } @@ -1288,7 +1416,7 @@ static void command_set_volume(struct pa_pdispatch *pd, uint32_t command, uint32 if (index != (uint32_t) -1) sink = pa_idxset_get_by_index(c->protocol->core->sinks, index); else - sink = pa_namereg_get(c->protocol->core, *name ? name : NULL, PA_NAMEREG_SINK, 1); + sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK, 1); } else { assert(command == PA_COMMAND_SET_SINK_INPUT_VOLUME); si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, index); @@ -1310,12 +1438,12 @@ static void command_set_volume(struct pa_pdispatch *pd, uint32_t command, uint32 static void command_cork_playback_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) { struct connection *c = userdata; uint32_t index; - uint32_t b; + int b; struct playback_stream *s; assert(c && t); if (pa_tagstruct_getu32(t, &index) < 0 || - pa_tagstruct_getu32(t, &b) < 0 || + pa_tagstruct_get_boolean(t, &b) < 0 || !pa_tagstruct_eof(t)) { protocol_error(c); return; @@ -1357,12 +1485,14 @@ static void command_flush_or_trigger_playback_stream(struct pa_pdispatch *pd, ui return; } - if (command == PA_COMMAND_TRIGGER_PLAYBACK_STREAM) + if (command == PA_COMMAND_PREBUF_PLAYBACK_STREAM) + pa_memblockq_prebuf_reenable(s->memblockq); + else if (command == PA_COMMAND_TRIGGER_PLAYBACK_STREAM) pa_memblockq_prebuf_disable(s->memblockq); else { assert(command == PA_COMMAND_FLUSH_PLAYBACK_STREAM); pa_memblockq_flush(s->memblockq); - /*fprintf(stderr, "flush: %u\n", pa_memblockq_get_length(s->memblockq));*/ + /*pa_log(__FILE__": flush: %u\n", pa_memblockq_get_length(s->memblockq));*/ } pa_sink_notify(s->sink_input->sink); @@ -1370,6 +1500,356 @@ static void command_flush_or_trigger_playback_stream(struct pa_pdispatch *pd, ui request_bytes(s); } +static void command_cork_record_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) { + struct connection *c = userdata; + uint32_t index; + struct record_stream *s; + int b; + assert(c && t); + + if (pa_tagstruct_getu32(t, &index) < 0 || + pa_tagstruct_get_boolean(t, &b) < 0 || + !pa_tagstruct_eof(t)) { + protocol_error(c); + return; + } + + if (!c->authorized) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_ACCESS); + return; + } + + if (!(s = pa_idxset_get_by_index(c->record_streams, index))) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY); + return; + } + + pa_source_output_cork(s->source_output, b); + pa_pstream_send_simple_ack(c->pstream, tag); +} + +static void command_flush_record_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) { + struct connection *c = userdata; + uint32_t index; + struct record_stream *s; + assert(c && t); + + if (pa_tagstruct_getu32(t, &index) < 0 || + !pa_tagstruct_eof(t)) { + protocol_error(c); + return; + } + + if (!c->authorized) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_ACCESS); + return; + } + + if (!(s = pa_idxset_get_by_index(c->record_streams, index))) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY); + return; + } + + pa_memblockq_flush(s->memblockq); + pa_pstream_send_simple_ack(c->pstream, tag); +} + +static void command_set_default_sink_or_source(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) { + struct connection *c = userdata; + uint32_t index; + const char *s; + assert(c && t); + + if (pa_tagstruct_getu32(t, &index) < 0 || + pa_tagstruct_gets(t, &s) < 0 || !s || + !pa_tagstruct_eof(t)) { + protocol_error(c); + return; + } + + if (!c->authorized) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_ACCESS); + return; + } + + pa_namereg_set_default(c->protocol->core, s, command == PA_COMMAND_SET_DEFAULT_SOURCE ? PA_NAMEREG_SOURCE : PA_NAMEREG_SINK); + pa_pstream_send_simple_ack(c->pstream, tag); +} + +static void command_set_stream_name(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) { + struct connection *c = userdata; + uint32_t index; + const char *name; + assert(c && t); + + if (pa_tagstruct_getu32(t, &index) < 0 || + pa_tagstruct_gets(t, &name) < 0 || !name || + !pa_tagstruct_eof(t)) { + protocol_error(c); + return; + } + + if (!c->authorized) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_ACCESS); + return; + } + + if (command == PA_COMMAND_SET_PLAYBACK_STREAM_NAME) { + struct playback_stream *s; + + if (!(s = pa_idxset_get_by_index(c->output_streams, index)) || s->type != PLAYBACK_STREAM) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY); + return; + } + + pa_sink_input_set_name(s->sink_input, name); + + } else { + struct record_stream *s; + + if (!(s = pa_idxset_get_by_index(c->record_streams, index))) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY); + return; + } + + pa_source_output_set_name(s->source_output, name); + } + + pa_pstream_send_simple_ack(c->pstream, tag); +} + +static void command_kill(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) { + struct connection *c = userdata; + uint32_t index; + assert(c && t); + + if (pa_tagstruct_getu32(t, &index) < 0 || + !pa_tagstruct_eof(t)) { + protocol_error(c); + return; + } + + if (!c->authorized) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_ACCESS); + return; + } + + if (command == PA_COMMAND_KILL_CLIENT) { + struct pa_client *client; + + if (!(client = pa_idxset_get_by_index(c->protocol->core->clients, index))) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY); + return; + } + + pa_client_kill(client); + } else if (command == PA_COMMAND_KILL_SINK_INPUT) { + struct pa_sink_input *s; + + if (!(s = pa_idxset_get_by_index(c->protocol->core->sink_inputs, index))) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY); + return; + } + + pa_sink_input_kill(s); + } else { + struct pa_source_output *s; + + assert(command == PA_COMMAND_KILL_SOURCE_OUTPUT); + + if (!(s = pa_idxset_get_by_index(c->protocol->core->source_outputs, index))) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY); + return; + } + + pa_source_output_kill(s); + } + + pa_pstream_send_simple_ack(c->pstream, tag); +} + +static void command_load_module(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) { + struct connection *c = userdata; + struct pa_module *m; + const char *name, *argument; + struct pa_tagstruct *reply; + assert(c && t); + + if (pa_tagstruct_gets(t, &name) < 0 || !name || + pa_tagstruct_gets(t, &argument) < 0 || + !pa_tagstruct_eof(t)) { + protocol_error(c); + return; + } + + if (!c->authorized) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_ACCESS); + return; + } + + if (!(m = pa_module_load(c->protocol->core, name, argument))) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_INITFAILED); + return; + } + + reply = pa_tagstruct_new(NULL, 0); + pa_tagstruct_putu32(reply, PA_COMMAND_REPLY); + pa_tagstruct_putu32(reply, tag); + pa_tagstruct_putu32(reply, m->index); + pa_pstream_send_tagstruct(c->pstream, reply); +} + +static void command_unload_module(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) { + struct connection *c = userdata; + uint32_t index; + struct pa_module *m; + assert(c && t); + + if (pa_tagstruct_getu32(t, &index) < 0 || + !pa_tagstruct_eof(t)) { + protocol_error(c); + return; + } + + if (!c->authorized) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_ACCESS); + return; + } + + if (!(m = pa_idxset_get_by_index(c->protocol->core->modules, index))) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY); + return; + } + + pa_module_unload_request(m); + pa_pstream_send_simple_ack(c->pstream, tag); +} + +static void command_add_autoload(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) { + struct connection *c = userdata; + const char *name, *module, *argument; + uint32_t type; + assert(c && t); + + if (pa_tagstruct_gets(t, &name) < 0 || !name || + pa_tagstruct_getu32(t, &type) < 0 || type > 1 || + pa_tagstruct_gets(t, &module) < 0 || !module || + pa_tagstruct_gets(t, &argument) < 0 || + !pa_tagstruct_eof(t)) { + protocol_error(c); + return; + } + + if (!c->authorized) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_ACCESS); + return; + } + + if (pa_autoload_add(c->protocol->core, name, type == 0 ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE, module, argument) < 0) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_EXIST); + return; + } + + pa_pstream_send_simple_ack(c->pstream, tag); +} + +static void command_remove_autoload(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) { + struct connection *c = userdata; + const char *name; + uint32_t type; + assert(c && t); + + if (pa_tagstruct_gets(t, &name) < 0 || !name || + pa_tagstruct_getu32(t, &type) < 0 || type > 1 || + !pa_tagstruct_eof(t)) { + protocol_error(c); + return; + } + + if (!c->authorized) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_ACCESS); + return; + } + + if (pa_autoload_remove(c->protocol->core, name, type == 0 ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE) < 0) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY); + return; + } + + pa_pstream_send_simple_ack(c->pstream, tag); +} + +static void autoload_fill_tagstruct(struct pa_tagstruct *t, struct pa_autoload_entry *e) { + assert(t && e); + pa_tagstruct_puts(t, e->name); + pa_tagstruct_putu32(t, e->type == PA_NAMEREG_SINK ? 0 : 1); + pa_tagstruct_puts(t, e->module); + pa_tagstruct_puts(t, e->argument); +} + +static void command_get_autoload_info(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) { + struct connection *c = userdata; + struct pa_autoload_entry *a = NULL; + uint32_t type; + const char *name; + struct pa_tagstruct *reply; + assert(c && t); + + if (pa_tagstruct_gets(t, &name) < 0 || name || + pa_tagstruct_getu32(t, &type) < 0 || type > 1 || + !pa_tagstruct_eof(t)) { + protocol_error(c); + return; + } + + if (!c->authorized) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_ACCESS); + return; + } + + if (!c->protocol->core->autoload_hashmap || !(a = pa_hashmap_get(c->protocol->core->autoload_hashmap, name)) || (a->type == PA_NAMEREG_SINK && type != 0) || (a->type == PA_NAMEREG_SOURCE && type != 1)) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY); + return; + } + + reply = pa_tagstruct_new(NULL, 0); + assert(reply); + pa_tagstruct_putu32(reply, PA_COMMAND_REPLY); + pa_tagstruct_putu32(reply, tag); + autoload_fill_tagstruct(reply, a); + pa_pstream_send_tagstruct(c->pstream, reply); +} + +static void command_get_autoload_info_list(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) { + struct connection *c = userdata; + struct pa_tagstruct *reply; + assert(c && t); + + if (!pa_tagstruct_eof(t)) { + protocol_error(c); + return; + } + + if (!c->authorized) { + pa_pstream_send_error(c->pstream, tag, PA_ERROR_ACCESS); + return; + } + + reply = pa_tagstruct_new(NULL, 0); + pa_tagstruct_putu32(reply, PA_COMMAND_REPLY); + pa_tagstruct_putu32(reply, tag); + + if (c->protocol->core->autoload_hashmap) { + struct pa_autoload_entry *a; + void *state = NULL; + + while ((a = pa_hashmap_iterate(c->protocol->core->autoload_hashmap, &state))) + autoload_fill_tagstruct(reply, a); + } + + pa_pstream_send_tagstruct(c->pstream, reply); +} + /*** pstream callbacks ***/ static void pstream_packet_callback(struct pa_pstream *p, struct pa_packet *packet, void *userdata) { @@ -1377,7 +1857,7 @@ static void pstream_packet_callback(struct pa_pstream *p, struct pa_packet *pack assert(p && packet && packet->data && c); if (pa_pdispatch_run(c->pdispatch, packet, c) < 0) { - fprintf(stderr, "protocol-native: invalid packet.\n"); + pa_log(__FILE__": invalid packet.\n"); connection_free(c); } } @@ -1386,9 +1866,9 @@ static void pstream_memblock_callback(struct pa_pstream *p, uint32_t channel, ui struct connection *c = userdata; struct output_stream *stream; assert(p && chunk && userdata); - + if (!(stream = pa_idxset_get_by_index(c->output_streams, channel))) { - fprintf(stderr, "protocol-native: client sent block for invalid stream.\n"); + pa_log(__FILE__": client sent block for invalid stream.\n"); connection_free(c); return; } @@ -1402,10 +1882,10 @@ static void pstream_memblock_callback(struct pa_pstream *p, uint32_t channel, ui pa_memblockq_push_align(p->memblockq, chunk, delta); assert(p->sink_input); - /*fprintf(stderr, "after_recv: %u\n", pa_memblockq_get_length(p->memblockq));*/ +/* pa_log(__FILE__": after_recv: %u\n", pa_memblockq_get_length(p->memblockq)); */ pa_sink_notify(p->sink_input->sink); - /*fprintf(stderr, "Recieved %u bytes.\n", chunk->length);*/ +/* pa_log(__FILE__": Recieved %u bytes.\n", chunk->length); */ } else { struct upload_stream *u = (struct upload_stream*) stream; @@ -1443,7 +1923,7 @@ static void pstream_die_callback(struct pa_pstream *p, void *userdata) { assert(p && c); connection_free(c); -/* fprintf(stderr, "protocol-native: connection died.\n");*/ +/* pa_log(__FILE__": connection died.\n");*/ } @@ -1466,10 +1946,11 @@ static void client_kill_cb(struct pa_client *c) { static void on_connection(struct pa_socket_server*s, struct pa_iochannel *io, void *userdata) { struct pa_protocol_native *p = userdata; struct connection *c; - assert(s && io && p); + assert(io && p); c = pa_xmalloc(sizeof(struct connection)); - c->authorized = p->public; + + c->authorized =!! p->public; c->protocol = p; assert(p->core); c->client = pa_client_new(p->core, "NATIVE", "Client"); @@ -1501,13 +1982,13 @@ static void on_connection(struct pa_socket_server*s, struct pa_iochannel *io, vo /*** module entry points ***/ -struct pa_protocol_native* pa_protocol_native_new(struct pa_core *core, struct pa_socket_server *server, struct pa_module *m, struct pa_modargs *ma) { +static struct pa_protocol_native* protocol_new_internal(struct pa_core *c, struct pa_module *m, struct pa_modargs *ma) { struct pa_protocol_native *p; - uint32_t public; - assert(core && server && ma); + int public = 0; + assert(c && ma); - if (pa_modargs_get_value_u32(ma, "public", &public) < 0) { - fprintf(stderr, __FILE__": public= expects numeric argument.\n"); + if (pa_modargs_get_value_boolean(ma, "public", &public) < 0) { + pa_log(__FILE__": public= expects a boolean argument.\n"); return NULL; } @@ -1520,11 +2001,21 @@ struct pa_protocol_native* pa_protocol_native_new(struct pa_core *core, struct p p->module = m; p->public = public; - p->server = server; - p->core = core; + p->server = NULL; + p->core = c; p->connections = pa_idxset_new(NULL, NULL); assert(p->connections); + return p; +} + +struct pa_protocol_native* pa_protocol_native_new(struct pa_core *core, struct pa_socket_server *server, struct pa_module *m, struct pa_modargs *ma) { + struct pa_protocol_native *p; + + if (!(p = protocol_new_internal(core, m, ma))) + return NULL; + + p->server = server; pa_socket_server_set_callback(p->server, on_connection, p); return p; @@ -1537,6 +2028,20 @@ void pa_protocol_native_free(struct pa_protocol_native *p) { while ((c = pa_idxset_first(p->connections, NULL))) connection_free(c); pa_idxset_free(p->connections, NULL, NULL); - pa_socket_server_unref(p->server); + + if (p->server) + pa_socket_server_unref(p->server); + pa_xfree(p); } + +struct pa_protocol_native* pa_protocol_native_new_iochannel(struct pa_core*core, struct pa_iochannel *io, struct pa_module *m, struct pa_modargs *ma) { + struct pa_protocol_native *p; + + if (!(p = protocol_new_internal(core, m, ma))) + return NULL; + + on_connection(NULL, io, p); + + return p; +}