/* This does the actual connection for a relay. A thread is
* started off if a connection can be acquired
*/
int open_relay (relay_server *relay)
{
source_t *src = relay->source;
relay_server_master *master = relay->masters;
client_t *client = src->client;
do
{
int ret;
if (master->skip)
{
INFO3 ("skipping %s:%d for %s", master->ip, master->port, relay->localmount);
continue;
}
thread_mutex_unlock (&src->lock);
ret = open_relay_connection (client, relay, master);
thread_mutex_lock (&src->lock);
if (ret < 0)
continue;
if (connection_complete_source (src) < 0)
{
WARN1 ("Failed to complete initialisation on %s", relay->localmount);
continue;
}
return 1;
} while ((master = master->next) && global.running == ICE_RUNNING);
return -1;
}
static void _handle_source_request (client_t *client, char *uri, int auth_style)
{
source_t *source;
INFO1("Source logging in at mountpoint \"%s\"", uri);
if (uri[0] != '/')
{
WARN0 ("source mountpoint not starting with /");
client_send_401 (client);
return;
}
if (auth_style == ICECAST_SOURCE_AUTH) {
if (connection_check_source_pass (client->parser, uri) == 0)
{
/* We commonly get this if the source client is using the wrong
* protocol: attempt to diagnose this and return an error
*/
/* TODO: Do what the above comment says */
INFO1("Source (%s) attempted to login with invalid or missing password", uri);
client_send_401(client);
return;
}
}
source = source_reserve (uri);
if (source)
{
if (auth_style == SHOUTCAST_SOURCE_AUTH) {
source->shoutcast_compat = 1;
}
source->client = client;
source->parser = client->parser;
source->con = client->con;
if (connection_complete_source (source, 1) < 0)
{
source_clear_source (source);
source_free_source (source);
}
else
{
refbuf_t *ok = refbuf_new (PER_CLIENT_REFBUF_SIZE);
client->respcode = 200;
snprintf (ok->data, PER_CLIENT_REFBUF_SIZE,
"HTTP/1.0 200 OK\r\n\r\n");
ok->len = strlen (ok->data);
/* we may have unprocessed data read in, so don't overwrite it */
ok->associated = client->refbuf;
client->refbuf = ok;
fserve_add_client_callback (client, source_client_callback, source);
}
}
else
{
client_send_404 (client, "Mountpoint in use");
WARN1 ("Mountpoint %s in use", uri);
}
}
static void _handle_source_request(connection_t *con,
http_parser_t *parser, char *uri)
{
client_t *client;
source_t *source;
client = client_create(con, parser);
INFO1("Source logging in at mountpoint \"%s\"", uri);
if (uri[0] != '/')
{
WARN0 ("source mountpoint not starting with /");
client_send_401 (client);
return;
}
if (!connection_check_source_pass(parser, uri)) {
/* We commonly get this if the source client is using the wrong
* protocol: attempt to diagnose this and return an error
*/
/* TODO: Do what the above comment says */
INFO1("Source (%s) attempted to login with invalid or missing password", uri);
client_send_401(client);
return;
}
source = source_reserve (uri);
if (source)
{
source->client = client;
source->parser = parser;
source->con = con;
if (connection_complete_source (source) < 0)
{
source->client = NULL;
source_free_source (source);
}
else
thread_create ("Source Thread", source_client_thread,
source, THREAD_DETACHED);
}
else
{
client_send_404 (client, "Mountpoint in use");
WARN1 ("Mountpoint %s in use", uri);
}
}
void source_startup (client_t *client, const char *uri, int auth_style)
{
source_t *source;
refbuf_t *ok;
source = source_reserve (uri);
if (!source) {
client_send_403 (client, "Mountpoint in use");
WARN1 ("Mountpoint %s in use", uri);
return;
}
source->client = client;
source->parser = client->parser;
source->con = client->con;
if (connection_complete_source (source, 1) < 0) {
source_clear_source (source);
source_free_source (source);
return;
}
client->respcode = 200;
switch (auth_style) {
case SHOUTCAST_SOURCE_AUTH:
source->shoutcast_compat = 1;
case NOAUTH_SOURCE_AUTH:
break;
case ICECAST_SOURCE_AUTH:
ok = refbuf_new (PER_CLIENT_REFBUF_SIZE);
client->respcode = 200;
snprintf (ok->data, PER_CLIENT_REFBUF_SIZE,
"HTTP/1.0 200 OK\r\n\r\n");
ok->len = strlen (ok->data);
/* we may have unprocessed data read in, so don't overwrite it */
ok->associated = client->refbuf;
client->refbuf = ok;
break;
default:
WARN1("Got unkown source auth type: %d", auth_style);
return;
}
fserve_add_client_callback (client, source_client_callback, source);
}
/* This does the actual connection for a relay. A thread is
* started off if a connection can be acquired
*/
static void *start_relay_stream (void *arg)
{
relay_server *relay = arg;
source_t *src = relay->source;
client_t *client;
ICECAST_LOG_INFO("Starting relayed source at mountpoint \"%s\"", relay->localmount);
do
{
client = open_relay_connection (relay);
if (client == NULL)
continue;
src->client = client;
src->parser = client->parser;
src->con = client->con;
if (connection_complete_source (src, 0) < 0)
{
ICECAST_LOG_INFO("Failed to complete source initialisation");
client_destroy (client);
src->client = NULL;
continue;
}
stats_event_inc(NULL, "source_relay_connections");
stats_event (relay->localmount, "source_ip", client->con->ip);
source_main (relay->source);
if (relay->on_demand == 0)
{
/* only keep refreshing YP entries for inactive on-demand relays */
yp_remove (relay->localmount);
relay->source->yp_public = -1;
relay->start = time(NULL) + 10; /* prevent busy looping if failing */
slave_update_all_mounts();
}
/* we've finished, now get cleaned up */
relay->cleanup = 1;
slave_rebuild_mounts();
return NULL;
} while (0); /* TODO allow looping through multiple servers */
if (relay->source->fallback_mount)
{
source_t *fallback_source;
ICECAST_LOG_DEBUG("failed relay, fallback to %s", relay->source->fallback_mount);
avl_tree_rlock(global.source_tree);
fallback_source = source_find_mount(relay->source->fallback_mount);
if (fallback_source != NULL)
source_move_clients(relay->source, fallback_source);
avl_tree_unlock(global.source_tree);
}
source_clear_source(relay->source);
/* cleanup relay, but prevent this relay from starting up again too soon */
thread_mutex_lock(&_slave_mutex);
thread_mutex_lock(&(config_locks()->relay_lock));
relay->source->on_demand = 0;
relay->start = time(NULL) + max_interval;
relay->cleanup = 1;
thread_mutex_unlock(&(config_locks()->relay_lock));
thread_mutex_unlock(&_slave_mutex);
return NULL;
}
static void *start_relay_stream (void *arg)
{
client_t *client = arg;
relay_server *relay;
source_t *src;
int failed = 1, sources;
global_lock();
sources = ++global.sources;
stats_event_args (NULL, "sources", "%d", global.sources);
global_unlock();
/* set the start time, because we want to decrease the sources on all failures */
client->connection.con_time = time (NULL);
do
{
ice_config_t *config = config_get_config();
mount_proxy *mountinfo;
relay = client->shared_data;
src = relay->source;
thread_rwlock_wlock (&src->lock);
src->flags |= SOURCE_PAUSE_LISTENERS;
if (sources > config->source_limit)
{
config_release_config();
WARN1 ("starting relayed mountpoint \"%s\" requires a higher sources limit", relay->localmount);
break;
}
config_release_config();
INFO1("Starting relayed source at mountpoint \"%s\"", relay->localmount);
if (open_relay (relay) < 0)
break;
if (connection_complete_source (src) < 0)
{
WARN1 ("Failed to complete initialisation on %s", relay->localmount);
break;
}
stats_event_inc (NULL, "source_relay_connections");
source_init (src);
config = config_get_config();
mountinfo = config_find_mount (config, src->mount);
source_update_settings (config, src, mountinfo);
INFO1 ("source %s is ready to start", src->mount);
config_release_config();
failed = 0;
} while (0);
client->ops = &relay_client_ops;
client->schedule_ms = timing_get_time();
if (failed)
{
/* failed to start any connection, better clean up and reset */
if (relay->on_demand == 0)
{
yp_remove (relay->localmount);
src->yp_public = -1;
}
relay->in_use = NULL;
INFO2 ("listener count remaining on %s is %d", src->mount, src->listeners);
src->flags &= ~(SOURCE_PAUSE_LISTENERS|SOURCE_RUNNING);
}
thread_rwlock_unlock (&src->lock);
thread_spin_lock (&relay_start_lock);
relays_connecting--;
thread_spin_unlock (&relay_start_lock);
client->flags |= CLIENT_ACTIVE;
worker_wakeup (client->worker);
return NULL;
}
static void *source_fallback_file (void *arg)
{
char *mount = arg;
char *type;
char *path;
unsigned int len;
FILE *file = NULL;
source_t *source = NULL;
ice_config_t *config;
http_parser_t *parser;
do
{
if (mount == NULL || mount[0] != '/')
break;
config = config_get_config();
len = strlen (config->webroot_dir) + strlen (mount) + 1;
path = malloc (len);
if (path)
snprintf (path, len, "%s%s", config->webroot_dir, mount);
config_release_config ();
if (path == NULL)
break;
file = fopen (path, "rb");
if (file == NULL)
{
WARN1 ("unable to open file \"%s\"", path);
free (path);
break;
}
free (path);
source = source_reserve (mount);
if (source == NULL)
{
WARN1 ("mountpoint \"%s\" already reserved", mount);
break;
}
INFO1 ("mountpoint %s is reserved", mount);
type = fserve_content_type (mount);
parser = httpp_create_parser();
httpp_initialize (parser, NULL);
httpp_setvar (parser, "content-type", type);
free (type);
source->hidden = 1;
source->yp_public = 0;
source->intro_file = file;
source->parser = parser;
file = NULL;
if (connection_complete_source (source, 0) < 0)
break;
source_client_thread (source);
httpp_destroy (parser);
} while (0);
if (file)
fclose (file);
free (mount);
return NULL;
}
