X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=net.c;h=aeeca20e41447d2f3912b3035e739219ff08c62d;hp=61f50dd71041a2a5e80008dbb2da110b75b70a42;hb=818d1a3aa98121ec2d5339d11dece7bc2f5aa6af;hpb=f948a91c447ac2fa070c0b7a6c57b83b7dfdd56c diff --git a/net.c b/net.c index 61f50dd7..aeeca20e 100644 --- a/net.c +++ b/net.c @@ -34,6 +34,7 @@ #include "crypt.h" #include "net.h" #include "string.h" +#include "list.h" #include "fd.h" /** @@ -187,6 +188,31 @@ failed: return NULL; } +/** + * Stringify port number, resolve into service name where defined. + * \param port 2-byte port number, in host-byte-order. + * \param transport Transport protocol name (e.g. "udp", "tcp"), or NULL. + * \return Pointer to static result buffer. + * + * \sa getservent(3), services(5), nsswitch.conf(5) + */ +const char *stringify_port(int port, const char *transport) +{ + static char service[NI_MAXSERV]; + + if (port < 0 || port > 0xFFFF) { + snprintf(service, sizeof(service), "undefined (%d)", port); + } else { + struct servent *se = getservbyport(htons(port), transport); + + if (se == NULL) + snprintf(service, sizeof(service), "%u", port); + else + snprintf(service, sizeof(service), "%s", se->s_name); + } + return service; +} + /** * Determine the socket type for a given layer-4 protocol. * @@ -217,6 +243,111 @@ static const char *layer4_name(const unsigned l4type) return "UNKNOWN PROTOCOL"; } +/** + * Flowopts: Transport-layer independent encapsulation of socket options. + * + * These collect individual socket options into a queue, which is disposed of + * directly after makesock(). The 'pre_conn_opt' structure is for internal use + * only and should not be visible elsewhere. + * + * \sa setsockopt(2), makesock() + */ +struct pre_conn_opt { + int sock_level; /**< Second argument to setsockopt() */ + int sock_option; /**< Third argument to setsockopt() */ + char *opt_name; /**< Stringified \a sock_option */ + void *opt_val; /**< Fourth argument to setsockopt() */ + socklen_t opt_len; /**< Fifth argument to setsockopt() */ + + struct list_head node; /**< FIFO, as sockopt order matters. */ +}; + +/** FIFO list of pre-connection socket options to be set */ +struct flowopts { + struct list_head sockopts; +}; + +struct flowopts *flowopt_new(void) +{ + struct flowopts *new = para_malloc(sizeof(*new)); + + INIT_LIST_HEAD(&new->sockopts); + return new; +} + +/** + * Append new socket option to flowopt queue. + * + * \param fo The flowopt queue to append to. + * \param lev Level at which \opt resides. + * \param opt New option to add. + * \param name Stringified name of \a opt. + * \param val The value to set \a opt to. + * \param len Length of \a val. + * + * \sa setsockopt(2) + */ +void flowopt_add(struct flowopts *fo, int lev, int opt, + char *name, const void *val, int len) +{ + struct pre_conn_opt *new = para_malloc(sizeof(*new)); + + new->sock_option = opt; + new->sock_level = lev; + new->opt_name = para_strdup(name); + + if (val == NULL) { + new->opt_val = NULL; + new->opt_len = 0; + } else { + new->opt_val = para_malloc(len); + new->opt_len = len; + memcpy(new->opt_val, val, len); + } + + list_add_tail(&new->node, &fo->sockopts); +} + +void flowopt_add_bool(struct flowopts *fo, int lev, int opt, + char *optname, bool on_or_off) +{ + int on = on_or_off; /* kernel takes 'int' */ + + flowopt_add(fo, lev, opt, optname, &on, sizeof(on)); +} + +/** Set the entire bunch of pre-connection options at once. */ +static void flowopt_setopts(int sockfd, struct flowopts *fo) +{ + struct pre_conn_opt *pc; + + if (fo == NULL) + return; + + list_for_each_entry(pc, &fo->sockopts, node) + if (setsockopt(sockfd, pc->sock_level, pc->sock_option, + pc->opt_val, pc->opt_len) < 0) { + PARA_EMERG_LOG("Can not set %s socket option: %s", + pc->opt_name, strerror(errno)); + exit(EXIT_FAILURE); + } +} + +static void flowopt_cleanup(struct flowopts *fo) +{ + struct pre_conn_opt *cur, *next; + + if (fo == NULL) + return; + + list_for_each_entry_safe(cur, next, &fo->sockopts, node) { + free(cur->opt_name); + free(cur->opt_val); + free(cur); + } + free(fo); +} + /** * Resolve IPv4/IPv6 address and create a ready-to-use active or passive socket. * @@ -225,6 +356,7 @@ static const char *layer4_name(const unsigned l4type) * \param passive Whether this is a passive (1) or active (0) socket. * \param host Remote or local hostname or IPv/6 address string. * \param port_number Decimal port number. + * \param fo Socket options to be set before making the connection. * * This creates a ready-made IPv4/v6 socket structure after looking up the * necessary parameters. The interpretation of \a host depends on the value of @@ -238,19 +370,21 @@ static const char *layer4_name(const unsigned l4type) * * Furthermore, bind(2) is called on passive sockets, and connect(2) on active * sockets. The algorithm tries all possible address combinations until it - * succeeds. + * succeeds. If \a fo is supplied, options are set and cleanup is performed. * * \return This function returns 1 on success and \a -E_ADDRESS_LOOKUP when no * matching connection could be set up (with details in the error log). * * \sa ipv6(7), getaddrinfo(3), bind(2), connect(2). */ -int makesock(unsigned l3type, unsigned l4type, int passive, - const char *host, unsigned short port_number) +int makesock(unsigned l4type, bool passive, + const char *host, uint16_t port_number, + struct flowopts *fo) { struct addrinfo *local = NULL, *src, *remote = NULL, *dst, hints; - int rc, on = 1, sockfd = -1, + unsigned int l3type = AF_UNSPEC; + int rc, sockfd = -1, socktype = sock_type(l4type); char port[6]; /* port number has at most 5 digits */ @@ -295,17 +429,7 @@ int makesock(unsigned l3type, unsigned l4type, int passive, if (sockfd < 0) goto get_next_dst; - /* - * Set those options that need to be set before establishing - * the connection. Reuse the address on passive (listening) - * sockets to avoid failure on restart. - */ - if (passive && setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, - &on, sizeof(on)) == -1) { - PARA_ERROR_LOG("can not set SO_REUSEADDR: %s\n", - strerror(errno)); - return -ERRNO_TO_PARA_ERROR(errno); - } + flowopt_setopts(sockfd, fo); if (src) { if (bind(sockfd, src->ai_addr, src->ai_addrlen) < 0) { @@ -330,12 +454,14 @@ get_next_src: freeaddrinfo(local); if (remote) freeaddrinfo(remote); + flowopt_cleanup(fo); if (src == NULL && dst == NULL) { + rc = errno; PARA_ERROR_LOG("can not create %s socket %s#%s.\n", layer4_name(l4type), host? host : (passive? "[loopback]" : "[localhost]"), port); - return -ERRNO_TO_PARA_ERROR(errno); + return -ERRNO_TO_PARA_ERROR(rc); } return sockfd; } @@ -343,24 +469,32 @@ get_next_src: /** * Create a passive / listening socket. * - * \param l3type The network-layer type (\p AF_xxx). * \param l4type The transport-layer type (\p IPPROTO_xxx). * \param port The decimal port number to listen on. + * \param fo Flowopts (if any) to set before starting to listen. * * \return Positive integer (socket descriptor) on success, negative value * otherwise. * * \sa makesock(), ip(7), ipv6(7), bind(2), listen(2). */ -int para_listen(unsigned l3type, unsigned l4type, unsigned short port) +int para_listen(unsigned l4type, uint16_t port, struct flowopts *fo) { - int ret, fd = makesock(l3type, l4type, 1, NULL, port); + int fd, ret; + + if (fo == NULL) + fo = flowopt_new(); + + /* Reuse the address to avoid failure on restart. */ + OPT_ENABLE(fo, SOL_SOCKET, SO_REUSEADDR); + fd = makesock(l4type, 1, NULL, port, fo); if (fd > 0) { ret = listen(fd, BACKLOG); if (ret < 0) { + ret = errno; close(fd); - return -ERRNO_TO_PARA_ERROR(errno); + return -ERRNO_TO_PARA_ERROR(ret); } PARA_INFO_LOG("listening on %s port %u, fd %d\n", layer4_name(l4type), port, fd); @@ -368,28 +502,70 @@ int para_listen(unsigned l3type, unsigned l4type, unsigned short port) return fd; } +/** + * Determine IPv4/v6 socket address length. + * \param sa Container of IPv4 or IPv6 address. + * \return Address-family dependent address length. + */ +static socklen_t salen(const struct sockaddr *sa) +{ + assert(sa->sa_family == AF_INET || sa->sa_family == AF_INET6); + + return sa->sa_family == AF_INET6 + ? sizeof(struct sockaddr_in6) + : sizeof(struct sockaddr_in); +} + +/** + * Process IPv4/v6 address, turn v6-mapped-v4 address into normal IPv4 address. + * \param ss Container of IPv4/6 address. + * \return Pointer to normalized address (may be static storage). + * + * \sa RFC 3493 + */ +static const struct sockaddr * +normalize_ip_address(const struct sockaddr_storage *ss) +{ + const struct sockaddr_in6 *ia6 = (const struct sockaddr_in6 *)ss; + + assert(ss->ss_family == AF_INET || ss->ss_family == AF_INET6); + + if (ss->ss_family == AF_INET6 && IN6_IS_ADDR_V4MAPPED(&ia6->sin6_addr)) { + static struct sockaddr_in ia; + + ia.sin_family = AF_INET; + ia.sin_port = ia6->sin6_port; + memcpy(&ia.sin_addr.s_addr, &(ia6->sin6_addr.s6_addr[12]), 4); + return (const struct sockaddr *)&ia; + } + return (const struct sockaddr *)ss; +} + /** * Print numeric host and port number (beware - uses static char). * * \param sa The IPv4/IPv6 socket address to use. - * \param len The length of \p sa. * - * \sa getnameinfo(3). + * \sa getnameinfo(3), services(5), nsswitch.conf(5) */ -static char *host_and_port(struct sockaddr *sa, socklen_t len) +static char *host_and_port(const struct sockaddr_storage *ss) { - static char output[NI_MAXHOST + NI_MAXSERV + 2]; + const struct sockaddr *sa = normalize_ip_address(ss); char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV]; + static char output[sizeof(hbuf) + sizeof(sbuf) + 2]; int ret; - ret = getnameinfo(sa, len, hbuf, sizeof(hbuf), sbuf, sizeof(sbuf), - NI_NUMERICHOST | NI_NUMERICSERV); - if (ret) { + ret = getnameinfo(sa, salen(sa), + hbuf, sizeof(hbuf), + sbuf, sizeof(sbuf), + NI_NUMERICHOST); + if (ret == 0) { + snprintf(output, sizeof(output), "%s#%s", hbuf, sbuf); + } else { + snprintf(output, sizeof(output), "(unknown)"); PARA_WARNING_LOG("hostname lookup error (%s).\n", - gai_strerror(ret)); - sprintf(output, "(unknown)"); - } else - sprintf(output, "%s#%s", hbuf, sbuf); + gai_strerror(ret)); + } return output; } @@ -417,7 +593,7 @@ static char *__get_sock_name(int fd, int (*getname)(int, struct sockaddr*, fd, strerror(errno)); return dont_know; } - return host_and_port((struct sockaddr *)&ss, sslen); + return host_and_port(&ss); } /** @@ -460,15 +636,10 @@ char *remote_name(int sockfd) struct in_addr extract_v4_addr(const struct sockaddr_storage *ss) { struct in_addr ia = {.s_addr = 0}; + const struct sockaddr *sa = normalize_ip_address(ss); - if (ss->ss_family == AF_INET) - ia.s_addr = ((struct sockaddr_in *)ss)->sin_addr.s_addr; - if (ss->ss_family == AF_INET6) { - const struct in6_addr v6_addr = ((struct sockaddr_in6 *)ss)->sin6_addr; - - if (IN6_IS_ADDR_V4MAPPED(&v6_addr)) - memcpy(&ia.s_addr, &(v6_addr.s6_addr[12]), 4); - } + if (sa->sa_family == AF_INET) + ia = ((struct sockaddr_in *)sa)->sin_addr; return ia; } @@ -599,6 +770,33 @@ int para_accept(int fd, void *addr, socklen_t size) return new_fd < 0? -ERRNO_TO_PARA_ERROR(errno) : new_fd; } +/** + * Probe the list of DCCP CCIDs supported locally by the host. + * \param ccids Array to be filled in. + * \param nccids Length of \a ccids. + * \return Pointer to \a ccids, NULL on failure. + * + * NB: This feature is only available on Linux > 2.6.30; on older kernels + * ENOPROTOOPT ("Protocol not available") will be returned. + */ +const uint8_t *dccp_available_ccids(uint8_t *ccids, uint8_t *nccids) +{ + int fd = makesock(IPPROTO_DCCP, 1, NULL, 0, NULL); + + if (fd < 0) + return NULL; + + if (getsockopt(fd, SOL_DCCP, DCCP_SOCKOPT_AVAILABLE_CCIDS, + ccids, (socklen_t *)nccids) < 0) { + PARA_ERROR_LOG("No DCCP_SOCKOPT_AVAILABLE_CCIDS: %s\n", + strerror(errno)); + *nccids = 0; + } + close(fd); + + return *nccids ? ccids : NULL; +} + /** * Prepare a structure for \p AF_UNIX socket addresses. * @@ -838,10 +1036,11 @@ int recv_pattern(int fd, const char *pattern, size_t bufsize) ret = 1; out: if (ret < 0) { - PARA_NOTICE_LOG("n = %d, did not receive pattern '%s'\n", n, - pattern); + PARA_NOTICE_LOG("did not receive pattern '%s'\n", pattern); if (n > 0) - PARA_NOTICE_LOG("recvd: %s\n", buf); + PARA_NOTICE_LOG("recvd %d bytes: %s\n", n, buf); + else if (n < 0) + PARA_NOTICE_LOG("%s\n", para_strerror(-n)); } free(buf); return ret;