stats.c 32.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10
/* Icecast
 *
 * This program is distributed under the GNU General Public License, version 2.
 * A copy of this license is included with this source.
 *
 * Copyright 2000-2004, Jack Moffitt <jack@xiph.org, 
 *                      Michael Smith <msmith@xiph.org>,
 *                      oddsock <oddsock@xiph.org>,
 *                      Karl Heyes <karl@xiph.org>
 *                      and others (see AUTHORS for details).
11
 * Copyright 2012-2014, Philipp "ph3-der-loewe" Schafft <lion@lion.leolix.org>,
12 13
 */

14 15 16 17
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

Jack Moffitt's avatar
Jack Moffitt committed
18 19 20 21
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
22
#include <ctype.h>
Jack Moffitt's avatar
Jack Moffitt committed
23

Michael Smith's avatar
Michael Smith committed
24 25 26
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
Jack Moffitt's avatar
Jack Moffitt committed
27

Marvin Scholz's avatar
Marvin Scholz committed
28 29 30 31
#include "common/thread/thread.h"
#include "common/avl/avl.h"
#include "common/httpp/httpp.h"
#include "common/net/sock.h"
Jack Moffitt's avatar
Jack Moffitt committed
32 33 34

#include "connection.h"

35
#include "source.h"
Jack Moffitt's avatar
Jack Moffitt committed
36 37 38
#include "global.h"
#include "refbuf.h"
#include "client.h"
39
#include "admin.h"
Jack Moffitt's avatar
Jack Moffitt committed
40
#include "stats.h"
41
#include "xslt.h"
42
#include "util.h"
43
#include "auth.h"
44 45
#define CATMODULE "stats"
#include "logging.h"
Jack Moffitt's avatar
Jack Moffitt committed
46

47
#ifdef _WIN32
48
#define atoll _atoi64
49
#define vsnprintf _vsnprintf
50
#define snprintf _snprintf
51
#endif
Jack Moffitt's avatar
Jack Moffitt committed
52

53 54 55 56
#define STATS_EVENT_SET     0
#define STATS_EVENT_INC     1
#define STATS_EVENT_DEC     2
#define STATS_EVENT_ADD     3
Karl Heyes's avatar
Karl Heyes committed
57 58 59
#define STATS_EVENT_SUB     4
#define STATS_EVENT_REMOVE  5
#define STATS_EVENT_HIDDEN  6
60

61 62 63 64 65 66 67 68
typedef struct _event_queue_tag
{
    volatile stats_event_t *head;
    volatile stats_event_t **tail;
} event_queue_t;

#define event_queue_init(qp)    { (qp)->head = NULL; (qp)->tail = &(qp)->head; }

Jack Moffitt's avatar
Jack Moffitt committed
69 70
typedef struct _event_listener_tag
{
71 72
    event_queue_t queue;
    mutex_t mutex;
Jack Moffitt's avatar
Jack Moffitt committed
73

74
    struct _event_listener_tag *next;
Jack Moffitt's avatar
Jack Moffitt committed
75 76
} event_listener_t;

77
static volatile int _stats_running = 0;
78
static thread_type *_stats_thread_id;
79
static volatile int _stats_threads = 0;
Jack Moffitt's avatar
Jack Moffitt committed
80

81 82
static stats_t _stats;
static mutex_t _stats_mutex;
Jack Moffitt's avatar
Jack Moffitt committed
83

84
static event_queue_t _global_event_queue;
Jack Moffitt's avatar
Jack Moffitt committed
85 86
mutex_t _global_event_mutex;

87
static volatile event_listener_t *_event_listeners;
Jack Moffitt's avatar
Jack Moffitt committed
88 89 90 91 92 93 94


static void *_stats_thread(void *arg);
static int _compare_stats(void *a, void *b, void *arg);
static int _compare_source_stats(void *a, void *b, void *arg);
static int _free_stats(void *key);
static int _free_source_stats(void *key);
95
static void _add_event_to_queue(stats_event_t *event, event_queue_t *queue);
96 97
static stats_node_t *_find_node(avl_tree *tree, const char *name);
static stats_source_t *_find_source(avl_tree *tree, const char *source);
Jack Moffitt's avatar
Jack Moffitt committed
98
static void _free_event(stats_event_t *event);
99
static stats_event_t *_get_event_from_queue(event_queue_t *queue);
100
static void __add_metadata(xmlNodePtr node, const char *tag);
Jack Moffitt's avatar
Jack Moffitt committed
101

102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125

/* simple helper function for creating an event */
static stats_event_t *build_event (const char *source, const char *name, const char *value)
{
    stats_event_t *event;

    event = (stats_event_t *)calloc(1, sizeof(stats_event_t));
    if (event)
    {
        if (source)
            event->source = (char *)strdup(source);
        if (name)
            event->name = (char *)strdup(name);
        if (value)
            event->value = (char *)strdup(value);
        else
            event->action = STATS_EVENT_REMOVE;
    }
    return event;
}

static void queue_global_event (stats_event_t *event)
{
    thread_mutex_lock(&_global_event_mutex);
126
    _add_event_to_queue (event, &_global_event_queue);
127 128 129
    thread_mutex_unlock(&_global_event_mutex);
}

