X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=http_send.c;h=9d0f49aee03cd6b30d6a73e9eda74dcb9be4cfc0;hp=828d99e2efc001f008e0df56946df3a990d3ab67;hb=224ab3f14af8e08a8a7159160eccea75be30ffd1;hpb=6668ac4a8c7f2a92efb9e6d405d954beff77d230 diff --git a/http_send.c b/http_send.c index 828d99e2..9d0f49ae 100644 --- a/http_send.c +++ b/http_send.c @@ -1,27 +1,30 @@ /* - * Copyright (C) 2005-2010 Andre Noll + * Copyright (C) 2005 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ /** \file http_send.c paraslash's http sender */ +#include +#include #include #include -#include -#include +#include +#include +#include #include "para.h" #include "error.h" #include "string.h" #include "server.cmdline.h" #include "afh.h" -#include "afs.h" #include "server.h" #include "http.h" -#include "vss.h" #include "list.h" #include "send.h" +#include "sched.h" +#include "vss.h" #include "close_on_fork.h" #include "net.h" #include "fd.h" @@ -53,7 +56,7 @@ static struct sender_status http_sender_status, *hss = &http_sender_status; static int http_send_msg(struct sender_client *sc, const char *msg) { - int ret = send_buffer(sc->fd, msg); + int ret = write_buffer(sc->fd, msg); if (ret < 0) shutdown_client(sc, hss); @@ -77,6 +80,66 @@ static void http_shutdown_clients(void) shutdown_clients(hss); } +static int queue_chunk_or_shutdown(struct sender_client *sc, + struct sender_status *ss, const char *buf, size_t num_bytes) +{ + int ret = cq_enqueue(sc->cq, buf, num_bytes); + if (ret < 0) + shutdown_client(sc, ss); + return ret; +} + +/** + * Send one chunk of audio data to a connected client. + * + * \param sc The client. + * \param ss The sender. + * \param current_chunk The number of the chunk to write. + * \param buf The data to write. + * \param len The number of bytes of \a buf. + * \param header_buf The audio file header. + * \param header_len The number of bytes of \a header_buf. + * + * On errors, the client is shut down. If only a part of the buffer could be + * written, the remainder is put into the chunk queue for that client. + */ +static void http_send_chunk(struct sender_client *sc, struct sender_status *ss, + long unsigned current_chunk, const char *buf, size_t len, + const char *header_buf, size_t header_len) +{ + int ret; + + if (!sc->header_sent && current_chunk) { + if (header_buf && header_len > 0) { + ret = queue_chunk_or_shutdown(sc, ss, header_buf, header_len); + if (ret < 0) + goto out; + } + } + sc->header_sent = 1; + ret = send_queued_chunks(sc->fd, sc->cq); + if (ret < 0) { + shutdown_client(sc, ss); + goto out; + } + if (!len) + goto out; + if (!ret) { /* still data left in the queue */ + ret = queue_chunk_or_shutdown(sc, ss, buf, len); + goto out; + } + ret = xwrite(sc->fd, buf, len); + if (ret < 0) { + shutdown_client(sc, ss); + goto out; + } + if (ret != len) + ret = queue_chunk_or_shutdown(sc, ss, buf + ret, len - ret); +out: + if (ret < 0) + PARA_NOTICE_LOG("%s\n", para_strerror(-ret)); +} + static void http_send(long unsigned current_chunk, __a_unused long unsigned chunks_sent, const char *buf, size_t len, const char *header_buf, size_t header_len) @@ -85,10 +148,10 @@ static void http_send(long unsigned current_chunk, list_for_each_entry_safe(sc, tmp, &hss->client_list, node) { struct private_http_sender_data *phsd = sc->private_data; - if (phsd->status != HTTP_STREAMING) - continue; - send_chunk(sc, hss, 0, current_chunk, buf, len, header_buf, - header_len); + + if (phsd->status == HTTP_STREAMING) + http_send_chunk(sc, hss, current_chunk, buf, len, + header_buf, header_len); } } @@ -96,23 +159,20 @@ static void http_post_select(fd_set *rfds, __a_unused fd_set *wfds) { struct sender_client *sc, *tmp; struct private_http_sender_data *phsd; + int ret; - if (hss->listen_fd < 0) - return; list_for_each_entry_safe(sc, tmp, &hss->client_list, node) { phsd = sc->private_data; switch (phsd->status) { case HTTP_STREAMING: /* nothing to do */ break; case HTTP_CONNECTED: /* need to recv get request */ - if (FD_ISSET(sc->fd, rfds)) { - if (recv_pattern(sc->fd, HTTP_GET_MSG, MAXLINE) - < 0) { - phsd->status = HTTP_INVALID_GET_REQUEST; - } else { - phsd->status = HTTP_GOT_GET_REQUEST; - PARA_INFO_LOG("received get request\n"); - } + ret = read_pattern(sc->fd, HTTP_GET_MSG, MAXLINE, rfds); + if (ret < 0) + phsd->status = HTTP_INVALID_GET_REQUEST; + else if (ret > 0) { + phsd->status = HTTP_GOT_GET_REQUEST; + PARA_INFO_LOG("received get request\n"); } break; case HTTP_GOT_GET_REQUEST: /* need to send ok msg */ @@ -125,9 +185,7 @@ static void http_post_select(fd_set *rfds, __a_unused fd_set *wfds) break; } } - if (!FD_ISSET(hss->listen_fd, rfds)) - return; - sc = accept_sender_client(hss); + sc = accept_sender_client(hss, rfds); if (!sc) return; phsd = para_malloc(sizeof(*phsd)); @@ -175,9 +233,9 @@ static int http_com_allow(struct sender_command_data *scd) return 1; } -static char *http_info(void) +static char *http_status(void) { - return get_sender_info(hss, "http"); + return generic_sender_status(hss, "http"); } /** @@ -191,18 +249,19 @@ static char *http_info(void) void http_send_init(struct sender *s) { int ret; - s->info = http_info; + s->status = http_status; s->send = http_send; s->pre_select = http_pre_select; s->post_select = http_post_select; s->shutdown_clients = http_shutdown_clients; + s->resolve_target = NULL; s->help = generic_sender_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; + 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; init_sender_status(hss, conf.http_access_arg, conf.http_access_given, conf.http_port_arg, conf.http_max_clients_arg,