connection.c 25.4 KB
Newer Older
1
/* -*- c-basic-offset: 4; indent-tabs-mode: nil; -*- */
Jack Moffitt's avatar
Jack Moffitt committed
2 3 4
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
5
#include <time.h>
Jack Moffitt's avatar
Jack Moffitt committed
6
#include <sys/types.h>
7
#include <sys/stat.h>
8 9 10
#ifdef HAVE_POLL
#include <sys/poll.h>
#endif
11 12 13

#ifndef _WIN32
#include <sys/time.h>
Jack Moffitt's avatar
Jack Moffitt committed
14 15
#include <sys/socket.h>
#include <netinet/in.h>
16
#else
17
#include <winsock2.h>
18 19
#define snprintf _snprintf
#define strcasecmp stricmp
20
#define strncasecmp strnicmp
21
#endif
Jack Moffitt's avatar
Jack Moffitt committed
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

#include "os.h"

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

#include "config.h"
#include "global.h"
#include "util.h"
#include "connection.h"
#include "refbuf.h"
#include "client.h"
#include "stats.h"
#include "logging.h"
39
#include "xslt.h"
40
#include "fserve.h"
41 42

#include "yp.h"
Jack Moffitt's avatar
Jack Moffitt committed
43
#include "source.h"
44
#include "format.h"
45
#include "format_mp3.h"
46
#include "event.h"
47
#include "admin.h"
Jack Moffitt's avatar
Jack Moffitt committed
48 49 50 51

#define CATMODULE "connection"

typedef struct con_queue_tag {
52 53
    connection_t *con;
    struct con_queue_tag *next;
Jack Moffitt's avatar
Jack Moffitt committed
54 55 56
} con_queue_t;

typedef struct _thread_queue_tag {
57 58
    thread_type *thread_id;
    struct _thread_queue_tag *next;
Jack Moffitt's avatar
Jack Moffitt committed
59 60 61 62 63 64 65 66 67 68 69 70
} thread_queue_t;

static mutex_t _connection_mutex;
static unsigned long _current_id = 0;
static int _initialized = 0;
static cond_t _pool_cond;

static con_queue_t *_queue = NULL;
static mutex_t _queue_mutex;

static thread_queue_t *_conhands = NULL;

71
rwlock_t _source_shutdown_rwlock;
Jack Moffitt's avatar
Jack Moffitt committed
72 73 74 75 76

static void *_handle_connection(void *arg);

void connection_initialize(void)
{
77 78 79 80 81 82
    if (_initialized) return;
    
    thread_mutex_create(&_connection_mutex);
    thread_mutex_create(&_queue_mutex);
    thread_rwlock_create(&_source_shutdown_rwlock);
    thread_cond_create(&_pool_cond);
83
    thread_cond_create(&global.shutdown_cond);
Jack Moffitt's avatar
Jack Moffitt committed
84

85
    _initialized = 1;
Jack Moffitt's avatar
Jack Moffitt committed
86 87 88 89
}

void connection_shutdown(void)
{
90 91
    if (!_initialized) return;
    
92
    thread_cond_destroy(&global.shutdown_cond);
93 94 95 96
    thread_cond_destroy(&_pool_cond);
    thread_rwlock_destroy(&_source_shutdown_rwlock);
    thread_mutex_destroy(&_queue_mutex);
    thread_mutex_destroy(&_connection_mutex);
Jack Moffitt's avatar
Jack Moffitt committed
97

98
    _initialized = 0;
Jack Moffitt's avatar
Jack Moffitt committed
99 100 101 102
}

static unsigned long _next_connection_id(void)
{
103
    unsigned long id;
Jack Moffitt's avatar
Jack Moffitt committed
104

105 106 107
    thread_mutex_lock(&_connection_mutex);
    id = _current_id++;
    thread_mutex_unlock(&_connection_mutex);
Jack Moffitt's avatar
Jack Moffitt committed
108

109
    return id;
Jack Moffitt's avatar
Jack Moffitt committed
110 111
}

