[paraslash.git] / http_send.c

/*
 * Copyright (C) 2005-2007 Andre Noll <maan@systemlinux.org>
 *
 * Licensed under the GPL v2. For licencing details see COPYING.
 */

/** \file http_send.c paraslash's http sender */


#include "server.cmdline.h"
#include "server.h"
#include "http.h"
#include "vss.h"
#include "send.h"
#include "list.h"
#include "close_on_fork.h"
#include "error.h"
#include "net.h"
#include "string.h"
#include "fd.h"

/** \cond convert sock_addr_in to ascii */
#define CLIENT_ADDR(hc) inet_ntoa((hc)->addr.sin_addr)
/* get the port number of a struct http_client */
#define CLIENT_PORT(hc) (hc)->addr.sin_port
#define HTTP_ERR_MSG "HTTP/1.0 400 Bad Request\n"
/** \endcond */

/** The possible states of a client from the server's POV. */
enum http_status {
        /** We accepted the connection on the tcp socket. */
        HTTP_CONNECTED,
        /** Successfully received the get request. */
        HTTP_GOT_GET_REQUEST,
        /** We sent the OK message back to the client. */
        HTTP_SENT_OK_MSG,
        /** Connection established, we might need to send the audio file header. */
        HTTP_READY_TO_STREAM,
        /** Connection is ready for sending audio data. */
        HTTP_STREAMING,
        /** We didn't receive a valid get request. */
        HTTP_INVALID_GET_REQUEST
};

/** Clients will be kicked if there are more than that many bytes pending. */
#define MAX_BACKLOG 400000
/** The list of connected clients. */
static struct list_head clients;
/** The whitelist/blacklist. */
static struct list_head access_perm_list;

struct chunk_queue{
        /** The list of pending chunks for this client. */
        struct list_head q;
        /** The number of pending bytes for this client. */
        unsigned long num_pending;
        unsigned long max_pending;
};

/** Describes one client that connected the tcp port of the http sender. */
struct http_client {
        /** The file descriptor of the client. */
        int fd;
        /** Address information about the client. */
        struct sockaddr_in addr;
        /** The client's current status. */
        enum http_status status;
        /** Non-zero if we included \a fd in the read set.*/
        int check_r;
        /** Non-zero if we included \a fd in the write set. */
        int check_w;
        /** The position of this client in the client list. */
        struct list_head node;
        /** The list of pending chunks for this client. */
        struct chunk_queue cq;
};

/**
 * Describes one queued chunk of the chunk queue.
 *
 * The send function of the http sender checks each client fd for writing. If a
 * client fd is not ready, it tries to queue that chunk for this client until
 * the number of queued bytes exceeds \p MAX_BACKLOG.
 */
struct queued_chunk {
        /** The number of the queued chunk, -1U means header. */
        unsigned chunk_num;
        /** The number of bytes already sent. */
        unsigned sent;
        /** Position of the chunk in the chunk queue. */
        struct list_head node;
};

/**
 * Describes one entry in the blacklist/whitelist of the http sender.
 */
struct access_info {
        /** The address to be black/whitelisted. */
        struct in_addr addr;
        /** The netmask for this entry. */
        unsigned netmask;
        /** The position of this entry in the access_perm_list. */
        struct list_head node;
};

static int server_fd = -1, numclients;
static struct sender *self;

static void http_shutdown_client(struct http_client *hc, const char *msg)
{
        struct queued_chunk *qc, *tmp;
        PARA_INFO_LOG("shutting down %s on fd %d (%s)\n", CLIENT_ADDR(hc),
                hc->fd, msg);
        numclients--;
        close(hc->fd);
        del_close_on_fork_list(hc->fd);
        list_for_each_entry_safe(qc, tmp, &hc->cq.q, node) {
                list_del(&qc->node);
                free(qc);
        }
        list_del(&hc->node);
        free(hc);
}