130
void stats_initialize(void)
Jack Moffitt's avatar
Jack Moffitt committed
131
{
132
    _event_listeners = NULL;
133

134 135 136
    /* set up global struct */
    _stats.global_tree = avl_tree_new(_compare_stats, NULL);
    _stats.source_tree = avl_tree_new(_compare_source_stats, NULL);
Jack Moffitt's avatar
Jack Moffitt committed
137

138 139
    /* set up global mutex */
    thread_mutex_create(&_stats_mutex);
Jack Moffitt's avatar
Jack Moffitt committed
140

141
    /* set up stats queues */
142
    event_queue_init(&_global_event_queue);
143
    thread_mutex_create(&_global_event_mutex);
Jack Moffitt's avatar
Jack Moffitt committed
144

145 146 147
    /* fire off the stats thread */
    _stats_running = 1;
    _stats_thread_id = thread_create("Stats Thread", _stats_thread, NULL, THREAD_ATTACHED);
Jack Moffitt's avatar
Jack Moffitt committed
148 149
}

150
void stats_shutdown(void)
Jack Moffitt's avatar
Jack Moffitt committed
151
{
152
    int n;
Jack Moffitt's avatar
Jack Moffitt committed
153

154
    if (!_stats_running) /* We can't shutdown if we're not running. */
155 156
        return;

157 158 159
    /* wait for thread to exit */
    _stats_running = 0;
    thread_join(_stats_thread_id);
Jack Moffitt's avatar
Jack Moffitt committed
160

161 162 163 164 165 166 167
    /* wait for other threads to shut down */
    do {
        thread_sleep(300000);
        thread_mutex_lock(&_stats_mutex);
        n = _stats_threads;
        thread_mutex_unlock(&_stats_mutex);
    } while (n > 0);
168
    ICECAST_LOG_INFO("stats thread finished");
169

170
    /* free the queues */
Jack Moffitt's avatar
Jack Moffitt committed
171

172 173
    /* destroy the queue mutexes */
    thread_mutex_destroy(&_global_event_mutex);
Jack Moffitt's avatar
Jack Moffitt committed
174

175 176 177
    thread_mutex_destroy(&_stats_mutex);
    avl_tree_free(_stats.source_tree, _free_source_stats);
    avl_tree_free(_stats.global_tree, _free_stats);
178

179 180 181 182
    while (1)
    {
        stats_event_t *event = _get_event_from_queue (&_global_event_queue);
        if (event == NULL) break;
183 184 185 186
        if(event->source)
            free(event->source);
        if(event->value)
            free(event->value);
187 188
        if(event->name)
            free(event->name);
189 190
        free(event);
    }
Jack Moffitt's avatar
Jack Moffitt committed
191 192
}

193
stats_t *stats_get_stats(void)
Jack Moffitt's avatar
Jack Moffitt committed
194
{
195
    /* lock global stats
196
     
197
     copy stats
Jack Moffitt's avatar
Jack Moffitt committed
198

199
     unlock global stats
Jack Moffitt's avatar
Jack Moffitt committed
200

201
     return copied stats */
Jack Moffitt's avatar
Jack Moffitt committed
202

203
    return NULL;
Jack Moffitt's avatar
Jack Moffitt committed
204 205
}

206 207
/* simple name=tag stat create/update */
void stats_event(const char *source, const char *name, const char *value)
Jack Moffitt's avatar
Jack Moffitt committed
208
{
209 210
    stats_event_t *event;

211 212
    if (value && xmlCheckUTF8 ((unsigned char *)value) == 0)
    {
213
        ICECAST_LOG_WARN("seen non-UTF8 data, probably incorrect metadata (%s, %s)", name, value);
214 215
        return;
    }
216
    event = build_event(source, name, value);
217
    if (event)
218
        queue_global_event(event);
Jack Moffitt's avatar
Jack Moffitt committed
219 220
}

221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241

/* wrapper for stats_event, this takes a charset to convert from */
void stats_event_conv(const char *mount, const char *name, const char *value, const char *charset)
{
    const char *metadata = value;
    xmlBufferPtr conv = xmlBufferCreate ();

    if (charset)
    {
        xmlCharEncodingHandlerPtr handle = xmlFindCharEncodingHandler (charset);

        if (handle)
        {
            xmlBufferPtr raw = xmlBufferCreate ();
            xmlBufferAdd (raw, (const xmlChar *)value, strlen (value));
            if (xmlCharEncInFunc (handle, conv, raw) > 0)
                metadata = (char *)xmlBufferContent (conv);
            xmlBufferFree (raw);
            xmlCharEncCloseFunc (handle);
        }
        else
242
            ICECAST_LOG_WARN("No charset found for \"%s\"", charset);
243 244 245 246 247 248
    }

    stats_event (mount, name, metadata);
    xmlBufferFree (conv);
}

249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
/* make stat hidden (non-zero). name can be NULL if it applies to a whole
 * source stats tree. */
void stats_event_hidden (const char *source, const char *name, int hidden)
{
    stats_event_t *event;
    const char *str = NULL;

    if (hidden)
        str = "";
    event = build_event (source, name, str);
    if (event)
    {
        event->action = STATS_EVENT_HIDDEN;
        queue_global_event (event);
    }
}
265 266 267

/* printf style formatting for stat create/update */
void stats_event_args(const char *source, char *name, char *format, ...)
Jack Moffitt's avatar
Jack Moffitt committed
268
{
269 270
    char buf[1024];
    va_list val;
271 272 273 274
    int ret;

    if (name == NULL)
        return;
275
    va_start(val, format);
276
    ret = vsnprintf(buf, sizeof(buf), format, val);
277
    va_end(val);
Jack Moffitt's avatar
Jack Moffitt committed
278

279 280
    if (ret < 0 || (unsigned int)ret >= sizeof (buf))
    {
281
        ICECAST_LOG_WARN("problem with formatting %s stat %s",
282 283 284
                source==NULL ? "global" : source, name);
        return;
    }
285
    stats_event(source, name, buf);
Jack Moffitt's avatar
Jack Moffitt committed
286 287
}

