admin.c 23.4 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12
/* 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).
 */

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

17 18
#include <string.h>
#include <stdlib.h>
19 20
#include <stdarg.h>
#include <time.h>
21 22 23
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
24

25
#include "cfgfile.h"
26 27 28 29 30 31 32
#include "connection.h"
#include "refbuf.h"
#include "client.h"
#include "source.h"
#include "global.h"
#include "event.h"
#include "stats.h"
33
#include "os.h"
34
#include "xslt.h"
35 36

#include "format.h"
37
#include "format_mp3.h"
38 39

#include "logging.h"
Ed "oddsock" Zaleski's avatar
Ed "oddsock" Zaleski committed
40 41 42
#ifdef _WIN32
#define snprintf _snprintf
#endif
43 44 45

#define CATMODULE "admin"

46 47 48
#define COMMAND_ERROR             (-1)

/* Mount-specific commands */
49
#define COMMAND_RAW_FALLBACK        1
50
#define COMMAND_METADATA_UPDATE     2
51 52 53 54 55 56
#define COMMAND_RAW_SHOW_LISTENERS  3
#define COMMAND_RAW_MOVE_CLIENTS    4

#define COMMAND_TRANSFORMED_FALLBACK        50
#define COMMAND_TRANSFORMED_SHOW_LISTENERS  53
#define COMMAND_TRANSFORMED_MOVE_CLIENTS    54
57 58

/* Global commands */
Karl Heyes's avatar
Karl Heyes committed
59 60 61 62 63 64 65
#define COMMAND_RAW_LIST_MOUNTS             101
#define COMMAND_RAW_STATS                   102
#define COMMAND_RAW_LISTSTREAM              103
#define COMMAND_PLAINTEXT_LISTSTREAM        104
#define COMMAND_TRANSFORMED_LIST_MOUNTS     201
#define COMMAND_TRANSFORMED_STATS           202
#define COMMAND_TRANSFORMED_LISTSTREAM      203
66

67
/* Client management commands */
Karl Heyes's avatar
Karl Heyes committed
68 69 70 71
#define COMMAND_RAW_KILL_CLIENT             301
#define COMMAND_RAW_KILL_SOURCE             302
#define COMMAND_TRANSFORMED_KILL_CLIENT     401
#define COMMAND_TRANSFORMED_KILL_SOURCE     402
72 73 74 75 76 77 78 79 80 81 82 83

#define FALLBACK_RAW_REQUEST "fallbacks"
#define FALLBACK_TRANSFORMED_REQUEST "fallbacks.xsl"
#define METADATA_REQUEST "metadata"
#define LISTCLIENTS_RAW_REQUEST "listclients"
#define LISTCLIENTS_TRANSFORMED_REQUEST "listclients.xsl"
#define STATS_RAW_REQUEST "stats"
#define STATS_TRANSFORMED_REQUEST "stats.xsl"
#define LISTMOUNTS_RAW_REQUEST "listmounts"
#define LISTMOUNTS_TRANSFORMED_REQUEST "listmounts.xsl"
#define STREAMLIST_RAW_REQUEST "streamlist"
#define STREAMLIST_TRANSFORMED_REQUEST "streamlist.xsl"
84
#define STREAMLIST_PLAINTEXT_REQUEST "streamlist.txt"
85 86 87 88 89 90 91 92 93 94 95 96
#define MOVECLIENTS_RAW_REQUEST "moveclients"
#define MOVECLIENTS_TRANSFORMED_REQUEST "moveclients.xsl"
#define KILLCLIENT_RAW_REQUEST "killclient"
#define KILLCLIENT_TRANSFORMED_REQUEST "killclient.xsl"
#define KILLSOURCE_RAW_REQUEST "killsource"
#define KILLSOURCE_TRANSFORMED_REQUEST "killsource.xsl"
#define ADMIN_XSL_RESPONSE "response.xsl"
#define DEFAULT_RAW_REQUEST ""
#define DEFAULT_TRANSFORMED_REQUEST ""

