void stats_initialize(void)
{
if (_stats_running)
return;
/* set up global struct */
_stats.global_tree = avl_tree_new(_compare_stats, NULL);
_stats.source_tree = avl_tree_new(_compare_source_stats, NULL);
_stats.event_listeners = NULL;
thread_mutex_create (&_stats.listeners_lock);
_stats_running = 1;
stats_event_time (NULL, "server_start", STATS_GENERAL);
/* global currently active stats */
stats_event_flags (NULL, "clients", "0", STATS_COUNTERS|STATS_REGULAR);
stats_event_flags (NULL, "listeners", "0", STATS_COUNTERS|STATS_REGULAR);
stats_event_flags (NULL, "connections", "0", STATS_COUNTERS|STATS_REGULAR);
stats_event_flags (NULL, "sources", "0", STATS_COUNTERS|STATS_REGULAR);
stats_event_flags (NULL, "stats", "0", STATS_COUNTERS|STATS_REGULAR);
stats_event_flags (NULL, "banned_IPs", "0", STATS_COUNTERS|STATS_REGULAR);
#ifdef GIT_VERSION
stats_event (NULL, "build", GIT_VERSION);
#endif
/* global accumulating stats */
stats_event_flags (NULL, "client_connections", "0", STATS_COUNTERS|STATS_REGULAR);
stats_event_flags (NULL, "source_client_connections", "0", STATS_COUNTERS|STATS_REGULAR);
stats_event_flags (NULL, "source_relay_connections", "0", STATS_COUNTERS|STATS_REGULAR);
stats_event_flags (NULL, "source_total_connections", "0", STATS_COUNTERS|STATS_REGULAR);
stats_event_flags (NULL, "stats_connections", "0", STATS_COUNTERS|STATS_REGULAR);
stats_event_flags (NULL, "listener_connections", "0", STATS_COUNTERS|STATS_REGULAR);
stats_event_flags (NULL, "outgoing_kbitrate", "0", STATS_COUNTERS|STATS_REGULAR);
stats_event_flags (NULL, "stream_kbytes_sent", "0", STATS_COUNTERS|STATS_REGULAR);
stats_event_flags (NULL, "stream_kbytes_read", "0", STATS_COUNTERS|STATS_REGULAR);
}
int main(void)
{
int rv;
thread_mutex_t *thread_mutex = NULL;
thread_cond_t *thread_cond = NULL;
thread_mutex_create(&thread_mutex,THREAD_MUTEX_DEFAULT);
thread_cond_create(&thread_cond);
rv = thread_cond_signal(thread_cond);
rv = thread_mutex_lock(thread_mutex);
rv = thread_cond_timedwait(thread_cond, thread_mutex, 10000);
printf("rv:%d\n",rv);
rv = thread_mutex_unlock(thread_mutex);
rv = thread_cond_broadcast(thread_cond);
rv = thread_mutex_lock(thread_mutex);
rv = thread_cond_timedwait(thread_cond, thread_mutex, 10000);
rv = thread_mutex_unlock(thread_mutex);
thread_cond_destroy(thread_cond);
thread_mutex_destroy(thread_mutex);
return 0;
}
/* Returns the pipe handle, or 0 if error */
pipe_handle_t thread_pipe_create_to_file( const char *filename, int truncate )
{
int flags;
pipe_handle_t ph = 0;
tl_pipedata_t *pipedata;
pipedata = malloc( sizeof(tl_pipedata_t) );
memset( pipedata, 0, sizeof(tl_pipedata_t) );
pipedata->mutex = thread_mutex_create();
flags = truncate ? OPEN_CREATE_FLAGS : OPEN_WRITE_FLAGS;
pipedata->phandles[1] = open(filename, flags, OPEN_WRITE_PERMISSION );
if( pipedata->phandles[1] == -1 ) {
/* Error */
free( pipedata );
} else {
ph = (pipe_handle_t) pipedata;
}
return( ph );
}
/**
* Initialize the queue_t.
*/
int queue_create(queue_t **q,
unsigned int queue_capacity)
{
int rv;
queue_t *queue;
queue = (queue_t*)malloc(sizeof(queue_t));
*q = queue;
/* nested doesn't work ;( */
rv = thread_mutex_create(&queue->one_big_mutex,
THREAD_MUTEX_UNNESTED);
if (rv != 0) {
return rv;
}
rv = thread_cond_create(&queue->not_empty);
if (rv != 0) {
return rv;
}
rv = thread_cond_create(&queue->not_full);
if (rv != 0) {
return rv;
}
/* Set all the data in the queue to NULL */
queue->data = malloc(queue_capacity * sizeof(void*));
queue->bounds = queue_capacity;
queue->nelts = 0;
queue->in = 0;
queue->out = 0;
queue->terminated = 0;
queue->full_waiters = 0;
queue->empty_waiters = 0;
return 0;
}
/* find/create handle and return it with the structure in a locked state */
static fh_node *open_fh (fbinfo *finfo)
{
fh_node *fh, *result;
if (finfo->mount == NULL)
finfo->mount = "";
fh = calloc (1, sizeof (fh_node));
memcpy (&fh->finfo, finfo, sizeof (fbinfo));
if (avl_get_by_key (fh_cache, fh, (void**)&result) == 0)
{
free (fh);
thread_mutex_lock (&result->lock);
avl_tree_unlock (fh_cache);
if (finfo->flags & FS_FALLBACK)
{
if (result->finfo.type != finfo->type && finfo->type != FORMAT_TYPE_UNDEFINED)
{
WARN1 ("format mismatched for %s", finfo->mount);
thread_mutex_unlock (&result->lock);
return NULL;
}
result->expire = (time_t)-1;
}
return result;
}
// insert new one
if (fh->finfo.mount[0])
{
char *fullpath= util_get_path_from_normalised_uri (fh->finfo.mount, fh->finfo.flags&FS_USE_ADMIN);
char *contenttype = fserve_content_type (fullpath);
format_type_t type = format_get_type (contenttype);
if (fh->finfo.type == FORMAT_TYPE_UNDEFINED)
fh->finfo.type = type;
if (finfo->flags & FS_FALLBACK)
{
if (fh->finfo.type != type && type != FORMAT_TYPE_UNDEFINED && fh->finfo.type != FORMAT_TYPE_UNDEFINED)
{
avl_tree_unlock (fh_cache);
free (contenttype);
free (fullpath);
free (fh);
WARN1 ("format mismatched for %s", finfo->mount);
return NULL;
}
fh->expire = (time_t)-1;
INFO2 ("lookup of fallback file \"%s\" (%d)", finfo->mount, finfo->limit);
}
else
INFO1 ("lookup of \"%s\"", finfo->mount);
if (file_open (&fh->f, fullpath) < 0)
{
INFO1 ("Failed to open \"%s\"", fullpath);
avl_tree_unlock (fh_cache);
free (contenttype);
free (fullpath);
free (fh);
return NULL;
}
free (fullpath);
fh->format = calloc (1, sizeof (format_plugin_t));
fh->format->type = fh->finfo.type;
fh->format->contenttype = strdup (contenttype);
free (contenttype);
if (fh->finfo.type != FORMAT_TYPE_UNDEFINED)
{
fh->format->mount = strdup (fh->finfo.mount);
if (format_get_plugin (fh->format) < 0)
{
avl_tree_unlock (fh_cache);
file_close (&fh->f);
free (fh->format);
free (fh);
return NULL;
}
}
if (fh->finfo.limit)
fh->out_bitrate = rate_setup (10000, 1000);
}
fh->clients = avl_tree_new (client_compare, NULL);
thread_mutex_create (&fh->lock);
thread_mutex_lock (&fh->lock);
avl_insert (fh_cache, fh);
avl_tree_unlock (fh_cache);
fh->refcount = 0;
fh->peak = 0;
fh->finfo.mount = strdup (finfo->mount);
fh->finfo.fallback = NULL;
return fh;
}
void input_loop(void)
{
input_module_t *inmod=NULL;
instance_t *instance, *prev, *next;
queue_item *queued;
int shutdown = 0;
int current_module = 0;
int valid_stream = 1;
int inc_count;
int not_waiting_for_critical;
int foundmodule = 0;
thread_cond_create(&ices_config->queue_cond);
thread_cond_create(&ices_config->event_pending_cond);
thread_mutex_create(&ices_config->refcount_lock);
thread_mutex_create(&ices_config->flush_lock);
memset (&control, 0, sizeof (control));
while(ices_config->playlist_module && modules[current_module].open)
{
if(!strcmp(ices_config->playlist_module, modules[current_module].name))
{
foundmodule = 1;
inmod = modules[current_module].open(ices_config->module_params);
break;
}
current_module++;
}
if(!inmod)
{
if(foundmodule)
LOG_ERROR1("Couldn't initialise input module \"%s\"",
ices_config->playlist_module);
else
LOG_ERROR1("No input module named \"%s\" could be found",
ices_config->playlist_module);
return;
}
ices_config->inmod = inmod;
/* ok, basic config stuff done. Now, we want to start all our listening
* threads.
*/
instance = ices_config->instances;
while(instance)
{
stream_description *arg = calloc(1, sizeof(stream_description));
arg->stream = instance;
arg->input = inmod;
/*
if(instance->savefilename != NULL)
thread_create("savefile", savefile_stream, arg, 1);
*/
thread_create("stream", ices_instance_stream, arg, 1);
instance = instance->next;
}
/* treat as if a signal has arrived straight away */
signal_usr1_handler (0);
/* now we go into the main loop
* We shut down the main thread ONLY once all the instances
* have killed themselves.
*/
while(!shutdown)
{
ref_buffer *chunk = calloc(1, sizeof(ref_buffer));
buffer_queue *current;
int ret;
instance = ices_config->instances;
prev = NULL;
while(instance)
{
/* if an instance has died, get rid of it
** this should be replaced with something that tries to
** restart the instance, probably.
*/
if (instance->died)
{
LOG_DEBUG0("An instance died, removing it");
next = instance->next;
if (prev)
prev->next = next;
else
ices_config->instances = next;
/* Just in case, flush any existing buffers
* Locks shouldn't be needed, but lets be SURE */
thread_mutex_lock(&ices_config->flush_lock);
input_flush_queue(instance->queue, 0);
thread_mutex_unlock(&ices_config->flush_lock);
config_free_instance(instance);
free(instance);
instance = next;
continue;
}
prev = instance;
instance = instance->next;
}
instance = ices_config->instances;
if(!instance)
{
shutdown = 1;
free(chunk);
continue;
}
if(ices_config->shutdown) /* We've been signalled to shut down, but */
{ /* the instances haven't done so yet... */
timing_sleep(250); /* sleep for quarter of a second */
free(chunk);
continue;
}
/* If this is the first time through, set initial time. This should
* be done before the call to inmod->getdata() below, in order to
* properly keep time if this input module blocks.
*/
if (control.starttime == 0)
control.starttime = timing_get_time();
/* get a chunk of data from the input module */
ret = inmod->getdata(inmod->internal, chunk);
/* input module signalled non-fatal error. Skip this chunk */
if(ret==0)
{
free(chunk);
continue;
}
/* Input module signalled fatal error, shut down - nothing we can do
* from here */
if(ret < 0)
{
ices_config->shutdown = 1;
thread_cond_broadcast(&ices_config->queue_cond);
free(chunk);
continue;
}
if(chunk->critical)
valid_stream = 1;
if(ret < 0) {
/* Tell the input module to go to the next track, hopefully allowing
* resync. */
ices_config->inmod->handle_event(ices_config->inmod,
EVENT_NEXTTRACK,NULL);
valid_stream = 0;
}
inc_count = 0;
not_waiting_for_critical = 0;
if(valid_stream)
{
while(instance)
{
if(instance->wait_for_critical && !chunk->critical)
{
instance = instance->next;
continue;
}
not_waiting_for_critical = 1;
if(instance->skip)
{
instance = instance->next;
continue;
}
queued = malloc(sizeof(queue_item));
queued->buf = chunk;
current = instance->queue;
inc_count++;
thread_mutex_lock(¤t->lock);
if(current->head == NULL)
{
current->head = current->tail = queued;
current->head->next = current->tail->next = NULL;
}
else
{
current->tail->next = queued;
queued->next = NULL;
current->tail = queued;
}
current->length++;
thread_mutex_unlock(¤t->lock);
instance = instance->next;
}
}
/* If everything is waiting for a critical buffer, force one
* early. (This will take effect on the next pass through)
*/
if(valid_stream && !not_waiting_for_critical) {
ices_config->inmod->handle_event(ices_config->inmod,
EVENT_NEXTTRACK,NULL);
instance = ices_config->instances;
while(instance) {
thread_mutex_lock(&ices_config->flush_lock);
input_flush_queue(instance->queue, 0);
instance->wait_for_critical = 0;
thread_mutex_unlock(&ices_config->flush_lock);
instance = instance->next;
}
}
/* Make sure we don't end up with a 0-refcount buffer that
* will never hit any of the free points. (this happens
* if all threads are set to skip, for example).
*/
thread_mutex_lock(&ices_config->refcount_lock);
chunk->count += inc_count;
if(!chunk->count)
{
free(chunk->buf);
free(chunk);
}
thread_mutex_unlock(&ices_config->refcount_lock);
if(valid_stream) {
/* wake up the instances */
thread_cond_broadcast(&ices_config->queue_cond);
}
}
LOG_INFO0 ("All instances removed, shutting down...");
ices_config->shutdown = 1;
thread_cond_broadcast(&ices_config->event_pending_cond);
timing_sleep(250); /* sleep for quarter of a second */
thread_cond_destroy(&ices_config->queue_cond);
thread_cond_destroy(&ices_config->event_pending_cond);
thread_mutex_destroy(&ices_config->flush_lock);
thread_mutex_destroy(&ices_config->refcount_lock);
inmod->handle_event(inmod, EVENT_SHUTDOWN, NULL);
return;
}
auth_t *auth_get_authenticator (xmlNodePtr node)
{
auth_t *auth = calloc (1, sizeof (auth_t));
config_options_t *options = NULL, **next_option = &options;
xmlNodePtr option;
if (auth == NULL)
return NULL;
option = node->xmlChildrenNode;
while (option)
{
xmlNodePtr current = option;
option = option->next;
if (xmlStrcmp (current->name, XMLSTR("option")) == 0)
{
config_options_t *opt = calloc (1, sizeof (config_options_t));
opt->name = (char *)xmlGetProp (current, XMLSTR("name"));
if (opt->name == NULL)
{
free(opt);
continue;
}
opt->value = (char *)xmlGetProp (current, XMLSTR("value"));
if (opt->value == NULL)
{
xmlFree (opt->name);
free (opt);
continue;
}
*next_option = opt;
next_option = &opt->next;
}
else
if (xmlStrcmp (current->name, XMLSTR("text")) != 0)
ICECAST_LOG_WARN("unknown auth setting (%s)", current->name);
}
auth->type = (char*)xmlGetProp (node, XMLSTR("type"));
if (get_authenticator (auth, options) < 0)
{
xmlFree (auth->type);
free (auth);
auth = NULL;
}
else
{
auth->tailp = &auth->head;
thread_mutex_create (&auth->lock);
auth->refcount = 1;
auth->running = 1;
auth->thread = thread_create ("auth thread", auth_run_thread, auth, THREAD_ATTACHED);
}
while (options)
{
config_options_t *opt = options;
options = opt->next;
xmlFree (opt->name);
xmlFree (opt->value);
free (opt);
}
return auth;
}
int auth_get_authenticator (xmlNodePtr node, void *x)
{
auth_t *auth = calloc (1, sizeof (auth_t));
config_options_t *options = NULL, **next_option = &options;
xmlNodePtr option;
int i;
if (auth == NULL)
return -1;
option = node->xmlChildrenNode;
while (option)
{
xmlNodePtr current = option;
option = option->next;
if (xmlStrcmp (current->name, XMLSTR("option")) == 0)
{
config_options_t *opt = calloc (1, sizeof (config_options_t));
opt->name = (char *)xmlGetProp (current, XMLSTR("name"));
if (opt->name == NULL)
{
free(opt);
continue;
}
opt->value = (char *)xmlGetProp (current, XMLSTR("value"));
if (opt->value == NULL)
{
xmlFree (opt->name);
free (opt);
continue;
}
*next_option = opt;
next_option = &opt->next;
}
else
if (xmlStrcmp (current->name, XMLSTR("text")) != 0)
WARN1 ("unknown auth setting (%s)", current->name);
}
auth->type = (char *)xmlGetProp (node, XMLSTR("type"));
if (get_authenticator (auth, options) < 0)
{
xmlFree (auth->type);
free (auth);
auth = NULL;
}
else
{
auth->tailp = &auth->head;
thread_mutex_create (&auth->lock);
/* allocate N threads */
auth->handles = calloc (auth->handlers, sizeof (auth_thread_t));
auth->refcount = 1;
auth->flags |= AUTH_RUNNING;
for (i=0; i<auth->handlers; i++)
{
if (auth->alloc_thread_data)
auth->handles[i].data = auth->alloc_thread_data (auth);
auth->handles[i].id = thread_id++;
auth->handles[i].auth = auth;
}
*(auth_t**)x = auth;
}
while (options)
{
config_options_t *opt = options;
options = opt->next;
xmlFree (opt->name);
xmlFree (opt->value);
free (opt);
}
return 0;
}
/* detected Sun Solaris */ /* A pthread_t is an unsigned int. */ fprintf(out_stream, "%u", thread); return; #endif #endif } /* internal data structures */ static pthread_mutex_t stream_mutex = thread_mutex_create(); /* definitions of exported functions */ /** * @brief Prints the entire trace message to the specified stream. * * @param out_stream The stream to print to. We flush after the * print. We also make one call to fprintf(), so the message should * be printed atomically. * * @param filename The filename that the message is coming from. Used * in message prefix.
input_module_t *sndio_open_module(module_param_t *params)
{
input_module_t *mod = calloc(1, sizeof(input_module_t));
im_sndio_state *s;
module_param_t *current;
char *device = NULL; /* default device */
int sample_rate = 44100;
int channels = 2;
int use_metadata = 1; /* Default to on */
mod->type = ICES_INPUT_PCM;
#ifdef WORDS_BIGENDIAN
mod->subtype = INPUT_PCM_BE_16;
#else
mod->subtype = INPUT_PCM_LE_16;
#endif
mod->getdata = sndio_read;
mod->handle_event = event_handler;
mod->metadata_update = metadata_update;
mod->internal = calloc(1, sizeof(im_sndio_state));
s = mod->internal;
thread_mutex_create(&s->metadatalock);
current = params;
while (current) {
if (!strcmp(current->name, "rate"))
sample_rate = atoi(current->value);
else if (!strcmp(current->name, "channels"))
channels = atoi(current->value);
else if (!strcmp(current->name, "device"))
device = current->value;
else if (!strcmp(current->name, "metadata"))
use_metadata = atoi(current->value);
else if(!strcmp(current->name, "metadatafilename"))
ices_config->metadata_filename = current->value;
else
LOG_WARN1("Unknown parameter %s for sndio module", current->name);
current = current->next;
}
/* First up, lets open the audio device */
if((s->hdl = sio_open(device, SIO_REC, 0)) == NULL) {
LOG_ERROR0("Failed to open sndio device");
goto fail;
}
/* Try and set up what we want */
sio_initpar(&s->par);
s->par.rate = sample_rate;
s->par.rchan = channels;
s->par.bits = 16;
s->par.sig = 1;
s->par.le = SIO_LE_NATIVE;
s->par.round = BUFSIZE;
s->par.appbufsz = BUFSIZE * 4;
if (!sio_setpar(s->hdl, &s->par) || !sio_getpar(s->hdl, &s->par)) {
LOG_ERROR0("Failed to configure sndio device");
goto fail;
}
/* Check all went according to plan */
if (s->par.rate != sample_rate) {
LOG_ERROR0("Couldn't set sampling rate");
goto fail;
}
if (s->par.rchan != channels) {
LOG_ERROR0("Couldn't set number of channels");
goto fail;
}
if (s->par.bits != 16) {
LOG_ERROR0("Couldn't set 16 bit precision");
goto fail;
}
if (s->par.sig != 1) {
LOG_ERROR0("Couldn't set signed linear encoding");
goto fail;
}
if (s->par.le != SIO_LE_NATIVE) {
LOG_ERROR0("Couldn't set proper endianness");
goto fail;
}
if (!sio_start(s->hdl)) {
LOG_ERROR0("Couldn't start sndio");
goto fail;
}
/* We're done, and we didn't fail! */
LOG_INFO2("Opened audio device for %d channel(s), %d Hz",
channels, sample_rate);
if(use_metadata)
{
LOG_INFO0("Starting metadata update thread");
if(ices_config->metadata_filename)
thread_create("im_sndio-metadata", metadata_thread_signal, mod, 1);
else
thread_create("im_sndio-metadata", metadata_thread_stdin, mod, 1);
}
return mod;
fail:
close_module(mod); /* safe, this checks for valid contents */
return NULL;
}
input_module_t *alsa_open_module(module_param_t *params)
{
input_module_t *mod = calloc(1, sizeof(input_module_t));
im_alsa_state *s;
module_param_t *current;
char *device = "plughw:0,0"; /* default device */
int format = AFMT_S16_LE;
int channels, rate;
int use_metadata = 1; /* Default to on */
unsigned int buffered_time;
snd_pcm_stream_t stream = SND_PCM_STREAM_CAPTURE;
snd_pcm_hw_params_t *hwparams;
int err;
mod->type = ICES_INPUT_PCM;
mod->subtype = INPUT_PCM_LE_16;
mod->getdata = alsa_read;
mod->handle_event = event_handler;
mod->metadata_update = metadata_update;
mod->internal = calloc(1, sizeof(im_alsa_state));
s = mod->internal;
s->fd = NULL; /* Set it to something invalid, for now */
s->rate = 44100; /* Defaults */
s->channels = 2;
thread_mutex_create(&s->metadatalock);
current = params;
while(current)
{
if(!strcmp(current->name, "rate"))
s->rate = atoi(current->value);
else if(!strcmp(current->name, "channels"))
s->channels = atoi(current->value);
else if(!strcmp(current->name, "device"))
device = current->value;
else if(!strcmp(current->name, "metadata"))
use_metadata = atoi(current->value);
else if(!strcmp(current->name, "metadatafilename"))
ices_config->metadata_filename = current->value;
else
LOG_WARN1("Unknown parameter %s for alsa module", current->name);
current = current->next;
}
snd_pcm_hw_params_alloca(&hwparams);
if ((err = snd_pcm_open(&s->fd, device, stream, 0)) < 0)
{
LOG_ERROR2("Failed to open audio device %s: %s", device, snd_strerror(err));
goto fail;
}
if ((err = snd_pcm_hw_params_any(s->fd, hwparams)) < 0)
{
LOG_ERROR1("Failed to initialize hwparams: %s", snd_strerror(err));
goto fail;
}
if ((err = snd_pcm_hw_params_set_access(s->fd, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
{
LOG_ERROR1("Error setting access: %s", snd_strerror(err));
goto fail;
}
if ((err = snd_pcm_hw_params_set_format(s->fd, hwparams, SND_PCM_FORMAT_S16_LE)) < 0)
{
LOG_ERROR1("Couldn't set sample format to SND_PCM_FORMAT_S16_LE: %s", snd_strerror(err));
goto fail;
}
if ((err = snd_pcm_hw_params_set_rate_near(s->fd, hwparams, &s->rate, 0)) < 0)
{
LOG_ERROR1("Error setting rate: %s", snd_strerror(err));
goto fail;
}
if ((err = snd_pcm_hw_params_set_channels(s->fd, hwparams, s->channels)) < 0)
{
LOG_ERROR1("Error setting channels: %s", snd_strerror(err));
goto fail;
}
if ((err = snd_pcm_hw_params_set_periods(s->fd, hwparams, 2, 0)) < 0)
{
LOG_ERROR1("Error setting periods: %s", snd_strerror(err));
goto fail;
}
buffered_time = 500000;
if ((err = snd_pcm_hw_params_set_buffer_time_near(s->fd, hwparams, &buffered_time, 0)) < 0)
{
LOG_ERROR1("Error setting buffersize: %s", snd_strerror(err));
goto fail;
}
if ((err = snd_pcm_hw_params(s->fd, hwparams)) < 0)
{
LOG_ERROR1("Error setting HW params: %s", snd_strerror(err));
goto fail;
}
/* We're done, and we didn't fail! */
LOG_INFO3("Opened audio device %s at %d channel(s), %d Hz",
device, s->channels, s->rate);
if(use_metadata)
{
if(ices_config->metadata_filename)
thread_create("im_alsa-metadata", metadata_thread_signal, mod, 1);
else
thread_create("im_alsa-metadata", metadata_thread_stdin, mod, 1);
LOG_INFO0("Started metadata update thread");
}
return mod;
fail:
close_module(mod); /* safe, this checks for valid contents */
return NULL;
}
int nc_connect(net_client_t **nc,const nc_arg_t *nc_arg)
{
//忽略SIGPIPE 信号
struct sigaction sa;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sa.sa_handler = SIG_IGN;
sigaction(SIGPIPE,&sa,NULL);
int rv,sd;
rv = nc_nbconnect(&sd,nc_arg);
if(rv < 0)
return -1;
int on=1;
setsockopt(sd, IPPROTO_TCP, TCP_NODELAY,(void *)&on,(socklen_t)sizeof(on));
allocator_t *allocator;
if(allocator_create(&allocator) < 0)
{
close(sd);
return -1;
}
(*nc) = (net_client_t *)malloc(sizeof(net_client_t));
memset((*nc),0,sizeof(net_client_t));
log_open(&(*nc)->log,"nc_log.txt");
thread_mutex_create(&((*nc)->mpool_mutex),0);
allocator_mutex_set(allocator,(*nc)->mpool_mutex);
(*nc)->allocator = allocator;
queue_create(&((*nc)->recv_queue),C_MAX_QUEUE_CAPACITY);
// BTPDQ_INIT(&(*nc)->recv_queue);
// thread_mutex_create(&((*nc)->recv_mutex),0);
thread_mutex_create(&((*nc)->peer_mutex),0);
if(nc_arg->data_func)
(*nc)->data_func = nc_arg->data_func;
else
(*nc)->data_func = default_process_func;
if(nc_arg->msg_func)
(*nc)->msg_func = nc_arg->msg_func;
if(nc_arg->close_func)
(*nc)->close_func = nc_arg->close_func;
int epfd = evloop_init();
(*nc)->epfd = epfd;
cpeer_create_out(sd,*nc);
pthread_t td;
pthread_create(&td,NULL,&start_threads,(*nc));
(*nc)->td_start = td;
log_error((*nc)->log,"nc connet server ip:%s,port:%d ok!",nc_arg->ip,nc_arg->port);
return 0;
}
void encode_init()
{
thread_mutex_create (&_serial_lock);
}
input_module_t *roar_open_module(module_param_t *params)
{
input_module_t *mod = calloc(1, sizeof(input_module_t));
im_roar_state *s;
module_param_t *current;
const char * server = NULL;
int dir = ROAR_DIR_MONITOR;
enum { MD_NONE = 0, MD_FILE = 1, MD_STREAM = 2 } use_metadata = MD_STREAM;
int err;
mod->getdata = roar_read;
mod->handle_event = event_handler;
mod->metadata_update = metadata_update;
mod->internal = calloc(1, sizeof(im_roar_state));
s = mod->internal;
if(roar_profile2info(&s->info, "default") == -1)
{
LOG_ERROR1("Failed to get default audio profile: %s",
roar_error2str(roar_error));
return NULL;
}
s->info.bits = 16;
s->vss = NULL;
s->plugins = roar_plugincontainer_new_simple(IM_ROAR_APPNAME, IM_ROAR_ABIVERSION);
if (!s->plugins)
{
LOG_ERROR1("Failed to create plugin container: %s",
roar_error2str(roar_error));
return NULL;
}
thread_mutex_create(&s->metadatalock);
current = params;
while(current)
{
if(!strcmp(current->name, "rate"))
s->info.rate = roar_str2rate(current->value);
else if(!strcmp(current->name, "channels"))
s->info.channels = roar_str2channels(current->value);
else if(!strcmp(current->name, "codec"))
s->info.codec = roar_str2codec(current->value);
else if(!strcmp(current->name, "aiprofile")) {
if (roar_profile2info(&s->info, current->value) == -1) {
LOG_WARN2("Can not get audio info profile %s: %s", current->value, roar_error2str(roar_error));
}
s->info.bits = 16;
} else if(!strcmp(current->name, "dir")) {
if ( !strcasecmp(current->value, "monitor") ) {
dir = ROAR_DIR_MONITOR;
} else if ( !strcasecmp(current->value, "record") ) {
dir = ROAR_DIR_RECORD;
} else {
LOG_WARN2("Unknown value %s for parameter %s for roar module", current->value, current->name);
}
} else if(!strcmp(current->name, "device") || !strcmp(current->name, "server"))
server = current->value;
else if(!strcmp(current->name, "metadata")) {
if ( !strcasecmp(current->value, "none") ) {
use_metadata = MD_NONE;
} else if ( !strcasecmp(current->value, "file") ) {
use_metadata = MD_FILE;
} else if ( !strcasecmp(current->value, "stream") ) {
use_metadata = MD_STREAM;
} else {
use_metadata = atoi(current->value);
}
} else if(!strcmp(current->name, "metadatafilename")) {
ices_config->metadata_filename = current->value;
use_metadata = MD_FILE;
} else if(!strcmp(current->name, "plugin")) {
roar_plugin_load(mod, current->value);
} else
LOG_WARN1("Unknown parameter %s for roar module", current->name);
current = current->next;
}
mod->type = ICES_INPUT_PCM;
switch (s->info.codec) {
case ROAR_CODEC_PCM_LE:
mod->subtype = INPUT_PCM_LE_16;
break;
case ROAR_CODEC_PCM_BE:
mod->subtype = INPUT_PCM_BE_16;
break;
case ROAR_CODEC_OGG_GENERAL:
LOG_WARN0("Codec may not work, specify ogg_vorbis for Vorbis streaming");
case ROAR_CODEC_OGG_VORBIS:
mod->type = ICES_INPUT_VORBIS;
// we do not set mod->subtype here, strange design ices2 has...
break;
case -1:
LOG_ERROR0("Unknown Codec");
return NULL;
default:
LOG_ERROR1("Unsupported Codec: %s", roar_codec2str(s->info.codec));
return NULL;
}
roar_plugincontainer_appsched_trigger(s->plugins, ROAR_DL_APPSCHED_INIT);
/* Open the VS connection */
if ( (s->vss = roar_vs_new(server, IM_ROAR_PROGNAME, &err)) == NULL ) {
LOG_ERROR2("Failed to open sound server %s: %s",
server, roar_vs_strerr(err));
goto fail;
}
/* Now, set the required parameters on that device */
if ( roar_vs_stream(s->vss, &s->info, dir, &err) == -1 ) {
LOG_ERROR2("Failed to create a new stream on sound server %s: %s",
server, roar_vs_strerr(err));
goto fail;
}
if ( _set_flags(roar_vs_connection_obj(s->vss, NULL), roar_vs_stream_obj(s->vss, NULL),
ROAR_FLAG_META, ROAR_RESET_FLAG) != 0 ) {
LOG_WARN0("Can not reset metadata flag from stream");
}
/* We're done, and we didn't fail! */
LOG_INFO3("Opened sound server at %s at %d channel(s), %d Hz",
server, s->info.channels, s->info.rate);
switch (use_metadata) {
case MD_NONE:
break;
case MD_FILE:
LOG_INFO0("Starting metadata update thread");
if(ices_config->metadata_filename)
thread_create("im_roar-metadata", metadata_thread_signal, mod, 1);
else
thread_create("im_roar-metadata", metadata_thread_stdin, mod, 1);
break;
case MD_STREAM:
if ( _set_flags(roar_vs_connection_obj(s->vss, NULL), roar_vs_stream_obj(s->vss, NULL),
ROAR_FLAG_META, ROAR_SET_FLAG) != 0 ) {
LOG_WARN0("Can not set metadata flag from stream");
}
break;
}
return mod;
fail:
close_module(mod); /* safe, this checks for valid contents */
return NULL;
}
int fserve_setup_client_fb (client_t *client, fbinfo *finfo)
{
fh_node *fh = &no_file;
int ret = 0;
refbuf_t *refbuf;
ssize_t bytes;
if (finfo)
{
mount_proxy *minfo;
if (finfo->flags & FS_FALLBACK && finfo->limit == 0)
return -1;
avl_tree_wlock (fh_cache);
fh = find_fh (finfo);
minfo = config_find_mount (config_get_config(), finfo->mount);
if (fh)
{
thread_mutex_lock (&fh->lock);
avl_tree_unlock (fh_cache);
client->shared_data = NULL;
if (minfo)
{
if (minfo->max_listeners >= 0 && fh->refcount > minfo->max_listeners)
{
thread_mutex_unlock (&fh->lock);
config_release_config();
return client_send_403redirect (client, finfo->mount, "max listeners reached");
}
if (check_duplicate_logins (finfo->mount, fh->clients, client, minfo->auth) == 0)
{
thread_mutex_unlock (&fh->lock);
config_release_config();
return client_send_403 (client, "Account already in use");
}
}
config_release_config();
}
else
{
if (minfo && minfo->max_listeners == 0)
{
avl_tree_unlock (fh_cache);
config_release_config();
client->shared_data = NULL;
return client_send_403redirect (client, finfo->mount, "max listeners reached");
}
config_release_config();
fh = open_fh (finfo);
if (fh == NULL)
return client_send_404 (client, NULL);
if (fh->finfo.limit)
DEBUG2 ("request for throttled file %s (bitrate %d)", fh->finfo.mount, fh->finfo.limit*8);
}
if (fh->finfo.limit)
{
client->timer_start = client->worker->current_time.tv_sec;
if (client->connection.sent_bytes == 0)
client->timer_start -= 2;
client->counter = 0;
client->intro_offset = 0;
global_reduce_bitrate_sampling (global.out_bitrate);
}
}
else
{
if (client->mount && (client->flags & CLIENT_AUTHENTICATED) && (client->respcode >= 300 || client->respcode < 200))
{
fh = calloc (1, sizeof (no_file));
fh->finfo.mount = strdup (client->mount);
fh->finfo.flags |= FS_DELETE;
fh->refcount = 1;
fh->f = SOCK_ERROR;
thread_mutex_create (&fh->lock);
}
thread_mutex_lock (&fh->lock);
}
client->mount = fh->finfo.mount;
if (fh->finfo.type == FORMAT_TYPE_UNDEFINED)
{
if (client->respcode == 0)
{
client->refbuf->len = 0;
ret = format_general_headers (fh->format, client);
}
}
else
{
if (fh->format->create_client_data && client->format_data == NULL)
ret = fh->format->create_client_data (fh->format, client);
if (fh->format->write_buf_to_client)
client->check_buffer = fh->format->write_buf_to_client;
}
if (ret < 0)
{
thread_mutex_unlock (&fh->lock);
return client_send_416 (client);
}
fh_add_client (fh, client);
thread_mutex_unlock (&fh->lock);
client->shared_data = fh;
if (client->check_buffer == NULL)
client->check_buffer = format_generic_write_to_client;
// workaround for #134: fill the preallocated, but empty, chained buffer in case a range request was made
if (client->flags & CLIENT_RANGE_END)
{
if (client->refbuf && client->refbuf->next)
{
refbuf = client->refbuf->next;
bytes = pread (fh->f, refbuf->data, refbuf->len, client->intro_offset);
if (bytes < 0)
return -1;
}
}
client->ops = &buffer_content_ops;
client->flags &= ~CLIENT_HAS_INTRO_CONTENT;
client->flags |= CLIENT_IN_FSERVE;
if (client->flags & CLIENT_ACTIVE)
{
client->schedule_ms = client->worker->time_ms;
if (finfo && finfo->flags & FS_FALLBACK)
return 0; // prevent a recursive loop
return client->ops->process (client);
}
else
{
worker_t *worker = client->worker;
ret = (fh->finfo.limit) ? 0 : -1;
client->flags |= CLIENT_ACTIVE;
worker_wakeup (worker); /* worker may of already processed client but make sure */
}
return ret;
}
static void create_locks(void) {
thread_mutex_create(&_locks.relay_lock);
thread_rwlock_create(&_locks.config_lock);
}
ENTER_NAMESPACE(qpipe);
/* debugging */
static int TRACE_MASK_WAITS = TRACE_COMPONENT_MASK_NONE;
static int TRACE_MASK_DISK = TRACE_COMPONENT_MASK_NONE;
static const bool FLUSH_TO_DISK_ON_FULL = false;
/* Global tuple_fifo statistics */
/* statistics data structures */
static pthread_mutex_t tuple_fifo_stats_mutex = thread_mutex_create();
static int open_fifo_count = 0;
static int total_fifos_created = 0;
static int total_fifos_experienced_read_wait = 0;
static int total_fifos_experienced_write_wait = 0;
static int total_fifos_experienced_wait = 0;
/* statistics methods */
/**
* @brief Return the number of currently open tuple_fifos. Not
* synchronized.
*/
int tuple_fifo::open_fifos() {