112
connection_t *create_connection(sock_t sock, sock_t serversock, char *ip) {
113 114 115 116
    connection_t *con;
    con = (connection_t *)malloc(sizeof(connection_t));
    memset(con, 0, sizeof(connection_t));
    con->sock = sock;
117
    con->serversock = serversock;
118 119 120
    con->con_time = time(NULL);
    con->id = _next_connection_id();
    con->ip = ip;
121 122 123 124

    con->event_number = EVENT_NO_EVENT;
    con->event = NULL;

125
    return con;
126 127
}

128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
static int wait_for_serversock(int timeout)
{
#ifdef HAVE_POLL
    struct pollfd ufds[MAX_LISTEN_SOCKETS];
    int i, ret;

    for(i=0; i < global.server_sockets; i++) {
        ufds[i].fd = global.serversock[i];
        ufds[i].events = POLLIN;
        ufds[i].revents = 0;
    }

    ret = poll(ufds, global.server_sockets, timeout);
    if(ret < 0) {
        return -2;
    }
    else if(ret == 0) {
        return -1;
    }
    else {
        for(i=0; i < global.server_sockets; i++) {
            if(ufds[i].revents == POLLIN)
                return ufds[i].fd;
        }
        return -1; /* Shouldn't happen */
    }
#else
    fd_set rfds;
    struct timeval tv, *p=NULL;
    int i, ret;
    int max = -1;

    FD_ZERO(&rfds);

    for(i=0; i < global.server_sockets; i++) {
        FD_SET(global.serversock[i], &rfds);
        if(global.serversock[i] > max)
            max = global.serversock[i];
    }

    if(timeout >= 0) {
        tv.tv_sec = timeout/1000;
170
        tv.tv_usec = (timeout % 1000) * 1000;
171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
        p = &tv;
    }

    ret = select(max+1, &rfds, NULL, NULL, p);
    if(ret < 0) {
        return -2;
    }
    else if(ret == 0) {
        return -1;
    }
    else {
        for(i=0; i < global.server_sockets; i++) {
            if(FD_ISSET(global.serversock[i], &rfds))
                return global.serversock[i];
        }
        return -1; /* Should be impossible, stop compiler warnings */
    }
#endif
}

Jack Moffitt's avatar
Jack Moffitt committed
191 192
static connection_t *_accept_connection(void)
{
193 194 195
    int sock;
    connection_t *con;
    char *ip;
196
    int serversock; 
Jack Moffitt's avatar
Jack Moffitt committed
197

198 199 200
    serversock = wait_for_serversock(100);
    if(serversock < 0)
        return NULL;
Jack Moffitt's avatar
Jack Moffitt committed
201

202 203
    /* malloc enough room for a full IP address (including ipv6) */
    ip = (char *)malloc(MAX_ADDR_LEN);
Jack Moffitt's avatar
Jack Moffitt committed
204

205 206
    sock = sock_accept(serversock, ip, MAX_ADDR_LEN);
    if (sock >= 0) {
207
        con = create_connection(sock, serversock, ip);
Jack Moffitt's avatar
Jack Moffitt committed
208

209 210
        return con;
    }
Jack Moffitt's avatar
Jack Moffitt committed
211

212 213 214 215
    if (!sock_recoverable(sock_error()))
        WARN2("accept() failed with error %d: %s", sock_error(), strerror(sock_error()));
    
    free(ip);
Jack Moffitt's avatar
Jack Moffitt committed
216

217
    return NULL;
Jack Moffitt's avatar
Jack Moffitt committed
218 219 220 221
}

static void _add_connection(connection_t *con)
{
222
    con_queue_t *node;
Jack Moffitt's avatar
Jack Moffitt committed
223

224 225 226 227 228 229 230
    node = (con_queue_t *)malloc(sizeof(con_queue_t));
    
    thread_mutex_lock(&_queue_mutex);
    node->con = con;
    node->next = _queue;
    _queue = node;
    thread_mutex_unlock(&_queue_mutex);
Jack Moffitt's avatar
Jack Moffitt committed
231 232 233 234 235

}

static void _signal_pool(void)
{
236
    thread_cond_signal(&_pool_cond);
Jack Moffitt's avatar
Jack Moffitt committed
237 238
}