#define RAW         1
#define TRANSFORMED 2
97
#define PLAINTEXT   3
98 99
int admin_get_command(char *command)
{
100 101 102 103 104
    if(!strcmp(command, FALLBACK_RAW_REQUEST))
        return COMMAND_RAW_FALLBACK;
    else if(!strcmp(command, FALLBACK_TRANSFORMED_REQUEST))
        return COMMAND_TRANSFORMED_FALLBACK;
    else if(!strcmp(command, METADATA_REQUEST))
105
        return COMMAND_METADATA_UPDATE;
106 107 108 109 110
    else if(!strcmp(command, LISTCLIENTS_RAW_REQUEST))
        return COMMAND_RAW_SHOW_LISTENERS;
    else if(!strcmp(command, LISTCLIENTS_TRANSFORMED_REQUEST))
        return COMMAND_TRANSFORMED_SHOW_LISTENERS;
    else if(!strcmp(command, STATS_RAW_REQUEST))
111
        return COMMAND_RAW_STATS;
112 113
    else if(!strcmp(command, STATS_TRANSFORMED_REQUEST))
        return COMMAND_TRANSFORMED_STATS;
114 115
    else if(!strcmp(command, "stats.xml")) /* The old way */
        return COMMAND_RAW_STATS;
116 117 118 119 120
    else if(!strcmp(command, LISTMOUNTS_RAW_REQUEST))
        return COMMAND_RAW_LIST_MOUNTS;
    else if(!strcmp(command, LISTMOUNTS_TRANSFORMED_REQUEST))
        return COMMAND_TRANSFORMED_LIST_MOUNTS;
    else if(!strcmp(command, STREAMLIST_RAW_REQUEST))
121
        return COMMAND_RAW_LISTSTREAM;
122 123
    else if(!strcmp(command, STREAMLIST_PLAINTEXT_REQUEST))
        return COMMAND_PLAINTEXT_LISTSTREAM;
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
    else if(!strcmp(command, MOVECLIENTS_RAW_REQUEST))
        return COMMAND_RAW_MOVE_CLIENTS;
    else if(!strcmp(command, MOVECLIENTS_TRANSFORMED_REQUEST))
        return COMMAND_TRANSFORMED_MOVE_CLIENTS;
    else if(!strcmp(command, KILLCLIENT_RAW_REQUEST))
        return COMMAND_RAW_KILL_CLIENT;
    else if(!strcmp(command, KILLCLIENT_TRANSFORMED_REQUEST))
        return COMMAND_TRANSFORMED_KILL_CLIENT;
    else if(!strcmp(command, KILLSOURCE_RAW_REQUEST))
        return COMMAND_RAW_KILL_SOURCE;
    else if(!strcmp(command, KILLSOURCE_TRANSFORMED_REQUEST))
        return COMMAND_TRANSFORMED_KILL_SOURCE;
    else if(!strcmp(command, DEFAULT_TRANSFORMED_REQUEST))
        return COMMAND_TRANSFORMED_STATS;
    else if(!strcmp(command, DEFAULT_RAW_REQUEST))
        return COMMAND_TRANSFORMED_STATS;
140 141 142 143
    else
        return COMMAND_ERROR;
}

144
static void command_fallback(client_t *client, source_t *source, int response);
145
static void command_metadata(client_t *client, source_t *source);
146 147 148 149 150 151 152 153 154 155
static void command_show_listeners(client_t *client, source_t *source,
        int response);
static void command_move_clients(client_t *client, source_t *source,
        int response);
static void command_stats(client_t *client, int response);
static void command_list_mounts(client_t *client, int response);
static void command_kill_client(client_t *client, source_t *source,
        int response);
static void command_kill_source(client_t *client, source_t *source,
        int response);
156 157 158
static void admin_handle_mount_request(client_t *client, source_t *source,
        int command);
static void admin_handle_general_request(client_t *client, int command);
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
static void admin_send_response(xmlDocPtr doc, client_t *client, 
        int response, char *xslt_template);
static void html_write(client_t *client, char *fmt, ...);

