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"
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
729
    else if(fileserve && stat(fullpath, &statbuf) == 0 && 
            S_ISREG(statbuf.st_mode)) 
Michael Smith's avatar
Michael Smith committed
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", 
Michael Smith's avatar
Michael Smith committed
749
750
                    host, 
                    port,
751
752
753
                    sourceuri
                    );
            if(bytes > 0) client->con->sent_bytes = bytes;
754
            client_destroy(client);
755
        }
Michael Smith's avatar
Michael Smith committed
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();
                        
Michael Smith's avatar
Michael Smith committed
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())) {
Michael Smith's avatar
Michael Smith committed
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
}