source.c 12.4 KB
Newer Older
Jack Moffitt's avatar
Jack Moffitt committed
1 2 3 4
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
5 6 7
#include <ogg/ogg.h>

#ifndef _WIN32
8
#include <unistd.h>
Jack Moffitt's avatar
Jack Moffitt committed
9 10
#include <sys/time.h>
#include <sys/socket.h>
11
#else
12 13
#include <winsock2.h>
#include <windows.h>
14
#endif
Jack Moffitt's avatar
Jack Moffitt committed
15 16 17 18 19 20 21 22 23 24 25

#include "thread.h"
#include "avl.h"
#include "httpp.h"
#include "sock.h"

#include "connection.h"
#include "global.h"
#include "refbuf.h"
#include "client.h"
#include "stats.h"
26
#include "log.h"
27
#include "logging.h"
28
#include "config.h"
29
#include "util.h"
Jack Moffitt's avatar
Jack Moffitt committed
30
#include "source.h"
Michael Smith's avatar
Michael Smith committed
31
#include "format.h"
Jack Moffitt's avatar
Jack Moffitt committed
32

33 34 35
#undef CATMODULE
#define CATMODULE "source"

Jack Moffitt's avatar
Jack Moffitt committed
36 37 38 39 40
/* avl tree helper */
static int _compare_clients(void *compare_arg, void *a, void *b);
static int _remove_client(void *key);
static int _free_client(void *key);

41
source_t *source_create(client_t *client, connection_t *con, http_parser_t *parser, const char *mount, format_type_t type)
Jack Moffitt's avatar
Jack Moffitt committed
42 43 44 45
{
	source_t *src;

	src = (source_t *)malloc(sizeof(source_t));
46
    src->client = client;
Jack Moffitt's avatar
Jack Moffitt committed
47
	src->mount = (char *)strdup(mount);
Michael Smith's avatar
Michael Smith committed
48
    src->fallback_mount = NULL;
Jack Moffitt's avatar
Jack Moffitt committed
49
	src->format = format_get_plugin(type, src->mount);
Jack Moffitt's avatar
Jack Moffitt committed
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
	src->con = con;
	src->parser = parser;
	src->client_tree = avl_tree_new(_compare_clients, NULL);
	src->pending_tree = avl_tree_new(_compare_clients, NULL);

	return src;
}

