connection.c 25.5 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"
Michael Smith's avatar
Michael Smith committed
44
#include "format.h"
45
#include "format_mp3.h"
Michael Smith's avatar
Michael Smith committed
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;
Michael Smith's avatar
Michael Smith committed
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];
Michael Smith's avatar
Michael Smith committed
286
    int threadpool_size;
Jack Moffitt's avatar
Jack Moffitt committed
287

288
    config = config_get_config();
Michael Smith's avatar
Michael Smith committed
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
}

Michael Smith's avatar
Michael Smith committed
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;
Michael Smith's avatar
Michael Smith committed
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
    
Michael Smith's avatar
Michael Smith committed
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);
Michael Smith's avatar
Michael Smith committed
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);
Michael Smith's avatar
Michael Smith committed
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);
Michael Smith's avatar
Michael Smith committed
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
{
Michael Smith's avatar
Michael Smith committed
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
{
Michael Smith's avatar
Michael Smith committed
538 539
    ice_config_t *config = config_get_config();
    char *pass = config->source_password;
540
    char *user = "source";
541
    int ret;
Michael Smith's avatar
Michael Smith committed
542
    int ice_login = config->ice_login;
543
    char *protocol;
Michael Smith's avatar
Michael Smith committed
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
    }

Michael Smith's avatar
Michael Smith committed
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;
Michael Smith's avatar
Michael Smith committed
649 650 651
    int fileserve;
    char *host;
    int port;
652 653 654 655
    int i;
    char *serverhost;
    int serverport;
    aliases *alias;
Michael Smith's avatar
Michael Smith committed
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;
Michael Smith's avatar
Michael Smith committed
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
    else if(fileserve && stat(fullpath, &statbuf) == 0 && 
Ed "oddsock" Zaleski's avatar
Ed "oddsock" Zaleski committed
729 730 731
#ifdef _WIN32
            (statbuf.st_mode == S_IFREG))
#else
732
            S_ISREG(statbuf.st_mode)) 
Ed "oddsock" Zaleski's avatar
Ed "oddsock" Zaleski committed
733
#endif
Michael Smith's avatar
Michael Smith committed
734
    {
735
        fserve_client_create(client, fullpath);
736 737 738
        free(fullpath);
        return;
    }
739 740 741 742 743 744
    free(fullpath);

    if(strcmp(util_get_extension(uri), "m3u") == 0) {
        char *sourceuri = strdup(uri);
        char *dot = strrchr(sourceuri, '.');
        *dot = 0;
745 746 747
        avl_tree_rlock(global.source_tree);
        source = source_find_mount(sourceuri);
           if (source) {
748 749 750 751 752
            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", 
Michael Smith's avatar
Michael Smith committed
753 754
                    host, 
                    port,
755 756 757
                    sourceuri
                    );
            if(bytes > 0) client->con->sent_bytes = bytes;
758
            client_destroy(client);
759
        }
Michael Smith's avatar
Michael Smith committed
760
        else if(fileserve) {
761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779
            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");
                }
            }
        }
780 781 782
        else {
            client_send_404(client, "The file you requested could not be found");
        }
783
        avl_tree_unlock(global.source_tree);
784 785 786 787
        free(sourceuri);
        return;
    }

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

        source->format->client_send_headers(source->format, source, client);
826 827
                        
        bytes = sock_write(client->con->sock, "\r\n");
828
        if(bytes > 0) client->con->sent_bytes += bytes;
829 830
                            
        sock_set_blocking(client->con->sock, SOCK_NONBLOCK);
831
        sock_set_nodelay(client->con->sock);
832 833 834 835 836 837 838 839 840
                        
        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) {
841 842
        DEBUG0("Source not found for client");
        client_send_404(client, "The source you requested could not be found.");
843
    }
844 845 846 847
}

static void *_handle_connection(void *arg)
{
848 849 850
    char header[4096];
    connection_t *con;
    http_parser_t *parser;
851
    char *rawuri, *uri;
852
    client_t *client;
Jack Moffitt's avatar
Jack Moffitt committed
853

854 855
    while (global.running == ICE_RUNNING) {
        memset(header, 0, 4096);
Jack Moffitt's avatar
Jack Moffitt committed
856

857 858
        thread_cond_wait(&_pool_cond);
        if (global.running != ICE_RUNNING) break;
Jack Moffitt's avatar
Jack Moffitt committed
859

860 861
        /* grab a connection and set the socket to blocking */
        while ((con = _get_connection())) {
Michael Smith's avatar
Michael Smith committed
862 863 864 865 866 867 868 869 870 871 872 873 874 875 876

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

877
            stats_event_inc(NULL, "connections");
Jack Moffitt's avatar
Jack Moffitt committed
878

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

881 882 883 884 885 886
            /* 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
887

888 889 890 891 892 893
            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)) &&
894
                    strcmp("HTTP", httpp_getvar(parser, HTTPP_VAR_PROTOCOL))) {
895
                    ERROR0("Bad HTTP protocol detected");
896 897 898 899
                    connection_close(con);
                    httpp_destroy(parser);
                    continue;
                }
Jack Moffitt's avatar
Jack Moffitt committed
900

901 902 903 904
                rawuri = httpp_getvar(parser, HTTPP_VAR_URI);
                uri = util_normalise_uri(rawuri);

                if(!uri) {
905
                    client = client_create(con, parser);
906
                    client_send_404(client, "The path you requested was invalid");
907 908
                    continue;
                }
909

910
                if (parser->req_type == httpp_req_source) {
911 912 913 914 915 916 917 918 919
                    _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 {
920
                    ERROR0("Wrong request type from client");
921 922
                    connection_close(con);
                    httpp_destroy(parser);
923 924 925
                }

                free(uri);
926
            } 
927 928
            else if(httpp_parse_icy(parser, header, strlen(header))) {
                /* TODO: Map incoming icy connections to /icy_0, etc. */
929 930 931 932 933 934 935 936 937 938 939 940
                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);
941 942
            }
            else {
943
                ERROR0("HTTP request parsing failed");
944 945 946 947 948 949
                connection_close(con);
                httpp_destroy(parser);
                continue;
            }
        }
    }
Jack Moffitt's avatar
Jack Moffitt committed
950

951
    thread_exit(0);
Jack Moffitt's avatar
Jack Moffitt committed
952

953
    return NULL;
Jack Moffitt's avatar
Jack Moffitt committed
954 955 956 957
}

void connection_close(connection_t *con)
{
958 959 960 961
    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
962
}