/***
This file is part of PulseAudio.
-
+
+ Copyright 2004-2006 Lennart Poettering
+ Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
+
PulseAudio is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
-
+
PulseAudio is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
-
+
You should have received a copy of the GNU Lesser General Public License
along with PulseAudio; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
#include <pulsecore/log.h>
#include <pulsecore/core-util.h>
#include <pulsecore/core-error.h>
+#include <pulsecore/ipacl.h>
#include "endianmacros.h"
pa_defer_event *defer_event;
char *original_name;
-
+
struct {
pa_memblock *current_memblock;
size_t memblock_index, fragment_size;
char *sink_name, *source_name;
unsigned n_player;
uint8_t esd_key[ESD_KEY_LEN];
+ pa_ip_acl *auth_ip_acl;
};
typedef struct proto_handler {
{ 3 * sizeof(int), esd_proto_stream_pan, "stream pan"},
{ 3 * sizeof(int), NULL, "sample pan" },
-
+
{ sizeof(int), NULL, "standby mode" },
{ 0, esd_proto_get_latency, "get latency" }
};
if (c->state == ESD_STREAMING_DATA)
c->protocol->n_player--;
-
+
pa_client_free(c->client);
if (c->sink_input) {
pa_sink_input_disconnect(c->sink_input);
pa_sink_input_unref(c->sink_input);
}
-
+
if (c->source_output) {
pa_source_output_disconnect(c->source_output);
pa_source_output_unref(c->source_output);
}
-
+
if (c->input_memblockq)
pa_memblockq_free(c->input_memblockq);
if (c->output_memblockq)
if (c->playback.current_memblock)
pa_memblock_unref(c->playback.current_memblock);
-
+
pa_xfree(c->read_data);
pa_xfree(c->write_data);
if (c->io)
pa_iochannel_free(c->io);
-
+
if (c->defer_event)
c->protocol->core->mainloop->defer_free(c->defer_event);
i = c->write_data_length;
c->write_data_length += length;
-
+
memcpy((char*)c->write_data + i, data, length);
}
static int format_native2esd(pa_sample_spec *ss) {
int format = 0;
-
+
format = (ss->format == PA_SAMPLE_U8) ? ESD_BITS8 : ESD_BITS16;
format |= (ss->channels >= 2) ? ESD_STEREO : ESD_MONO;
return format;
}
-#define CHECK_VALIDITY(expression, string) do { \
+#define CHECK_VALIDITY(expression, ...) do { \
if (!(expression)) { \
- pa_log_warn(__FILE__ ": " string); \
+ pa_log_warn(__FILE__ ": " __VA_ARGS__); \
return -1; \
} \
} while(0);
if (!c->authorized) {
if (memcmp(data, c->protocol->esd_key, ESD_KEY_LEN) != 0) {
- pa_log(__FILE__": kicked client with invalid authorization key.");
+ pa_log("kicked client with invalid authorization key.");
return -1;
}
else if (ekey == ESD_SWAP_ENDIAN_KEY)
c->swap_byte_order = 1;
else {
- pa_log(__FILE__": client sent invalid endian key");
+ pa_log("client sent invalid endian key");
return -1;
}
static int esd_proto_stream_play(struct connection *c, PA_GCC_UNUSED esd_proto_t request, const void *data, size_t length) {
char name[ESD_NAME_MAX], *utf8_name;
int32_t format, rate;
- pa_sink *sink;
pa_sample_spec ss;
size_t l;
+ pa_sink *sink = NULL;
+ pa_sink_input_new_data sdata;
assert(c && length == (sizeof(int32_t)*2+ESD_NAME_MAX));
-
+
memcpy(&format, data, sizeof(int32_t));
format = MAYBE_INT32_SWAP(c->swap_byte_order, format);
data = (const char*)data + sizeof(int32_t);
format_esd2native(format, c->swap_byte_order, &ss);
CHECK_VALIDITY(pa_sample_spec_valid(&ss), "Invalid sample specification");
- sink = pa_namereg_get(c->protocol->core, c->protocol->sink_name, PA_NAMEREG_SINK, 1);
- CHECK_VALIDITY(sink, "No such sink");
+
+ if (c->protocol->sink_name) {
+ sink = pa_namereg_get(c->protocol->core, c->protocol->sink_name, PA_NAMEREG_SINK, 1);
+ CHECK_VALIDITY(sink, "No such sink: %s", c->protocol->sink_name);
+ }
strncpy(name, data, sizeof(name));
name[sizeof(name)-1] = 0;
+
utf8_name = pa_utf8_filter(name);
-
pa_client_set_name(c->client, utf8_name);
+ pa_xfree(utf8_name);
+
c->original_name = pa_xstrdup(name);
assert(!c->sink_input && !c->input_memblockq);
- c->sink_input = pa_sink_input_new(sink, __FILE__, utf8_name, &ss, NULL, NULL, 0, -1);
-
- pa_xfree(utf8_name);
+ pa_sink_input_new_data_init(&sdata);
+ sdata.sink = sink;
+ sdata.driver = __FILE__;
+ sdata.name = c->client->name;
+ pa_sink_input_new_data_set_sample_spec(&sdata, &ss);
+ sdata.module = c->protocol->module;
+ sdata.client = c->client;
+ c->sink_input = pa_sink_input_new(c->protocol->core, &sdata, 0);
CHECK_VALIDITY(c->sink_input, "Failed to create sink input.");
- l = (size_t) (pa_bytes_per_second(&ss)*PLAYBACK_BUFFER_SECONDS);
+ l = (size_t) (pa_bytes_per_second(&ss)*PLAYBACK_BUFFER_SECONDS);
c->input_memblockq = pa_memblockq_new(
0,
l,
pa_frame_size(&ss),
(size_t) -1,
l/PLAYBACK_BUFFER_FRAGMENTS,
- NULL,
- c->protocol->core->memblock_stat);
+ NULL);
pa_iochannel_socket_set_rcvbuf(c->io, l/PLAYBACK_BUFFER_FRAGMENTS*2);
c->playback.fragment_size = l/10;
- c->sink_input->owner = c->protocol->module;
- c->sink_input->client = c->client;
c->sink_input->peek = sink_input_peek_cb;
c->sink_input->drop = sink_input_drop_cb;
c->sink_input->kill = sink_input_kill_cb;
c->state = ESD_STREAMING_DATA;
c->protocol->n_player++;
-
+
return 0;
}
static int esd_proto_stream_record(struct connection *c, esd_proto_t request, const void *data, size_t length) {
char name[ESD_NAME_MAX], *utf8_name;
int32_t format, rate;
- pa_source *source;
+ pa_source *source = NULL;
pa_sample_spec ss;
size_t l;
+ pa_source_output_new_data sdata;
assert(c && length == (sizeof(int32_t)*2+ESD_NAME_MAX));
-
+
memcpy(&format, data, sizeof(int32_t));
format = MAYBE_INT32_SWAP(c->swap_byte_order, format);
data = (const char*)data + sizeof(int32_t);
pa_sink* sink;
if (!(sink = pa_namereg_get(c->protocol->core, c->protocol->sink_name, PA_NAMEREG_SINK, 1))) {
- pa_log(__FILE__": no such sink.");
+ pa_log("no such sink.");
return -1;
}
if (!(source = sink->monitor_source)) {
- pa_log(__FILE__": no such monitor source.");
+ pa_log("no such monitor source.");
return -1;
}
} else {
assert(request == ESD_PROTO_STREAM_REC);
-
- if (!(source = pa_namereg_get(c->protocol->core, c->protocol->source_name, PA_NAMEREG_SOURCE, 1))) {
- pa_log(__FILE__": no such source.");
- return -1;
+
+ if (c->protocol->source_name) {
+ if (!(source = pa_namereg_get(c->protocol->core, c->protocol->source_name, PA_NAMEREG_SOURCE, 1))) {
+ pa_log("no such source.");
+ return -1;
+ }
}
}
-
+
strncpy(name, data, sizeof(name));
name[sizeof(name)-1] = 0;
utf8_name = pa_utf8_filter(name);
pa_client_set_name(c->client, utf8_name);
pa_xfree(utf8_name);
-
+
c->original_name = pa_xstrdup(name);
assert(!c->output_memblockq && !c->source_output);
- if (!(c->source_output = pa_source_output_new(source, __FILE__, c->client->name, &ss, NULL, -1))) {
- pa_log(__FILE__": failed to create source output");
- return -1;
- }
+ pa_source_output_new_data_init(&sdata);
+ sdata.source = source;
+ sdata.driver = __FILE__;
+ sdata.name = c->client->name;
+ pa_source_output_new_data_set_sample_spec(&sdata, &ss);
+ sdata.module = c->protocol->module;
+ sdata.client = c->client;
+
+ c->source_output = pa_source_output_new(c->protocol->core, &sdata, 9);
+ CHECK_VALIDITY(c->source_output, "Failed to create source_output.");
- l = (size_t) (pa_bytes_per_second(&ss)*RECORD_BUFFER_SECONDS);
+ l = (size_t) (pa_bytes_per_second(&ss)*RECORD_BUFFER_SECONDS);
c->output_memblockq = pa_memblockq_new(
0,
l,
pa_frame_size(&ss),
1,
0,
- NULL,
- c->protocol->core->memblock_stat);
+ NULL);
pa_iochannel_socket_set_sndbuf(c->io, l/RECORD_BUFFER_FRAGMENTS*2);
-
- c->source_output->owner = c->protocol->module;
- c->source_output->client = c->client;
+
c->source_output->push = source_output_push_cb;
c->source_output->kill = source_output_kill_cb;
c->source_output->get_latency = source_output_get_latency_cb;
c->state = ESD_STREAMING_DATA;
c->protocol->n_player++;
-
+
return 0;
}
double usec = pa_sink_get_latency(sink);
latency = (int) ((usec*44100)/1000000);
}
-
+
latency = MAYBE_INT32_SWAP(c->swap_byte_order, latency);
connection_write(c, &latency, sizeof(int32_t));
return 0;
char terminator[sizeof(int32_t)*6+ESD_NAME_MAX];
assert(c && data && length == sizeof(int32_t));
-
+
if (esd_proto_server_info(c, request, data, length) < 0)
return -1;
continue;
assert(t >= k*2+s);
-
+
if (conn->sink_input) {
pa_cvolume volume = *pa_sink_input_get_volume(conn->sink_input);
rate = conn->sink_input->sample_spec.rate;
rvolume = (volume.values[1]*ESD_VOLUME_BASE)/PA_VOLUME_NORM;
format = format_native2esd(&conn->sink_input->sample_spec);
}
-
+
/* id */
id = MAYBE_INT32_SWAP(c->swap_byte_order, (int32_t) (conn->index+1));
connection_write(c, &id, sizeof(int32_t));
if (nsamples) {
pa_scache_entry *ce;
-
+
idx = PA_IDXSET_INVALID;
for (ce = pa_idxset_first(c->protocol->core->scache, &idx); ce; ce = pa_idxset_next(c->protocol->core->scache, &idx)) {
int32_t id, rate, lvolume, rvolume, format, len;
/* id */
id = MAYBE_INT32_SWAP(c->swap_byte_order, (int) (ce->index+1));
connection_write(c, &id, sizeof(int32_t));
-
+
/* name */
memset(name, 0, ESD_NAME_MAX); /* don't leak old data */
if (strncmp(ce->name, SCACHE_PREFIX, sizeof(SCACHE_PREFIX)-1) == 0)
else
snprintf(name, ESD_NAME_MAX, "native.%s", ce->name);
connection_write(c, name, ESD_NAME_MAX);
-
+
/* rate */
rate = MAYBE_UINT32_SWAP(c->swap_byte_order, ce->sample_spec.rate);
connection_write(c, &rate, sizeof(int32_t));
-
+
/* left */
lvolume = MAYBE_UINT32_SWAP(c->swap_byte_order, (ce->volume.values[0]*ESD_VOLUME_BASE)/PA_VOLUME_NORM);
connection_write(c, &lvolume, sizeof(int32_t));
-
+
/*right*/
rvolume = MAYBE_UINT32_SWAP(c->swap_byte_order, (ce->volume.values[0]*ESD_VOLUME_BASE)/PA_VOLUME_NORM);
connection_write(c, &rvolume, sizeof(int32_t));
-
+
/*format*/
format = MAYBE_INT32_SWAP(c->swap_byte_order, format_native2esd(&ce->sample_spec));
connection_write(c, &format, sizeof(int32_t));
struct connection *conn;
assert(c && data && length == sizeof(int32_t)*3);
-
+
memcpy(&idx, data, sizeof(uint32_t));
idx = MAYBE_UINT32_SWAP(c->swap_byte_order, idx) - 1;
data = (const char*)data + sizeof(uint32_t);
ok = 0;
connection_write(c, &ok, sizeof(int32_t));
-
+
return 0;
}
memcpy(&rate, data, sizeof(int32_t));
rate = MAYBE_INT32_SWAP(c->swap_byte_order, rate);
data = (const char*)data + sizeof(int32_t);
-
+
ss.rate = rate;
format_esd2native(format, c->swap_byte_order, &ss);
sc_length = MAYBE_INT32_SWAP(c->swap_byte_order, sc_length);
data = (const char*)data + sizeof(int32_t);
- CHECK_VALIDITY(sc_length <= MAX_CACHE_SAMPLE_SIZE, "Sample too large.");
+ CHECK_VALIDITY(sc_length <= MAX_CACHE_SAMPLE_SIZE, "Sample too large (%d bytes).", (int)sc_length);
strcpy(name, SCACHE_PREFIX);
strncpy(name+sizeof(SCACHE_PREFIX)-1, data, ESD_NAME_MAX);
name[sizeof(name)-1] = 0;
CHECK_VALIDITY(pa_utf8_valid(name), "Invalid UTF8 in sample name.");
-
+
assert(!c->scache.memchunk.memblock);
- c->scache.memchunk.memblock = pa_memblock_new(sc_length, c->protocol->core->memblock_stat);
+ c->scache.memchunk.memblock = pa_memblock_new(c->protocol->core->mempool, sc_length);
c->scache.memchunk.index = 0;
c->scache.memchunk.length = sc_length;
c->scache.sample_spec = ss;
assert(!c->scache.name);
c->scache.name = pa_xstrdup(name);
-
+
c->state = ESD_CACHING_SAMPLE;
pa_scache_add_item(c->protocol->core, c->scache.name, NULL, NULL, NULL, &idx);
idx += 1;
connection_write(c, &idx, sizeof(uint32_t));
-
+
return 0;
}
idx = MAYBE_UINT32_SWAP(c->swap_byte_order, idx) - 1;
ok = 0;
-
+
if ((name = pa_scache_get_name_by_id(c->protocol->core, idx))) {
if (request == ESD_PROTO_SAMPLE_PLAY) {
pa_sink *sink;
-
+
if ((sink = pa_namereg_get(c->protocol->core, c->protocol->sink_name, PA_NAMEREG_SINK, 1)))
if (pa_scache_play_item(c->protocol->core, name, sink, PA_VOLUME_NORM) >= 0)
ok = idx + 1;
ok = idx + 1;
}
}
-
+
connection_write(c, &ok, sizeof(int32_t));
return 0;
assert(c && c->io);
/* pa_log("READ"); */
-
+
if (c->state == ESD_NEXT_REQUEST) {
ssize_t r;
assert(c->read_data_length < sizeof(c->request));
if ((r = pa_iochannel_read(c->io, ((uint8_t*) &c->request) + c->read_data_length, sizeof(c->request) - c->read_data_length)) <= 0) {
- pa_log_debug(__FILE__": read(): %s", r < 0 ? pa_cstrerror(errno) : "EOF");
+ pa_log_debug("read(): %s", r < 0 ? pa_cstrerror(errno) : "EOF");
return -1;
}
if ((c->read_data_length+= r) >= sizeof(c->request)) {
struct proto_handler *handler;
-
+
c->request = MAYBE_INT32_SWAP(c->swap_byte_order, c->request);
if (c->request < ESD_PROTO_CONNECT || c->request > ESD_PROTO_MAX) {
- pa_log(__FILE__": recieved invalid request.");
+ pa_log("recieved invalid request.");
return -1;
}
handler = proto_map+c->request;
-/* pa_log(__FILE__": executing request #%u", c->request); */
+/* pa_log("executing request #%u", c->request); */
if (!handler->proc) {
- pa_log(__FILE__": recieved unimplemented request #%u.", c->request);
+ pa_log("recieved unimplemented request #%u.", c->request);
return -1;
}
-
+
if (handler->data_length == 0) {
c->read_data_length = 0;
if (handler->proc(c, c->request, NULL, 0) < 0)
return -1;
-
+
} else {
if (c->read_data_alloc < handler->data_length)
c->read_data = pa_xrealloc(c->read_data, c->read_data_alloc = handler->data_length);
assert(c->read_data);
-
+
c->state = ESD_NEEDS_REQDATA;
c->read_data_length = 0;
}
struct proto_handler *handler = proto_map+c->request;
assert(handler->proc);
-
+
assert(c->read_data && c->read_data_length < handler->data_length);
if ((r = pa_iochannel_read(c->io, (uint8_t*) c->read_data + c->read_data_length, handler->data_length - c->read_data_length)) <= 0) {
- pa_log_debug(__FILE__": read(): %s", r < 0 ? pa_cstrerror(errno) : "EOF");
+ pa_log_debug("read(): %s", r < 0 ? pa_cstrerror(errno) : "EOF");
return -1;
}
c->state = ESD_NEXT_REQUEST;
c->read_data_length = 0;
-
+
if (handler->proc(c, c->request, c->read_data, l) < 0)
return -1;
}
} else if (c->state == ESD_CACHING_SAMPLE) {
ssize_t r;
+ void *p;
- assert(c->scache.memchunk.memblock && c->scache.name && c->scache.memchunk.index < c->scache.memchunk.length);
-
- if ((r = pa_iochannel_read(c->io, (uint8_t*) c->scache.memchunk.memblock->data+c->scache.memchunk.index, c->scache.memchunk.length-c->scache.memchunk.index)) <= 0) {
- pa_log_debug(__FILE__": read(): %s", r < 0 ? pa_cstrerror(errno) : "EOF");
+ assert(c->scache.memchunk.memblock);
+ assert(c->scache.name);
+ assert(c->scache.memchunk.index < c->scache.memchunk.length);
+
+ p = pa_memblock_acquire(c->scache.memchunk.memblock);
+
+ if ((r = pa_iochannel_read(c->io, (uint8_t*) p+c->scache.memchunk.index, c->scache.memchunk.length-c->scache.memchunk.index)) <= 0) {
+ pa_memblock_release(c->scache.memchunk.memblock);
+ pa_log_debug("read(): %s", r < 0 ? pa_cstrerror(errno) : "EOF");
return -1;
}
+ pa_memblock_release(c->scache.memchunk.memblock);
+
c->scache.memchunk.index += r;
assert(c->scache.memchunk.index <= c->scache.memchunk.length);
-
+
if (c->scache.memchunk.index == c->scache.memchunk.length) {
uint32_t idx;
-
+
c->scache.memchunk.index = 0;
pa_scache_add_item(c->protocol->core, c->scache.name, &c->scache.sample_spec, NULL, &c->scache.memchunk, &idx);
idx += 1;
connection_write(c, &idx, sizeof(uint32_t));
}
-
+
} else if (c->state == ESD_STREAMING_DATA && c->sink_input) {
pa_memchunk chunk;
ssize_t r;
size_t l;
+ void *p;
assert(c->input_memblockq);
if (l > c->playback.fragment_size)
l = c->playback.fragment_size;
- if (c->playback.current_memblock)
- if (c->playback.current_memblock->length - c->playback.memblock_index < l) {
+ if (c->playback.current_memblock)
+ if (pa_memblock_get_length(c->playback.current_memblock) - c->playback.memblock_index < l) {
pa_memblock_unref(c->playback.current_memblock);
c->playback.current_memblock = NULL;
c->playback.memblock_index = 0;
}
-
+
if (!c->playback.current_memblock) {
- c->playback.current_memblock = pa_memblock_new(c->playback.fragment_size*2, c->protocol->core->memblock_stat);
- assert(c->playback.current_memblock && c->playback.current_memblock->length >= l);
+ c->playback.current_memblock = pa_memblock_new(c->protocol->core->mempool, c->playback.fragment_size*2);
+ assert(c->playback.current_memblock);
+ assert(pa_memblock_get_length(c->playback.current_memblock) >= l);
c->playback.memblock_index = 0;
}
- if ((r = pa_iochannel_read(c->io, (uint8_t*) c->playback.current_memblock->data+c->playback.memblock_index, l)) <= 0) {
- pa_log_debug(__FILE__": read(): %s", r < 0 ? pa_cstrerror(errno) : "EOF");
+ p = pa_memblock_acquire(c->playback.current_memblock);
+
+ if ((r = pa_iochannel_read(c->io, (uint8_t*) p+c->playback.memblock_index, l)) <= 0) {
+ pa_memblock_release(c->playback.current_memblock);
+ pa_log_debug("read(): %s", r < 0 ? pa_cstrerror(errno) : "EOF");
return -1;
}
-
+ pa_memblock_release(c->playback.current_memblock);
+
chunk.memblock = c->playback.current_memblock;
chunk.index = c->playback.memblock_index;
chunk.length = r;
assert(chunk.memblock);
c->playback.memblock_index += r;
-
+
assert(c->input_memblockq);
pa_memblockq_push_align(c->input_memblockq, &chunk);
assert(c->sink_input);
pa_sink_notify(c->sink_input->sink);
}
-
+
return 0;
}
assert(c && c->io);
/* pa_log("WRITE"); */
-
+
if (c->write_data_length) {
ssize_t r;
-
+
assert(c->write_data_index < c->write_data_length);
if ((r = pa_iochannel_write(c->io, (uint8_t*) c->write_data+c->write_data_index, c->write_data_length-c->write_data_index)) < 0) {
- pa_log(__FILE__": write(): %s", pa_cstrerror(errno));
+ pa_log("write(): %s", pa_cstrerror(errno));
return -1;
}
-
+
if ((c->write_data_index +=r) >= c->write_data_length)
c->write_data_length = c->write_data_index = 0;
-
+
} else if (c->state == ESD_STREAMING_DATA && c->source_output) {
pa_memchunk chunk;
ssize_t r;
+ void *p;
assert(c->output_memblockq);
if (pa_memblockq_peek(c->output_memblockq, &chunk) < 0)
return 0;
-
- assert(chunk.memblock && chunk.length);
-
- if ((r = pa_iochannel_write(c->io, (uint8_t*) chunk.memblock->data+chunk.index, chunk.length)) < 0) {
+
+ assert(chunk.memblock);
+ assert(chunk.length);
+
+ p = pa_memblock_acquire(chunk.memblock);
+
+ if ((r = pa_iochannel_write(c->io, (uint8_t*) p+chunk.index, chunk.length)) < 0) {
+ pa_memblock_release(chunk.memblock);
pa_memblock_unref(chunk.memblock);
- pa_log(__FILE__": write(): %s", pa_cstrerror(errno));
+ pa_log("write(): %s", pa_cstrerror(errno));
return -1;
}
+ pa_memblock_release(chunk.memblock);
+
pa_memblockq_drop(c->output_memblockq, &chunk, r);
pa_memblock_unref(chunk.memblock);
pa_source_notify(c->source_output->source);
}
-
+
return 0;
}
if (pa_iochannel_is_writable(c->io))
if (do_write(c) < 0)
goto fail;
-
+
return;
fail:
assert(a && c && c->defer_event == e);
/* pa_log("DEFER"); */
-
+
do_work(c);
}
struct connection*c;
assert(i && i->userdata && chunk);
c = i->userdata;
-
+
if (pa_memblockq_peek(c->input_memblockq, chunk) < 0) {
if (c->dead)
connection_free(c);
-
+
return -1;
}
assert(i && c && length);
/* pa_log("DROP"); */
-
+
pa_memblockq_drop(c->input_memblockq, chunk, length);
/* do something */
assert(s && io && p);
if (pa_idxset_size(p->connections)+1 > MAX_CONNECTIONS) {
- pa_log(__FILE__": Warning! Too many connections (%u), dropping incoming connection.", MAX_CONNECTIONS);
+ pa_log("Warning! Too many connections (%u), dropping incoming connection.", MAX_CONNECTIONS);
pa_iochannel_free(io);
return;
}
-
+
c = pa_xnew(struct connection, 1);
c->protocol = p;
c->io = io;
c->client->owner = p->module;
c->client->kill = client_kill_cb;
c->client->userdata = c;
-
- c->authorized = p->public;
+
+ c->authorized = !!p->public;
c->swap_byte_order = 0;
c->dead = 0;
c->original_name = NULL;
+ if (!c->authorized && p->auth_ip_acl && pa_ip_acl_check(p->auth_ip_acl, pa_iochannel_get_recv_fd(io)) > 0) {
+ pa_log_info("Client authenticated by IP ACL.");
+ c->authorized = 1;
+ }
+
if (!c->authorized) {
struct timeval tv;
pa_gettimeofday(&tv);
c->auth_timeout_event = p->core->mainloop->time_new(p->core->mainloop, &tv, auth_timeout, c);
} else
c->auth_timeout_event = NULL;
-
+
c->defer_event = p->core->mainloop->defer_new(p->core->mainloop, defer_callback, c);
assert(c->defer_event);
p->core->mainloop->defer_enable(c->defer_event, 0);
pa_protocol_esound* pa_protocol_esound_new(pa_core*core, pa_socket_server *server, pa_module *m, pa_modargs *ma) {
pa_protocol_esound *p;
int public = 0;
- assert(core && server && ma);
+ const char *acl;
+
+ assert(core);
+ assert(server);
+ assert(m);
+ assert(ma);
p = pa_xnew(pa_protocol_esound, 1);
if (pa_modargs_get_value_boolean(ma, "auth-anonymous", &public) < 0) {
- pa_log(__FILE__": auth-anonymous= expects a boolean argument.");
- return NULL;
+ pa_log("auth-anonymous= expects a boolean argument.");
+ goto fail;
}
- if (pa_authkey_load_auto(pa_modargs_get_value(ma, "cookie", DEFAULT_COOKIE_FILE), p->esd_key, sizeof(p->esd_key)) < 0) {
- pa_xfree(p);
- return NULL;
- }
+ if (pa_authkey_load_auto(pa_modargs_get_value(ma, "cookie", DEFAULT_COOKIE_FILE), p->esd_key, sizeof(p->esd_key)) < 0)
+ goto fail;
+
+ if ((acl = pa_modargs_get_value(ma, "auth-ip-acl", NULL))) {
+
+ if (!(p->auth_ip_acl = pa_ip_acl_new(acl))) {
+ pa_log("Failed to parse IP ACL '%s'", acl);
+ goto fail;
+ }
+ } else
+ p->auth_ip_acl = NULL;
p->module = m;
p->public = public;
p->n_player = 0;
return p;
+
+fail:
+ pa_xfree(p);
+ return NULL;
}
void pa_protocol_esound_free(pa_protocol_esound *p) {
pa_idxset_free(p->connections, NULL, NULL);
pa_socket_server_unref(p->server);
+
+ if (p->auth_ip_acl)
+ pa_ip_acl_free(p->auth_ip_acl);
+
pa_xfree(p);
}