239
static void _push_thread(thread_queue_t **queue, thread_type *thread_id)
Jack Moffitt's avatar
Jack Moffitt committed
240
{
241 242 243 244 245 246 247 248 249 250 251 252 253 254
    /* create item */
    thread_queue_t *item = (thread_queue_t *)malloc(sizeof(thread_queue_t));
    item->thread_id = thread_id;
    item->next = NULL;


    thread_mutex_lock(&_queue_mutex);
    if (*queue == NULL) {
        *queue = item;
    } else {
        item->next = *queue;
        *queue = item;
    }
    thread_mutex_unlock(&_queue_mutex);
Jack Moffitt's avatar
Jack Moffitt committed
255 256
}

257
static thread_type *_pop_thread(thread_queue_t **queue)
Jack Moffitt's avatar
Jack Moffitt committed
258
{
259 260
    thread_type *id;
    thread_queue_t *item;
Jack Moffitt's avatar
Jack Moffitt committed
261

262
    thread_mutex_lock(&_queue_mutex);
Jack Moffitt's avatar
Jack Moffitt committed
263

264 265 266 267 268
    item = *queue;
    if (item == NULL) {
        thread_mutex_unlock(&_queue_mutex);
        return NULL;
    }
Jack Moffitt's avatar
Jack Moffitt committed
269

270 271 272 273
    *queue = item->next;
    item->next = NULL;
    id = item->thread_id;
    free(item);
Jack Moffitt's avatar
Jack Moffitt committed
274

275
    thread_mutex_unlock(&_queue_mutex);
Jack Moffitt's avatar
Jack Moffitt committed
276

277
    return id;
Jack Moffitt's avatar
Jack Moffitt committed
278 279 280 281
}

static void _build_pool(void)
{
282 283
    ice_config_t *config;
    int i;
284
    thread_type *tid;
285
    char buff[64];
286
    int threadpool_size;
Jack Moffitt's avatar
Jack Moffitt committed
287

288
    config = config_get_config();
289 290
    threadpool_size = config->threadpool_size;
    config_release_config();
Jack Moffitt's avatar
Jack Moffitt committed
291

292 293 294 295 296
    for (i = 0; i < threadpool_size; i++) {
        snprintf(buff, 64, "Connection Thread #%d", i);
        tid = thread_create(buff, _handle_connection, NULL, THREAD_ATTACHED);
        _push_thread(&_conhands, tid);
    }
Jack Moffitt's avatar
Jack Moffitt committed
297 298 299 300
}

static void _destroy_pool(void)
{
301 302 303 304 305 306 307 308 309 310 311 312
    thread_type *id;
    int i;

    i = 0;

    thread_cond_broadcast(&_pool_cond);
    id = _pop_thread(&_conhands);
    while (id != NULL) {
        thread_join(id);
        _signal_pool();
        id = _pop_thread(&_conhands);
    }
Jack Moffitt's avatar
Jack Moffitt committed
313 314 315 316
}

void connection_accept_loop(void)
{
317
    connection_t *con;
Jack Moffitt's avatar
Jack Moffitt committed
318

319
    _build_pool();
Jack Moffitt's avatar
Jack Moffitt committed
320

321 322
    while (global.running == ICE_RUNNING) {
        con = _accept_connection();
Jack Moffitt's avatar
Jack Moffitt committed
323

324 325 326 327 328
        if (con) {
            _add_connection(con);
            _signal_pool();
        }
    }
Jack Moffitt's avatar
Jack Moffitt committed
329

330 331 332
    /* Give all the other threads notification to shut down */
    thread_cond_broadcast(&global.shutdown_cond);

333
    _destroy_pool();
Jack Moffitt's avatar
Jack Moffitt committed
334

335 336 337
    /* wait for all the sources to shutdown */
    thread_rwlock_wlock(&_source_shutdown_rwlock);
    thread_rwlock_unlock(&_source_shutdown_rwlock);
Jack Moffitt's avatar
Jack Moffitt committed
338 339 340 341
}