static void http_shutdown_clients(void)
{
        struct http_client *hc, *tmp;
        list_for_each_entry_safe(hc, tmp, &clients, node)
                http_shutdown_client(hc, "vss request");
}

static int http_send_msg(struct http_client *hc, const char *msg)
{
        int ret = send_buffer(hc->fd, msg);

        if (ret < 0)
                http_shutdown_client(hc, "send msg failed");
        return ret;
}

static void http_send_ok_msg(struct http_client *hc)
{
        PARA_INFO_LOG("sending http ok message to fd %d\n", hc->fd);
        http_send_msg(hc, HTTP_OK_MSG);
}

static int http_send_err_msg(struct http_client *hc)
{
        PARA_NOTICE_LOG("sending bad request message to fd %d\n", hc->fd);
        return http_send_msg(hc, HTTP_ERR_MSG);
}

static int enqueue_chunk(struct chunk_queue *cq, long unsigned chunk_num,
        size_t sent)
{
        struct queued_chunk *qc;
        char *buf;
        size_t len;
        int ret;

        if (chunk_num != -1U) {
                ret = vss_get_chunk(chunk_num, &buf, &len);
                if (ret < 0)
                        return ret;
        } else
                buf = vss_get_header(&len);
        if (cq->num_pending + len > MAX_BACKLOG)
                return -E_QUEUE;
        qc = para_malloc(sizeof(struct queued_chunk));
        cq->num_pending += len;
        qc->chunk_num = chunk_num;
        qc->sent = sent;
        list_add_tail(&qc->node, &cq->q);
        PARA_INFO_LOG("%lu bytes queued for q %p\n", cq->num_pending, &cq->q);
        return 1;
}

static int send_queued_chunks(struct http_client *hc)
{
        int ret;
        struct queued_chunk *qc, *tmp;

        if (list_empty(&hc->cq.q))
                return 1;
        list_for_each_entry_safe(qc, tmp, &hc->cq.q, node) {
                char *buf;
                size_t len;
                ret = write_ok(hc->fd);
                if (ret <= 0)
                        return ret? -E_WRITE_OK : 0;
                if (qc->chunk_num != -1U) {
                        ret = vss_get_chunk(qc->chunk_num, &buf, &len);
                        if (ret < 0)
                                return ret;
                } else
                        buf = vss_get_header(&len);
                assert(len && len > qc->sent);
                ret = write(hc->fd, buf + qc->sent, len - qc->sent);
                if (ret < 0)
                        return -1; /* FIXME */
                hc->cq.num_pending -= ret;
                if (ret != len - qc->sent) {
                        qc->sent += ret;
                        return 0;
                }
                list_del(&qc->node);
                free(qc);
        }
        return 1;
}

static int queue_chunk_or_shutdown(struct http_client *hc, long unsigned chunk_num,
        size_t sent)
{
        int ret = enqueue_chunk(&hc->cq, chunk_num, sent);
        if (ret < 0)
                http_shutdown_client(hc, "queue error");
        return ret;
}

static void http_send( long unsigned current_chunk,
        __a_unused long unsigned chunks_sent, const char *buf, size_t len)
{
        struct http_client *hc, *tmp;
        int ret;

        list_for_each_entry_safe(hc, tmp, &clients, node) {
                if (hc->status != HTTP_STREAMING &&
                                hc->status != HTTP_READY_TO_STREAM)
                        continue;
                if (hc->status == HTTP_READY_TO_STREAM) {
                        unsigned hlen;
                        char *hbuf = vss_get_header(&hlen);
                        if (hbuf && hlen > 0 && current_chunk) {
                                /* need to send header */
                                PARA_INFO_LOG("queueing header: %d\n", hlen);
                                if (queue_chunk_or_shutdown(hc, -1U, 0) < 0)
                                        continue;
                        } else
                                PARA_INFO_LOG("no need to queue header\n");
                        hc->status = HTTP_STREAMING;
                }
                ret = send_queued_chunks(hc);
                if (ret < 0) {
                        http_shutdown_client(hc, "queue send error");
                        continue;
                }
                if (!len)
                        continue;
                if (!ret || write_ok(hc->fd) <= 0) {
                        PARA_INFO_LOG("fd %d not ready (%lu bytes queued),"
                                " trying to queue chunk\n", hc->fd,
                                hc->cq.num_pending);
                        queue_chunk_or_shutdown(hc, current_chunk, 0);
                        continue;
                }
//              PARA_DEBUG_LOG("sending %d -> %s\n", len, CLIENT_ADDR(hc));
                ret = write(hc->fd, buf, len);
//              PARA_DEBUG_LOG("ret: %d\n", ret);
                if (ret < 0) {
                        http_shutdown_client(hc, "send error");
                        continue;
                }
                if (ret != len)
                        queue_chunk_or_shutdown(hc, current_chunk, ret);
        }
}