xmlDocPtr admin_build_sourcelist(char *current_source)
{
    avl_node *node;
    source_t *source;
    xmlNodePtr xmlnode, srcnode;
    xmlDocPtr doc;
    char buf[22];
    time_t now = time(NULL);

    doc = xmlNewDoc("1.0");
    xmlnode = xmlNewDocNode(doc, NULL, "icestats", NULL);
    xmlDocSetRootElement(doc, xmlnode);
175

176 177 178 179 180 181 182
    if (current_source) {
        xmlNewChild(xmlnode, NULL, "current_source", current_source);
    }

    node = avl_get_first(global.source_tree);
    while(node) {
        source = (source_t *)node->key;
183 184 185 186
        if (source->running)
        {
            srcnode = xmlNewChild(xmlnode, NULL, "source", NULL);
            xmlSetProp(srcnode, "mount", source->mount);
187

188
            xmlNewChild(srcnode, NULL, "fallback", 
189 190
                    (source->fallback_mount != NULL)?
                    source->fallback_mount:"");
191 192
            snprintf(buf, sizeof(buf), "%ld", source->listeners);
            xmlNewChild(srcnode, NULL, "listeners", buf);
Karl Heyes's avatar
Karl Heyes committed
193 194
            snprintf(buf, sizeof(buf), "%lu",
                    (unsigned long)(now - source->con->con_time));
195 196 197 198
            xmlNewChild(srcnode, NULL, "Connected", buf);
            xmlNewChild(srcnode, NULL, "Format", 
                    source->format->format_description);
        }
199 200 201 202 203 204 205 206
        node = avl_get_next(node);
    }
    return(doc);
}

void admin_send_response(xmlDocPtr doc, client_t *client, 
        int response, char *xslt_template)
{
207
    xmlChar *buff = NULL;
208 209 210 211 212 213 214 215
    int len = 0;
    ice_config_t *config;
    char *fullpath_xslt_template;
    int fullpath_xslt_template_len;
    char *adminwebroot;

    client->respcode = 200;
    if (response == RAW) {
216
        xmlDocDumpMemory(doc, &buff, &len);
217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243
        html_write(client, "HTTP/1.0 200 OK\r\n"
               "Content-Length: %d\r\n"
               "Content-Type: text/xml\r\n"
               "\r\n", len);
        html_write(client, buff);
    }
    if (response == TRANSFORMED) {
        config = config_get_config();
        adminwebroot = config->adminroot_dir;
        config_release_config();
        fullpath_xslt_template_len = strlen(adminwebroot) + 
            strlen(xslt_template) + 2;
        fullpath_xslt_template = malloc(fullpath_xslt_template_len);
        memset(fullpath_xslt_template, '\000', fullpath_xslt_template_len);
        snprintf(fullpath_xslt_template, fullpath_xslt_template_len, "%s%s%s",
            adminwebroot, PATH_SEPARATOR, xslt_template);
        html_write(client, "HTTP/1.0 200 OK\r\n"
               "Content-Type: text/html\r\n"
               "\r\n");
        DEBUG1("Sending XSLT (%s)", fullpath_xslt_template);
        xslt_transform(doc, fullpath_xslt_template, client);
        free(fullpath_xslt_template);
    }
    if (buff) {
        xmlFree(buff);
    }
}
244 245 246 247 248 249 250 251 252 253 254 255 256
void admin_handle_request(client_t *client, char *uri)
{
    char *mount, *command_string;
    int command;

    if(strncmp("/admin/", uri, 7)) {
        ERROR0("Internal error: admin request isn't");
        client_send_401(client);
        return;
    }

    command_string = uri + 7;

257
    DEBUG1("Got command (%s)", command_string);
258 259 260 261 262 263 264 265 266 267 268 269 270 271 272
    command = admin_get_command(command_string);

    if(command < 0) {
        ERROR1("Error parsing command string or unrecognised command: %s",
                command_string);
        client_send_400(client, "Unrecognised command");
        return;
    }

    mount = httpp_get_query_param(client->parser, "mount");

    if(mount != NULL) {
        source_t *source;

        /* This is a mount request, handle it as such */
273 274
        if(!connection_check_admin_pass(client->parser)) {
            if(!connection_check_source_pass(client->parser, mount)) {
275
                INFO1("Bad or missing password on mount modification admin "
276 277 278 279
                      "request (command: %s)", command_string);
                client_send_401(client);
                return;
            }
280 281 282
        }
        
        avl_tree_rlock(global.source_tree);
Michael Smith's avatar
Michael Smith committed
283
        source = source_find_mount_raw(mount);
284

285 286
        if (source == NULL)
        {
287 288
            WARN2("Admin command %s on non-existent source %s", 
                    command_string, mount);
289
            avl_tree_unlock(global.source_tree);
290 291
            client_send_400(client, "Source does not exist");
        }
292 293
        else
        {
294 295 296 297 298 299 300 301
            if (source->running == 0)
            {
                INFO2("Received admin command %s on unavailable mount \"%s\"",
                        command_string, mount);
                avl_tree_unlock (global.source_tree);
                client_send_400 (client, "Source is not available");
                return;
            }
302 303 304
            INFO2("Received admin command %s on mount \"%s\"", 
                    command_string, mount);
            admin_handle_mount_request(client, source, command);
305
            avl_tree_unlock(global.source_tree);
306
        }
307 308 309
    }
    else {

310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327
        if (command == COMMAND_PLAINTEXT_LISTSTREAM) {
        /* this request is used by a slave relay to retrieve
           mounts from the master, so handle this request
           validating against the relay password */
            if(!connection_check_relay_pass(client->parser)) {
                INFO1("Bad or missing password on admin command "
                      "request (command: %s)", command_string);
                client_send_401(client);
                return;
            }
        }
        else {
            if(!connection_check_admin_pass(client->parser)) {
                INFO1("Bad or missing password on admin command "
                      "request (command: %s)", command_string);
                client_send_401(client);
                return;
            }
328 329 330 331 332 333 334 335 336 337
        }
        
        admin_handle_general_request(client, command);
    }
}

