X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=http_recv.c;h=13e9ede23d4d3cda0dcea71fbeef9dc0602dbd6f;hp=da28faaaecd2bb19948d96a3606310c3cb9fbb84;hb=c9c96581d5a29830f555079e861dcac8d48722d5;hpb=f4fb0289834e76a23839719ab0e89fe29b591d3f diff --git a/http_recv.c b/http_recv.c index da28faaa..13e9ede2 100644 --- a/http_recv.c +++ b/http_recv.c @@ -1,31 +1,26 @@ /* - * Copyright (C) 2005-2006 Andre Noll + * Copyright (C) 2005-2009 Andre Noll * - * 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. + * Licensed under the GPL v2. For licencing details see COPYING. */ /** \file http_recv.c paraslash's http receiver */ -#include "para.h" +#include +#include +#include +#include "para.h" +#include "error.h" #include "http.h" +#include "list.h" +#include "sched.h" +#include "ggo.h" #include "recv.h" #include "http_recv.cmdline.h" -#include "error.h" #include "net.h" #include "string.h" +#include "fd.h" /** the output buffer size of the http receiver */ #define BUFSIZE (32 * 1024) @@ -48,7 +43,7 @@ struct private_http_recv_data { * * the current status of the http receiver node * - * It gets initialized to #HTTP_CONNECTED by the open function of the + * It gets initialized to \p HTTP_CONNECTED by the open function of the * http receiver. * * \sa receiver::open, receiver_node. @@ -66,11 +61,11 @@ struct private_http_recv_data { * * 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 #HTTP_STREAMING, \a fd is + * 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 + * \sa receiver::pre_select receiver::post_select receiver_node, http_recv_status */ int fd; }; @@ -83,67 +78,68 @@ static void http_shutdown(void) static char *make_request_msg(void) { char *ret, *hn = para_hostname(); - ret = make_message("%s\nHost: %s\nUser-Agent: para_recv/%s\n\n\n", - HTTP_GET_MSG, hn, VERSION); + ret = make_message("%s1.0\nHost: %s\nUser-Agent: para_recv/%s\n\n\n", + HTTP_GET_MSG, hn, PACKAGE_VERSION); free(hn); return ret; } -static int http_pre_select(struct receiver_node *rn, fd_set *rfds, fd_set *wfds, - __unused struct timeval *timeout) +static void http_recv_pre_select(struct sched *s, struct task *t) { + struct receiver_node *rn = container_of(t, struct receiver_node, task); struct private_http_recv_data *phd = rn->private_data; + t->error = 0; if (phd->status == HTTP_CONNECTED) - FD_SET(phd->fd, wfds); + para_fd_set(phd->fd, &s->wfds, &s->max_fileno); else - FD_SET(phd->fd, rfds); - return phd->fd; + para_fd_set(phd->fd, &s->rfds, &s->max_fileno); } -static int http_post_select(struct receiver_node *rn, int select_ret, - fd_set *rfds, fd_set *wfds) + +static void http_recv_post_select(struct sched *s, struct task *t) { - int ret; + struct receiver_node *rn = container_of(t, struct receiver_node, task); struct private_http_recv_data *phd = rn->private_data; - if (!select_ret) /* we're not interested in timeouts */ - return 1; + if (rn->output_error && *rn->output_error < 0) { + t->error = *rn->output_error; + return; + } if (phd->status == HTTP_CONNECTED) { char *rq; - if (!FD_ISSET(phd->fd, wfds)) - return 1; /* nothing to do */ + if (!FD_ISSET(phd->fd, &s->wfds)) + return; rq = make_request_msg(); - PARA_NOTICE_LOG("%s", "sending http request\n"); - ret = send_va_buffer(phd->fd, "%s", rq); + PARA_INFO_LOG("sending http request\n"); + t->error = send_va_buffer(phd->fd, "%s", rq); free(rq); - if (ret < 0) - return E_SEND_HTTP_REQUEST; - phd->status = HTTP_SENT_GET_REQUEST; - return 1; + if (t->error >= 0) + phd->status = HTTP_SENT_GET_REQUEST; + return; } - if (!FD_ISSET(phd->fd, rfds)) - return 1; /* nothing to do */ + if (!FD_ISSET(phd->fd, &s->rfds)) + return; if (phd->status == HTTP_SENT_GET_REQUEST) { - ret = recv_pattern(phd->fd, HTTP_OK_MSG, MAXLINE); - if (ret < 0) - return -E_MISSING_OK; - PARA_NOTICE_LOG("%s", "received ok msg, streaming\n"); - phd->status = HTTP_STREAMING; - return 1; + t->error = recv_pattern(phd->fd, HTTP_OK_MSG, strlen(HTTP_OK_MSG)); + if (t->error >= 0) { + PARA_INFO_LOG("received ok msg, streaming\n"); + phd->status = HTTP_STREAMING; + } + return; } - /* already streaming */ if (rn->loaded >= BUFSIZE) { - PARA_ERROR_LOG("%s", "buffer overrun\n"); - return -E_OVERRUN; + t->error = -E_HTTP_RECV_OVERRUN; + return; } - ret = recv_bin_buffer(phd->fd, rn->buf + rn->loaded, BUFSIZE - rn->loaded); - if (ret <= 0) { - PARA_NOTICE_LOG("recv returned %d/%zd\n", ret, BUFSIZE - rn->loaded); - return ret < 0? -E_HTTP_RECV_BUF : 0; + t->error = recv_bin_buffer(phd->fd, rn->buf + rn->loaded, + BUFSIZE - rn->loaded); + if (t->error > 0) { + rn->loaded += t->error; + return; } - rn->loaded += ret; - return 1; + if (!t->error) + t->error = -E_RECV_EOF; } static void http_recv_close(struct receiver_node *rn) @@ -167,35 +163,23 @@ static void *http_recv_parse_config(int argc, char **argv) static int http_recv_open(struct receiver_node *rn) { struct private_http_recv_data *phd; - struct hostent *he; struct http_recv_args_info *conf = rn->conf; - struct sockaddr_in their_addr; - int ret; - - rn->buf = para_calloc(BUFSIZE); - rn->private_data = para_calloc(sizeof(struct private_http_recv_data)); - phd = rn->private_data; - ret = -E_HOST_INFO; - if (!(he = get_host_info(conf->host_arg))) - goto err_out; - /* get new socket */ - ret = -E_SOCKET; - if ((phd->fd = get_socket()) < 0) - goto err_out; - /* init their_addr */ - init_sockaddr(&their_addr, conf->port_arg, he); - /* connect */ - PARA_NOTICE_LOG("connecting to %s:%d\n", conf->host_arg, + int fd, ret = makesock(AF_UNSPEC, IPPROTO_TCP, 0, conf->host_arg, conf->port_arg); - ret = para_connect(phd->fd, &their_addr); + if (ret < 0) - goto err_out; + return ret; + fd = ret; + ret = mark_fd_nonblocking(fd); + if (ret < 0) { + close(fd); + return ret; + } + rn->buf = para_calloc(BUFSIZE); + rn->private_data = phd = para_calloc(sizeof(struct private_http_recv_data)); + phd->fd = fd; phd->status = HTTP_CONNECTED; return 1; -err_out: - free(rn->private_data); - free(rn->buf); - return ret; } /** @@ -207,10 +191,18 @@ err_out: */ 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_pre_select; - r->post_select = http_post_select; + 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->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); }