288
static char *_get_stats(const char *source, const char *name)
Jack Moffitt's avatar
Jack Moffitt committed
289
{
290 291 292
    stats_node_t *stats = NULL;
    stats_source_t *src = NULL;
    char *value = NULL;
Jack Moffitt's avatar
Jack Moffitt committed
293

294
    thread_mutex_lock(&_stats_mutex);
Jack Moffitt's avatar
Jack Moffitt committed
295

296 297 298 299 300 301 302 303
    if (source == NULL) {
        stats = _find_node(_stats.global_tree, name);
    } else {
        src = _find_source(_stats.source_tree, source);
        if (src) {
            stats = _find_node(src->stats_tree, name);
        }
    }
Jack Moffitt's avatar
Jack Moffitt committed
304

305
    if (stats) value = (char *)strdup(stats->value);
Jack Moffitt's avatar
Jack Moffitt committed
306

307
    thread_mutex_unlock(&_stats_mutex);
Jack Moffitt's avatar
Jack Moffitt committed
308

309
    return value;
Jack Moffitt's avatar
Jack Moffitt committed
310 311
}

312
char *stats_get_value(const char *source, const char *name)
313
{
314
    return(_get_stats(source, name));
315
}
316 317 318

/* increase the value in the provided stat by 1 */
void stats_event_inc(const char *source, const char *name)
Jack Moffitt's avatar
Jack Moffitt committed
319
{
320
    stats_event_t *event = build_event (source, name, NULL);
321
    /* ICECAST_LOG_DEBUG("%s on %s", name, source==NULL?"global":source); */
322 323 324 325
    if (event)
    {
        event->action = STATS_EVENT_INC;
        queue_global_event (event);
326
    }
Jack Moffitt's avatar
Jack Moffitt committed
327 328
}

329
void stats_event_add(const char *source, const char *name, unsigned long value)
Jack Moffitt's avatar
Jack Moffitt committed
330
{
331
    stats_event_t *event = build_event (source, name, NULL);
332
    /* ICECAST_LOG_DEBUG("%s on %s", name, source==NULL?"global":source); */
333 334 335 336 337 338
    if (event)
    {
        event->value = malloc (16);
        snprintf (event->value, 16, "%ld", value);
        event->action = STATS_EVENT_ADD;
        queue_global_event (event);
339
    }
Jack Moffitt's avatar
Jack Moffitt committed
340 341
}

Karl Heyes's avatar
Karl Heyes committed
342 343 344 345 346 347 348 349 350 351 352 353
void stats_event_sub(const char *source, const char *name, unsigned long value)
{
    stats_event_t *event = build_event (source, name, NULL);
    if (event)
    {
        event->value = malloc (16);
        snprintf (event->value, 16, "%ld", value);
        event->action = STATS_EVENT_SUB;
        queue_global_event (event);
    }
}

354 355
/* decrease the value in the provided stat by 1 */
void stats_event_dec(const char *source, const char *name)
Jack Moffitt's avatar
Jack Moffitt committed
356
{
357
    /* ICECAST_LOG_DEBUG("%s on %s", name, source==NULL?"global":source); */
358 359 360 361 362
    stats_event_t *event = build_event (source, name, NULL);
    if (event)
    {
        event->action = STATS_EVENT_DEC;
        queue_global_event (event);
363
    }
Jack Moffitt's avatar
Jack Moffitt committed
364 365 366 367 368
}

/* note: you must call this function only when you have exclusive access
** to the avl_tree
*/
369
static stats_node_t *_find_node(avl_tree *stats_tree, const char *name)
Jack Moffitt's avatar
Jack Moffitt committed
370
{
371 372 373 374 375 376
    stats_node_t *stats;
    avl_node *node;
    int cmp;

    /* get the root node */
    node = stats_tree->root->right;
377

378
    while (node) {
379
        stats = (stats_node_t *) node->key;
380 381 382 383 384 385 386 387 388 389 390
        cmp = strcmp(name, stats->name);
        if (cmp < 0) 
            node = node->left;
        else if (cmp > 0)
            node = node->right;
        else
            return stats;
    }
    
    /* didn't find it */
    return NULL;
Jack Moffitt's avatar
Jack Moffitt committed
391 392 393 394 395
}

/* note: you must call this function only when you have exclusive access
** to the avl_tree
*/
396
static stats_source_t *_find_source(avl_tree *source_tree, const char *source)
Jack Moffitt's avatar
Jack Moffitt committed
397
{
398 399 400 401 402 403 404
    stats_source_t *stats;
    avl_node *node;
    int cmp;

    /* get the root node */
    node = source_tree->root->right;
    while (node) {
405
        stats = (stats_source_t *) node->key;
406 407 408 409 410 411 412 413
        cmp = strcmp(source, stats->source);
        if (cmp < 0)
            node = node->left;
        else if (cmp > 0)
            node = node->right;
        else
            return stats;
    }
Jack Moffitt's avatar
Jack Moffitt committed
414

415 416
    /* didn't find it */
    return NULL;
Jack Moffitt's avatar
Jack Moffitt committed
417 418 419 420
}

static stats_event_t *_copy_event(stats_event_t *event)
{
421
    stats_event_t *copy = (stats_event_t *)calloc(1, sizeof(stats_event_t));
422 423 424 425
    if (event->source) 
        copy->source = (char *)strdup(event->source);
    else
        copy->source = NULL;
426 427
    if (event->name)
        copy->name = (char *)strdup(event->name);
428 429 430 431
    if (event->value)
        copy->value = (char *)strdup(event->value);
    else
        copy->value = NULL;
432
    copy->hidden = event->hidden;
433
    copy->next = NULL;
Jack Moffitt's avatar
Jack Moffitt committed
434

435
    return copy;
Jack Moffitt's avatar
Jack Moffitt committed
436 437
}