static int host_in_access_perm_list(struct http_client *hc)
{
        struct access_info *ai, *tmp;
        list_for_each_entry_safe(ai, tmp, &access_perm_list, node) {
                unsigned mask = ((~0U) >> ai->netmask);
                if ((hc->addr.sin_addr.s_addr & mask) == (ai->addr.s_addr & mask))
                        return 1;
        }
        return 0;
}

static void http_post_select(fd_set *rfds, fd_set *wfds)
{
        int i = -1, match;
        struct http_client *hc, *tmp;
        const char *err_msg;

        list_for_each_entry_safe(hc, tmp, &clients, node) {
                i++;
//              PARA_DEBUG_LOG("handling client %d: %s\n", i, CLIENT_ADDR(hc));
                switch (hc->status) {
                case HTTP_STREAMING: /* nothing to do */
                case HTTP_READY_TO_STREAM:
                        break;
                case HTTP_CONNECTED: /* need to recv get request */
                        if (hc->check_r && FD_ISSET(hc->fd, rfds)) {
                                if (recv_pattern(hc->fd, HTTP_GET_MSG, MAXLINE)
                                                < 0) {
                                        hc->status = HTTP_INVALID_GET_REQUEST;
                                } else {
                                        hc->status = HTTP_GOT_GET_REQUEST;
                                        PARA_INFO_LOG("%s",
                                                "received get request\n");
                                }
                        }
                        break;
                case HTTP_GOT_GET_REQUEST: /* need to send ok msg */
                        if (hc->check_w && FD_ISSET(hc->fd, wfds)) {
                                hc->status = HTTP_SENT_OK_MSG;
                                http_send_ok_msg(hc);
                        }
                        break;
                case HTTP_INVALID_GET_REQUEST: /* need to send err msg */
                        if (hc->check_w && FD_ISSET(hc->fd, wfds)) {
                                if (http_send_err_msg(hc) >= 0)
                                        http_shutdown_client(hc,
                                                "invalid get request");
                        }
                        break;
                case HTTP_SENT_OK_MSG: /* need to send header? */
                        if (hc->check_w && FD_ISSET(hc->fd, wfds))
                                hc->status = HTTP_READY_TO_STREAM;
                        break;
                }
        }
        if (!FD_ISSET(server_fd, rfds))
                return;
        hc = para_calloc(sizeof(struct http_client));
        err_msg = "accept error";
        hc->fd = para_accept(server_fd, &hc->addr, sizeof(struct sockaddr_in));
        if (hc->fd <= 0)
                goto err_out;
        PARA_NOTICE_LOG("connection from %s (fd %d)\n", CLIENT_ADDR(hc), hc->fd);
        if (conf.http_max_clients_arg > 0 && numclients >=
                        conf.http_max_clients_arg) {
                err_msg = "server full";
                goto err_out;
        }
        match = host_in_access_perm_list(hc);
        PARA_DEBUG_LOG("host_in_access_perm_list: %d\n", match);
        if ((match && !conf.http_default_deny_given) ||
                        (!match && conf.http_default_deny_given)) {
                err_msg = "permission denied";
                goto err_out;
        }
        hc->status = HTTP_CONNECTED;
        INIT_LIST_HEAD(&hc->cq.q);
        PARA_INFO_LOG("accepted client #%d: %s (fd %d)\n", numclients,
                CLIENT_ADDR(hc), hc->fd);
        numclients++;
        para_list_add(&hc->node, &clients);
        add_close_on_fork_list(hc->fd);
        mark_fd_nonblock(hc->fd);
        return;
err_out:
        PARA_WARNING_LOG("ignoring connect request from %s (%s)\n",
                CLIENT_ADDR(hc), err_msg);
        if (hc->fd > 0)
                close(hc->fd);
        free(hc);
}