static void admin_handle_general_request(client_t *client, int command)
{
    switch(command) {
        case COMMAND_RAW_STATS:
338
            command_stats(client, RAW);
339
            break;
340 341
        case COMMAND_RAW_LIST_MOUNTS:
            command_list_mounts(client, RAW);
342 343
            break;
        case COMMAND_RAW_LISTSTREAM:
344 345
            command_list_mounts(client, RAW);
            break;
346 347 348
        case COMMAND_PLAINTEXT_LISTSTREAM:
            command_list_mounts(client, PLAINTEXT);
            break;
349 350 351 352 353 354 355 356 357 358 359
        case COMMAND_TRANSFORMED_STATS:
            command_stats(client, TRANSFORMED);
            break;
        case COMMAND_TRANSFORMED_LIST_MOUNTS:
            command_list_mounts(client, TRANSFORMED);
            break;
        case COMMAND_TRANSFORMED_LISTSTREAM:
            command_list_mounts(client, TRANSFORMED);
            break;
        case COMMAND_TRANSFORMED_MOVE_CLIENTS:
            command_list_mounts(client, TRANSFORMED);
360
            break;
361 362 363 364 365 366 367 368 369 370 371
        default:
            WARN0("General admin request not recognised");
            client_send_400(client, "Unknown admin request");
            return;
    }
}

static void admin_handle_mount_request(client_t *client, source_t *source, 
        int command)
{
    switch(command) {
372 373
        case COMMAND_RAW_FALLBACK:
            command_fallback(client, source, RAW);
374 375 376 377
            break;
        case COMMAND_METADATA_UPDATE:
            command_metadata(client, source);
            break;
378 379 380 381 382 383 384 385
        case COMMAND_RAW_SHOW_LISTENERS:
            command_show_listeners(client, source, RAW);
            break;
        case COMMAND_RAW_MOVE_CLIENTS:
            command_move_clients(client, source, RAW);
            break;
        case COMMAND_RAW_KILL_CLIENT:
            command_kill_client(client, source, RAW);
386
            break;
387 388
        case COMMAND_RAW_KILL_SOURCE:
            command_kill_source(client, source, RAW);
389
            break;
390 391
        case COMMAND_TRANSFORMED_FALLBACK:
            command_fallback(client, source, RAW);
392
            break;
393 394 395 396 397 398 399 400 401 402 403
        case COMMAND_TRANSFORMED_SHOW_LISTENERS:
            command_show_listeners(client, source, TRANSFORMED);
            break;
        case COMMAND_TRANSFORMED_MOVE_CLIENTS:
            command_move_clients(client, source, TRANSFORMED);
            break;
        case COMMAND_TRANSFORMED_KILL_CLIENT:
            command_kill_client(client, source, TRANSFORMED);
            break;
        case COMMAND_TRANSFORMED_KILL_SOURCE:
            command_kill_source(client, source, TRANSFORMED);
404
            break;
405 406 407
        default:
            WARN0("Mount request not recognised");
            client_send_400(client, "Mount request unknown");
408
            break;
409 410 411 412 413 414 415 416 417 418 419
    }
}

