X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=http_recv.c;h=def5e6201f45f6da58da8c41edc87665bc50899e;hp=a3167bd8626f8bc40361bfb71369079db955d9cc;hb=217c259f244ec0d00e90a313b3a8b6e79d77054f;hpb=806fcbb5a8c00d6b8c1a228b9b4d6b6758f613ca diff --git a/http_recv.c b/http_recv.c index a3167bd8..def5e620 100644 --- a/http_recv.c +++ b/http_recv.c @@ -1,11 +1,12 @@ /* - * Copyright (C) 2005-2008 Andre Noll + * Copyright (C) 2005-2009 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ /** \file http_recv.c paraslash's http receiver */ +#include #include #include @@ -14,11 +15,13 @@ #include "http.h" #include "list.h" #include "sched.h" +#include "ggo.h" #include "recv.h" #include "http_recv.cmdline.h" #include "net.h" #include "string.h" #include "fd.h" +#include "buffer_tree.h" /** the output buffer size of the http receiver */ #define BUFSIZE (32 * 1024) @@ -31,41 +34,38 @@ enum http_recv_status {HTTP_CONNECTED, HTTP_SENT_GET_REQUEST, HTTP_STREAMING}; /** - * data specific to the http receiver + * Data specific to the http receiver. * * Each running instance of the http receiver reserves space for one such struct. */ struct private_http_recv_data { -/** - * - * - * the current status of the http receiver node - * - * It gets initialized to \p HTTP_CONNECTED by the open function of the - * http receiver. - * - * \sa receiver::open, receiver_node. - */ + /** + * The current status of the http receiver node. + * + * It gets initialized to \p HTTP_CONNECTED by the open function of the + * http receiver. + * + * \sa receiver::open, receiver_node. + */ enum http_recv_status status; -/** - * - * - * the file descriptor used for receiving the http stream - * - * The pre_select function of the http receiver adds this file descriptor to - * the set of file decriptors which are checked for reading/writing (depending - * on the current status) by the select loop of the application (para_audiod or - * para_recv). - * - * The post_select function of the http receiver uses \a fd, if ready, to - * establish the http connection, and updates \a status according to the new - * state of the connection. As soon as \a status is \p HTTP_STREAMING, \a fd is - * going to be only checked for reading. If data is available, it is read into - * the output buffer of the receiver node by post_select. - * - * \sa receiver::pre_select receiver::post_select receiver_node, http_recv_status - */ + /** + * The file descriptor used for receiving the http stream. + * + * The pre_select function of the http receiver adds this file descriptor to + * the set of file decriptors which are checked for reading/writing (depending + * on the current status) by the select loop of the application (para_audiod or + * para_recv). + * + * The post_select function of the http receiver uses \a fd, if ready, to + * establish the http connection, and updates \a status according to the new + * state of the connection. As soon as \a status is \p HTTP_STREAMING, \a fd is + * going to be only checked for reading. If data is available, it is read into + * the output buffer of the receiver node by post_select. + * + * \sa receiver::pre_select receiver::post_select receiver_node, http_recv_status + */ int fd; + struct btr_pool *btrp; }; static void http_shutdown(void) @@ -84,72 +84,107 @@ static char *make_request_msg(void) static void http_recv_pre_select(struct sched *s, struct task *t) { - struct receiver_node *rn = t->private_data; + struct receiver_node *rn = container_of(t, struct receiver_node, task); struct private_http_recv_data *phd = rn->private_data; + int ret; - t->ret = 1; + if (rn->btrn) { + ret = generic_recv_pre_select(s, t); + if (ret <= 0) + return; + } + t->error = 0; if (phd->status == HTTP_CONNECTED) para_fd_set(phd->fd, &s->wfds, &s->max_fileno); else para_fd_set(phd->fd, &s->rfds, &s->max_fileno); } - static void http_recv_post_select(struct sched *s, struct task *t) { - struct receiver_node *rn = t->private_data; + struct receiver_node *rn = container_of(t, struct receiver_node, task); struct private_http_recv_data *phd = rn->private_data; - - if (rn->output_error && *rn->output_error) { - t->ret = *rn->output_error; - goto out; + struct btr_node *btrn = rn->btrn; + int ret; + + t->error = 0; + if (btrn) { + ret = btr_node_status(btrn, 0, BTR_NT_ROOT); + if (ret < 0) + goto err; + if (ret == 0) + return; + } else { + if (rn->output_error && *rn->output_error < 0) { + ret = *rn->output_error; + goto err; + } } - t->ret = 1; - if (!s->select_ret) - goto out; - if (phd->status == HTTP_CONNECTED) { + if (phd->status == HTTP_CONNECTED) { char *rq; if (!FD_ISSET(phd->fd, &s->wfds)) - goto out; + return; rq = make_request_msg(); PARA_INFO_LOG("sending http request\n"); - t->ret = send_va_buffer(phd->fd, "%s", rq); + ret = send_va_buffer(phd->fd, "%s", rq); free(rq); - if (t->ret > 0) - phd->status = HTTP_SENT_GET_REQUEST; - goto out; + if (ret < 0) + goto err; + phd->status = HTTP_SENT_GET_REQUEST; + return; } if (!FD_ISSET(phd->fd, &s->rfds)) - goto out; + return; if (phd->status == HTTP_SENT_GET_REQUEST) { - t->ret = recv_pattern(phd->fd, HTTP_OK_MSG, MAXLINE); - if (t->ret < 0) - goto out; + ret = recv_pattern(phd->fd, HTTP_OK_MSG, strlen(HTTP_OK_MSG)); + if (ret < 0) + goto err; PARA_INFO_LOG("received ok msg, streaming\n"); - t->ret = 1; phd->status = HTTP_STREAMING; - goto out; + return; } - t->ret = -E_HTTP_RECV_OVERRUN; + if (btrn) { + char *buf; + size_t sz; + + sz = btr_pool_get_buffer(phd->btrp, &buf); + //PARA_CRIT_LOG("max buffer %p: %zu\n", buf, sz); + ret = -E_HTTP_RECV_OVERRUN; + if (sz == 0) + goto err; + //buf = para_malloc(HTTP_RECV_READ_BUF_SIZE); + //sz = HTTP_RECV_READ_BUF_SIZE; + ret = recv_bin_buffer(phd->fd, buf, sz); + if (ret == 0) + ret = -E_RECV_EOF; + if (ret < 0) + goto err; + btr_add_output_pool(phd->btrp, ret, btrn); + return; + } + ret = -E_HTTP_RECV_OVERRUN; if (rn->loaded >= BUFSIZE) - goto out; - t->ret = recv_bin_buffer(phd->fd, rn->buf + rn->loaded, + goto err; + ret = recv_bin_buffer(phd->fd, rn->buf + rn->loaded, BUFSIZE - rn->loaded); - if (t->ret <= 0) { - if (!t->ret) - t->ret = -E_RECV_EOF; - goto out; - } - rn->loaded += t->ret; -out: - if (t->ret < 0) - rn->error = t->ret; + if (ret == 0) + ret = -E_RECV_EOF; + if (ret < 0) + goto err; + rn->loaded += ret; + return; +err: + if (btrn) + btr_remove_node(rn->btrn); + t->error = ret; } static void http_recv_close(struct receiver_node *rn) { struct private_http_recv_data *phd = rn->private_data; + close(phd->fd); + btr_pool_free(phd->btrp); free(rn->buf); free(rn->private_data); } @@ -183,22 +218,37 @@ static int http_recv_open(struct receiver_node *rn) rn->private_data = phd = para_calloc(sizeof(struct private_http_recv_data)); phd->fd = fd; phd->status = HTTP_CONNECTED; + phd->btrp = btr_pool_new("http_recv", 320 * 1024); return 1; } +static void http_recv_free_config(void *conf) +{ + http_recv_cmdline_parser_free(conf); +} + /** - * the init function of the http receiver + * The init function of the http receiver. * - * \param r pointer to the receiver struct to initialize + * \param r Pointer to the receiver struct to initialize. * - * Just initialize all function pointers of \a r. + * This initializes all function pointers of \a r. */ void http_recv_init(struct receiver *r) { + struct http_recv_args_info dummy; + + http_recv_cmdline_parser_init(&dummy); r->open = http_recv_open; r->close = http_recv_close; r->pre_select = http_recv_pre_select; r->post_select = http_recv_post_select; r->shutdown = http_shutdown; r->parse_config = http_recv_parse_config; + r->free_config = http_recv_free_config; + r->help = (struct ggo_help) { + .short_help = http_recv_args_info_help, + .detailed_help = http_recv_args_info_detailed_help + }; + http_recv_cmdline_parser_free(&dummy); }