438 439

/* helper to apply specialised changes to a stats node */
440
static void modify_node_event(stats_node_t *node, stats_event_t *event)
441 442 443
{
    char *str;

444 445 446 447 448 449 450 451
    if (event->action == STATS_EVENT_HIDDEN)
    {
        if (event->value)
            node->hidden = 1;
        else
            node->hidden = 0;
        return;
    }
452 453
    if (event->action != STATS_EVENT_SET)
    {
454
        int64_t value = 0;
455 456 457 458 459 460 461 462 463 464 465 466

        switch (event->action)
        {
            case STATS_EVENT_INC:
                value = atoi (node->value)+1;
                break;
            case STATS_EVENT_DEC:
                value = atoi (node->value)-1;
                break;
            case STATS_EVENT_ADD:
                value = atoi (node->value)+atoi (event->value);
                break;
467 468 469
            case STATS_EVENT_SUB:
                value = atoll (node->value) - atoll (event->value);
                break;
470
            default:
471
                ICECAST_LOG_WARN("unhandled event (%d) for %s", event->action, event->source);
472 473 474
                break;
        }
        str = malloc (16);
475
        snprintf (str, 16, "%" PRId64, value);
476 477
        if (event->value == NULL)
            event->value = strdup (str);
478 479 480 481 482
    }
    else
        str = (char *)strdup (event->value);
    free (node->value);
    node->value = str;
483
    if (event->source)
484
        ICECAST_LOG_DEBUG("update \"%s\" %s (%s)", event->source, node->name, node->value);
485
    else
486
        ICECAST_LOG_DEBUG("update global %s (%s)", node->name, node->value);
487 488 489 490 491 492 493
}


static void process_global_event (stats_event_t *event)
{
    stats_node_t *node;

494
    /* ICECAST_LOG_DEBUG("global event %s %s %d", event->name, event->value, event->action); */
495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529
    if (event->action == STATS_EVENT_REMOVE)
    {
        /* we're deleting */
        node = _find_node(_stats.global_tree, event->name);
        if (node != NULL)
            avl_delete(_stats.global_tree, (void *)node, _free_stats);
        return;
    }
    node = _find_node(_stats.global_tree, event->name);
    if (node)
    {
        modify_node_event (node, event);
    }
    else
    {
        /* add node */
        node = (stats_node_t *)calloc(1, sizeof(stats_node_t));
        node->name = (char *)strdup(event->name);
        node->value = (char *)strdup(event->value);

        avl_insert(_stats.global_tree, (void *)node);
    }
}


static void process_source_event (stats_event_t *event)
{
    stats_source_t *snode = _find_source(_stats.source_tree, event->source);
    if (snode == NULL)
    {
        if (event->action == STATS_EVENT_REMOVE)
            return;
        snode = (stats_source_t *)calloc(1,sizeof(stats_source_t));
        if (snode == NULL)
            return;
530
        ICECAST_LOG_DEBUG("new source stat %s", event->source);
531 532
        snode->source = (char *)strdup(event->source);
        snode->stats_tree = avl_tree_new(_compare_stats, NULL);
533 534 535 536
        if (event->action == STATS_EVENT_HIDDEN)
            snode->hidden = 1;
        else
            snode->hidden = 0;
537

538
        avl_insert(_stats.source_tree, (void *) snode);
539 540 541 542 543 544 545 546 547 548 549
    }
    if (event->name)
    {
        stats_node_t *node = _find_node(snode->stats_tree, event->name);
        if (node == NULL)
        {
            if (event->action == STATS_EVENT_REMOVE)
                return;
            /* adding node */
            if (event->value)
            {
550
                ICECAST_LOG_DEBUG("new node %s (%s)", event->name, event->value);
551 552 553
                node = (stats_node_t *)calloc(1,sizeof(stats_node_t));
                node->name = (char *)strdup(event->name);
                node->value = (char *)strdup(event->value);
554
                node->hidden = snode->hidden;
555 556 557 558 559 560 561

                avl_insert(snode->stats_tree, (void *)node);
            }
            return;
        }
        if (event->action == STATS_EVENT_REMOVE)
        {
562
            ICECAST_LOG_DEBUG("delete node %s", event->name);
563 564 565 566 567 568
            avl_delete(snode->stats_tree, (void *)node, _free_stats);
            return;
        }
        modify_node_event (node, event);
        return;
    }
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
    if (event->action == STATS_EVENT_HIDDEN)
    {
        avl_node *node = avl_get_first (snode->stats_tree);

        if (event->value)
            snode->hidden = 1;
        else
            snode->hidden = 0;
        while (node)
        {
            stats_node_t *stats = (stats_node_t*)node->key;
            stats->hidden = snode->hidden;
            node = avl_get_next (node);
        }
        return;
    }
585 586
    if (event->action == STATS_EVENT_REMOVE)
    {
587
        ICECAST_LOG_DEBUG("delete source node %s", event->source);
588 589 590 591
        avl_delete(_stats.source_tree, (void *)snode, _free_source_stats);
    }
}