#define COMMAND_REQUIRE(client,name,var) \
    do { \
        (var) = httpp_get_query_param((client)->parser, (name)); \
        if((var) == NULL) { \
            client_send_400((client), "Missing parameter"); \
            return; \
        } \
    } while(0);
420 421
#define COMMAND_OPTIONAL(client,name,var) \
    (var) = httpp_get_query_param((client)->parser, (name))
422

423
static void html_success(client_t *client, char *message)
424 425 426 427 428 429 430 431 432 433 434 435
{
    int bytes;

    client->respcode = 200;
    bytes = sock_write(client->con->sock, 
            "HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n" 
            "<html><head><title>Admin request successful</title></head>"
            "<body><p>%s</p></body></html>", message);
    if(bytes > 0) client->con->sent_bytes = bytes;
    client_destroy(client);
}

436 437 438 439 440 441 442 443 444 445 446
static void html_write(client_t *client, char *fmt, ...)
{
    int bytes;
    va_list ap;

    va_start(ap, fmt);
    bytes = sock_write_fmt(client->con->sock, fmt, ap);
    va_end(ap);
    if(bytes > 0) client->con->sent_bytes = bytes;
}

447 448
static void command_move_clients(client_t *client, source_t *source,
    int response)
449 450 451
{
    char *dest_source;
    source_t *dest;
452 453 454 455 456 457
    xmlDocPtr doc;
    xmlNodePtr node;
    char buf[255];
    int parameters_passed = 0;

    DEBUG0("Doing optional check");
458
    if((COMMAND_OPTIONAL(client, "destination", dest_source))) {
459 460 461 462 463 464 465 466 467 468 469
        parameters_passed = 1;
    }
    DEBUG1("Done optional check (%d)", parameters_passed);
    if (!parameters_passed) {
        doc = admin_build_sourcelist(source->mount);
        admin_send_response(doc, client, response, 
             MOVECLIENTS_TRANSFORMED_REQUEST);
        xmlFreeDoc(doc);
        client_destroy(client);
        return;
    }
470

471 472 473 474 475 476 477 478
    dest = source_find_mount (dest_source);

    if (dest == NULL)
    {
        client_send_400 (client, "No such destination");
        return;
    }

Karl Heyes's avatar
Karl Heyes committed
479
    if (strcmp (dest->mount, source->mount) == 0)
480 481 482 483 484
    {
        client_send_400 (client, "supplied mountpoints are identical");
        return;
    }

485 486 487
    if (dest->running == 0)
    {
        client_send_400 (client, "Destination not running");
488 489 490
        return;
    }

491 492 493 494
    doc = xmlNewDoc("1.0");
    node = xmlNewDocNode(doc, NULL, "iceresponse", NULL);
    xmlDocSetRootElement(doc, node);

495
    source_move_clients (source, dest);
496

497
    memset(buf, '\000', sizeof(buf));
498 499
    snprintf (buf, sizeof(buf), "Clients moved from %s to %s",
            source->mount, dest_source);
500 501 502 503 504 505 506
    xmlNewChild(node, NULL, "message", buf);
    xmlNewChild(node, NULL, "return", "1");

    admin_send_response(doc, client, response, 
        ADMIN_XSL_RESPONSE);
    xmlFreeDoc(doc);
    client_destroy(client);
507 508
}

509 510
static void command_show_listeners(client_t *client, source_t *source,
    int response)