/* you must already have a read lock on the global source tree
** to call this function
*/
source_t *source_find_mount(const char *mount)
{
	source_t *source;
	avl_node *node;
	int cmp;

67 68 69
	if (!mount) {
		return NULL;
	}
Jack Moffitt's avatar
Jack Moffitt committed
70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
	/* 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;
}

int source_compare_sources(void *arg, void *a, void *b)
{
	source_t *srca = (source_t *)a;
	source_t *srcb = (source_t *)b;

	return strcmp(srca->mount, srcb->mount);
}

int source_free_source(void *key)
{
	source_t *source = (source_t *)key;

	free(source->mount);
Michael Smith's avatar
Michael Smith committed
101
    free(source->fallback_mount);
102
    client_destroy(source->client);
Jack Moffitt's avatar
Jack Moffitt committed
103 104
	avl_tree_free(source->pending_tree, _free_client);
	avl_tree_free(source->client_tree, _free_client);
105
	source->format->free_plugin(source->format);
Jack Moffitt's avatar
Jack Moffitt committed
106 107 108 109 110 111 112 113 114
	free(source);

	return 1;
}
	

void *source_main(void *arg)
{
	source_t *source = (source_t *)arg;
Michael Smith's avatar
Michael Smith committed
115
    source_t *fallback_source;
Jack Moffitt's avatar
Jack Moffitt committed
116 117
	char buffer[4096];
	long bytes, sbytes;
118
	int ret, timeout;
Jack Moffitt's avatar
Jack Moffitt committed
119 120
	client_t *client;
	avl_node *client_node;
Jack Moffitt's avatar
Jack Moffitt committed
121
	char *s;
Jack Moffitt's avatar
Jack Moffitt committed
122 123 124 125 126 127

	refbuf_t *refbuf, *abuf;
	int data_done;

	int listeners = 0;

128 129
	timeout = config_get_config()->source_timeout;

Jack Moffitt's avatar
Jack Moffitt committed
130 131 132 133 134 135 136 137 138 139 140 141 142
	/* grab a read lock, to make sure we get a chance to cleanup */
	thread_rwlock_rlock(source->shutdown_rwlock);

	/* get a write lock on the global source tree */
	avl_tree_wlock(global.source_tree);
	/* 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);


	/* start off the statistics */
	stats_event(source->mount, "listeners", "0");
Jack Moffitt's avatar
Jack Moffitt committed
143 144 145 146
	if ((s = httpp_getvar(source->parser, "ice-name")))
		stats_event(source->mount, "name", s);
	if ((s = httpp_getvar(source->parser, "ice-url")))
		stats_event(source->mount, "url", s);
147 148
	if ((s = httpp_getvar(source->parser, "ice-genre")))
		stats_event(source->mount, "genre", s);
Jack Moffitt's avatar
Jack Moffitt committed
149 150 151 152
	if ((s = httpp_getvar(source->parser, "ice-bitrate")))
		stats_event(source->mount, "bitrate", s);
	if ((s = httpp_getvar(source->parser, "ice-description")))
		stats_event(source->mount, "description", s);
153
    stats_event(source->mount, "type", source->format->format_description);
Jack Moffitt's avatar
Jack Moffitt committed
154 155

	while (global.running == ICE_RUNNING) {
156
		ret = source->format->get_buffer(source->format, NULL, 0, &refbuf);
Michael Smith's avatar
Michael Smith committed
157 158 159 160
        if(ret < 0) {
            WARN0("Bad data from source");
            break;
        }
161
        bytes = 1; /* Set to > 0 so that the post-loop check won't be tripped */
Jack Moffitt's avatar
Jack Moffitt committed
162 163 164
		while (refbuf == NULL) {
			bytes = 0;
			while (bytes <= 0) {
165 166 167
                ret = util_timed_wait_for_fd(source->con->sock, timeout*1000);

				if (ret <= 0) { /* timeout expired */
168 169
                    WARN1("Disconnecting source: socket timeout (%d s) expired",
                           timeout);
170 171 172
					bytes = 0;
					break;
				}
Jack Moffitt's avatar
Jack Moffitt committed
173 174

				bytes = sock_read_bytes(source->con->sock, buffer, 4096);
175 176 177
				if (bytes == 0 || (bytes < 0 && !sock_recoverable(sock_error()))) {
                    DEBUG1("Disconnecting source due to socket read error: %s",
                            strerror(sock_error()));
178
                    break;
179
                }
Jack Moffitt's avatar
Jack Moffitt committed
180 181
			}
			if (bytes <= 0) break;
182
            source->client->con->sent_bytes += bytes;
Michael Smith's avatar
Michael Smith committed
183 184 185 186 187
			ret = source->format->get_buffer(source->format, buffer, bytes, &refbuf);
            if(ret < 0) {
                WARN0("Bad data from source");
                goto done;
            }
Jack Moffitt's avatar
Jack Moffitt committed
188 189 190
		}

		if (bytes <= 0) {
191
			INFO0("Removing source following disconnection");
Jack Moffitt's avatar
Jack Moffitt committed
192 193 194 195 196
			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
Michael Smith's avatar
Michael Smith committed
197
		** immediately, it should store it on its queue for the next
Jack Moffitt's avatar
Jack Moffitt committed
198 199 200
		** go around.
		**
		** instead of sending the current block, a client should send
Michael Smith's avatar
Michael Smith committed
201
		** all data in the queue, plus the current block, until either
Jack Moffitt's avatar
Jack Moffitt committed
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226
		** 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
		*/

		/* acquire read lock on client_tree */
		avl_tree_rlock(source->client_tree);

		client_node = avl_get_first(source->client_tree);
		while (client_node) {
			/* acquire read lock on node */
			avl_node_wlock(client_node);

			client = (client_t *)client_node->key;
			
			data_done = 0;

			/* 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;

227 228
				sbytes = source->format->write_buf_to_client(source->format,
                        client, &abuf->data[client->pos], bytes);
229 230
				if (sbytes >= 0) {
                    if(sbytes != bytes) {
231 232 233
                        /* We didn't send the entire buffer. Leave it for
                         * the moment, handle it in the next iteration.
                         */
234 235 236 237 238 239
                        client->pos += sbytes;
                        refbuf_queue_insert(&client->queue, abuf);
                        data_done = 1;
                        break;
                    }
                }
240 241 242
                else {
                    DEBUG0("Client has unrecoverable error catching up. Client has probably disconnected");
                    client->con->error = 1;
Jack Moffitt's avatar
Jack Moffitt committed
243
					data_done = 1;
244
                    refbuf_release(abuf);
Jack Moffitt's avatar
Jack Moffitt committed
245 246 247 248 249 250 251 252 253 254 255 256 257 258 259
					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 {
260 261
				sbytes = source->format->write_buf_to_client(source->format,
                        client, refbuf->data, refbuf->len);
262
				if (sbytes >= 0) {
263 264
                    if(sbytes != refbuf->len) {
                        /* Didn't send the entire buffer, queue it */
265 266
                        client->pos = sbytes;
						refbuf_addref(refbuf);
Michael Smith's avatar
Michael Smith committed
267
                        refbuf_queue_insert(&client->queue, refbuf);
268 269
                    }
                }
270 271 272
                else {
                    DEBUG0("Client had unrecoverable error with new data, probably due to client disconnection");
                    client->con->error = 1;
Jack Moffitt's avatar
Jack Moffitt committed
273 274 275 276 277 278 279 280 281 282
				}
			}

			/* 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.
			** the queue_limit might need to be tuned, but should work fine.
			** TODO: put queue_limit in a config file
			*/
			if (refbuf_queue_size(&client->queue) > 25) {
283
                DEBUG0("Client has fallen too far behind, removing");
Jack Moffitt's avatar
Jack Moffitt committed
284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309
				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);
310
                DEBUG0("Client removed");
Jack Moffitt's avatar
Jack Moffitt committed
311 312 313 314 315 316 317 318 319 320 321 322 323
				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);
			listeners++;
324
            DEBUG0("Client added");
Jack Moffitt's avatar
Jack Moffitt committed
325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351
			stats_event_inc(NULL, "clients");
			stats_event_inc(source->mount, "connections");
			stats_event_args(source->mount, "listeners", "%d", 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, _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);
	}

Michael Smith's avatar
Michael Smith committed
352 353
done:

354
    DEBUG0("Source exiting");
Jack Moffitt's avatar
Jack Moffitt committed
355

Michael Smith's avatar
Michael Smith committed
356 357 358 359
    avl_tree_rlock(global.source_tree);
    fallback_source = source_find_mount(source->fallback_mount);
    avl_tree_unlock(global.source_tree);

Jack Moffitt's avatar
Jack Moffitt committed
360 361 362
	/* we need to empty the client and pending trees */
	avl_tree_wlock(source->pending_tree);
	while (avl_get_first(source->pending_tree)) {
Michael Smith's avatar
Michael Smith committed
363 364 365 366 367 368 369 370 371 372 373 374 375
        client_t *client = (client_t *)avl_get_first(
                source->pending_tree)->key;
        if(fallback_source) {
            avl_delete(source->pending_tree, client, _remove_client);

            // TODO: reset client local format data? 
            avl_tree_wlock(fallback_source->pending_tree);
            avl_insert(fallback_source->pending_tree, (void *)client);
            avl_tree_unlock(fallback_source->pending_tree);
        }
        else {
    		avl_delete(source->pending_tree, client, _free_client);
        }
Jack Moffitt's avatar
Jack Moffitt committed
376 377
	}
	avl_tree_unlock(source->pending_tree);
Michael Smith's avatar
Michael Smith committed
378

Jack Moffitt's avatar
Jack Moffitt committed
379 380
	avl_tree_wlock(source->client_tree);
	while (avl_get_first(source->client_tree)) {
Michael Smith's avatar
Michael Smith committed
381 382 383 384 385 386 387 388 389 390 391 392 393
        client_t *client = (client_t *)avl_get_first(source->client_tree)->key;

        if(fallback_source) {
            avl_delete(source->client_tree, client, _remove_client);

            // TODO: reset client local format data? 
            avl_tree_wlock(fallback_source->pending_tree);
            avl_insert(fallback_source->pending_tree, (void *)client);
            avl_tree_unlock(fallback_source->pending_tree);
        }
        else {
		    avl_delete(source->client_tree, client, _free_client);
        }
Jack Moffitt's avatar
Jack Moffitt committed
394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419
	}
	avl_tree_unlock(source->client_tree);

	/* delete this sources stats */
	stats_event_dec(NULL, "sources");
	stats_event(source->mount, "listeners", NULL);

	global_lock();
	global.sources--;
	global_unlock();

	/* release our hold on the lock so the main thread can continue cleaning up */
	thread_rwlock_unlock(source->shutdown_rwlock);

	avl_tree_wlock(global.source_tree);
	avl_delete(global.source_tree, source, source_free_source);
	avl_tree_unlock(global.source_tree);

	thread_exit(0);
      
	return NULL;
}

static int _compare_clients(void *compare_arg, void *a, void *b)
{
	connection_t *cona = (connection_t *)a;
420
    connection_t *conb = (connection_t *)b;
Jack Moffitt's avatar
Jack Moffitt committed
421 422 423 424 425 426 427 428 429 430 431 432 433 434 435

	if (cona->id < conb->id) return -1;
	if (cona->id > conb->id) return 1;

	return 0;
}

static int _remove_client(void *key)
{
	return 1;
}

static int _free_client(void *key)
{
	client_t *client = (client_t *)key;
436 437 438 439 440

	global_lock();
	global.clients--;
	global_unlock();
	stats_event_dec(NULL, "clients");
Jack Moffitt's avatar
Jack Moffitt committed
441 442 443 444 445
	
	client_destroy(client);
	
	return 1;
}