static connection_t *_get_connection(void)
{
342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
    con_queue_t *node = NULL;
    con_queue_t *oldnode = NULL;
    connection_t *con = NULL;

    thread_mutex_lock(&_queue_mutex);
    if (_queue) {
        node = _queue;
        while (node->next) {
            oldnode = node;
            node = node->next;
        }
        
        /* node is now the last node
        ** and oldnode is the previous one, or NULL
        */
        if (oldnode) oldnode->next = NULL;
        else (_queue) = NULL;
    }
    thread_mutex_unlock(&_queue_mutex);

    if (node) {
        con = node->con;
        free(node);
    }

    return con;
Jack Moffitt's avatar
Jack Moffitt committed
368 369
}

370 371 372 373 374 375 376 377 378 379
void connection_inject_event(int eventnum, void *event_data) {
    connection_t *con = calloc(1, sizeof(connection_t));

    con->event_number = eventnum;
    con->event = event_data;

    _add_connection(con);
    _signal_pool();
}

380 381 382
/* TODO: Make this return an appropriate error code so that we can use HTTP
 * codes where appropriate
 */
383
int connection_create_source(client_t *client, connection_t *con, http_parser_t *parser, char *mount) {
384 385
    source_t *source;
    char *contenttype;
Michael Smith's avatar
Michael Smith committed
386
    mount_proxy *mountproxy, *mountinfo = NULL;
387 388 389 390 391 392
    int source_limit;
    ice_config_t *config;

    config = config_get_config();
    source_limit = config->source_limit;
    config_release_config();
393

394 395 396 397 398 399 400 401 402 403 404 405 406
    /* check to make sure this source wouldn't
    ** be over the limit
    */
    global_lock();
    if (global.sources >= source_limit) {
        INFO1("Source (%s) logged in, but there are too many sources", mount);
        global_unlock();
        return 0;
    }
    global.sources++;
    global_unlock();

    stats_event_inc(NULL, "sources");
Michael Smith's avatar
Michael Smith committed
407
    
408 409 410 411 412
    config = config_get_config();
    mountproxy = config->mounts;
    thread_mutex_lock(&(config_locks()->mounts_lock));
    config_release_config();

Michael Smith's avatar
Michael Smith committed
413 414 415 416 417 418 419
    while(mountproxy) {
        if(!strcmp(mountproxy->mountname, mount)) {
            mountinfo = mountproxy;
            break;
        }
        mountproxy = mountproxy->next;
    }
420

421
    contenttype = httpp_getvar(parser, "content-type");
422

423 424 425 426
    if (contenttype != NULL) {
        format_type_t format = format_get_type(contenttype);
        if (format == FORMAT_ERROR) {
            WARN1("Content-type \"%s\" not supported, dropping source", contenttype);
427
            thread_mutex_unlock(&(config_locks()->mounts_lock));
428
            goto fail;
429 430
        } else {
            source = source_create(client, con, parser, mount, 
Michael Smith's avatar
Michael Smith committed
431
                    format, mountinfo);
432
            thread_mutex_unlock(&(config_locks()->mounts_lock));
433 434
        }
    } else {
435
        format_type_t format = FORMAT_TYPE_MP3;
436
        ERROR0("No content-type header, falling back to backwards compatibility mode for icecast 1.x relays. Assuming content is mp3.");
Michael Smith's avatar
Michael Smith committed
437
        source = source_create(client, con, parser, mount, format, mountinfo);
438
        thread_mutex_unlock(&(config_locks()->mounts_lock));
439
    }
440

441
    source->send_return = 1;
442 443 444 445
    source->shutdown_rwlock = &_source_shutdown_rwlock;
    sock_set_blocking(con->sock, SOCK_NONBLOCK);
    thread_create("Source Thread", source_main, (void *)source, THREAD_DETACHED);
    return 1;
446 447 448 449 450 451 452 453

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

    stats_event_dec(NULL, "sources");
    return 0;
454 455
}

456 457
static int _check_pass_http(http_parser_t *parser, 
        char *correctuser, char *correctpass)
458 459 460 461 462 463 464 465 466 467 468 469 470
{
    /* This will look something like "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==" */
    char *header = httpp_getvar(parser, "authorization");
    char *userpass, *tmp;
    char *username, *password;

    if(header == NULL)
        return 0;

    if(strncmp(header, "Basic ", 6))
        return 0;

    userpass = util_base64_decode(header+6);
471 472 473
    if(userpass == NULL) {
        WARN1("Base64 decode of Authorization header \"%s\" failed",
                header+6);
474
        return 0;
475
    }
476 477 478 479 480 481 482 483 484 485

    tmp = strchr(userpass, ':');
    if(!tmp) {
        free(userpass);
        return 0;
    }
    *tmp = 0;
    username = userpass;
    password = tmp+1;

486
    if(strcmp(username, correctuser) || strcmp(password, correctpass)) {
487 488 489
        free(userpass);
        return 0;
    }
490
    free(userpass);
491 492 493 494

    return 1;
}