static void http_pre_select(int *max_fileno, fd_set *rfds, fd_set *wfds)
{
        struct http_client *hc, *tmp;

        if (server_fd < 0)
                return;
        para_fd_set(server_fd, rfds, max_fileno);
        list_for_each_entry_safe(hc, tmp, &clients, node) {
                //PARA_DEBUG_LOG("hc %p on fd %d: status %d\n", hc, hc->fd, hc->status);
                hc->check_r = 0;
                hc->check_w = 0;
                switch (hc->status) {
                case HTTP_STREAMING:
                case HTTP_READY_TO_STREAM:
                        break;
                case HTTP_CONNECTED: /* need to recv get request */
                        para_fd_set(hc->fd, rfds, max_fileno);
                        hc->check_r = 1;
                        break;
                case HTTP_GOT_GET_REQUEST: /* need to send ok msg */
                case HTTP_INVALID_GET_REQUEST: /* need to send err msg */
                        para_fd_set(hc->fd, wfds, max_fileno);
                        hc->check_w = 1;
                        break;
                case HTTP_SENT_OK_MSG:
                        if (!vss_playing())
                                break; /* wait until server starts playing */
                        para_fd_set(hc->fd, wfds, max_fileno);
                        hc->check_w = 1;
                        break;
                }
        }
}

static int open_tcp_port(int port)
{
        int ret;

        server_fd = init_tcp_socket(port);
        if (server_fd < 0) {
                http_shutdown_clients();
                self->status = SENDER_OFF;
                return server_fd;
        }
        ret = mark_fd_nonblock(server_fd);
        if (ret < 0) {
                PARA_EMERG_LOG("%s\n", PARA_STRERROR(-ret));
                exit(EXIT_FAILURE);
        }
        self->status = SENDER_ON;
        add_close_on_fork_list(server_fd);
        return 1;
}

static int http_com_on(__a_unused struct sender_command_data *scd)
{
        if (self->status == SENDER_ON)
                return 1;
        return open_tcp_port(conf.http_port_arg);
}

static int http_com_off(__a_unused struct sender_command_data *scd)
{
        self->status = SENDER_OFF;
        if (server_fd > 0) {
                close(server_fd);
                del_close_on_fork_list(server_fd);
                server_fd = -1;
        }
        http_shutdown_clients();
        return 1;
}

static void del_perm_list_entry(struct sender_command_data *scd)
{
        struct access_info *ai, *tmp;

        list_for_each_entry_safe(ai, tmp, &access_perm_list, node) {
                char *nad = para_strdup(inet_ntoa(ai->addr));
                if (!strcmp(nad, inet_ntoa(scd->addr)) &&
                                ai->netmask == scd->netmask) {
                        PARA_NOTICE_LOG("removing %s/%i from access list\n",
                                nad, ai->netmask);
                        list_del(&ai->node);
                        free(ai);
                }
                free(nad);
        }
}

static void add_perm_list_entry(struct sender_command_data *scd)
{
        struct access_info *ai = para_malloc(sizeof(struct access_info));
        ai->addr = scd->addr;
        ai->netmask = scd->netmask;
        PARA_INFO_LOG("adding %s/%i to access list\n", inet_ntoa(ai->addr),
                ai->netmask);
        para_list_add(&ai->node, &access_perm_list);
}