592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639
/* NOTE: implicit %z is added to format string. */
static inline void __format_time(char * buffer, size_t len, const char * format) {
    time_t now = time(NULL);
    struct tm local;
    char tzbuffer[32];
    char timebuffer[128];
#ifdef _WIN32
    struct tm *thetime;
    int time_days, time_hours, time_tz;
    int tempnum1, tempnum2;
    char sign;
#endif

    localtime_r (&now, &local);
#ifndef _WIN32
    strftime (tzbuffer, sizeof(tzbuffer), "%z", &local);
#else
    thetime = gmtime (&now);
    time_days = local.tm_yday - thetime->tm_yday;

    if (time_days < -1) {
        tempnum1 = 24;
    } else {
        tempnum1 = 1;
    }

    if (tempnum1 < time_days) {
        tempnum2 = -24;
    } else {
        tempnum2 = time_days*24;
    }

    time_hours = (tempnum2 + local.tm_hour - thetime->tm_hour);
    time_tz = time_hours * 60 + local.tm_min - thetime->tm_min;

    if (time_tz < 0) {
        sign = '-';
        time_tz = -time_tz;
    } else {
        sign = '+';
    }

    snprintf(tzbuffer, sizeof(tzbuffer), "%c%.2d%.2d", sign, time_tz / 60, time_tz % 60);
#endif
    strftime (timebuffer, sizeof(timebuffer), format, &local);

    snprintf(buffer, len, "%s%s", timebuffer, tzbuffer);
}
640

Karl Heyes's avatar
Karl Heyes committed
641 642 643 644
void stats_event_time (const char *mount, const char *name)
{
    char buffer[100];

645
    __format_time(buffer, sizeof(buffer), "%a, %d %b %Y %H:%M:%S ");
Karl Heyes's avatar
Karl Heyes committed
646 647 648 649
    stats_event (mount, name, buffer);
}


650 651 652 653
void stats_event_time_iso8601 (const char *mount, const char *name)
{
    char buffer[100];

654
    __format_time(buffer, sizeof(buffer), "%Y-%m-%dT%H:%M:%S");
655 656 657 658
    stats_event (mount, name, buffer);
}


Karl Heyes's avatar
Karl Heyes committed
659 660
void stats_global (ice_config_t *config)
{
661
    stats_event (NULL, "server_id", config->server_id);
Karl Heyes's avatar
Karl Heyes committed
662 663 664 665 666 667
    stats_event (NULL, "host", config->hostname);
    stats_event (NULL, "location", config->location);
    stats_event (NULL, "admin", config->admin);
}


Jack Moffitt's avatar
Jack Moffitt committed
668 669
static void *_stats_thread(void *arg)
{
670 671 672 673
    stats_event_t *event;
    stats_event_t *copy;
    event_listener_t *listener;

Karl Heyes's avatar
Karl Heyes committed
674
    stats_event_time (NULL, "server_start");
675
    stats_event_time_iso8601 (NULL, "server_start_iso8601");
676 677 678 679 680 681

    /* global currently active stats */
    stats_event (NULL, "clients", "0");
    stats_event (NULL, "connections", "0");
    stats_event (NULL, "sources", "0");
    stats_event (NULL, "stats", "0");
Karl Heyes's avatar
Karl Heyes committed
682
    stats_event (NULL, "listeners", "0");
683 684 685 686 687 688 689

    /* global accumulating stats */
    stats_event (NULL, "client_connections", "0");
    stats_event (NULL, "source_client_connections", "0");
    stats_event (NULL, "source_relay_connections", "0");
    stats_event (NULL, "source_total_connections", "0");
    stats_event (NULL, "stats_connections", "0");
690
    stats_event (NULL, "listener_connections", "0");
691

692
    ICECAST_LOG_INFO("stats thread started");
693
    while (_stats_running) {
694
        thread_mutex_lock(&_global_event_mutex);
695
        if (_global_event_queue.head != NULL) {
696
            /* grab the next event from the queue */
697
            event = _get_event_from_queue (&_global_event_queue);
698 699
            thread_mutex_unlock(&_global_event_mutex);

700 701
            if (event == NULL)
                continue;
702 703 704
            event->next = NULL;

            thread_mutex_lock(&_stats_mutex);
705 706 707 708 709 710

            /* check if we are dealing with a global or source event */
            if (event->source == NULL)
                process_global_event (event);
            else
                process_source_event (event);
711 712 713
            
            /* now we have an event that's been processed into the running stats */
            /* this event should get copied to event listeners' queues */
714
            listener = (event_listener_t *)_event_listeners;
715 716
            while (listener) {
                copy = _copy_event(event);
717 718 719
                thread_mutex_lock (&listener->mutex);
                _add_event_to_queue (copy, &listener->queue);
                thread_mutex_unlock (&listener->mutex);
720 721 722 723 724 725 726 727

                listener = listener->next;
            }

            /* now we need to destroy the event */
            _free_event(event);

            thread_mutex_unlock(&_stats_mutex);
728
            continue;
729
        }
730 731 732 733
        else
        {
            thread_mutex_unlock(&_global_event_mutex);
        }
734

735
        thread_sleep(300000);
736 737 738
    }

    return NULL;
Jack Moffitt's avatar
Jack Moffitt committed
739 740
}

741
/* you must have the _stats_mutex locked here */
742
static void _unregister_listener(event_listener_t *listener)
743 744 745 746 747
{
    event_listener_t **prev = (event_listener_t **)&_event_listeners,
                     *current = *prev;
    while (current)
    {
748
        if (current == listener)
749 750 751 752 753 754 755 756 757 758
        {
            *prev = current->next;
            break;
        }
        prev = &current->next;
        current = *prev;
    }
}


