X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=dccp_send.c;h=9ab21f8a096426cdb3f7d3a549bd53e270762655;hp=b13f719ecf6e4ce0c9e245ce4fd49e74c6fe95d1;hb=0b786d977ded3c3922e851e5b8d60837b43469b9;hpb=f099900540c4e4c54b10181254b895ccfe6ef410 diff --git a/dccp_send.c b/dccp_send.c index b13f719e..9ab21f8a 100644 --- a/dccp_send.c +++ b/dccp_send.c @@ -1,8 +1,4 @@ -/* - * Copyright (C) 2006-2010 Andre Noll - * - * Licensed under the GPL v2. For licencing details see COPYING. - */ +/* Copyright (C) 2006 Andre Noll , see file COPYING. */ /** \file dccp_send.c Paraslash's dccp sender. */ @@ -11,38 +7,36 @@ * (C) 2005 Ian McDonald */ +#include +#include #include #include -#include -#include +#include +#include +#include +#include +#include "server.lsg.h" #include "para.h" #include "error.h" #include "string.h" #include "afh.h" -#include "afs.h" #include "server.h" #include "net.h" #include "list.h" #include "send.h" +#include "sched.h" #include "vss.h" #include "fd.h" #include "close_on_fork.h" #include "chunk_queue.h" -#include "server.cmdline.h" #include "acl.h" -/** Do not write more than that many bytes at once. */ -#define DCCP_MAX_BYTES_PER_WRITE 1024 - static struct sender_status dccp_sender_status, *dss = &dccp_sender_status; -static struct sender *self; - struct dccp_fec_client { struct fec_client_parms fcp; struct fec_client *fc; - struct sender_client *sc; }; static void dccp_pre_select(int *max_fileno, fd_set *rfds, @@ -89,25 +83,33 @@ static void dccp_shutdown_clients(void) dccp_shutdown_client(sc); } -static int dccp_open(void *client, struct fec_client_parms **fcp) +/** * Obtain current MPS according to RFC 4340, sec. 14. */ +static int dccp_init_fec(struct sender_client *sc) { - struct dccp_fec_client *dfc = client; - - dfc->fcp.slices_per_group = 4; - dfc->fcp.data_slices_per_group = 3; - dfc->fcp.max_slice_bytes = 1472; - *fcp = &dfc->fcp; - return 1; + int mps, ret; + socklen_t ml = sizeof(mps); + uint32_t mss; /* max slize size */ + + /* If call fails, return some sensible minimum value */ + ret = getsockopt(sc->fd, SOL_DCCP, DCCP_SOCKOPT_GET_CUR_MPS, &mps, &ml); + if (ret < 0) { + PARA_NOTICE_LOG("can not determine MPS: %s\n", strerror(errno)); + mps = generic_max_transport_msg_size(sc->fd) - DCCP_MAX_HEADER; + } + PARA_INFO_LOG("current MPS = %d bytes\n", mps); + assert(mps > 0); + mss = OPT_UINT32_VAL(DCCP_MAX_SLICE_SIZE); + if (mss > 0 && mss <= INT_MAX) + mps = PARA_MIN(mps, (int)mss); + return mps; } -static int dccp_send_fec(char *buf, size_t len, void *private_data) +static void dccp_send_fec(struct sender_client *sc, char *buf, size_t len) { - struct dccp_fec_client *dfc = private_data; - int ret = write_nonblock(dfc->sc->fd, buf, len, DCCP_MAX_BYTES_PER_WRITE); + int ret = xwrite(sc->fd, buf, len); if (ret < 0) - dccp_shutdown_client(dfc->sc); - return ret; + dccp_shutdown_client(sc); } static void dccp_post_select(fd_set *rfds, __a_unused fd_set *wfds) @@ -115,6 +117,7 @@ static void dccp_post_select(fd_set *rfds, __a_unused fd_set *wfds) struct sender_client *sc; struct dccp_fec_client *dfc; int tx_ccid; + uint32_t k, n; sc = accept_sender_client(dss, rfds); if (!sc) @@ -131,7 +134,7 @@ static void dccp_post_select(fd_set *rfds, __a_unused fd_set *wfds) /* * Bypass unused CCID paths: the sender does not receive application data * from the client; by shutting down this unused communication path we can - * reduce processing costs a bit. See analogous comment in dccp_recv.c. + * reduce processing costs a bit. See analogous comment in \ref dccp_recv.c. */ if (shutdown(sc->fd, SHUT_RD) < 0) { PARA_WARNING_LOG("%s\n", strerror(errno)); @@ -140,8 +143,20 @@ static void dccp_post_select(fd_set *rfds, __a_unused fd_set *wfds) } dfc = para_calloc(sizeof(*dfc)); sc->private_data = dfc; - dfc->sc = sc; - /* XXX RESOLVED LATER vss_add_fec_client(self, dfc, &dfc->fc); */ + k = OPT_UINT32_VAL(DCCP_DATA_SLICES_PER_GROUP); + n = OPT_UINT32_VAL(DCCP_SLICES_PER_GROUP); + if (k == 0 || n == 0 || k >= n) { + PARA_WARNING_LOG("invalid FEC parameters, using defaults\n"); + dfc->fcp.data_slices_per_group = 3; + dfc->fcp.slices_per_group = 4; + } else { + dfc->fcp.data_slices_per_group = k; + dfc->fcp.slices_per_group = n; + } + dfc->fcp.init_fec = dccp_init_fec; + dfc->fcp.send_fec = dccp_send_fec; + dfc->fcp.need_periodic_header = false; + dfc->fc = vss_add_fec_client(sc, &dfc->fcp); } static int dccp_com_on(__a_unused struct sender_command_data *scd) @@ -151,6 +166,7 @@ static int dccp_com_on(__a_unused struct sender_command_data *scd) static int dccp_com_off(__a_unused struct sender_command_data *scd) { + dccp_shutdown_clients(); generic_com_off(dss); return 1; } @@ -189,47 +205,51 @@ static const char *dccp_list_available_ccids(void) return list; } -static char *dccp_info(void) +static char *dccp_status(void) { - char *info = get_sender_info(dss, "dccp"); - char *ret = make_message("%s" "\tsupported ccids: %s\n", - info, dccp_list_available_ccids()); - free(info); - return ret; + char *status = generic_sender_status(dss, "dccp"); + char *result = make_message("%ssupported ccids: %s\n", status, + dccp_list_available_ccids()); + free(status); + return result; } -/** - * The init function of the dccp sender. - * - * \param s pointer to the dccp sender struct. - * - * It initializes all function pointers of \a s and starts - * listening on the given port. +/* + * Initialize the client list and the access control list and listen on the + * dccp port. */ -void dccp_send_init(struct sender *s) +static void dccp_send_init(void) { int ret; - s->info = dccp_info; - s->send = NULL; - s->open = dccp_open; - s->send_fec = dccp_send_fec; - s->pre_select = dccp_pre_select; - s->post_select = dccp_post_select; - s->shutdown_clients = dccp_shutdown_clients; - s->help = generic_sender_help; - s->client_cmds[SENDER_ON] = dccp_com_on; - s->client_cmds[SENDER_OFF] = dccp_com_off; - s->client_cmds[SENDER_DENY] = dccp_com_deny; - s->client_cmds[SENDER_ALLOW] = dccp_com_allow; - s->client_cmds[SENDER_ADD] = NULL; - s->client_cmds[SENDER_DELETE] = NULL; - - init_sender_status(dss, conf.dccp_access_arg, conf.dccp_access_given, - conf.dccp_port_arg, conf.dccp_max_clients_arg, - conf.dccp_default_deny_given); + init_sender_status(dss, OPT_RESULT(DCCP_ACCESS), + OPT_UINT32_VAL(DCCP_PORT), OPT_UINT32_VAL(DCCP_MAX_CLIENTS), + OPT_GIVEN(DCCP_DEFAULT_DENY)); ret = generic_com_on(dss, IPPROTO_DCCP); if (ret < 0) PARA_ERROR_LOG("%s\n", para_strerror(-ret)); - self = s; } + +/** + * The DCCP sender. + * + * This sender offers congestion control not available in plain TCP. Most + * methods of the sender structure are implemented as simple wrappers for the + * generic functions defined in \ref send_common.c. Like UDP streams, DCCP + * streams are sent FEC-encoded. + */ +const struct sender dccp_sender = { + .name = "dccp", + .init = dccp_send_init, + .pre_select = dccp_pre_select, + .post_select = dccp_post_select, + .shutdown_clients = dccp_shutdown_clients, + .client_cmds = { + [SENDER_on] = dccp_com_on, + [SENDER_off] = dccp_com_off, + [SENDER_deny] = dccp_com_deny, + [SENDER_allow] = dccp_com_allow, + }, + .help = generic_sender_help, + .status = dccp_status, +};