495 496 497 498 499 500 501 502
static int _check_pass_icy(http_parser_t *parser, char *correctpass)
{
    char *password;

    password = httpp_getvar(parser, HTTPP_VAR_ICYPASSWORD);
    if(!password)
        return 0;

503
    if (strcmp(password, correctpass))
504 505 506 507 508
        return 0;
    else
        return 1;
}

509
static int _check_pass_ice(http_parser_t *parser, char *correctpass)
510
{
511
    char *password;
512 513 514 515 516

    password = httpp_getvar(parser, "ice-password");
    if(!password)
        password = "";

517
    if (strcmp(password, correctpass))
518 519 520 521 522
        return 0;
    else
        return 1;
}

523
int connection_check_admin_pass(http_parser_t *parser)
524
{
525 526 527 528 529
    ice_config_t *config = config_get_config();
    char *pass = config->admin_password;
    char *user = config->admin_username;
    config_release_config();

530 531 532
    if(!pass || !user)
        return 0;

533
    return _check_pass_http(parser, user, pass);
534 535
}

536
int connection_check_source_pass(http_parser_t *parser, char *mount)
537
{
538 539
    ice_config_t *config = config_get_config();
    char *pass = config->source_password;
540
    char *user = "source";
541
    int ret;
542
    int ice_login = config->ice_login;
543
    char *protocol;
544 545 546 547

    mount_proxy *mountinfo = config->mounts;
    thread_mutex_lock(&(config_locks()->mounts_lock));
    config_release_config();
548

549 550
    while(mountinfo) {
        if(!strcmp(mountinfo->mountname, mount)) {
551 552 553 554
            if(mountinfo->password)
                pass = mountinfo->password;
            if(mountinfo->username)
                user = mountinfo->username;
555 556
            break;
        }
557
        mountinfo = mountinfo->next;
558 559
    }

560 561
    thread_mutex_unlock(&(config_locks()->mounts_lock));

562 563 564 565 566
    if(!pass) {
        WARN0("No source password set, rejecting source");
        return 0;
    }

567
    protocol = httpp_getvar(parser, HTTPP_VAR_PROTOCOL);
568 569 570 571 572 573 574 575 576 577 578
    if(protocol != NULL && !strcmp(protocol, "ICY")) {
        ret = _check_pass_icy(parser, pass);
    }
    else {
        ret = _check_pass_http(parser, user, pass);
        if(!ret && ice_login)
        {
            ret = _check_pass_ice(parser, pass);
            if(ret)
                WARN0("Source is using deprecated icecast login");
        }
579 580
    }
    return ret;
581 582
}

583 584 585
static void _handle_source_request(connection_t *con, 
        http_parser_t *parser, char *uri)
{
586 587
    client_t *client;

588
    client = client_create(con, parser);
589

590 591
    INFO1("Source logging in at mountpoint \"%s\"", uri);
    stats_event_inc(NULL, "source_connections");
592 593 594
                
    if (!connection_check_source_pass(parser, uri)) {
        INFO1("Source (%s) attempted to login with invalid or missing password", uri);
595
        client_send_401(client);
596
        return;
597
    }
598

599 600 601
    /* check to make sure this source has
    ** a unique mountpoint
    */
602

603 604 605 606
    avl_tree_rlock(global.source_tree);
    if (source_find_mount(uri) != NULL) {
        avl_tree_unlock(global.source_tree);
        INFO1("Source tried to log in as %s, but mountpoint is already used", uri);
607
        client_send_404(client, "Mountpoint in use");
608 609 610
        return;
    }
    avl_tree_unlock(global.source_tree);
611

612
    if (!connection_create_source(client, con, parser, uri)) {
613
        client_send_404(client, "Mountpoint in use");
614
    }
615 616 617 618
}

