[paraslash.git] / http_send.c

/*
 * Copyright (C) 2005-2006 Andre Noll <maan@systemlinux.org>
 *
 *     This program is free software; you can redistribute it and/or modify
 *     it under the terms of the GNU General Public License as published by
 *     the Free Software Foundation; either version 2 of the License, or
 *     (at your option) any later version.
 *
 *     This program is distributed in the hope that it will be useful,
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *     GNU General Public License for more details.
 *
 *     You should have received a copy of the GNU General Public License
 *     along with this program; if not, write to the Free Software
 *     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
 */

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


#include "server.cmdline.h"
#include "server.h"
#include "http.h"
#include "afs.h"
#include "send.h"
#include "list.h"
#include "close_on_fork.h"
#include "error.h"
#include "net.h"
#include "string.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 */

extern struct gengetopt_args_info conf;

/** the possible states of a client from the server's POV */
enum http_status {
        HTTP_CONNECTED,
        HTTP_GOT_GET_REQUEST,
        HTTP_SENT_OK_MSG,
        HTTP_READY_TO_STREAM,
        HTTP_STREAMING,
        HTTP_INVALID_GET_REQUEST
};

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

/** 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 packets for this client */
        struct list_head packet_queue;
/** the number of pending bytes for this client */
        unsigned long pq_bytes;
};

/**
 * describes one queued data packet for a client
 *
 * 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 packet for this client until
 * the number of queued bytes exceeds \p MAX_BACKLOG.
 */
struct queued_packet {
/** the length of the packet in bytes */
        unsigned int len;
/** pointer to the packet data */
        char *packet;
/** position of the packet in the packet list */
        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 */
        int 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_packet *qp, *tmp;
        PARA_INFO_LOG("shutting down %s on fd %d (%s)\n", CLIENT_ADDR(hc),
                hc->fd, msg);
        numclients--;
        close(hc->fd);

        list_for_each_entry_safe(qp, tmp, &hc->packet_queue, node) {
                free(qp->packet);
                list_del(&qp->node);
                free(qp);
        }
        list_del(&hc->node);
        free(hc);
        return;
}

static void http_shutdown_clients_real(void)
{
        struct http_client *hc, *tmp;
        list_for_each_entry_safe(hc, tmp, &clients, node)
                http_shutdown_client(hc, "afs request");
}
static void http_shutdown_clients(void)
{
        struct http_client *hc, *tmp;
        list_for_each_entry_safe(hc, tmp, &clients, node)
                if (hc->status == HTTP_STREAMING)
                        http_shutdown_client(hc, "afs 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 queue_packet(struct http_client *hc, const char *buf, size_t len)
{
        struct queued_packet *qp;
        if (hc->pq_bytes + len > MAX_BACKLOG) {
                http_shutdown_client(hc, "packet queue overrun");
                return -E_QUEUE;
        }
        qp = para_malloc(sizeof(struct queued_packet));
        hc->pq_bytes += len;
        qp->packet = para_malloc(len);
        memcpy(qp->packet, buf, len);
        qp->len = len;
        list_add_tail(&qp->node, &hc->packet_queue);
        PARA_INFO_LOG("%lu bytes queued for fd %d\n", hc->pq_bytes, hc->fd);
        return 1;
}

static int send_queued_packets(struct http_client *hc)
{
        int ret;
        struct queued_packet *qp, *tmp;

        if (list_empty(&hc->packet_queue))
                return 1;
        list_for_each_entry_safe(qp, tmp, &hc->packet_queue, node) {
                ret = write_ok(hc->fd);
                if (ret <= 0)
                        return ret? -E_WRITE_OK : 0;
                ret = write(hc->fd, qp->packet, qp->len);
                if (ret < 0)
                        return ret;
                if (ret != qp->len) {
                        qp->len -= ret;
                        memmove(qp->packet, qp->packet + ret, qp->len);
                        return 0;
                }
                hc->pq_bytes -= qp->len;
                free(qp->packet);
                list_del(&qp->node);
                free(qp);
        }
        return 1;
}

static void http_send(__a_unused struct audio_format *af,
                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) {
                        if (af->get_header_info && current_chunk) {
                                /* need to send header */
                                int hlen;
                                char *buf = af->get_header_info(&hlen);
                                if (!buf || hlen <= 0)
                                        continue; /* header not yet available */
                                PARA_INFO_LOG("queueing header: %d\n", hlen);
                                if (queue_packet(hc, buf, hlen) < 0)
                                        continue;
                        } else
                                PARA_INFO_LOG("%s", "no need to queue header\n");
                        hc->status = HTTP_STREAMING;
                }
                ret = send_queued_packets(hc);
                if (ret < 0) {
                        http_shutdown_client(hc, "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 packet\n", hc->fd,
                                hc->pq_bytes);
                        queue_packet(hc, buf, len);
                        continue;
                }
//              PARA_DEBUG_LOG("sending %d -> %s\n", len, CLIENT_ADDR(hc));
                ret = write(hc->fd, buf, len);
                if (ret < 0) {
                        http_shutdown_client(hc, "send error");
                        continue;
                }
                if (ret != len)
                        queue_packet(hc, buf + ret, len - 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 = ((~0) >> ai->netmask);
                if ((hc->addr.sin_addr.s_addr & mask) == (ai->addr.s_addr & mask))
                        return 1;
        }
        return 0;
}

static void http_post_select(__a_unused struct audio_format *af, 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->packet_queue);
        PARA_INFO_LOG("accepted client #%d: %s (fd %d)\n", numclients,
                CLIENT_ADDR(hc), hc->fd);
        numclients++;
        list_add(&hc->node, &clients);
        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(struct audio_format *af, int *max_fileno, fd_set *rfds,
                fd_set *wfds)
{
        struct http_client *hc, *tmp;

        if (server_fd < 0)
                return;
        FD_SET(server_fd, rfds);
        *max_fileno = MAX(*max_fileno, server_fd);
        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 */
                        FD_SET(hc->fd, rfds);
                        *max_fileno = MAX(*max_fileno, hc->fd);
                        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 */
                        FD_SET(hc->fd, wfds);
                        *max_fileno = MAX(*max_fileno, hc->fd);
                        hc->check_w = 1;
                        break;
                case HTTP_SENT_OK_MSG:
                        if (!af || !afs_playing())
                                break; /* wait until server starts playing */
                        FD_SET(hc->fd, wfds);
                        *max_fileno = MAX(*max_fileno, hc->fd);
                        hc->check_w = 1;
                        break;
                }
        }
}

static int open_tcp_port(int port)
{
        server_fd = init_tcp_socket(port);
        if (server_fd < 0) {
                http_shutdown_clients_real();
                self->status = SENDER_OFF;
                return server_fd;
        }
        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_real();
        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);
        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, init the client list and the
 * acess control list as well. If autostart is wanted, open the tcp port.
 */
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);
        PARA_DEBUG_LOG("%s", "http sender init complete\n");
}