Jack Moffitt's avatar
Jack Moffitt committed
759 760
static stats_event_t *_make_event_from_node(stats_node_t *node, char *source)
{
761 762 763 764 765 766 767 768
    stats_event_t *event = (stats_event_t *)malloc(sizeof(stats_event_t));
    
    if (source != NULL)
        event->source = (char *)strdup(source);
    else
        event->source = NULL;
    event->name = (char *)strdup(node->name);
    event->value = (char *)strdup(node->value);
769
    event->hidden = node->hidden;
770
    event->action = STATS_EVENT_SET;
771
    event->next = NULL;
Jack Moffitt's avatar
Jack Moffitt committed
772

773
    return event;
Jack Moffitt's avatar
Jack Moffitt committed
774 775 776
}


777 778 779 780
static void _add_event_to_queue(stats_event_t *event, event_queue_t *queue)
{
    *queue->tail = event;
    queue->tail = (volatile stats_event_t **)&event->next;
Jack Moffitt's avatar
Jack Moffitt committed
781 782 783
}


784 785 786
static stats_event_t *_get_event_from_queue (event_queue_t *queue)
{
    stats_event_t *event = NULL;
Jack Moffitt's avatar
Jack Moffitt committed
787

788 789 790 791 792 793 794
    if (queue && queue->head)
    {
        event = (stats_event_t *)queue->head;
        queue->head = event->next;
        if (queue->head == NULL)
            queue->tail = &queue->head;
    }
Jack Moffitt's avatar
Jack Moffitt committed
795

796
    return event;
Jack Moffitt's avatar
Jack Moffitt committed
797 798
}

799
static int _send_event_to_client(stats_event_t *event, client_t *client)
Jack Moffitt's avatar
Jack Moffitt committed
800
{
801
    int len;
802
    char buf [200];
Jack Moffitt's avatar
Jack Moffitt committed
803

804
    /* send data to the client!!!! */
805
    len = snprintf (buf, sizeof (buf), "EVENT %s %s %s\n",
806 807 808
            (event->source != NULL) ? event->source : "global",
            event->name ? event->name : "null",
            event->value ? event->value : "null");
809
    if (len > 0 && len < (int)sizeof (buf))
810 811 812 813 814 815
    {
        client_send_bytes (client, buf, len);
        if (client->con->error)
            return -1;
    }
    return 0;
Jack Moffitt's avatar
Jack Moffitt committed
816 817
}

818 819

static xmlNodePtr _dump_stats_to_doc (xmlNodePtr root, const char *show_mount, int hidden)
Jack Moffitt's avatar
Jack Moffitt committed
820
{
821 822
    avl_node *avlnode;
    xmlNodePtr ret = NULL;
823 824

    thread_mutex_lock(&_stats_mutex);
825 826 827 828 829 830 831 832 833 834 835 836 837 838
    /* general stats first */
    avlnode = avl_get_first(_stats.global_tree);
    while (avlnode)
    {
        stats_node_t *stat = avlnode->key;
        if (stat->hidden <=  hidden)
            xmlNewTextChild (root, NULL, XMLSTR(stat->name), XMLSTR(stat->value));
        avlnode = avl_get_next (avlnode);
    }
    /* now per mount stats */
    avlnode = avl_get_first(_stats.source_tree);
    while (avlnode)
    {
        stats_source_t *source = (stats_source_t *)avlnode->key;
839

840 841 842
        if (source->hidden <= hidden &&
                (show_mount == NULL || strcmp (show_mount, source->source) == 0))
        {
843
            xmlNodePtr metadata, authentication, role;
844
            source_t *source_real;
845 846 847
            ice_config_t *config;
            mount_proxy *mountproxy;
            auth_stack_t *stack;
848 849
            int i;

850 851
            avl_node *avlnode2 = avl_get_first (source->stats_tree);
            xmlNodePtr xmlnode = xmlNewTextChild (root, NULL, XMLSTR("source"), NULL);
852

853 854 855 856 857 858 859 860 861
            xmlSetProp (xmlnode, XMLSTR("mount"), XMLSTR(source->source));
            if (ret == NULL)
                ret = xmlnode;
            while (avlnode2)
            {
                stats_node_t *stat = avlnode2->key;
                xmlNewTextChild (xmlnode, NULL, XMLSTR(stat->name), XMLSTR(stat->value));
                avlnode2 = avl_get_next (avlnode2);
            }
862 863 864 865 866


            metadata = xmlNewTextChild(xmlnode, NULL, XMLSTR("metadata"), NULL);
            avl_tree_rlock(global.source_tree);
            source_real = source_find_mount_raw(source->source);
867 868 869 870
            if (source_real->format) {
                for (i = 0; i < source_real->format->vc.comments; i++)
                    __add_metadata(metadata, source_real->format->vc.user_comments[i]);
            }
871
            avl_tree_unlock(global.source_tree);
872 873 874 875 876 877 878 879 880 881 882

            authentication = xmlNewTextChild(xmlnode, NULL, XMLSTR("authentication"), NULL);
            config = config_get_config();
            mountproxy = config_find_mount(config, source->source, MOUNT_TYPE_NORMAL);
            auth_stack_addref(stack = mountproxy->authstack);
            while (stack) {
                auth_t *auth = auth_stack_get(stack);
                char idbuf[32];
                snprintf(idbuf, sizeof(idbuf), "%lu", auth->id);
                role = xmlNewTextChild(authentication, NULL, XMLSTR("role"), NULL);
                xmlSetProp(role, XMLSTR("id"), XMLSTR(idbuf));
883 884
                if (auth->type)
                    xmlSetProp(role, XMLSTR("type"), XMLSTR(auth->type));
885 886
                if (auth->role)
                    xmlSetProp(role, XMLSTR("name"), XMLSTR(auth->role));
887 888
                if (auth->management_url)
                    xmlSetProp(role, XMLSTR("management-url"), XMLSTR(auth->management_url));
889 890 891 892
                auth_release(auth);
                auth_stack_next(&stack);
            }
            config_release_config();
893
        }
894
        avlnode = avl_get_next (avlnode);
895 896
    }
    thread_mutex_unlock(&_stats_mutex);
897
    return ret;
Jack Moffitt's avatar
Jack Moffitt committed
898 899
}