static void _handle_stats_request(connection_t *con, 
        http_parser_t *parser, char *uri)
Jack Moffitt's avatar
Jack Moffitt committed
619
{
620
    stats_connection_t *stats;
621

622 623 624
    stats_event_inc(NULL, "stats_connections");
                
    if (!connection_check_admin_pass(parser)) {
625
        ERROR0("Bad password for stats connection");
626 627
        connection_close(con);
        httpp_destroy(parser);
628
        return;
629 630 631 632 633 634 635 636 637 638
    }
                    
    stats_event_inc(NULL, "stats");
                    
    /* create stats connection and create stats handler thread */
    stats = (stats_connection_t *)malloc(sizeof(stats_connection_t));
    stats->parser = parser;
    stats->con = con;
                    
    thread_create("Stats Connection", stats_connection, (void *)stats, THREAD_DETACHED);
639 640 641 642 643 644
}

static void _handle_get_request(connection_t *con,
        http_parser_t *parser, char *uri)
{
    char *fullpath;
645
    client_t *client;
646
    int bytes;
647 648
    struct stat statbuf;
    source_t *source;
649 650 651
    int fileserve;
    char *host;
    int port;
652 653 654 655
    int i;
    char *serverhost;
    int serverport;
    aliases *alias;
656 657 658 659 660 661 662
    ice_config_t *config;
    int client_limit;

    config = config_get_config();
    fileserve = config->fileserve;
    host = config->hostname;
    port = config->port;
663 664 665 666 667 668 669 670
    for(i = 0; i < MAX_LISTEN_SOCKETS; i++) {
        if(global.serversock[i] == con->serversock) {
            serverhost = config->listeners[i].bind_address;
            serverport = config->listeners[i].port;
            break;
        }
    }
    alias = config->aliases;
671 672 673
    client_limit = config->client_limit;
    config_release_config();

674 675 676

    DEBUG0("Client connected");

677 678 679 680 681 682 683
    /* make a client */
    client = client_create(con, parser);
    stats_event_inc(NULL, "client_connections");
                    
    /* there are several types of HTTP GET clients
    ** media clients, which are looking for a source (eg, URI = /stream.ogg)
    ** stats clients, which are looking for /admin/stats.xml
684
    ** and directory server authorizers, which are looking for /GUID-xxxxxxxx 
685
    ** (where xxxxxx is the GUID in question) - this isn't implemented yet.
686 687 688 689
    ** we need to handle the latter two before the former, as the latter two
    ** aren't subject to the limits.
    */
    /* TODO: add GUID-xxxxxx */
690

691 692 693 694 695 696 697 698 699
    /* Handle aliases */
    while(alias) {
        if(strcmp(uri, alias->source) == 0 && (alias->port == -1 || alias->port == serverport) && (alias->bind_address == NULL || (serverhost != NULL && strcmp(alias->bind_address, serverhost) == 0))) {
            uri = alias->destination;
            break;
        }
        alias = alias->next;
    }

700
    /* Dispatch all admin requests */
701
    if (strncmp(uri, "/admin/", 7) == 0) {
702
        admin_handle_request(client, uri);
Michael Smith's avatar
Michael Smith committed
703 704 705
        return;
    }

706 707 708 709
    /* Here we are parsing the URI request to see
    ** if the extension is .xsl, if so, then process
    ** this request as an XSLT request
    */
710 711
    fullpath = util_get_path_from_normalised_uri(uri);
    if (util_check_valid_extension(fullpath) == XSLT_CONTENT) {
712 713
        /* If the file exists, then transform it, otherwise, write a 404 */
        if (stat(fullpath, &statbuf) == 0) {
714
            DEBUG0("Stats request, sending XSL transformed stats");
715
            client->respcode = 200;
716
            bytes = sock_write(client->con->sock, 
717 718 719
                    "HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n");
            if(bytes > 0) client->con->sent_bytes = bytes;
            stats_transform_xslt(client, fullpath);
720 721 722
            client_destroy(client);
        }
        else {
723
            client_send_404(client, "The file you requested could not be found");
724
        }
725 726
        free(fullpath);
        return;
727
    }
728 729
    else if(fileserve && stat(fullpath, &statbuf) == 0 && 
            S_ISREG(statbuf.st_mode)) 
730
    {
731
        fserve_client_create(client, fullpath);
732 733 734
        free(fullpath);
        return;
    }
735 736 737 738 739 740
    free(fullpath);

    if(strcmp(util_get_extension(uri), "m3u") == 0) {
        char *sourceuri = strdup(uri);
        char *dot = strrchr(sourceuri, '.');
        *dot = 0;
741 742 743
        avl_tree_rlock(global.source_tree);
        source = source_find_mount(sourceuri);
           if (source) {
744 745 746 747 748
            client->respcode = 200;
            bytes = sock_write(client->con->sock,
                    "HTTP/1.0 200 OK\r\n"
                    "Content-Type: audio/x-mpegurl\r\n\r\n"
                    "http://%s:%d%s", 
749 750
                    host, 
                    port,
751 752 753
                    sourceuri
                    );
            if(bytes > 0) client->con->sent_bytes = bytes;
754
            client_destroy(client);
755
        }
756
        else if(fileserve) {
757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775
            fullpath = util_get_path_from_normalised_uri(sourceuri);
            if(stat(fullpath, &statbuf) == 0) {
                fserve_client_create(client, fullpath);
                free(fullpath);
            }
            else {
                free(fullpath);
                fullpath = util_get_path_from_normalised_uri(uri);
                if(stat(fullpath, &statbuf) == 0) {
                    fserve_client_create(client, fullpath);
                    free(fullpath);
                }
                else {
                    free(fullpath);
                    client_send_404(client, 
                            "The file you requested could not be found");
                }
            }
        }
776 777 778
        else {
            client_send_404(client, "The file you requested could not be found");
        }
779
        avl_tree_unlock(global.source_tree);
780 781 782 783
        free(sourceuri);
        return;
    }

784 785
    global_lock();
    if (global.clients >= client_limit) {
Michael Smith's avatar
Michael Smith committed
786 787
        client_send_504(client,
                "The server is already full. Try again later.");
788
        global_unlock();
789
        return;
790 791 792 793 794 795
    }
    global_unlock();
                    
    avl_tree_rlock(global.source_tree);
    source = source_find_mount(uri);
    if (source) {
796
        DEBUG0("Source found for client");
797 798 799
                        
        global_lock();
        if (global.clients >= client_limit) {
Michael Smith's avatar
Michael Smith committed
800 801
            client_send_504(client, 
                    "The server is already full. Try again later.");
802
            global_unlock();
803 804
            avl_tree_unlock(global.source_tree);
            return;
805
        }
Michael Smith's avatar
Michael Smith committed
806 807 808 809 810
        else if(source->max_listeners != -1 && 
                source->listeners >= source->max_listeners) 
        {
            client_send_504(client, 
                    "Too many clients on this mountpoint. Try again later.");
811
            global_unlock();
Michael Smith's avatar
Michael Smith committed
812 813 814
            avl_tree_unlock(global.source_tree);
            return;
        }
815 816 817
        global.clients++;
        global_unlock();
                        
818 819 820 821
        client->format_data = source->format->create_client_data(
                source->format, source, client);

        source->format->client_send_headers(source->format, source, client);
822 823
                        
        bytes = sock_write(client->con->sock, "\r\n");
824
        if(bytes > 0) client->con->sent_bytes += bytes;
825 826
                            
        sock_set_blocking(client->con->sock, SOCK_NONBLOCK);
827
        sock_set_nodelay(client->con->sock);
828 829 830 831 832 833 834 835 836
                        
        avl_tree_wlock(source->pending_tree);
        avl_insert(source->pending_tree, (void *)client);
        avl_tree_unlock(source->pending_tree);
    }
                    
    avl_tree_unlock(global.source_tree);
                    
    if (!source) {
837 838
        DEBUG0("Source not found for client");
        client_send_404(client, "The source you requested could not be found.");
839
    }
840 841 842 843
}

