From 62e9f05c8a2ae669e3efa1f92f6ae5cebde9878d Mon Sep 17 00:00:00 2001 From: Andre Noll Date: Mon, 4 Feb 2008 09:31:55 +0100 Subject: [PATCH] Make the http sender use the generic sender code. --- error.h | 2 + http_send.c | 267 +++++++++++++++------------------------------------- 2 files changed, 78 insertions(+), 191 deletions(-) diff --git a/error.h b/error.h index 3a05fe04..644c8044 100644 --- a/error.h +++ b/error.h @@ -319,6 +319,8 @@ extern const char **para_errlist[]; #define HTTP_SEND_ERRORS \ PARA_ERROR(WRITE_OK, "can not check whether fd is writable"), \ + PARA_ERROR(MAX_CLIENTS, "maximal number of clients exceeded"), \ + PARA_ERROR(ACL_PERM, "access denied by acl"), \ #define COMMAND_ERRORS \ diff --git a/http_send.c b/http_send.c index b629d957..40f0c0af 100644 --- a/http_send.c +++ b/http_send.c @@ -49,269 +49,149 @@ static struct list_head clients; /** The whitelist/blacklist. */ static struct list_head http_acl; -/** Describes one client that connected the tcp port of the http sender. */ -struct http_client { - /** The file descriptor of the client. */ - int fd; - /** The socket `name' of the client. */ - char *name; - /** The client's current status. */ - enum http_status status; - /** The position of this client in the client list. */ - struct list_head node; - /** non-zero if audio file header has been sent */ - int header_sent; - /** The list of pending chunks for this client. */ - struct chunk_queue *cq; -}; - static int listen_fd = -1, numclients; +struct private_http_sender_data { + enum http_status status; +}; -static void http_shutdown_client(struct http_client *hc, const char *msg) -{ - PARA_INFO_LOG("shutting down %s on fd %d (%s)\n", hc->name, hc->fd, - msg); - numclients--; - free(hc->name); - close(hc->fd); - del_close_on_fork_list(hc->fd); - cq_destroy(hc->cq); - 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) +static int http_send_msg(struct sender_client *sc, const char *msg) { - int ret = send_buffer(hc->fd, msg); + int ret = send_buffer(sc->fd, msg); if (ret < 0) - http_shutdown_client(hc, "send msg failed"); + shutdown_client(sc); 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) +static void http_send_ok_msg(struct sender_client *sc) { - PARA_NOTICE_LOG("sending bad request message to fd %d\n", hc->fd); - return http_send_msg(hc, HTTP_ERR_MSG); -} - -/* - * ret: Negative on errors, zero if nothing was written and write returned - * EAGAIN, number of bytes written else. - */ -static int http_write(int fd, const char *buf, size_t len) -{ - size_t written = 0; - - while (written < len) { - int ret = write(fd, buf + written, len - written); - if (ret < 0 && errno == EAGAIN) - return written; - if (ret < 0) - return -ERRNO_TO_PARA_ERROR(errno); - written += ret; - } - return written; + PARA_INFO_LOG("sending http ok message to fd %d\n", sc->fd); + http_send_msg(sc, HTTP_OK_MSG); } - -static int send_queued_chunks(struct http_client *hc) +static int http_send_err_msg(struct sender_client *sc) { - struct queued_chunk *qc; - while ((qc = cq_peek(hc->cq))) { - char *buf; - size_t len; - int ret; - cq_get(qc, &buf, &len); - ret = http_write(hc->fd, buf, len); - if (ret < 0) - return ret; - cq_update(hc->cq, ret); - if (ret != len) - return 1; - cq_dequeue(hc->cq); - } - return 1; + PARA_NOTICE_LOG("sending bad request message to fd %d\n", sc->fd); + return http_send_msg(sc, HTTP_ERR_MSG); } -static int queue_chunk_or_shutdown(struct http_client *hc, long unsigned chunk_num, - size_t sent) +static void http_shutdown_clients(void) { - int ret = cq_enqueue(hc->cq, chunk_num, sent); - if (ret < 0) - http_shutdown_client(hc, "queue error"); - return ret; + struct sender_client *sc, *tmp; + list_for_each_entry_safe(sc, tmp, &clients, node) + shutdown_client(sc); } 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; + struct sender_client *sc, *tmp; - list_for_each_entry_safe(hc, tmp, &clients, node) { - if (hc->status != HTTP_STREAMING) - continue; - if (!hc->header_sent && current_chunk) { - size_t hlen; - char *hbuf = vss_get_header(&hlen); - if (hbuf && hlen > 0) { /* need to send header */ - PARA_INFO_LOG("queueing header: %zu\n", hlen); - if (queue_chunk_or_shutdown(hc, -1U, 0) < 0) - continue; - } else - PARA_INFO_LOG("no need to queue header\n"); - hc->header_sent = 1; - } - ret = send_queued_chunks(hc); - if (ret < 0) { - http_shutdown_client(hc, "queue send error"); + list_for_each_entry_safe(sc, tmp, &clients, node) { + struct private_http_sender_data *phsd = sc->private_data; + if (phsd->status != HTTP_STREAMING) continue; - } - if (!len) - continue; - ret = http_write(hc->fd, buf, len); - if (ret < 0) { - http_shutdown_client(hc, "send error"); - continue; - } - if (ret != len) - queue_chunk_or_shutdown(hc, current_chunk, ret); + send_chunk(sc, 0, current_chunk, buf, len); } } static void http_post_select(fd_set *rfds, __a_unused fd_set *wfds) { - int i = -1, match; - struct http_client *hc, *tmp; - const char *err_msg; + int ret, i = -1, match; + struct sender_client *sc, *tmp; + struct private_http_sender_data *phsd; if (listen_fd < 0) return; - list_for_each_entry_safe(hc, tmp, &clients, node) { + list_for_each_entry_safe(sc, tmp, &clients, node) { i++; -// PARA_DEBUG_LOG("handling client %d: %s\n", i, remote_name(hc->fd)); - switch (hc->status) { + phsd = sc->private_data; +// PARA_DEBUG_LOG("handling client %d: %s\n", i, remote_name(sc->fd)); + switch (phsd->status) { case HTTP_STREAMING: /* nothing to do */ break; case HTTP_CONNECTED: /* need to recv get request */ - if (FD_ISSET(hc->fd, rfds)) { - if (recv_pattern(hc->fd, HTTP_GET_MSG, MAXLINE) + if (FD_ISSET(sc->fd, rfds)) { + if (recv_pattern(sc->fd, HTTP_GET_MSG, MAXLINE) < 0) { - hc->status = HTTP_INVALID_GET_REQUEST; + phsd->status = HTTP_INVALID_GET_REQUEST; } else { - hc->status = HTTP_GOT_GET_REQUEST; + phsd->status = HTTP_GOT_GET_REQUEST; PARA_INFO_LOG("%s", "received get request\n"); } } break; case HTTP_GOT_GET_REQUEST: /* need to send ok msg */ - hc->status = HTTP_STREAMING; - http_send_ok_msg(hc); + phsd->status = HTTP_STREAMING; + http_send_ok_msg(sc); break; case HTTP_INVALID_GET_REQUEST: /* need to send err msg */ - if (http_send_err_msg(hc) >= 0) - http_shutdown_client(hc, "invalid get request"); + if (http_send_err_msg(sc) >= 0) + shutdown_client(sc); break; } } if (!FD_ISSET(listen_fd, rfds)) return; - hc = para_calloc(sizeof(struct http_client)); - err_msg = "accept error"; - hc->fd = para_accept(listen_fd, NULL, 0); - if (hc->fd <= 0) + ret = para_accept(listen_fd, NULL, 0); + if (ret < 0) goto err_out; - hc->name = make_message("%s", remote_name(hc->fd)); - PARA_NOTICE_LOG("connection from %s (fd %d)\n", hc->name, hc->fd); + sc = para_calloc(sizeof(*sc)); + sc->fd = ret; + sc->name = make_message("%s", remote_name(sc->fd)); + PARA_NOTICE_LOG("connection from %s (fd %d)\n", sc->name, sc->fd); + ret = -E_MAX_CLIENTS; if (conf.http_max_clients_arg > 0 && numclients >= conf.http_max_clients_arg) { - err_msg = "server full"; goto err_out; } - match = acl_lookup(hc->fd, &http_acl); + match = acl_lookup(sc->fd, &http_acl); PARA_DEBUG_LOG("acl lookup returned %d\n", match); + ret = -E_ACL_PERM; if ((match && !conf.http_default_deny_given) || - (!match && conf.http_default_deny_given)) { - err_msg = "permission denied"; + (!match && conf.http_default_deny_given)) goto err_out; - } - err_msg = "failed to mark fd non-blocking"; - if (mark_fd_nonblocking(hc->fd) < 0) + ret = mark_fd_nonblocking(sc->fd); + if (ret < 0) goto err_out; - hc->status = HTTP_CONNECTED; - hc->cq = cq_new(MAX_BACKLOG); + phsd = para_malloc(sizeof(*phsd)); + sc->private_data = phsd; + phsd->status = HTTP_CONNECTED; + sc->cq = cq_new(MAX_BACKLOG); numclients++; PARA_INFO_LOG("accepted client #%d: %s (fd %d)\n", numclients, - hc->name, hc->fd); - para_list_add(&hc->node, &clients); - add_close_on_fork_list(hc->fd); + sc->name, sc->fd); + para_list_add(&sc->node, &clients); + add_close_on_fork_list(sc->fd); return; err_out: - PARA_WARNING_LOG("ignoring connect request from %s (%s)\n", - hc->name, err_msg); - if (hc->fd > 0) - close(hc->fd); - free(hc); + PARA_WARNING_LOG("%s\n", para_strerror(-ret)); + if (sc->fd > 0) + close(sc->fd); + free(sc); } static void http_pre_select(int *max_fileno, fd_set *rfds, __a_unused fd_set *wfds) { - struct http_client *hc, *tmp; + struct sender_client *sc, *tmp; if (listen_fd < 0) return; para_fd_set(listen_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); - switch (hc->status) { - case HTTP_STREAMING: - case HTTP_GOT_GET_REQUEST: /* need to send ok msg */ - case HTTP_INVALID_GET_REQUEST: /* need to send err msg */ - break; - case HTTP_CONNECTED: /* need to recv get request */ - para_fd_set(hc->fd, rfds, max_fileno); - break; - } - } -} - -static int http_open(void) -{ - int ret; - - listen_fd = para_listen(AF_UNSPEC, IPPROTO_TCP, conf.http_port_arg); - if (listen_fd < 0) - return listen_fd; - ret = mark_fd_nonblocking(listen_fd); - if (ret < 0) { - PARA_EMERG_LOG("%s\n", para_strerror(-ret)); - exit(EXIT_FAILURE); + list_for_each_entry_safe(sc, tmp, &clients, node) { + struct private_http_sender_data *phsd = sc->private_data; + if (phsd->status == HTTP_CONNECTED) /* need to recv get request */ + para_fd_set(sc->fd, rfds, max_fileno); } - add_close_on_fork_list(listen_fd); - return 1; } static int http_com_on(__a_unused struct sender_command_data *scd) { if (listen_fd >= 0) return 1; - return http_open(); + return open_sender(IPPROTO_TCP, conf.http_port_arg); } static int http_com_off(__a_unused struct sender_command_data *scd) @@ -347,11 +227,11 @@ static int http_com_allow(struct sender_command_data *scd) static char *http_info(void) { char *clnts = NULL, *ret; - struct http_client *hc, *tmp_hc; + struct sender_client *sc, *tmp_sc; char *acl_contents = acl_get_contents(&http_acl); - list_for_each_entry_safe(hc, tmp_hc, &clients, node) { - char *tmp = make_message("%s%s ", clnts? clnts : "", hc->name); + list_for_each_entry_safe(sc, tmp_sc, &clients, node) { + char *tmp = make_message("%s%s ", clnts? clnts : "", sc->name); free(clnts); clnts = tmp; } @@ -395,6 +275,7 @@ static char *http_help(void) */ void http_send_init(struct sender *s) { + int ret; INIT_LIST_HEAD(&clients); s->info = http_info; s->send = http_send; @@ -409,7 +290,11 @@ void http_send_init(struct sender *s) s->client_cmds[SENDER_ADD] = NULL; s->client_cmds[SENDER_DELETE] = NULL; acl_init(&http_acl, conf.http_access_arg, conf.http_access_given); - if (!conf.http_no_autostart_given) - http_open(); /* ignore errors */ - PARA_DEBUG_LOG("%s", "http sender init complete\n"); + if (conf.http_no_autostart_given) + return; + ret = open_sender(IPPROTO_TCP, conf.http_port_arg); + if (ret < 0) + PARA_ERROR_LOG("%s\n", para_strerror(-ret)); + else + listen_fd = ret; } -- 2.39.5