511
{
512 513
    xmlDocPtr doc;
    xmlNodePtr node, srcnode, listenernode;
514 515
    avl_node *client_node;
    client_t *current;
516 517
    char buf[22];
    char *userAgent = NULL;
518 519
    time_t now = time(NULL);

520 521 522 523 524
    doc = xmlNewDoc("1.0");
    node = xmlNewDocNode(doc, NULL, "icestats", NULL);
    srcnode = xmlNewChild(node, NULL, "source", NULL);
    xmlSetProp(srcnode, "mount", source->mount);
    xmlDocSetRootElement(doc, node);
525

526
    memset(buf, '\000', sizeof(buf));
527
    snprintf(buf, sizeof(buf)-1, "%ld", source->listeners);
528
    xmlNewChild(srcnode, NULL, "Listeners", buf);
529 530 531 532 533 534

    avl_tree_rlock(source->client_tree);

    client_node = avl_get_first(source->client_tree);
    while(client_node) {
        current = (client_t *)client_node->key;
535 536 537 538 539 540 541 542 543 544
        listenernode = xmlNewChild(srcnode, NULL, "listener", NULL);
        xmlNewChild(listenernode, NULL, "IP", current->con->ip);
        userAgent = httpp_getvar(current->parser, "user-agent");
        if (userAgent) {
            xmlNewChild(listenernode, NULL, "UserAgent", userAgent);
        }
        else {
            xmlNewChild(listenernode, NULL, "UserAgent", "Unknown");
        }
        memset(buf, '\000', sizeof(buf));
545
        snprintf(buf, sizeof(buf)-1, "%ld", now - current->con->con_time);
546 547
        xmlNewChild(listenernode, NULL, "Connected", buf);
        memset(buf, '\000', sizeof(buf));
548
        snprintf(buf, sizeof(buf)-1, "%lu", current->con->id);
549
        xmlNewChild(listenernode, NULL, "ID", buf);
550 551 552 553
        client_node = avl_get_next(client_node);
    }

    avl_tree_unlock(source->client_tree);
554 555 556
    admin_send_response(doc, client, response, 
        LISTCLIENTS_TRANSFORMED_REQUEST);
    xmlFreeDoc(doc);
557 558 559
    client_destroy(client);
}

560 561
static void command_kill_source(client_t *client, source_t *source,
    int response)
562
{
563 564 565 566 567 568 569 570 571
    xmlDocPtr doc;
    xmlNodePtr node;

    doc = xmlNewDoc("1.0");
    node = xmlNewDocNode(doc, NULL, "iceresponse", NULL);
    xmlNewChild(node, NULL, "message", "Source Removed");
    xmlNewChild(node, NULL, "return", "1");
    xmlDocSetRootElement(doc, node);

572 573
    source->running = 0;

574 575 576 577
    admin_send_response(doc, client, response, 
        ADMIN_XSL_RESPONSE);
    xmlFreeDoc(doc);
    client_destroy(client);
578 579
}

580 581
static void command_kill_client(client_t *client, source_t *source,
    int response)
582 583 584 585
{
    char *idtext;
    int id;
    client_t *listener;
586 587 588
    xmlDocPtr doc;
    xmlNodePtr node;
    char buf[50] = "";
589 590 591 592 593 594 595

    COMMAND_REQUIRE(client, "id", idtext);

    id = atoi(idtext);

    listener = source_find_client(source, id);

596 597 598 599 600
    doc = xmlNewDoc("1.0");
    node = xmlNewDocNode(doc, NULL, "iceresponse", NULL);
    xmlDocSetRootElement(doc, node);
    DEBUG1("Response is %d", response);

601 602 603 604 605 606 607
    if(listener != NULL) {
        INFO1("Admin request: client %d removed", id);

        /* This tags it for removal on the next iteration of the main source
         * loop
         */
        listener->con->error = 1;
608 609 610 611
        memset(buf, '\000', sizeof(buf));
        snprintf(buf, sizeof(buf)-1, "Client %d removed", id);
        xmlNewChild(node, NULL, "message", buf);
        xmlNewChild(node, NULL, "return", "1");
612 613
    }
    else {
614 615 616 617
        memset(buf, '\000', sizeof(buf));
        snprintf(buf, sizeof(buf)-1, "Client %d not found", id);
        xmlNewChild(node, NULL, "message", buf);
        xmlNewChild(node, NULL, "return", "0");
618
    }
619 620 621 622
    admin_send_response(doc, client, response, 
        ADMIN_XSL_RESPONSE);
    xmlFreeDoc(doc);
    client_destroy(client);
623 624
}

625 626
static void command_fallback(client_t *client, source_t *source,
    int response)
