X-Git-Url: http://git.meshlink.io/?p=meshlink;a=blobdiff_plain;f=src%2Fnetutl.c;h=f4ee5aa0f123151400b9628a1a0decd3a177b6a3;hp=7d32e21cad1287908acb24f4fbc131bee22bd5ca;hb=963c5055505f2fc117cd5efa06eaa02c9b2bf85d;hpb=0b9175e998c2180e5d73ef3d644a49d620c68cad diff --git a/src/netutl.c b/src/netutl.c index 7d32e21c..f4ee5aa0 100644 --- a/src/netutl.c +++ b/src/netutl.c @@ -1,7 +1,6 @@ /* netutl.c -- some supporting network utility code - Copyright (C) 1998-2002 Ivo Timmermans - 2000-2002 Guus Sliepen + Copyright (C) 2014-2017 Guus Sliepen 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 @@ -13,271 +12,309 @@ 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., 675 Mass Ave, Cambridge, MA 02139, USA. - - $Id: netutl.c,v 1.12.4.45 2003/07/06 22:11:32 guus Exp $ + 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., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#include "config.h" - -#include -#include -#include -#include -#include -#ifdef HAVE_INTTYPES_H -#include -#endif -#include -#include -#include -#include - -#include -#include - -#include "errno.h" -#include "conf.h" +#include "system.h" + #include "net.h" #include "netutl.h" #include "logger.h" - -#include "system.h" - -int hostnames = 0; +#include "utils.h" +#include "xalloc.h" /* Turn a string into a struct addrinfo. Return NULL on failure. */ -struct addrinfo *str2addrinfo(char *address, char *service, int socktype) -{ - struct addrinfo hint, *ai; +struct addrinfo *str2addrinfo(const char *address, const char *service, int socktype) { + struct addrinfo *ai; int err; - cp(); - - memset(&hint, 0, sizeof(hint)); - - hint.ai_family = addressfamily; - hint.ai_socktype = socktype; + struct addrinfo hint = { + .ai_family = AF_UNSPEC, + .ai_socktype = socktype, + }; err = getaddrinfo(address, service, &hint, &ai); if(err) { - logger(DEBUG_ALWAYS, LOG_WARNING, _("Error looking up %s port %s: %s\n"), address, - service, gai_strerror(err)); + logger(NULL, MESHLINK_WARNING, "Error looking up %s port %s: %s", address, service, err == EAI_SYSTEM ? strerror(errno) : gai_strerror(err)); return NULL; } return ai; } -sockaddr_t str2sockaddr(char *address, char *port) -{ - struct addrinfo hint, *ai; +sockaddr_t str2sockaddr(const char *address, const char *port) { + struct addrinfo *ai; sockaddr_t result; int err; - cp(); - - memset(&hint, 0, sizeof(hint)); + memset(&result, 0, sizeof(result)); - hint.ai_family = AF_UNSPEC; - hint.ai_flags = AI_NUMERICHOST; - hint.ai_socktype = SOCK_STREAM; + struct addrinfo hint = { + .ai_family = AF_UNSPEC, + .ai_flags = AI_NUMERICHOST, + .ai_socktype = SOCK_STREAM, + }; err = getaddrinfo(address, port, &hint, &ai); if(err || !ai) { - logger(DEBUG_ALWAYS, LOG_ERR, _("Error looking up %s port %s: %s\n"), address, port, - gai_strerror(err)); - cp_trace(); - raise(SIGFPE); - exit(0); + logger(NULL, MESHLINK_DEBUG, "Unknown type address %s port %s", address, port); + result.sa.sa_family = AF_UNKNOWN; + result.unknown.address = xstrdup(address); + result.unknown.port = xstrdup(port); + return result; } - result = *(sockaddr_t *) ai->ai_addr; + memcpy(&result, ai->ai_addr, ai->ai_addrlen); freeaddrinfo(ai); return result; } -void sockaddr2str(sockaddr_t *sa, char **addrstr, char **portstr) -{ +void sockaddr2str(const sockaddr_t *sa, char **addrstr, char **portstr) { char address[NI_MAXHOST]; char port[NI_MAXSERV]; char *scopeid; int err; - cp(); + if(sa->sa.sa_family == AF_UNKNOWN) { + if(addrstr) { + *addrstr = xstrdup(sa->unknown.address); + } + + if(portstr) { + *portstr = xstrdup(sa->unknown.port); + } + + return; + } err = getnameinfo(&sa->sa, SALEN(sa->sa), address, sizeof(address), port, sizeof(port), NI_NUMERICHOST | NI_NUMERICSERV); if(err) { - logger(DEBUG_ALWAYS, LOG_ERR, _("Error while translating addresses: %s"), - gai_strerror(err)); - cp_trace(); - raise(SIGFPE); - exit(0); + logger(NULL, MESHLINK_ERROR, "Error while translating addresses: %s", err == EAI_SYSTEM ? strerror(errno) : gai_strerror(err)); + abort(); } scopeid = strchr(address, '%'); - if(scopeid) - *scopeid = '\0'; /* Descope. */ + if(scopeid) { + *scopeid = '\0'; /* Descope. */ + } - *addrstr = xstrdup(address); - *portstr = xstrdup(port); + if(addrstr) { + *addrstr = xstrdup(address); + } + + if(portstr) { + *portstr = xstrdup(port); + } } -char *sockaddr2hostname(sockaddr_t *sa) -{ +char *sockaddr2hostname(const sockaddr_t *sa) { char *str; char address[NI_MAXHOST] = "unknown"; char port[NI_MAXSERV] = "unknown"; int err; - cp(); + if(sa->sa.sa_family == AF_UNKNOWN) { + xasprintf(&str, "%s port %s", sa->unknown.address, sa->unknown.port); + return str; + } + + err = getnameinfo(&sa->sa, SALEN(sa->sa), address, sizeof(address), port, sizeof(port), NI_NUMERICHOST | NI_NUMERICSERV); - err = getnameinfo(&sa->sa, SALEN(sa->sa), address, sizeof(address), port, sizeof(port), - hostnames ? 0 : (NI_NUMERICHOST | NI_NUMERICSERV)); if(err) { - logger(DEBUG_ALWAYS, LOG_ERR, _("Error while looking up hostname: %s"), - gai_strerror(err)); + logger(NULL, MESHLINK_ERROR, "Error while looking up hostname: %s", err == EAI_SYSTEM ? strerror(errno) : gai_strerror(err)); + abort(); } - asprintf(&str, _("%s port %s"), address, port); + xasprintf(&str, "%s port %s", address, port); return str; } -int sockaddrcmp(sockaddr_t *a, sockaddr_t *b) -{ +int sockaddrcmp_noport(const sockaddr_t *a, const sockaddr_t *b) { int result; - cp(); - result = a->sa.sa_family - b->sa.sa_family; - if(result) + if(result) { return result; + } - switch (a->sa.sa_family) { - case AF_UNSPEC: - return 0; + switch(a->sa.sa_family) { + case AF_UNSPEC: + return 0; - case AF_INET: - result = memcmp(&a->in.sin_addr, &b->in.sin_addr, sizeof(a->in.sin_addr)); + case AF_UNKNOWN: + return strcmp(a->unknown.address, b->unknown.address); - if(result) - return result; + case AF_INET: + return memcmp(&a->in.sin_addr, &b->in.sin_addr, sizeof(a->in.sin_addr)); - return memcmp(&a->in.sin_port, &b->in.sin_port, sizeof(a->in.sin_port)); + case AF_INET6: + return memcmp(&a->in6.sin6_addr, &b->in6.sin6_addr, sizeof(a->in6.sin6_addr)); - case AF_INET6: - result = memcmp(&a->in6.sin6_addr, &b->in6.sin6_addr, sizeof(a->in6.sin6_addr)); + default: + logger(NULL, MESHLINK_ERROR, "sockaddrcmp() was called with unknown address family %d, exitting!", + a->sa.sa_family); + abort(); + } +} - if(result) - return result; +int sockaddrcmp(const sockaddr_t *a, const sockaddr_t *b) { + int result; - return memcmp(&a->in6.sin6_port, &b->in6.sin6_port, sizeof(a->in6.sin6_port)); + result = a->sa.sa_family - b->sa.sa_family; - default: - logger(DEBUG_ALWAYS, LOG_ERR, _("sockaddrcmp() was called with unknown address family %d, exitting!"), - a->sa.sa_family); - cp_trace(); - raise(SIGFPE); - exit(0); + if(result) { + return result; } -} -void sockaddrunmap(sockaddr_t *sa) -{ - if(sa->sa.sa_family == AF_INET6 && IN6_IS_ADDR_V4MAPPED(&sa->in6.sin6_addr)) { - sa->in.sin_addr.s_addr = ((uint32_t *) & sa->in6.sin6_addr)[3]; - sa->in.sin_family = AF_INET; - } -} + switch(a->sa.sa_family) { + case AF_UNSPEC: + return 0; + + case AF_UNKNOWN: + result = strcmp(a->unknown.address, b->unknown.address); -/* Subnet mask handling */ + if(result) { + return result; + } -int maskcmp(void *va, void *vb, int masklen, int len) -{ - int i, m, result; - char *a = va; - char *b = vb; + return strcmp(a->unknown.port, b->unknown.port); - cp(); + case AF_INET: + result = memcmp(&a->in.sin_addr, &b->in.sin_addr, sizeof(a)->in.sin_addr); - for(m = masklen, i = 0; m >= 8; m -= 8, i++) { - result = a[i] - b[i]; - if(result) + if(result) { return result; - } + } - if(m) - return (a[i] & (0x100 - (1 << (8 - m)))) - - (b[i] & (0x100 - (1 << (8 - m)))); - - return 0; -} + return memcmp(&a->in.sin_port, &b->in.sin_port, sizeof(a)->in.sin_port); -void mask(void *va, int masklen, int len) -{ - int i; - char *a = va; + case AF_INET6: + result = memcmp(&a->in6.sin6_addr, &b->in6.sin6_addr, sizeof(a)->in6.sin6_addr); - cp(); + if(result) { + return result; + } - i = masklen / 8; - masklen %= 8; + return memcmp(&a->in6.sin6_port, &b->in6.sin6_port, sizeof(a)->in6.sin6_port); - if(masklen) - a[i++] &= (0x100 - (1 << masklen)); + default: + logger(NULL, MESHLINK_ERROR, "sockaddrcmp() was called with unknown address family %d, exitting!", + a->sa.sa_family); + abort(); + } +} - for(; i < len; i++) - a[i] = 0; +void sockaddrcpy(sockaddr_t *a, const sockaddr_t *b) { + if(b->sa.sa_family != AF_UNKNOWN) { + *a = *b; + } else { + a->unknown.family = AF_UNKNOWN; + a->unknown.address = xstrdup(b->unknown.address); + a->unknown.port = xstrdup(b->unknown.port); + } } -void maskcpy(void *va, void *vb, int masklen, int len) -{ - int i, m; - char *a = va; - char *b = vb; +void sockaddrcpy_setport(sockaddr_t *a, const sockaddr_t *b, uint16_t port) { + sockaddrcpy(a, b); - cp(); + switch(b->sa.sa_family) { + case AF_INET: + a->in.sin_port = htons(port); + break; - for(m = masklen, i = 0; m >= 8; m -= 8, i++) - a[i] = b[i]; + case AF_INET6: + a->in6.sin6_port = htons(port); + break; - if(m) { - a[i] = b[i] & (0x100 - (1 << m)); - i++; + default: + break; } +} - for(; i < len; i++) - a[i] = 0; +void sockaddrfree(sockaddr_t *a) { + if(a->sa.sa_family == AF_UNKNOWN) { + free(a->unknown.address); + free(a->unknown.port); + } } -int maskcheck(void *va, int masklen, int len) -{ - int i; - char *a = va; +void sockaddrunmap(sockaddr_t *sa) { + if(sa->sa.sa_family == AF_INET6 && IN6_IS_ADDR_V4MAPPED(&sa->in6.sin6_addr)) { + sa->in.sin_addr.s_addr = ((uint32_t *) & sa->in6.sin6_addr)[3]; + sa->in.sin_family = AF_INET; + } +} - cp(); +void packmsg_add_sockaddr(packmsg_output_t *out, const sockaddr_t *sa) { + switch(sa->sa.sa_family) { + case AF_INET: { + uint8_t buf[6]; + memcpy(buf + 0, &sa->in.sin_port, 2); + memcpy(buf + 2, &sa->in.sin_addr, 4); + packmsg_add_ext(out, 4, buf, sizeof(buf)); + break; + } - i = masklen / 8; - masklen %= 8; + case AF_INET6: { + uint8_t buf[18]; + memcpy(buf + 0, &sa->in6.sin6_port, 2); + memcpy(buf + 2, &sa->in6.sin6_addr, 16); + packmsg_add_ext(out, 6, buf, sizeof(buf)); + break; + } - if(masklen && a[i++] & (0xff >> masklen)) - return -1; + default: + packmsg_output_invalidate(out); + break; + } +} - for(; i < len; i++) - if(a[i] != 0) - return -2; +sockaddr_t packmsg_get_sockaddr(packmsg_input_t *in) { + sockaddr_t sa = {0}; + + int8_t type; + const void *data; + uint32_t len = packmsg_get_ext_raw(in, &type, &data); + + switch(type) { + case 4: + if(len != 6) { + packmsg_input_invalidate(in); + return sa; + } + + sa.sa.sa_family = AF_INET; + memcpy(&sa.in.sin_port, (uint8_t *)data + 0, 2); + memcpy(&sa.in.sin_addr, (uint8_t *)data + 2, 4); + break; + + case 6: + if(len != 18) { + packmsg_input_invalidate(in); + return sa; + } + + sa.sa.sa_family = AF_INET6; + memcpy(&sa.in6.sin6_port, (uint8_t *)data + 0, 2); + memcpy(&sa.in6.sin6_addr, (uint8_t *)data + 2, 16); + break; + + default: + packmsg_input_invalidate(in); + return sa; + } - return 0; + return sa; }