X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=http_send.c;h=e60b3f90f2853c6ff12f9958d642cb8b3e691e36;hp=2597066a2a329787ba713f4c48146818d7abd56a;hb=36df09fbcf3f6e80cc0990bad92ec16a0d1b2a00;hpb=34ac5d7569ecf504bd869c0c14cb6abf2c028b13 diff --git a/http_send.c b/http_send.c index 2597066a..e60b3f90 100644 --- a/http_send.c +++ b/http_send.c @@ -6,25 +6,28 @@ /** \file http_send.c paraslash's http sender */ +#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 "send.h" #include "list.h" #include "close_on_fork.h" -#include "error.h" #include "net.h" -#include "string.h" #include "fd.h" +#include "chunk_queue.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 +/** Message sent to clients that do not send a valid get request. */ #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 { @@ -49,20 +52,12 @@ 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 socket `name' of the client. */ + char *name; /** The client's current status. */ enum http_status status; /** Non-zero if we included \a fd in the read set.*/ @@ -72,23 +67,7 @@ struct http_client { /** 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; + struct chunk_queue *cq; }; /** @@ -106,18 +85,16 @@ struct access_info { 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); + 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); - list_for_each_entry_safe(qc, tmp, &hc->cq.q, node) { - list_del(&qc->node); - free(qc); - } + cq_destroy(hc->cq); list_del(&hc->node); free(hc); } @@ -150,61 +127,23 @@ static int http_send_err_msg(struct http_client *hc) 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) { + struct queued_chunk *qc; + while ((qc = cq_peek(hc->cq))) { char *buf; size_t len; - ret = write_ok(hc->fd); + int 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); + cq_get(qc, &buf, &len); + ret = write(hc->fd, buf, len); 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 -E_SEND_QUEUED_CHUNK; + cq_update(hc->cq, ret); + if (ret != len) + return 1; + cq_dequeue(hc->cq); } return 1; } @@ -212,7 +151,7 @@ static int send_queued_chunks(struct http_client *hc) 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); + int ret = cq_enqueue(hc->cq, chunk_num, sent); if (ret < 0) http_shutdown_client(hc, "queue error"); return ret; @@ -229,11 +168,11 @@ static void http_send( long unsigned current_chunk, hc->status != HTTP_READY_TO_STREAM) continue; if (hc->status == HTTP_READY_TO_STREAM) { - unsigned hlen; + size_t 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); + PARA_INFO_LOG("queueing header: %zu\n", hlen); if (queue_chunk_or_shutdown(hc, -1U, 0) < 0) continue; } else @@ -248,13 +187,10 @@ static void http_send( long unsigned current_chunk, 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)); +// PARA_DEBUG_LOG("sending %d -> %s\n", len, remote_name(hc->fd)); ret = write(hc->fd, buf, len); // PARA_DEBUG_LOG("ret: %d\n", ret); if (ret < 0) { @@ -266,14 +202,37 @@ static void http_send( long unsigned current_chunk, } } +/** + * Return true if addr_1 matches addr_2 in the first `netmask' bits. + */ +static int v4_addr_match(uint32_t addr_1, uint32_t addr_2, uint8_t netmask) +{ + uint32_t mask = ~0U; + + if (netmask < 32) + mask <<= (32 - netmask); + return (htonl(addr_1) & mask) == (htonl(addr_2) & mask); +} + 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; + struct sockaddr_storage ss; + socklen_t sslen = sizeof(ss); + struct in_addr v4_addr; + + if (getpeername(hc->fd, (struct sockaddr *)&ss, &sslen) < 0) { + PARA_ERROR_LOG("Can not determine peer address: %s\n", strerror(errno)); + goto no_match; } + v4_addr = extract_v4_addr(&ss); + if (!v4_addr.s_addr) + goto no_match; + + list_for_each_entry_safe(ai, tmp, &access_perm_list, node) + if (v4_addr_match(v4_addr.s_addr, ai->addr.s_addr, ai->netmask)) + return 1; +no_match: return 0; } @@ -285,7 +244,7 @@ static void http_post_select(fd_set *rfds, fd_set *wfds) list_for_each_entry_safe(hc, tmp, &clients, node) { i++; -// PARA_DEBUG_LOG("handling client %d: %s\n", i, CLIENT_ADDR(hc)); +// PARA_DEBUG_LOG("handling client %d: %s\n", i, remote_name(hc->fd)); switch (hc->status) { case HTTP_STREAMING: /* nothing to do */ case HTTP_READY_TO_STREAM: @@ -325,10 +284,11 @@ static void http_post_select(fd_set *rfds, fd_set *wfds) return; hc = para_calloc(sizeof(struct http_client)); err_msg = "accept error"; - hc->fd = para_accept(server_fd, &hc->addr, sizeof(struct sockaddr_in)); + hc->fd = para_accept(server_fd, NULL, 0); if (hc->fd <= 0) goto err_out; - PARA_NOTICE_LOG("connection from %s (fd %d)\n", CLIENT_ADDR(hc), hc->fd); + hc->name = make_message("%s", remote_name(hc->fd)); + PARA_NOTICE_LOG("connection from %s (fd %d)\n", hc->name, hc->fd); if (conf.http_max_clients_arg > 0 && numclients >= conf.http_max_clients_arg) { err_msg = "server full"; @@ -342,17 +302,17 @@ static void http_post_select(fd_set *rfds, fd_set *wfds) 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); + hc->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); - mark_fd_nonblock(hc->fd); + mark_fd_nonblocking(hc->fd); return; err_out: PARA_WARNING_LOG("ignoring connect request from %s (%s)\n", - CLIENT_ADDR(hc), err_msg); + hc->name, err_msg); if (hc->fd > 0) close(hc->fd); free(hc); @@ -396,15 +356,15 @@ static int open_tcp_port(int port) { int ret; - server_fd = init_tcp_socket(port); + server_fd = para_listen(AF_UNSPEC, IPPROTO_TCP, port); if (server_fd < 0) { http_shutdown_clients(); self->status = SENDER_OFF; return server_fd; } - ret = mark_fd_nonblock(server_fd); + ret = mark_fd_nonblocking(server_fd); if (ret < 0) { - PARA_EMERG_LOG("%s\n", PARA_STRERROR(-ret)); + PARA_EMERG_LOG("%s\n", para_strerror(-ret)); exit(EXIT_FAILURE); } self->status = SENDER_ON; @@ -489,8 +449,7 @@ static char *http_info(void) 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)); + char *tmp = make_message("%s%s ", clnts? clnts : "", hc->name); free(clnts); clnts = tmp; } @@ -527,7 +486,7 @@ static void init_access_control_list(void) if (!p) goto err; *p = '\0'; - if (!inet_aton(arg, &scd.addr)) + if (!inet_pton(AF_INET, arg, &scd.addr)) goto err; scd.netmask = atoi(++p); if (scd.netmask < 0 || scd.netmask > 32)