static void *_handle_connection(void *arg)
{
844 845 846
    char header[4096];
    connection_t *con;
    http_parser_t *parser;
847
    char *rawuri, *uri;
848
    client_t *client;
Jack Moffitt's avatar
Jack Moffitt committed
849

850 851
    while (global.running == ICE_RUNNING) {
        memset(header, 0, 4096);
Jack Moffitt's avatar
Jack Moffitt committed
852

853 854
        thread_cond_wait(&_pool_cond);
        if (global.running != ICE_RUNNING) break;
Jack Moffitt's avatar
Jack Moffitt committed
855

856 857
        /* grab a connection and set the socket to blocking */
        while ((con = _get_connection())) {
858 859 860 861 862 863 864 865 866 867 868 869 870 871 872

            /* Handle meta-connections */
            if(con->event_number > 0) {
                switch(con->event_number) {
                    case EVENT_CONFIG_READ:
                        event_config_read(con->event);
                        break;
                    default:
                        ERROR1("Unknown event number: %d", con->event_number);
                        break;
                }
                free(con);
                continue;
            }

873
            stats_event_inc(NULL, "connections");
Jack Moffitt's avatar
Jack Moffitt committed
874

875
            sock_set_blocking(con->sock, SOCK_BLOCK);
Jack Moffitt's avatar
Jack Moffitt committed
876

877 878 879 880 881 882
            /* fill header with the http header */
            if (util_read_header(con->sock, header, 4096) == 0) {
                /* either we didn't get a complete header, or we timed out */
                connection_close(con);
                continue;
            }
Jack Moffitt's avatar
Jack Moffitt committed
883

884 885 886 887 888 889
            parser = httpp_create_parser();
            httpp_initialize(parser, NULL);
            if (httpp_parse(parser, header, strlen(header))) {
                /* handle the connection or something */
                
                if (strcmp("ICE",  httpp_getvar(parser, HTTPP_VAR_PROTOCOL)) &&
890
                    strcmp("HTTP", httpp_getvar(parser, HTTPP_VAR_PROTOCOL))) {
891
                    ERROR0("Bad HTTP protocol detected");
892 893 894 895
                    connection_close(con);
                    httpp_destroy(parser);
                    continue;
                }
Jack Moffitt's avatar
Jack Moffitt committed
896

897 898 899 900
                rawuri = httpp_getvar(parser, HTTPP_VAR_URI);
                uri = util_normalise_uri(rawuri);

                if(!uri) {
901
                    client = client_create(con, parser);
902
                    client_send_404(client, "The path you requested was invalid");
903 904
                    continue;
                }
905

906
                if (parser->req_type == httpp_req_source) {
907 908 909 910 911 912 913 914 915
                    _handle_source_request(con, parser, uri);
                }
                else if (parser->req_type == httpp_req_stats) {
                    _handle_stats_request(con, parser, uri);
                }
                else if (parser->req_type == httpp_req_get) {
                    _handle_get_request(con, parser, uri);
                }
                else {
916
                    ERROR0("Wrong request type from client");
917 918
                    connection_close(con);
                    httpp_destroy(parser);
919 920 921
                }

                free(uri);
922
            } 
923 924
            else if(httpp_parse_icy(parser, header, strlen(header))) {
                /* TODO: Map incoming icy connections to /icy_0, etc. */
925 926 927 928 929 930 931 932 933 934 935 936
                char mount[20];
                int i = 0;

                strcpy(mount, "/");

                avl_tree_rlock(global.source_tree);
                while(source_find_mount(mount) != NULL) {
                    sprintf(mount, "/icy_%d", i++);
                }
                avl_tree_unlock(global.source_tree);

                _handle_source_request(con, parser, mount);
937 938
            }
            else {
939
                ERROR0("HTTP request parsing failed");
940 941 942 943 944 945
                connection_close(con);
                httpp_destroy(parser);
                continue;
            }
        }
    }
Jack Moffitt's avatar
Jack Moffitt committed
946

947
    thread_exit(0);
Jack Moffitt's avatar
Jack Moffitt committed
948

949
    return NULL;
Jack Moffitt's avatar
Jack Moffitt committed
950 951 952 953
}

void connection_close(connection_t *con)
{
954 955 956 957
    sock_close(con->sock);
    if (con->ip) free(con->ip);
    if (con->host) free(con->host);
    free(con);
Jack Moffitt's avatar
Jack Moffitt committed
958
}