X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=udp_send.c;h=24ebf5848ed3c2de5d671de98dab142ce9018581;hp=5c1cdf02c2fb9e1be95783f65cfeb12994a15056;hb=f10742c3fdc05a3ff719ad7e01eacfd5e8c0dae0;hpb=34d059caa24a68c2e420050ce3a67d32ce3fbdea diff --git a/udp_send.c b/udp_send.c index 5c1cdf02..24ebf584 100644 --- a/udp_send.c +++ b/udp_send.c @@ -11,6 +11,7 @@ #include #include #include +#include #include #include @@ -31,12 +32,21 @@ #include "close_on_fork.h" #include "chunk_queue.h" +/** + * Time window during which ICMP Destination/Port Unreachable messages are + * ignored, covering transient receiver problems such as restarting the + * client, rebooting, reconfiguration, or handover. + */ +#define UDP_MAX_UNREACHABLE_TIME 30 + /** Describes one entry in the list of targets for the udp sender. */ struct udp_target { /** The hostname (DNS name or IPv4/v6 address string). */ char host[MAX_HOSTLEN]; /** The UDP port. */ int port; + /** Track time (seconds) of last ICMP Port Unreachable error */ + time_t last_unreachable; /** Common sender client data */ struct sender_client *sc; /** The opaque structure returned by vss_add_fec_client(). */ @@ -50,13 +60,14 @@ static int sender_status; static void udp_close_target(struct sender_client *sc) { - if (sc->fd < 0) - return; - close(sc->fd); - del_close_on_fork_list(sc->fd); - cq_destroy(sc->cq); - sc->cq = NULL; - sc->fd = -1; + if (sc->cq != NULL) { + del_close_on_fork_list(sc->fd); + cq_destroy(sc->cq); + free(sc->name); + sc->name = NULL; + sc->cq = NULL; + + } } static void udp_delete_target(struct udp_target *ut, const char *msg) @@ -75,26 +86,28 @@ static void udp_delete_target(struct udp_target *ut, const char *msg) * Perform AF-independent multicast sender setup. * * \param sc The connected sender client. - * \param ttl UDPv4 multicast TTL or UDPv6 multicast number of hops. - * Use -1 to mean default, 0..255 otherwise. - * \param iface The outgoing multicast interface, or NULL for the default. * * \return Zero if okay, negative on error. */ -static int mcast_sender_setup(struct sender_client *sc, int ttl, char *iface) +static int mcast_sender_setup(struct sender_client *sc) { struct sockaddr_storage ss; socklen_t sslen = sizeof(ss); - + int ttl = conf.udp_ttl_arg, id = 0; const int on = 1; - int id = iface == NULL ? 0 : if_nametoindex(iface); + + if (conf.udp_mcast_iface_given) { + char *iface = conf.udp_mcast_iface_arg; + + id = if_nametoindex(iface); + if (id == 0) + PARA_WARNING_LOG("could not resolve interface '%s', " + "using default", iface); + } if (getpeername(sc->fd, (struct sockaddr *)&ss, &sslen) < 0) goto err; - if (iface != NULL && id == 0) - PARA_WARNING_LOG("could not resolve interface %s, using default", iface); - /* RFC 3493, 5.2: -1 means 'use kernel default' */ if (ttl < 0 || ttl > 255) ttl = -1; @@ -150,56 +163,28 @@ err: /** The maximal size of the per-target chunk queue. */ #define UDP_CQ_BYTES 40000 -static int udp_init_session(struct sender_client *sc) +static void udp_init_session(struct sender_client *sc) { - struct udp_target *ut = sc->private_data; - int ret; - char *iface = NULL; - - if (sc->fd >= 0) /* nothing to do */ - return 0; - - ret = para_connect_simple(IPPROTO_UDP, ut->host, ut->port); - if (ret < 0) - return ret; - sc->fd = ret; - - if (conf.udp_mcast_iface_given) - iface = conf.udp_mcast_iface_arg; - - ret = mcast_sender_setup(sc, conf.udp_ttl_arg, iface); - if (ret < 0) { - close(sc->fd); - return ret; - } - - ret = mark_fd_nonblocking(sc->fd); - if (ret < 0) { - close(sc->fd); - return ret; + if (sc->cq == NULL) { + add_close_on_fork_list(sc->fd); + sc->cq = cq_new(UDP_CQ_BYTES); + sc->name = para_strdup(remote_name(sc->fd)); + PARA_NOTICE_LOG("sending to udp %s\n", sc->name); } - add_close_on_fork_list(sc->fd); - sc->cq = cq_new(UDP_CQ_BYTES); - PARA_NOTICE_LOG("sending to udp %s#%d\n", ut->host, ut->port); - return 1; } static void udp_shutdown_targets(void) { struct sender_client *sc, *tmp; - const char *buf = NULL; - size_t len = 0; /* STFU, gcc */ - - list_for_each_entry_safe(sc, tmp, &targets, node) { - int ubuntu_glibc_headers_suck; - if (sc->fd < 0) - continue; - if (!buf) - len = vss_get_fec_eof_packet(&buf); - /* ignore return value, we're closing the target anyway. */ - ubuntu_glibc_headers_suck = write(sc->fd, buf, len); /* STFU */ - udp_close_target(sc); - } + const char *buf; + size_t len = vss_get_fec_eof_packet(&buf); + + list_for_each_entry_safe(sc, tmp, &targets, node) + if (sc->cq != NULL) { + /* ignore return value, closing the target anyway. */ + (void)write(sc->fd, buf, len); + udp_close_target(sc); + } } static int udp_com_on(__a_unused struct sender_command_data *scd) @@ -232,6 +217,49 @@ static int udp_com_delete(struct sender_command_data *scd) return 1; } +/** Initialize UDP session and set maximum payload size. */ +static int udp_init_fec(struct sender_client *sc) +{ + int mps; + + udp_init_session(sc); + mps = generic_max_transport_msg_size(sc->fd) - sizeof(struct udphdr); + PARA_INFO_LOG("current MPS = %d bytes\n", mps); + return mps; +} + +/** Check and clear socket error if any. */ +static int udp_check_socket_state(struct udp_target *ut) +{ + int ret; + socklen_t errlen = sizeof(ret); + + if (getsockopt(ut->sc->fd, SOL_SOCKET, SO_ERROR, &ret, &errlen) < 0) { + PARA_ERROR_LOG("SO_ERROR failed: %s\n", strerror(ret)); + return 0; + } else if (ret == 0) { + return 0; + } else if (ret == ECONNREFUSED) { + time_t dist = now->tv_sec - ut->last_unreachable; + + if (dist <= UDP_MAX_UNREACHABLE_TIME) { + return 0; + } else if (dist > 2 * UDP_MAX_UNREACHABLE_TIME) { + ut->last_unreachable = now->tv_sec; + return 0; + } else { + /* + * unreachable_time < dist <= 2 * unreachable_time + * No errors are allowed during this time window. + */ + PARA_NOTICE_LOG("Evicting %s#%d after %d seconds " + "of connection errors.\n", + ut->host, ut->port, (int)dist); + } + } + return -ERRNO_TO_PARA_ERROR(ret); +} + static int udp_send_fec(struct sender_client *sc, char *buf, size_t len) { struct udp_target *ut = sc->private_data; @@ -239,23 +267,27 @@ static int udp_send_fec(struct sender_client *sc, char *buf, size_t len) if (sender_status == SENDER_OFF) return 0; - ret = udp_init_session(sc); + if (len == 0 && !cq_peek(ut->sc->cq)) + return 0; + ret = udp_check_socket_state(ut); if (ret < 0) goto fail; - ret = send_queued_chunks(sc->fd, sc->cq, 0); - if (ret == -ERRNO_TO_PARA_ERROR(ECONNREFUSED)) - ret = 0; + ret = send_queued_chunks(sc->fd, sc->cq); if (ret < 0) goto fail; - if (!len) - return 0; if (!ret) { /* still data left in the queue */ ret = cq_force_enqueue(sc->cq, buf, len); assert(ret >= 0); + return 0; } - ret = write_nonblock(sc->fd, buf, len, 0); - if (ret == -ERRNO_TO_PARA_ERROR(ECONNREFUSED)) + ret = write_nonblock(sc->fd, buf, len); + if (ret == -ERRNO_TO_PARA_ERROR(ECONNREFUSED)) { + /* + * Happens if meanwhile an ICMP Destination / Port Unreachable + * has arrived. Ignore, persistent errors will be caught above. + */ ret = 0; + } if (ret < 0) goto fail; if (ret != len) { @@ -270,6 +302,7 @@ fail: static void udp_add_target(struct sender_command_data *scd) { + int ret, port = scd->port > 0 ? scd->port : conf.udp_default_port_arg; struct udp_target *ut = para_calloc(sizeof(*ut)); strncpy(ut->host, scd->host, sizeof(ut->host)); @@ -278,16 +311,34 @@ static void udp_add_target(struct sender_command_data *scd) ut->fcp.slices_per_group = scd->slices_per_group; ut->fcp.data_slices_per_group = scd->data_slices_per_group; ut->fcp.max_slice_bytes = scd->max_slice_bytes; - ut->fcp.init_fec = NULL; /* FIXME */ + ut->fcp.init_fec = udp_init_fec; ut->fcp.send_fec = udp_send_fec; ut->sc = para_calloc(sizeof(*ut->sc)); - ut->sc->fd = -1; /* not yet connected */ ut->sc->private_data = ut; - ut->fc = vss_add_fec_client(ut->sc, &ut->fcp); + ut->sc->fd = -1; + ret = para_connect_simple(IPPROTO_UDP, scd->host, port); + if (ret < 0) + goto err; + ut->sc->fd = ret; + ret = mcast_sender_setup(ut->sc); + if (ret < 0) + goto err; + ret = mark_fd_nonblocking(ut->sc->fd); + if (ret < 0) + goto err; PARA_INFO_LOG("adding to target list (%s#%d)\n", ut->host, ut->port); + ut->fc = vss_add_fec_client(ut->sc, &ut->fcp); para_list_add(&ut->sc->node, &targets); + return; +err: + if (ut->sc->fd >= 0) + close(ut->sc->fd); + PARA_NOTICE_LOG("failed to set up %s#%d (%s)- not adding it\n", + scd->host, port, para_strerror(-ret)); + free(ut->sc); + free(ut); } static int udp_com_add(struct sender_command_data *scd)