static int http_com_deny(struct sender_command_data *scd)
{
        if (conf.http_default_deny_given)
                del_perm_list_entry(scd);
        else
                add_perm_list_entry(scd);
        return 1;
}

static int http_com_allow(struct sender_command_data *scd)
{
        if (conf.http_default_deny_given)
                add_perm_list_entry(scd);
        else
                del_perm_list_entry(scd);
        return 1;
}

static char *http_info(void)
{
        char *clnts = NULL, *ap = NULL, *ret;
        struct access_info *ai, *tmp_ai;
        struct http_client *hc, *tmp_hc;

        list_for_each_entry_safe(ai, tmp_ai, &access_perm_list, node) {
                char *tmp = make_message("%s%s/%d ", ap? ap : "",
                        inet_ntoa(ai->addr), ai->netmask);
                free(ap);
                ap = tmp;
        }
        list_for_each_entry_safe(hc, tmp_hc, &clients, node) {
                char *tmp = make_message("%s%s:%d ", clnts? clnts : "",
                        CLIENT_ADDR(hc), CLIENT_PORT(hc));
                free(clnts);
                clnts = tmp;
        }
        ret = make_message(
                "http status: %s\n"
                "http tcp port: %d\n"
                "http clients: %d\n"
                "http maximal number of clients: %d%s\n"
                "http connected clients: %s\n"
                "http access %s list: %s\n",
                (self->status == SENDER_ON)? "on" : "off",
                conf.http_port_arg,
                numclients,
                conf.http_max_clients_arg,
                conf.http_max_clients_arg > 0? "" : " (unlimited)",
                clnts? clnts : "(none)",
                conf.http_default_deny_given? "allow" : "deny",
                ap? ap : "(none)"
        );
        free(ap);
        free(clnts);
        return ret;
}

static void init_access_control_list(void)
{
        int i;
        struct sender_command_data scd;

        INIT_LIST_HEAD(&access_perm_list);
        for (i = 0; i < conf.http_access_given; i++) {
                char *arg = para_strdup(conf.http_access_arg[i]);
                char *p = strchr(arg, '/');
                if (!p)
                        goto err;
                *p = '\0';
                if (!inet_aton(arg, &scd.addr))
                        goto err;
                scd.netmask = atoi(++p);
                if (scd.netmask < 0 || scd.netmask > 32)
                        goto err;
                add_perm_list_entry(&scd);
                goto success;
err:
                PARA_CRIT_LOG("syntax error for http_access option "
                        "#%d, ignoring\n", i);
success:
                free(arg);
                continue;
        }
}

static char *http_help(void)
{
        return make_message(
                "usage: {on|off}\n"
                "usage: {allow|deny} IP mask\n"
                "example: allow 127.0.0.1 32\n"
        );
}

/**
 * The init function of the http sender.
 *
 * \param s Pointer to the http sender struct.
 *
 * It initializes all function pointers of \a s, the client list and the access
 * control list. If the autostart option was given, the tcp port is opened.
 */
void http_send_init(struct sender *s)
{
        INIT_LIST_HEAD(&clients);
        s->info = http_info;
        s->send = http_send;
        s->pre_select = http_pre_select;
        s->post_select = http_post_select;
        s->shutdown_clients = http_shutdown_clients;
        s->help = http_help;
        s->client_cmds[SENDER_ON] = http_com_on;
        s->client_cmds[SENDER_OFF] = http_com_off;
        s->client_cmds[SENDER_DENY] = http_com_deny;
        s->client_cmds[SENDER_ALLOW] = http_com_allow;
        s->client_cmds[SENDER_ADD] = NULL;
        s->client_cmds[SENDER_DELETE] = NULL;
        self = s;
        init_access_control_list();
        if (!conf.http_no_autostart_given)
                open_tcp_port(conf.http_port_arg); /* ignore errors */
        PARA_DEBUG_LOG("%s", "http sender init complete\n");
}