2003-03-27 12:10:14 -05:00
|
|
|
/* -*- c-basic-offset: 4; indent-tabs-mode: nil; -*- */
|
2003-07-20 21:58:54 -04:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include <config.h>
|
|
|
|
#endif
|
|
|
|
|
2001-09-09 22:21:46 -04:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <sys/types.h>
|
2001-10-20 02:43:04 -04:00
|
|
|
#include <ogg/ogg.h>
|
2003-03-02 05:13:59 -05:00
|
|
|
#include <errno.h>
|
2001-10-20 02:43:04 -04:00
|
|
|
|
|
|
|
#ifndef _WIN32
|
2002-02-06 20:04:09 -05:00
|
|
|
#include <unistd.h>
|
2001-09-09 22:21:46 -04:00
|
|
|
#include <sys/time.h>
|
|
|
|
#include <sys/socket.h>
|
2001-10-20 02:43:04 -04:00
|
|
|
#else
|
2002-02-06 20:04:09 -05:00
|
|
|
#include <winsock2.h>
|
|
|
|
#include <windows.h>
|
2001-10-20 02:43:04 -04:00
|
|
|
#endif
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-07-16 15:41:59 -04:00
|
|
|
#include "thread/thread.h"
|
|
|
|
#include "avl/avl.h"
|
|
|
|
#include "httpp/httpp.h"
|
|
|
|
#include "net/sock.h"
|
2001-09-09 22:21:46 -04:00
|
|
|
|
|
|
|
#include "connection.h"
|
|
|
|
#include "global.h"
|
|
|
|
#include "refbuf.h"
|
|
|
|
#include "client.h"
|
|
|
|
#include "stats.h"
|
2002-01-20 22:56:16 -05:00
|
|
|
#include "logging.h"
|
2003-07-20 21:58:54 -04:00
|
|
|
#include "cfgfile.h"
|
2002-07-24 10:52:28 -04:00
|
|
|
#include "util.h"
|
2003-05-28 11:04:53 -04:00
|
|
|
#ifdef USE_YP
|
2003-02-02 09:33:17 -05:00
|
|
|
#include "geturl.h"
|
2003-03-27 12:10:14 -05:00
|
|
|
#endif
|
2001-09-09 22:21:46 -04:00
|
|
|
#include "source.h"
|
2002-12-30 02:55:56 -05:00
|
|
|
#include "format.h"
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2002-01-20 22:56:16 -05:00
|
|
|
#undef CATMODULE
|
|
|
|
#define CATMODULE "source"
|
|
|
|
|
2001-09-09 22:21:46 -04:00
|
|
|
/* avl tree helper */
|
|
|
|
static int _compare_clients(void *compare_arg, void *a, void *b);
|
|
|
|
static int _free_client(void *key);
|
2003-02-26 18:52:23 -05:00
|
|
|
static int _parse_audio_info(source_t *source, char *s);
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-02-26 18:52:23 -05:00
|
|
|
source_t *source_create(client_t *client, connection_t *con,
|
2003-03-02 05:13:59 -05:00
|
|
|
http_parser_t *parser, const char *mount, format_type_t type,
|
|
|
|
mount_proxy *mountinfo)
|
2001-09-09 22:21:46 -04:00
|
|
|
{
|
2003-03-14 21:10:19 -05:00
|
|
|
source_t *src;
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
src = (source_t *)malloc(sizeof(source_t));
|
2002-08-16 10:26:48 -04:00
|
|
|
src->client = client;
|
2003-03-14 21:10:19 -05:00
|
|
|
src->mount = (char *)strdup(mount);
|
2002-12-31 02:49:34 -05:00
|
|
|
src->fallback_mount = NULL;
|
2003-03-14 21:10:19 -05:00
|
|
|
src->format = format_get_plugin(type, src->mount, parser);
|
|
|
|
src->con = con;
|
|
|
|
src->parser = parser;
|
|
|
|
src->client_tree = avl_tree_new(_compare_clients, NULL);
|
|
|
|
src->pending_tree = avl_tree_new(_compare_clients, NULL);
|
2003-02-06 08:10:48 -05:00
|
|
|
src->running = 1;
|
2003-03-14 21:10:19 -05:00
|
|
|
src->num_yp_directories = 0;
|
|
|
|
src->listeners = 0;
|
2003-03-02 05:36:24 -05:00
|
|
|
src->max_listeners = -1;
|
2003-02-17 08:01:37 -05:00
|
|
|
src->send_return = 0;
|
2003-03-02 05:13:59 -05:00
|
|
|
src->dumpfilename = NULL;
|
|
|
|
src->dumpfile = NULL;
|
2003-02-26 18:52:23 -05:00
|
|
|
src->audio_info = util_dict_new();
|
2003-06-26 09:32:04 -04:00
|
|
|
src->yp_public = 0;
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-03-02 05:13:59 -05:00
|
|
|
if(mountinfo != NULL) {
|
|
|
|
src->fallback_mount = mountinfo->fallback_mount;
|
|
|
|
src->max_listeners = mountinfo->max_listeners;
|
|
|
|
src->dumpfilename = mountinfo->dumpfile;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(src->dumpfilename != NULL) {
|
|
|
|
src->dumpfile = fopen(src->dumpfilename, "ab");
|
|
|
|
if(src->dumpfile == NULL) {
|
|
|
|
WARN2("Cannot open dump file \"%s\" for appending: %s, disabling.",
|
|
|
|
src->dumpfilename, strerror(errno));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
return src;
|
2001-09-09 22:21:46 -04:00
|
|
|
}
|
|
|
|
|
2003-03-14 02:59:58 -05:00
|
|
|
static int source_remove_source(void *key)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2001-09-09 22:21:46 -04:00
|
|
|
/* you must already have a read lock on the global source tree
|
|
|
|
** to call this function
|
|
|
|
*/
|
|
|
|
source_t *source_find_mount(const char *mount)
|
|
|
|
{
|
2003-03-14 21:10:19 -05:00
|
|
|
source_t *source;
|
|
|
|
avl_node *node;
|
|
|
|
int cmp;
|
|
|
|
|
|
|
|
if (!mount) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
/* get the root node */
|
|
|
|
node = global.source_tree->root->right;
|
|
|
|
|
|
|
|
while (node) {
|
|
|
|
source = (source_t *)node->key;
|
|
|
|
cmp = strcmp(mount, source->mount);
|
|
|
|
if (cmp < 0)
|
|
|
|
node = node->left;
|
|
|
|
else if (cmp > 0)
|
|
|
|
node = node->right;
|
|
|
|
else
|
|
|
|
return source;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* didn't find it */
|
|
|
|
return NULL;
|
2001-09-09 22:21:46 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
int source_compare_sources(void *arg, void *a, void *b)
|
|
|
|
{
|
2003-03-14 21:10:19 -05:00
|
|
|
source_t *srca = (source_t *)a;
|
|
|
|
source_t *srcb = (source_t *)b;
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
return strcmp(srca->mount, srcb->mount);
|
2001-09-09 22:21:46 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
int source_free_source(void *key)
|
|
|
|
{
|
2003-03-14 02:59:58 -05:00
|
|
|
source_t *source = key;
|
2003-05-28 11:04:53 -04:00
|
|
|
#ifdef USE_YP
|
|
|
|
int i;
|
|
|
|
#endif
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
free(source->mount);
|
2002-12-30 10:19:46 -05:00
|
|
|
free(source->fallback_mount);
|
2002-08-16 10:26:48 -04:00
|
|
|
client_destroy(source->client);
|
2003-03-14 21:10:19 -05:00
|
|
|
avl_tree_free(source->pending_tree, _free_client);
|
|
|
|
avl_tree_free(source->client_tree, _free_client);
|
|
|
|
source->format->free_plugin(source->format);
|
2003-05-28 11:04:53 -04:00
|
|
|
#ifdef USE_YP
|
2003-02-02 11:48:15 -05:00
|
|
|
for (i=0; i<source->num_yp_directories; i++) {
|
|
|
|
yp_destroy_ypdata(source->ypdata[i]);
|
|
|
|
}
|
2003-03-27 12:10:14 -05:00
|
|
|
#endif
|
2003-02-26 18:52:23 -05:00
|
|
|
util_dict_free(source->audio_info);
|
2003-03-14 21:10:19 -05:00
|
|
|
free(source);
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
return 1;
|
2001-09-09 22:21:46 -04:00
|
|
|
}
|
2003-03-30 08:52:27 -05:00
|
|
|
|
|
|
|
client_t *source_find_client(source_t *source, int id)
|
|
|
|
{
|
|
|
|
client_t fakeclient;
|
|
|
|
client_t *result;
|
|
|
|
connection_t fakecon;
|
|
|
|
|
|
|
|
fakeclient.con = &fakecon;
|
|
|
|
fakeclient.con->id = id;
|
|
|
|
|
|
|
|
avl_tree_rlock(source->client_tree);
|
|
|
|
if(avl_get_by_key(source->client_tree, &fakeclient, (void **)&result) == 0)
|
|
|
|
{
|
|
|
|
avl_tree_unlock(source->client_tree);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
avl_tree_unlock(source->client_tree);
|
|
|
|
return NULL;
|
|
|
|
}
|
2003-03-14 21:10:19 -05:00
|
|
|
|
2001-09-09 22:21:46 -04:00
|
|
|
|
|
|
|
void *source_main(void *arg)
|
|
|
|
{
|
2003-03-14 21:10:19 -05:00
|
|
|
source_t *source = (source_t *)arg;
|
2002-12-30 10:19:46 -05:00
|
|
|
source_t *fallback_source;
|
2003-03-14 21:10:19 -05:00
|
|
|
char buffer[4096];
|
|
|
|
long bytes, sbytes;
|
|
|
|
int ret, timeout;
|
|
|
|
client_t *client;
|
|
|
|
avl_node *client_node;
|
|
|
|
|
|
|
|
refbuf_t *refbuf, *abuf;
|
|
|
|
int data_done;
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-02-26 18:52:23 -05:00
|
|
|
int listeners = 0;
|
2003-05-28 11:04:53 -04:00
|
|
|
#ifdef USE_YP
|
|
|
|
char *s;
|
|
|
|
long current_time;
|
|
|
|
int i;
|
2003-02-26 18:52:23 -05:00
|
|
|
char *ai;
|
2003-06-26 09:32:04 -04:00
|
|
|
int listen_url_size;
|
2003-05-28 11:04:53 -04:00
|
|
|
#endif
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-03-05 08:03:35 -05:00
|
|
|
long queue_limit;
|
|
|
|
ice_config_t *config;
|
|
|
|
char *hostname;
|
|
|
|
int port;
|
|
|
|
|
|
|
|
config = config_get_config();
|
|
|
|
|
|
|
|
queue_limit = config->queue_size_limit;
|
2003-03-14 21:10:19 -05:00
|
|
|
timeout = config->source_timeout;
|
2003-03-05 08:03:35 -05:00
|
|
|
hostname = config->hostname;
|
|
|
|
port = config->port;
|
|
|
|
|
2003-05-28 11:04:53 -04:00
|
|
|
#ifdef USE_YP
|
2003-03-14 21:10:19 -05:00
|
|
|
for (i=0;i<config->num_yp_directories;i++) {
|
|
|
|
if (config->yp_url[i]) {
|
|
|
|
source->ypdata[source->num_yp_directories] = yp_create_ypdata();
|
|
|
|
source->ypdata[source->num_yp_directories]->yp_url =
|
2003-03-05 08:03:35 -05:00
|
|
|
config->yp_url[i];
|
2003-03-14 21:10:19 -05:00
|
|
|
source->ypdata[source->num_yp_directories]->yp_url_timeout =
|
2003-03-05 08:03:35 -05:00
|
|
|
config->yp_url_timeout[i];
|
2003-03-14 21:10:19 -05:00
|
|
|
source->ypdata[source->num_yp_directories]->yp_touch_interval = 0;
|
|
|
|
source->num_yp_directories++;
|
|
|
|
}
|
|
|
|
}
|
2003-03-27 12:10:14 -05:00
|
|
|
#endif
|
|
|
|
|
2003-03-05 08:03:35 -05:00
|
|
|
config_release_config();
|
2002-01-20 23:28:30 -05:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
/* grab a read lock, to make sure we get a chance to cleanup */
|
|
|
|
thread_rwlock_rlock(source->shutdown_rwlock);
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-02-17 08:01:37 -05:00
|
|
|
avl_tree_wlock(global.source_tree);
|
|
|
|
/* Now, we must do a final check with write lock taken out that the
|
|
|
|
* mountpoint is available..
|
|
|
|
*/
|
|
|
|
if (source_find_mount(source->mount) != NULL) {
|
|
|
|
avl_tree_unlock(global.source_tree);
|
|
|
|
if(source->send_return) {
|
|
|
|
client_send_404(source->client, "Mountpoint in use");
|
|
|
|
}
|
|
|
|
thread_exit(0);
|
|
|
|
return NULL;
|
|
|
|
}
|
2003-03-14 21:10:19 -05:00
|
|
|
/* insert source onto source tree */
|
|
|
|
avl_insert(global.source_tree, (void *)source);
|
|
|
|
/* release write lock on global source tree */
|
|
|
|
avl_tree_unlock(global.source_tree);
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-02-17 08:01:37 -05:00
|
|
|
/* If we connected successfully, we can send the message (if requested)
|
|
|
|
* back
|
|
|
|
*/
|
|
|
|
if(source->send_return) {
|
|
|
|
source->client->respcode = 200;
|
|
|
|
bytes = sock_write(source->client->con->sock,
|
|
|
|
"HTTP/1.0 200 OK\r\n\r\n");
|
|
|
|
if(bytes > 0) source->client->con->sent_bytes = bytes;
|
|
|
|
}
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
/* start off the statistics */
|
|
|
|
source->listeners = 0;
|
2003-03-27 12:10:14 -05:00
|
|
|
stats_event(source->mount, "listeners", "0");
|
|
|
|
stats_event(source->mount, "type", source->format->format_description);
|
2003-05-28 11:04:53 -04:00
|
|
|
#ifdef USE_YP
|
2003-06-26 09:32:04 -04:00
|
|
|
/* ice-* is icecast, icy-* is shoutcast */
|
|
|
|
if ((s = httpp_getvar(source->parser, "ice-url"))) {
|
|
|
|
add_yp_info(source, "server_url", s, YP_SERVER_URL);
|
|
|
|
}
|
2003-03-14 21:10:19 -05:00
|
|
|
if ((s = httpp_getvar(source->parser, "ice-name"))) {
|
2003-06-26 09:32:04 -04:00
|
|
|
add_yp_info(source, "server_name", s, YP_SERVER_NAME);
|
|
|
|
}
|
|
|
|
if ((s = httpp_getvar(source->parser, "icy-name"))) {
|
|
|
|
add_yp_info(source, "server_name", s, YP_SERVER_NAME);
|
2003-03-14 21:10:19 -05:00
|
|
|
}
|
|
|
|
if ((s = httpp_getvar(source->parser, "ice-url"))) {
|
2003-06-26 09:32:04 -04:00
|
|
|
add_yp_info(source, "server_url", s, YP_SERVER_URL);
|
|
|
|
}
|
|
|
|
if ((s = httpp_getvar(source->parser, "icy-url"))) {
|
|
|
|
add_yp_info(source, "server_url", s, YP_SERVER_URL);
|
2003-03-14 21:10:19 -05:00
|
|
|
}
|
|
|
|
if ((s = httpp_getvar(source->parser, "ice-genre"))) {
|
2003-06-26 09:32:04 -04:00
|
|
|
add_yp_info(source, "genre", s, YP_SERVER_GENRE);
|
|
|
|
}
|
|
|
|
if ((s = httpp_getvar(source->parser, "icy-genre"))) {
|
|
|
|
add_yp_info(source, "genre", s, YP_SERVER_GENRE);
|
2003-03-14 21:10:19 -05:00
|
|
|
}
|
|
|
|
if ((s = httpp_getvar(source->parser, "ice-bitrate"))) {
|
2003-06-26 09:32:04 -04:00
|
|
|
add_yp_info(source, "bitrate", s, YP_BITRATE);
|
|
|
|
}
|
|
|
|
if ((s = httpp_getvar(source->parser, "icy-br"))) {
|
|
|
|
add_yp_info(source, "bitrate", s, YP_BITRATE);
|
2003-03-14 21:10:19 -05:00
|
|
|
}
|
|
|
|
if ((s = httpp_getvar(source->parser, "ice-description"))) {
|
2003-06-26 09:32:04 -04:00
|
|
|
add_yp_info(source, "server_description", s, YP_SERVER_DESC);
|
2003-03-14 21:10:19 -05:00
|
|
|
}
|
2003-06-26 09:32:04 -04:00
|
|
|
if ((s = httpp_getvar(source->parser, "ice-public"))) {
|
2003-03-14 21:10:19 -05:00
|
|
|
stats_event(source->mount, "public", s);
|
2003-06-26 09:32:04 -04:00
|
|
|
source->yp_public = atoi(s);
|
|
|
|
}
|
|
|
|
if ((s = httpp_getvar(source->parser, "icy-pub"))) {
|
|
|
|
stats_event(source->mount, "public", s);
|
|
|
|
source->yp_public = atoi(s);
|
2003-03-14 21:10:19 -05:00
|
|
|
}
|
|
|
|
if ((s = httpp_getvar(source->parser, "ice-audio-info"))) {
|
2003-06-26 09:32:04 -04:00
|
|
|
stats_event(source->mount, "audio_info", s);
|
2003-02-26 18:52:23 -05:00
|
|
|
if (_parse_audio_info(source, s)) {
|
|
|
|
ai = util_dict_urlencode(source->audio_info, '&');
|
2003-06-26 09:32:04 -04:00
|
|
|
add_yp_info(source, "audio_info",
|
2003-02-26 18:52:23 -05:00
|
|
|
ai,
|
|
|
|
YP_AUDIO_INFO);
|
2003-06-26 09:32:04 -04:00
|
|
|
if (ai) {
|
|
|
|
free(ai);
|
|
|
|
}
|
2003-02-26 18:52:23 -05:00
|
|
|
}
|
2003-03-14 21:10:19 -05:00
|
|
|
}
|
|
|
|
for (i=0;i<source->num_yp_directories;i++) {
|
2003-06-26 09:32:04 -04:00
|
|
|
add_yp_info(source, "server_type",
|
2003-04-10 23:00:24 -04:00
|
|
|
source->format->format_description,
|
|
|
|
YP_SERVER_TYPE);
|
2003-03-14 21:10:19 -05:00
|
|
|
if (source->ypdata[i]->listen_url) {
|
|
|
|
free(source->ypdata[i]->listen_url);
|
|
|
|
}
|
|
|
|
/* 6 for max size of port */
|
|
|
|
listen_url_size = strlen("http://") +
|
2003-03-05 08:03:35 -05:00
|
|
|
strlen(hostname) +
|
2003-02-06 08:10:48 -05:00
|
|
|
strlen(":") + 6 + strlen(source->mount) + 1;
|
2003-03-14 21:10:19 -05:00
|
|
|
source->ypdata[i]->listen_url = malloc(listen_url_size);
|
|
|
|
sprintf(source->ypdata[i]->listen_url, "http://%s:%d%s",
|
2003-03-05 08:03:35 -05:00
|
|
|
hostname, port, source->mount);
|
2003-03-14 21:10:19 -05:00
|
|
|
}
|
2003-02-02 09:33:17 -05:00
|
|
|
|
2003-06-26 09:32:04 -04:00
|
|
|
if(source->yp_public) {
|
2003-02-06 08:10:48 -05:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
current_time = time(NULL);
|
2003-02-02 09:33:17 -05:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
for (i=0;i<source->num_yp_directories;i++) {
|
2003-02-26 18:52:23 -05:00
|
|
|
/* Give the source 5 seconds to update the metadata
|
|
|
|
before we do our first touch */
|
2003-02-06 08:10:48 -05:00
|
|
|
/* Don't permit touch intervals of less than 30 seconds */
|
2003-03-14 21:10:19 -05:00
|
|
|
if (source->ypdata[i]->yp_touch_interval <= 30) {
|
|
|
|
source->ypdata[i]->yp_touch_interval = 30;
|
|
|
|
}
|
2003-06-26 09:32:04 -04:00
|
|
|
source->ypdata[i]->yp_last_touch = 0;
|
2003-03-14 21:10:19 -05:00
|
|
|
}
|
2003-02-06 08:10:48 -05:00
|
|
|
}
|
2003-03-27 12:10:14 -05:00
|
|
|
#endif
|
2003-02-06 08:10:48 -05:00
|
|
|
|
2003-02-25 04:40:34 -05:00
|
|
|
DEBUG0("Source creation complete");
|
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
while (global.running == ICE_RUNNING && source->running) {
|
|
|
|
ret = source->format->get_buffer(source->format, NULL, 0, &refbuf);
|
2002-04-05 04:28:26 -05:00
|
|
|
if(ret < 0) {
|
|
|
|
WARN0("Bad data from source");
|
|
|
|
break;
|
|
|
|
}
|
2002-10-06 05:57:07 -04:00
|
|
|
bytes = 1; /* Set to > 0 so that the post-loop check won't be tripped */
|
2003-03-14 21:10:19 -05:00
|
|
|
while (refbuf == NULL) {
|
|
|
|
bytes = 0;
|
|
|
|
while (bytes <= 0) {
|
2002-07-24 10:52:28 -04:00
|
|
|
ret = util_timed_wait_for_fd(source->con->sock, timeout*1000);
|
|
|
|
|
2003-07-11 15:03:30 -04:00
|
|
|
if (ret < 0 && sock_recoverable (sock_error()))
|
|
|
|
continue;
|
2003-03-14 21:10:19 -05:00
|
|
|
if (ret <= 0) { /* timeout expired */
|
2002-10-03 10:07:34 -04:00
|
|
|
WARN1("Disconnecting source: socket timeout (%d s) expired",
|
|
|
|
timeout);
|
2003-03-14 21:10:19 -05:00
|
|
|
bytes = 0;
|
|
|
|
break;
|
|
|
|
}
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
bytes = sock_read_bytes(source->con->sock, buffer, 4096);
|
|
|
|
if (bytes == 0 || (bytes < 0 && !sock_recoverable(sock_error()))) {
|
2002-10-03 10:07:34 -04:00
|
|
|
DEBUG1("Disconnecting source due to socket read error: %s",
|
|
|
|
strerror(sock_error()));
|
2002-07-24 10:52:28 -04:00
|
|
|
break;
|
2002-10-03 10:07:34 -04:00
|
|
|
}
|
2003-03-14 21:10:19 -05:00
|
|
|
}
|
|
|
|
if (bytes <= 0) break;
|
2002-08-17 00:35:23 -04:00
|
|
|
source->client->con->sent_bytes += bytes;
|
2003-03-14 21:10:19 -05:00
|
|
|
ret = source->format->get_buffer(source->format, buffer, bytes, &refbuf);
|
2002-04-05 04:28:26 -05:00
|
|
|
if(ret < 0) {
|
|
|
|
WARN0("Bad data from source");
|
|
|
|
goto done;
|
|
|
|
}
|
2003-03-14 21:10:19 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
if (bytes <= 0) {
|
|
|
|
INFO0("Removing source following disconnection");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* we have a refbuf buffer, which a data block to be sent to
|
|
|
|
** all clients. if a client is not able to send the buffer
|
|
|
|
** immediately, it should store it on its queue for the next
|
|
|
|
** go around.
|
|
|
|
**
|
|
|
|
** instead of sending the current block, a client should send
|
|
|
|
** all data in the queue, plus the current block, until either
|
|
|
|
** it runs out of data, or it hits a recoverable error like
|
|
|
|
** EAGAIN. this will allow a client that got slightly lagged
|
|
|
|
** to catch back up if it can
|
|
|
|
*/
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-03-02 05:13:59 -05:00
|
|
|
/* First, stream dumping, if enabled */
|
|
|
|
if(source->dumpfile) {
|
|
|
|
if(fwrite(refbuf->data, 1, refbuf->len, source->dumpfile) !=
|
|
|
|
refbuf->len)
|
|
|
|
{
|
|
|
|
WARN1("Write to dump file failed, disabling: %s",
|
|
|
|
strerror(errno));
|
|
|
|
fclose(source->dumpfile);
|
|
|
|
source->dumpfile = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
/* acquire read lock on client_tree */
|
|
|
|
avl_tree_rlock(source->client_tree);
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
client_node = avl_get_first(source->client_tree);
|
|
|
|
while (client_node) {
|
|
|
|
/* acquire read lock on node */
|
|
|
|
avl_node_wlock(client_node);
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
client = (client_t *)client_node->key;
|
|
|
|
|
|
|
|
data_done = 0;
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
/* do we have any old buffers? */
|
|
|
|
abuf = refbuf_queue_remove(&client->queue);
|
|
|
|
while (abuf) {
|
|
|
|
if (client->pos > 0)
|
|
|
|
bytes = abuf->len - client->pos;
|
|
|
|
else
|
|
|
|
bytes = abuf->len;
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
sbytes = source->format->write_buf_to_client(source->format,
|
2002-12-29 03:10:10 -05:00
|
|
|
client, &abuf->data[client->pos], bytes);
|
2003-03-14 21:10:19 -05:00
|
|
|
if (sbytes >= 0) {
|
2002-05-08 01:18:43 -04:00
|
|
|
if(sbytes != bytes) {
|
2002-05-08 10:02:02 -04:00
|
|
|
/* We didn't send the entire buffer. Leave it for
|
|
|
|
* the moment, handle it in the next iteration.
|
|
|
|
*/
|
2002-05-08 01:18:43 -04:00
|
|
|
client->pos += sbytes;
|
|
|
|
refbuf_queue_insert(&client->queue, abuf);
|
|
|
|
data_done = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2002-12-29 03:10:10 -05:00
|
|
|
else {
|
|
|
|
DEBUG0("Client has unrecoverable error catching up. Client has probably disconnected");
|
|
|
|
client->con->error = 1;
|
2003-03-14 21:10:19 -05:00
|
|
|
data_done = 1;
|
2003-01-18 01:54:29 -05:00
|
|
|
refbuf_release(abuf);
|
2003-03-14 21:10:19 -05:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* we're done with that refbuf, release it and reset the pos */
|
|
|
|
refbuf_release(abuf);
|
|
|
|
client->pos = 0;
|
|
|
|
|
|
|
|
abuf = refbuf_queue_remove(&client->queue);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* now send or queue the new data */
|
|
|
|
if (data_done) {
|
|
|
|
refbuf_addref(refbuf);
|
|
|
|
refbuf_queue_add(&client->queue, refbuf);
|
|
|
|
} else {
|
|
|
|
sbytes = source->format->write_buf_to_client(source->format,
|
2002-12-29 03:10:10 -05:00
|
|
|
client, refbuf->data, refbuf->len);
|
2003-03-14 21:10:19 -05:00
|
|
|
if (sbytes >= 0) {
|
2002-05-08 10:02:02 -04:00
|
|
|
if(sbytes != refbuf->len) {
|
|
|
|
/* Didn't send the entire buffer, queue it */
|
2002-05-08 01:18:43 -04:00
|
|
|
client->pos = sbytes;
|
2003-03-14 21:10:19 -05:00
|
|
|
refbuf_addref(refbuf);
|
2002-05-08 10:07:42 -04:00
|
|
|
refbuf_queue_insert(&client->queue, refbuf);
|
2002-05-08 01:18:43 -04:00
|
|
|
}
|
|
|
|
}
|
2002-12-29 03:10:10 -05:00
|
|
|
else {
|
|
|
|
DEBUG0("Client had unrecoverable error with new data, probably due to client disconnection");
|
|
|
|
client->con->error = 1;
|
2003-03-14 21:10:19 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if the client is too slow, its queue will slowly build up.
|
|
|
|
** we need to make sure the client is keeping up with the
|
|
|
|
** data, so we'll kick any client who's queue gets to large.
|
|
|
|
*/
|
|
|
|
if (refbuf_queue_length(&client->queue) > queue_limit) {
|
2002-08-09 04:06:00 -04:00
|
|
|
DEBUG0("Client has fallen too far behind, removing");
|
2003-03-14 21:10:19 -05:00
|
|
|
client->con->error = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* release read lock on node */
|
|
|
|
avl_node_unlock(client_node);
|
|
|
|
|
|
|
|
/* get the next node */
|
|
|
|
client_node = avl_get_next(client_node);
|
|
|
|
}
|
|
|
|
/* release read lock on client_tree */
|
|
|
|
avl_tree_unlock(source->client_tree);
|
|
|
|
|
|
|
|
refbuf_release(refbuf);
|
|
|
|
|
|
|
|
/* acquire write lock on client_tree */
|
|
|
|
avl_tree_wlock(source->client_tree);
|
|
|
|
|
|
|
|
/** delete bad clients **/
|
|
|
|
client_node = avl_get_first(source->client_tree);
|
|
|
|
while (client_node) {
|
|
|
|
client = (client_t *)client_node->key;
|
|
|
|
if (client->con->error) {
|
|
|
|
client_node = avl_get_next(client_node);
|
|
|
|
avl_delete(source->client_tree, (void *)client, _free_client);
|
|
|
|
listeners--;
|
|
|
|
stats_event_args(source->mount, "listeners", "%d", listeners);
|
|
|
|
source->listeners = listeners;
|
2002-08-09 04:06:00 -04:00
|
|
|
DEBUG0("Client removed");
|
2003-03-14 21:10:19 -05:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
client_node = avl_get_next(client_node);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* acquire write lock on pending_tree */
|
|
|
|
avl_tree_wlock(source->pending_tree);
|
|
|
|
|
|
|
|
/** add pending clients **/
|
|
|
|
client_node = avl_get_first(source->pending_tree);
|
|
|
|
while (client_node) {
|
|
|
|
avl_insert(source->client_tree, client_node->key);
|
2003-05-15 17:03:32 -04:00
|
|
|
/* listener count may have changed */
|
|
|
|
listeners = source->listeners;
|
2003-03-14 21:10:19 -05:00
|
|
|
listeners++;
|
2002-08-09 04:06:00 -04:00
|
|
|
DEBUG0("Client added");
|
2003-03-14 21:10:19 -05:00
|
|
|
stats_event_inc(NULL, "clients");
|
|
|
|
stats_event_inc(source->mount, "connections");
|
|
|
|
stats_event_args(source->mount, "listeners", "%d", listeners);
|
|
|
|
source->listeners = listeners;
|
|
|
|
|
|
|
|
/* we have to send cached headers for some data formats
|
|
|
|
** this is where we queue up the buffers to send
|
|
|
|
*/
|
|
|
|
if (source->format->has_predata) {
|
|
|
|
client = (client_t *)client_node->key;
|
|
|
|
client->queue = source->format->get_predata(source->format);
|
|
|
|
}
|
|
|
|
|
|
|
|
client_node = avl_get_next(client_node);
|
|
|
|
}
|
|
|
|
|
|
|
|
/** clear pending tree **/
|
|
|
|
while (avl_get_first(source->pending_tree)) {
|
|
|
|
avl_delete(source->pending_tree, avl_get_first(source->pending_tree)->key, source_remove_client);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* release write lock on pending_tree */
|
|
|
|
avl_tree_unlock(source->pending_tree);
|
|
|
|
|
|
|
|
/* release write lock on client_tree */
|
|
|
|
avl_tree_unlock(source->client_tree);
|
|
|
|
}
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2002-04-05 04:28:26 -05:00
|
|
|
done:
|
|
|
|
|
2003-03-31 07:54:44 -05:00
|
|
|
INFO1("Source \"%s\" exiting", source->mount);
|
2003-03-27 12:10:14 -05:00
|
|
|
|
2003-05-28 11:04:53 -04:00
|
|
|
#ifdef USE_YP
|
2003-06-26 09:32:04 -04:00
|
|
|
if(source->yp_public) {
|
2003-03-14 21:10:19 -05:00
|
|
|
yp_remove(source);
|
|
|
|
}
|
2003-03-27 12:10:14 -05:00
|
|
|
#endif
|
|
|
|
|
2002-12-30 10:19:46 -05:00
|
|
|
avl_tree_rlock(global.source_tree);
|
|
|
|
fallback_source = source_find_mount(source->fallback_mount);
|
|
|
|
avl_tree_unlock(global.source_tree);
|
|
|
|
|
2003-03-14 02:59:58 -05:00
|
|
|
/* Now, we must remove this source from the source tree before
|
|
|
|
* removing the clients, otherwise new clients can sneak into the pending
|
|
|
|
* tree after we've cleared it
|
|
|
|
*/
|
2003-03-14 21:10:19 -05:00
|
|
|
avl_tree_wlock(global.source_tree);
|
|
|
|
avl_delete(global.source_tree, source, source_remove_source);
|
|
|
|
avl_tree_unlock(global.source_tree);
|
2003-03-14 02:59:58 -05:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
/* we need to empty the client and pending trees */
|
|
|
|
avl_tree_wlock(source->pending_tree);
|
|
|
|
while (avl_get_first(source->pending_tree)) {
|
2002-12-30 10:19:46 -05:00
|
|
|
client_t *client = (client_t *)avl_get_first(
|
|
|
|
source->pending_tree)->key;
|
|
|
|
if(fallback_source) {
|
2003-03-14 02:59:58 -05:00
|
|
|
avl_delete(source->pending_tree, client, source_remove_client);
|
2002-12-30 10:19:46 -05:00
|
|
|
|
2003-02-06 08:10:48 -05:00
|
|
|
/* TODO: reset client local format data? */
|
2002-12-30 10:19:46 -05:00
|
|
|
avl_tree_wlock(fallback_source->pending_tree);
|
|
|
|
avl_insert(fallback_source->pending_tree, (void *)client);
|
|
|
|
avl_tree_unlock(fallback_source->pending_tree);
|
|
|
|
}
|
|
|
|
else {
|
2003-03-14 21:10:19 -05:00
|
|
|
avl_delete(source->pending_tree, client, _free_client);
|
2002-12-30 10:19:46 -05:00
|
|
|
}
|
2003-03-14 21:10:19 -05:00
|
|
|
}
|
|
|
|
avl_tree_unlock(source->pending_tree);
|
2002-12-30 10:19:46 -05:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
avl_tree_wlock(source->client_tree);
|
|
|
|
while (avl_get_first(source->client_tree)) {
|
2002-12-30 10:19:46 -05:00
|
|
|
client_t *client = (client_t *)avl_get_first(source->client_tree)->key;
|
|
|
|
|
|
|
|
if(fallback_source) {
|
2003-03-14 02:59:58 -05:00
|
|
|
avl_delete(source->client_tree, client, source_remove_client);
|
2002-12-30 10:19:46 -05:00
|
|
|
|
2003-02-06 08:10:48 -05:00
|
|
|
/* TODO: reset client local format data? */
|
2002-12-30 10:19:46 -05:00
|
|
|
avl_tree_wlock(fallback_source->pending_tree);
|
|
|
|
avl_insert(fallback_source->pending_tree, (void *)client);
|
|
|
|
avl_tree_unlock(fallback_source->pending_tree);
|
|
|
|
}
|
|
|
|
else {
|
2003-03-14 21:10:19 -05:00
|
|
|
avl_delete(source->client_tree, client, _free_client);
|
2002-12-30 10:19:46 -05:00
|
|
|
}
|
2003-03-14 21:10:19 -05:00
|
|
|
}
|
|
|
|
avl_tree_unlock(source->client_tree);
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
/* delete this sources stats */
|
|
|
|
stats_event_dec(NULL, "sources");
|
|
|
|
stats_event(source->mount, "listeners", NULL);
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
global_lock();
|
|
|
|
global.sources--;
|
|
|
|
global_unlock();
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-03-05 08:03:35 -05:00
|
|
|
if(source->dumpfile)
|
|
|
|
fclose(source->dumpfile);
|
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
/* release our hold on the lock so the main thread can continue cleaning up */
|
|
|
|
thread_rwlock_unlock(source->shutdown_rwlock);
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-03-19 02:59:32 -05:00
|
|
|
source_free_source(source);
|
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
thread_exit(0);
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
return NULL;
|
2001-09-09 22:21:46 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int _compare_clients(void *compare_arg, void *a, void *b)
|
|
|
|
{
|
2003-03-30 08:52:27 -05:00
|
|
|
client_t *clienta = (client_t *)a;
|
|
|
|
client_t *clientb = (client_t *)b;
|
|
|
|
|
|
|
|
connection_t *cona = clienta->con;
|
|
|
|
connection_t *conb = clientb->con;
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
if (cona->id < conb->id) return -1;
|
|
|
|
if (cona->id > conb->id) return 1;
|
2001-09-09 22:21:46 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
return 0;
|
2001-09-09 22:21:46 -04:00
|
|
|
}
|
|
|
|
|
2003-03-14 02:59:58 -05:00
|
|
|
int source_remove_client(void *key)
|
2001-09-09 22:21:46 -04:00
|
|
|
{
|
2003-03-14 21:10:19 -05:00
|
|
|
return 1;
|
2001-09-09 22:21:46 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int _free_client(void *key)
|
|
|
|
{
|
2003-03-14 21:10:19 -05:00
|
|
|
client_t *client = (client_t *)key;
|
|
|
|
|
|
|
|
global_lock();
|
|
|
|
global.clients--;
|
|
|
|
global_unlock();
|
|
|
|
stats_event_dec(NULL, "clients");
|
|
|
|
|
|
|
|
client_destroy(client);
|
|
|
|
|
|
|
|
return 1;
|
2001-09-09 22:21:46 -04:00
|
|
|
}
|
2003-02-06 08:10:48 -05:00
|
|
|
|
2003-02-26 18:52:23 -05:00
|
|
|
static int _parse_audio_info(source_t *source, char *s)
|
|
|
|
{
|
2003-02-26 22:01:12 -05:00
|
|
|
char *token = NULL;
|
|
|
|
char *pvar = NULL;
|
|
|
|
char *variable = NULL;
|
|
|
|
char *value = NULL;
|
2003-02-26 18:52:23 -05:00
|
|
|
|
|
|
|
while ((token = strtok(s,";")) != NULL) {
|
|
|
|
pvar = strchr(token, '=');
|
|
|
|
if (pvar) {
|
|
|
|
variable = (char *)malloc(pvar-token+1);
|
2003-03-14 21:10:19 -05:00
|
|
|
strncpy(variable, token, pvar-token);
|
2003-03-19 02:55:42 -05:00
|
|
|
variable[pvar-token] = 0;
|
2003-02-26 18:52:23 -05:00
|
|
|
pvar++;
|
|
|
|
if (strlen(pvar)) {
|
2003-03-06 09:17:33 -05:00
|
|
|
value = util_url_unescape(pvar);
|
2003-02-26 18:52:23 -05:00
|
|
|
util_dict_set(source->audio_info, variable, value);
|
|
|
|
stats_event(source->mount, variable, value);
|
2003-02-26 22:01:12 -05:00
|
|
|
if (value) {
|
|
|
|
free(value);
|
|
|
|
}
|
2003-02-26 18:52:23 -05:00
|
|
|
}
|
|
|
|
if (variable) {
|
2003-03-06 09:17:33 -05:00
|
|
|
free(variable);
|
2003-02-26 18:52:23 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
s = NULL;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|