627 628 629 630 631 632 633 634 635 636 637 638
{
    char *fallback;
    char *old;

    DEBUG0("Got fallback request");

    COMMAND_REQUIRE(client, "fallback", fallback);

    old = source->fallback_mount;
    source->fallback_mount = strdup(fallback);
    free(old);

639
    html_success(client, "Fallback configured");
640 641 642 643 644 645
}

static void command_metadata(client_t *client, source_t *source)
{
    char *action;
    char *value;
646
    mp3_state *state;
647 648 649 650
#ifdef USE_YP
    int i;
    time_t current_time;
#endif
651 652 653 654 655 656

    DEBUG0("Got metadata update request");

    COMMAND_REQUIRE(client, "mode", action);
    COMMAND_REQUIRE(client, "song", value);

657
    if (source->format->type != FORMAT_TYPE_MP3)
Karl Heyes's avatar
Karl Heyes committed
658 659
    {
        client_send_400 (client, "Not mp3, cannot update metadata");
660 661 662
        return;
    }

Karl Heyes's avatar
Karl Heyes committed
663 664 665
    if (strcmp (action, "updinfo") != 0)
    {
        client_send_400 (client, "No such action");
666 667
        return;
    }
668 669 670 671 672 673 674 675

    state = source->format->_state;

    thread_mutex_lock(&(state->lock));
    free(state->metadata);
    state->metadata = strdup(value);
    state->metadata_age++;
    thread_mutex_unlock(&(state->lock));
676

677 678
    DEBUG2("Metadata on mountpoint %s changed to \"%s\"", 
        source->mount, value);
679
    stats_event(source->mount, "title", value);
Karl Heyes's avatar
Karl Heyes committed
680

681 682 683 684 685 686 687 688 689 690
#ifdef USE_YP
    /* If we get an update on the mountpoint, force a
       yp touch */
    current_time = time(NULL);
    for (i=0; i<source->num_yp_directories; i++) {
        source->ypdata[i]->yp_last_touch = current_time - 
            source->ypdata[i]->yp_touch_interval + 2;
    }
#endif

691
    html_success(client, "Metadata update successful");
692 693
}

694 695 696
static void command_stats(client_t *client, int response) {
    xmlDocPtr doc;

697 698
    DEBUG0("Stats request, sending xml stats");

699 700 701
    stats_get_xml(&doc);
    admin_send_response(doc, client, response, STATS_TRANSFORMED_REQUEST);
    xmlFreeDoc(doc);
702 703 704 705
    client_destroy(client);
    return;
}

Karl Heyes's avatar
Karl Heyes committed
706 707
static void command_list_mounts(client_t *client, int response)
{
708 709
    avl_node *node;
    source_t *source;
710 711 712

    DEBUG0("List mounts request");

Karl Heyes's avatar
Karl Heyes committed
713
    avl_tree_rlock (global.source_tree);
714 715
    if (response == PLAINTEXT)
    {
Karl Heyes's avatar
Karl Heyes committed
716 717 718 719 720
        char buffer [4096], *buf = buffer;
        unsigned remaining = sizeof (buffer);
        int ret = sprintf (buffer,
                "HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n");

721
        node = avl_get_first(global.source_tree);
Karl Heyes's avatar
Karl Heyes committed
722 723 724 725
        while (node && ret > 0 && ret < remaining)
        {
            remaining -= ret;
            buf += ret;
726
            source = (source_t *)node->key;
Karl Heyes's avatar
Karl Heyes committed
727
            ret = snprintf (buf, remaining, "%s\n", source->mount);
728 729
            node = avl_get_next(node);
        }
Karl Heyes's avatar
Karl Heyes committed
730 731 732 733 734 735 736 737
        avl_tree_unlock (global.source_tree);
        /* handle last line */
        if (ret > 0 && ret < remaining)
        {
            remaining -= ret;
            buf += ret;
        }
        sock_write_bytes (client->con->sock, buffer, sizeof (buffer)-remaining);
738
    }
Karl Heyes's avatar
Karl Heyes committed
739 740 741 742
    else
    {
        xmlDocPtr doc = admin_build_sourcelist(NULL);
        avl_tree_unlock (global.source_tree);
743 744 745 746 747

        admin_send_response(doc, client, response, 
            LISTMOUNTS_TRANSFORMED_REQUEST);
        xmlFreeDoc(doc);
    }
748
    client_destroy(client);
749

750 751 752
    return;
}