900

901 902 903 904 905
/* factoring out code for stats loops
** this function copies all stats to queue, and registers 
** the queue for all new events atomically.
** note: mutex must already be created!
*/
906
static void _register_listener (event_listener_t *listener)
Jack Moffitt's avatar
Jack Moffitt committed
907
{
908 909 910 911
    avl_node *node;
    avl_node *node2;
    stats_event_t *event;
    stats_source_t *source;
Jack Moffitt's avatar
Jack Moffitt committed
912

913
    thread_mutex_lock(&_stats_mutex);
Jack Moffitt's avatar
Jack Moffitt committed
914

915
    /* first we fill our queue with the current stats */
916

917 918 919
    /* start with the global stats */
    node = avl_get_first(_stats.global_tree);
    while (node) {
920 921
        event = _make_event_from_node((stats_node_t *) node->key, NULL);
        _add_event_to_queue(event, &listener->queue);
Jack Moffitt's avatar
Jack Moffitt committed
922

923 924
        node = avl_get_next(node);
    }
Jack Moffitt's avatar
Jack Moffitt committed
925

926 927 928 929 930 931 932
    /* now the stats for each source */
    node = avl_get_first(_stats.source_tree);
    while (node) {
        source = (stats_source_t *)node->key;
        node2 = avl_get_first(source->stats_tree);
        while (node2) {
            event = _make_event_from_node((stats_node_t *)node2->key, source->source);
933
            _add_event_to_queue (event, &listener->queue);
934 935 936 937 938 939

            node2 = avl_get_next(node2);
        }
        
        node = avl_get_next(node);
    }
Jack Moffitt's avatar
Jack Moffitt committed
940

941
    /* now we register to receive future event notices */
942 943
    listener->next = (event_listener_t *)_event_listeners;
    _event_listeners = listener;
Jack Moffitt's avatar
Jack Moffitt committed
944

945
    thread_mutex_unlock(&_stats_mutex);
946 947 948 949
}

void *stats_connection(void *arg)
{
950
    client_t *client = (client_t *)arg;
951
    stats_event_t *event;
952
    event_listener_t listener;
953

954
    ICECAST_LOG_INFO("stats client starting");
955

956
    event_queue_init (&listener.queue);
957 958 959
    /* increment the thread count */
    thread_mutex_lock(&_stats_mutex);
    _stats_threads++;
960
    stats_event_args (NULL, "stats", "%d", _stats_threads);
961 962
    thread_mutex_unlock(&_stats_mutex);

963
    thread_mutex_create (&(listener.mutex));
964

965
    _register_listener (&listener);
966 967

    while (_stats_running) {
968 969 970
        thread_mutex_lock (&listener.mutex);
        event = _get_event_from_queue (&listener.queue);
        thread_mutex_unlock (&listener.mutex);
971
        if (event != NULL) {
972
            if (_send_event_to_client(event, client) < 0) {
973 974 975 976 977 978
                _free_event(event);
                break;
            }
            _free_event(event);
            continue;
        }
979
        thread_sleep (500000);
980 981 982
    }

    thread_mutex_lock(&_stats_mutex);
983
    _unregister_listener (&listener);
984
    _stats_threads--;
985
    stats_event_args (NULL, "stats", "%d", _stats_threads);
986 987
    thread_mutex_unlock(&_stats_mutex);

988
    thread_mutex_destroy (&listener.mutex);
989
    client_destroy (client);
990
    ICECAST_LOG_INFO("stats client finished");
991

992
    return NULL;
Jack Moffitt's avatar
Jack Moffitt committed
993 994
}

995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007

void stats_callback (client_t *client, void *notused)
{
    if (client->con->error)
    {
        client_destroy (client);
        return;
    }
    client_set_queue (client, NULL);
    thread_create("Stats Connection", stats_connection, (void *)client, THREAD_DETACHED);
}


Jack Moffitt's avatar
Jack Moffitt committed
1008
typedef struct _source_xml_tag {
1009 1010
    char *mount;
    xmlNodePtr node;
Jack Moffitt's avatar
Jack Moffitt committed
1011

1012
    struct _source_xml_tag *next;
Jack Moffitt's avatar
Jack Moffitt committed
1013 1014 1015
} source_xml_t;


1016
void stats_transform_xslt(client_t *client, const char *uri)
1017 1018
{
    xmlDocPtr doc;
1019 1020
    char *xslpath = util_get_path_from_normalised_uri(uri);
    const char *mount = httpp_get_query_param(client->parser, "mount");
1021

1022
    doc = stats_get_xml(0, mount, client->mode);
1023

1024
    xslt_transform(doc, xslpath, client);
1025 1026

    xmlFreeDoc(doc);
1027
    free(xslpath);
1028 1029
}

1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
static void __add_metadata(xmlNodePtr node, const char *tag) {
    const char *value = strstr(tag, "=");
    char *name = NULL;
    size_t namelen = value - tag + 1;
    size_t i;

    if (!value)
        return;

    name = malloc(namelen);
    if (!name)
        return;

    for (i = 0; i < (namelen - 1); i++)
        name[i] = tolower(tag[i]);

    name[namelen-1] = 0;

    xmlNewTextChild(node, NULL, XMLSTR(name), XMLSTR(value+1));

    free(name);
}

1053
xmlDocPtr stats_get_xml(int show_hidden, const char *show_mount, operation_mode mode)
Jack Moffitt's avatar
Jack Moffitt committed
1054
{
1055
    xmlDocPtr doc;
1056
    xmlNodePtr node;
1057
    source_t * source;
1058

1059 1060
    doc = xmlNewDoc (XMLSTR("1.0"));
    node = xmlNewDocNode (doc, NULL, XMLSTR("icestats"), NULL);
1061 1062
    xmlDocSetRootElement(doc, node);

1063
    node = _dump_stats_to_doc (node, show_mount, show_hidden);
1064

1065 1066 1067
    if (show_mount && node) {
        avl_tree_rlock(global.source_tree);
        source = source_find_mount_raw(show_mount);
1068
        admin_add_listeners_to_mount(source, node, mode);
1069 1070 1071
        avl_tree_unlock(global.source_tree);
    }

1072
    return doc;
Jack Moffitt's avatar
Jack Moffitt committed
1073 1074
}

1075

Jack Moffitt's avatar
Jack Moffitt committed
1076 1077
static int _compare_stats(void *arg, void *a, void *b)
{
1078 1079
    stats_node_t *nodea = (stats_node_t *)a;
    stats_node_t *nodeb = (stats_node_t *)b;
Jack Moffitt's avatar
Jack Moffitt committed
1080

1081
    return strcmp(nodea->name, nodeb->name);
Jack Moffitt's avatar
Jack Moffitt committed
1082 1083 1084 1085
}

static int _compare_source_stats(void *arg, void *a, void *b)
{
1086 1087
    stats_source_t *nodea = (stats_source_t *)a;
    stats_source_t *nodeb = (stats_source_t *)b;
Jack Moffitt's avatar
Jack Moffitt committed
1088

1089
    return strcmp(nodea->source, nodeb->source);
Jack Moffitt's avatar
Jack Moffitt committed
1090 1091 1092 1093
}

static int _free_stats(void *key)
{
1094 1095 1096 1097 1098 1099
    stats_node_t *node = (stats_node_t *)key;
    free(node->value);
    free(node->name);
    free(node);
    
    return 1;
Jack Moffitt's avatar
Jack Moffitt committed
1100 1101 1102 1103
}

static int _free_source_stats(void *key)
{
1104 1105 1106
    stats_source_t *node = (stats_source_t *)key;
    avl_tree_free(node->stats_tree, _free_stats);
    free(node->source);
1107
    free(node);
Jack Moffitt's avatar
Jack Moffitt committed
1108

1109
    return 1;
Jack Moffitt's avatar
Jack Moffitt committed
1110 1111 1112 1113
}

static void _free_event(stats_event_t *event)
{
1114 1115 1116 1117
    if (event->source) free(event->source);
    if (event->name) free(event->name);
    if (event->value) free(event->value);
    free(event);
Jack Moffitt's avatar
Jack Moffitt committed
1118
}
1119 1120


1121
refbuf_t *stats_get_streams (void)
1122
{
1123
#define STREAMLIST_BLKSIZE  4096
1124
    avl_node *node;
1125
    unsigned int remaining = STREAMLIST_BLKSIZE;
1126 1127
    refbuf_t *start = refbuf_new (remaining), *cur = start;
    char *buffer = cur->data;
1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138

    /* now the stats for each source */
    thread_mutex_lock (&_stats_mutex);
    node = avl_get_first(_stats.source_tree);
    while (node)
    {
        int ret;
        stats_source_t *source = (stats_source_t *)node->key;

        if (source->hidden == 0)
        {
1139
            if (remaining <= strlen (source->source) + 3)
1140
            {
1141 1142 1143 1144 1145
                cur->len = STREAMLIST_BLKSIZE - remaining;
                cur->next = refbuf_new (STREAMLIST_BLKSIZE);
                remaining = STREAMLIST_BLKSIZE;
                cur = cur->next;
                buffer = cur->data;
1146 1147 1148 1149 1150 1151 1152 1153 1154 1155
            }
            ret = snprintf (buffer, remaining, "%s\r\n", source->source);
            if (ret > 0)
            {
                buffer += ret;
                remaining -= ret;
            }
        }
        node = avl_get_next(node);
    }
1156
    thread_mutex_unlock(&_stats_mutex);
1157 1158
    cur->len = STREAMLIST_BLKSIZE - remaining;
    return start;
1159 1160
}

1161 1162


1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181
/* This removes any source stats from virtual mountpoints, ie mountpoints
 * where no source_t exists. This function requires the global sources lock
 * to be held before calling.
 */
void stats_clear_virtual_mounts (void)
{
    avl_node *snode;

    thread_mutex_lock (&_stats_mutex);
    snode = avl_get_first(_stats.source_tree);
    while (snode)
    {
        stats_source_t *src = (stats_source_t *)snode->key;
        source_t *source = source_find_mount_raw (src->source);

        if (source == NULL)
        {
            /* no source_t is reserved so remove them now */
            snode = avl_get_next (snode);
1182
            ICECAST_LOG_DEBUG("releasing %s stats", src->source);
1183 1184 1185 1186 1187 1188 1189 1190 1191
            avl_delete (_stats.source_tree, src, _free_source_stats);
            continue;
        }

        snode = avl_get_next (snode);
    }
    thread_mutex_unlock (&_stats_mutex);
}