diff options
Diffstat (limited to 'kdecore/netsupp.cpp')
| -rw-r--r-- | kdecore/netsupp.cpp | 1237 |
1 files changed, 1237 insertions, 0 deletions
diff --git a/kdecore/netsupp.cpp b/kdecore/netsupp.cpp new file mode 100644 index 000000000..ee8ddad23 --- /dev/null +++ b/kdecore/netsupp.cpp @@ -0,0 +1,1237 @@ +/* + * This file is part of the KDE libraries + * Copyright (C) 2000,2001 Thiago Macieira <thiago.macieira@kdemail.net> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + **/ + +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/un.h> +#include <netinet/in.h> +#include <stdlib.h> +#include <stdio.h> +#include <errno.h> +#include <unistd.h> +#include <arpa/inet.h> + +#include <qglobal.h> + +// This is so that, if addrinfo is defined, it doesn't clobber our definition +// It might be defined in the few cases in which we are replacing the system's +// broken getaddrinfo +#include <netdb.h> + +#include "config.h" +#include "kdebug.h" +#include "klocale.h" + +#ifndef IN6_IS_ADDR_V4MAPPED +#define NEED_IN6_TESTS +#endif +#undef CLOBBER_IN6 +#include "netsupp.h" + +#if defined(__hpux) || defined(_HPUX_SOURCE) +extern int h_errno; +#endif + +#include <kdemacros.h> + +#if !defined(kde_sockaddr_in6) +/* + * kde_sockaddr_in6 might have got defined even though we #undef'ed + * CLOBBER_IN6. This happens when we are compiling under --enable-final. + * However, in that case, if it was defined, that's because ksockaddr.cpp + * had it defined because sockaddr_in6 didn't exist, and so sockaddr_in6 + * exists and is our kde_sockaddr_in6 + */ +# define sockaddr_in6 kde_sockaddr_in6 +# define in6_addr kde_in6_addr +#endif + +#ifdef offsetof +#undef offsetof +#endif +#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER) + +/* + * These constants tell the flags in KDE::resolverFlags + * The user could (but shouldn't) test the variable to know what kind of + * resolution is supported + */ +#define KRF_KNOWS_AF_INET6 0x01 /* if present, the code knows about AF_INET6 */ +#define KRF_USING_OWN_GETADDRINFO 0x02 /* if present, we are using our own getaddrinfo */ +#define KRF_USING_OWN_INET_NTOP 0x04 /* if present, we are using our own inet_ntop */ +#define KRF_USING_OWN_INET_PTON 0x08 /* if present, we are using our own inet_pton */ +#define KRF_CAN_RESOLVE_UNIX 0x100 /* if present, the resolver can resolve Unix sockets */ +#define KRF_CAN_RESOLVE_IPV4 0x200 /* if present, the resolver can resolve to IPv4 */ +#define KRF_CAN_RESOLVE_IPV6 0x400 /* if present, the resolver can resolve to IPv6 */ + + +static void dofreeaddrinfo(struct addrinfo *ai) +{ + while (ai) + { + struct addrinfo *ai2 = ai; + if (ai->ai_canonname != NULL) + free(ai->ai_canonname); + + if (ai->ai_addr != NULL) + free(ai->ai_addr); + + ai = ai->ai_next; + free(ai2); + } +} + +void kde_freeaddrinfo(struct kde_addrinfo *ai) +{ + if (ai->origin == KAI_LOCALUNIX) + { + struct addrinfo *p, *last = NULL; + /* We've added one AF_UNIX socket in here, to the + * tail of the linked list. We have to find it */ + for (p = ai->data; p; p = p->ai_next) + { + if (p->ai_family == AF_UNIX) + { + if (last) + { + last->ai_next = NULL; + freeaddrinfo(ai->data); + } + dofreeaddrinfo(p); + break; + } + last = p; + } + } + else + freeaddrinfo(ai->data); + + free(ai); +} + +static struct addrinfo* +make_unix(const char *name, const char *serv) +{ + const char *buf; + struct addrinfo *p; + struct sockaddr_un *_sun; + int len; + + p = (addrinfo*)malloc(sizeof(*p)); + if (p == NULL) + return NULL; + memset(p, 0, sizeof(*p)); + + if (name != NULL) + buf = name; + else + buf = serv; + + // Calculate length of the binary representation + len = strlen(buf) + offsetof(struct sockaddr_un, sun_path) + 1; + if (*buf != '/') + len += 5; // strlen("/tmp/"); + + _sun = (sockaddr_un*)malloc(len); + if (_sun == NULL) + { + // Oops + free(p); + return NULL; + } + + _sun->sun_family = AF_UNIX; +# ifdef HAVE_STRUCT_SOCKADDR_SA_LEN + _sun->sun_len = len; +# endif + if (*buf == '/') + *_sun->sun_path = '\0'; // empty it + else + strcpy(_sun->sun_path, "/tmp/"); + strcat(_sun->sun_path, buf); + + // Set the addrinfo + p->ai_family = AF_UNIX; + p->ai_addrlen = len; + p->ai_addr = (sockaddr*)_sun; + p->ai_canonname = strdup(buf); + + return p; +} + +// Ugh. I hate #ifdefs +// Anyways, here's what this does: +// KDE_IPV6_LOOKUP_MODE != 1, this function doesn't exist +// AF_INET6 not defined, we say there is no IPv6 stack +// otherwise, we try to create a socket. +// returns: 1 for IPv6 stack available, 2 for not available +#if defined(KDE_IPV6_LOOKUP_MODE) && KDE_IPV6_LOOKUP_MODE == 1 +static int check_ipv6_stack() +{ +# ifndef AF_INET6 + return 2; // how can we check? +# else + if (getenv("KDE_NO_IPV6")) + return 2; + int fd = ::socket(AF_INET6, SOCK_STREAM, 0); + if (fd == -1) + return 2; + + ::close(fd); + return 1; +# endif +} +#endif + + +/* + * Reason for using this function: kde_getaddrinfo + * + * I decided to add this wrapper function for getaddrinfo + * and have this be called by KExtendedSocket instead of + * the real getaddrinfo so that we can make sure that the + * behavior is the desired one. + * + * Currently, the only "undesired" behavior is getaddrinfo + * not returning PF_UNIX sockets in some implementations. + * + * getaddrinfo and family are defined in POSIX 1003.1g + * (Protocol Independent Interfaces) and in RFC 2553 + * (Basic Socket Interface for IPv6). Whereas the RFC is ambiguosly + * vague whether this family of functions should return Internet + * sockets only or not, the name of the POSIX draft says + * otherwise: it should be independent of protocol. + * + * So, my interpretation is that they should return every + * kind of socket available and known and that's how I + * designed KExtendedSocket on top of it. + * + * That's why there's this wrapper, to make sure PF_UNIX + * sockets are returned when expected. + */ + +int kde_getaddrinfo(const char *name, const char *service, + const struct addrinfo* hint, + struct kde_addrinfo** result) +{ + struct kde_addrinfo* res; + struct addrinfo* p; + int err = EAI_SERVICE; +#if defined(KDE_IPV6_LOOKUP_MODE) && KDE_IPV6_LOOKUP_MODE == 1 + // mode 1: do a check on whether we have an IPv6 stack + static int ipv6_stack = 0; // 0: unknown, 1: yes, 2: no +#endif + + // allocate memory for results + res = (kde_addrinfo*)malloc(sizeof(*res)); + if (res == NULL) + return EAI_MEMORY; + res->data = NULL; + res->origin = KAI_SYSTEM; // at first, it'll be only system data + + struct addrinfo* last = NULL; + + // Skip the getaddrinfo call and the ipv6 check for a UNIX socket. + if (hint && (hint->ai_family == PF_UNIX)) + { + if (service == NULL || *service == '\0') + goto out; // can't be Unix if no service was requested + + // Unix sockets must be localhost + // That is, either name is NULL or, if it's not, it must be empty, + // "*" or "localhost" + if (name != NULL && !(name[0] == '\0' || (name[0] == '*' && name[1] == '\0') || + strcmp("localhost", name) == 0)) + goto out; // isn't localhost + + goto do_unix; + } + +#if defined(KDE_IPV6_LOOKUP_MODE) && KDE_IPV6_LOOKUP_MODE != 0 +# if KDE_IPV6_LOOKUP_MODE == 1 + // mode 1: do a check on whether we have an IPv6 stack + if (ipv6_stack == 0) + ipv6_stack = check_ipv6_stack(); + + if (ipv6_stack == 2) + { +# endif + // here we have modes 1 and 2 (no lookups) + // this is shared code + struct addrinfo our_hint; + if (hint != NULL) + { + memcpy(&our_hint, hint, sizeof(our_hint)); + if (our_hint.ai_family == AF_UNSPEC) + our_hint.ai_family = AF_INET; + } + else + { + memset(&our_hint, 0, sizeof(our_hint)); + our_hint.ai_family = AF_INET; + } + + // do the actual resolution + err = getaddrinfo(name, service, &our_hint, &res->data); +# if KDE_IPV6_LOOKUP_MODE == 1 + } + else +# endif +#endif +#if defined(KDE_IPV6_LOOKUP_MODE) && KDE_IPV6_LOOKUP_MODE != 2 + // do the IPV6 resolution + err = getaddrinfo(name, service, hint, &res->data); +#endif + + // Now we have to check whether the user could want a Unix socket + + if (service == NULL || *service == '\0') + goto out; // can't be Unix if no service was requested + + // Unix sockets must be localhost + // That is, either name is NULL or, if it's not, it must be empty, + // "*" or "localhost" + if (name != NULL && !(name[0] == '\0' || (name[0] == '*' && name[1] == '\0') || + strcmp("localhost", name) == 0)) + goto out; // isn't localhost + + // Unix sockets can only be returned if the user asked for a PF_UNSPEC + // or PF_UNIX socket type or gave us a NULL hint + if (hint != NULL && (hint->ai_family != PF_UNSPEC && hint->ai_family != PF_UNIX)) + goto out; // user doesn't want Unix + + // If we got here, then it means that the user might be expecting Unix + // sockets. The user wants a local socket, with a non-null service and + // has told us that they accept PF_UNIX sockets + // Check whether the system implementation returned Unix + if (err == 0) + for (p = res->data; p; p = p->ai_next) + { + last = p; // we have to find out which one is last anyways + if (p->ai_family == AF_UNIX) + // there is an Unix node + goto out; + } + + do_unix: + // So, give the user a PF_UNIX socket + p = make_unix(NULL, service); + if (p == NULL) + { + err = EAI_MEMORY; + goto out; + } + if (hint != NULL) + p->ai_socktype = hint->ai_socktype; + if (p->ai_socktype == 0) + p->ai_socktype = SOCK_STREAM; // default + + if (last) + last->ai_next = p; + else + res->data = p; + res->origin = KAI_LOCALUNIX; + *result = res; + return 0; + + out: + if (res->data != NULL) + freeaddrinfo(res->data); + free(res); + return err; +} + +#if defined(HAVE_GETADDRINFO) && !defined(HAVE_BROKEN_GETADDRINFO) + +#define KRF_getaddrinfo 0 +#define KRF_resolver 0 + +#else // !defined(HAVE_GETADDRINFO) || defined(HAVE_BROKEN_GETADDRINFO) + +#define KRF_getaddrinfo KRF_USING_OWN_GETADDRINFO +#define KRF_resolver KRF_CAN_RESOLVE_UNIX | KRF_CAN_RESOLVE_IPV4 + +/* + * No getaddrinfo() in this system. + * We shall provide our own + */ + +/** TODO + * Try and use gethostbyname2_r before gethostbyname2 and gethostbyname + */ +static int inet_lookup(const char *name, int portnum, int protonum, + struct addrinfo *p, const struct addrinfo *hint, + struct addrinfo** result) +{ + struct addrinfo *q; + struct hostent *h; + struct sockaddr **psa = NULL; + int len; + + // TODO + // Currently, this never resolves IPv6 (need gethostbyname2, etc.) +# ifdef AF_INET6 + if (hint->ai_family == AF_INET6) + { + if (p != NULL) + { + *result = p; + return 0; + } + return EAI_FAIL; + } +# endif + + q = (addrinfo*)malloc(sizeof(*q)); + if (q == NULL) + { + freeaddrinfo(p); + return EAI_MEMORY; + } + + h = gethostbyname(name); + if (h == NULL) + { + if (p != NULL) + { + // There already is a suitable result + *result = p; + return 0; + } + + switch (h_errno) + { + case HOST_NOT_FOUND: + return EAI_NONAME; + case TRY_AGAIN: + return EAI_AGAIN; + case NO_RECOVERY: + return EAI_FAIL; + case NO_ADDRESS: + return EAI_NODATA; + default: + // EH!? + return EAI_FAIL; + } + } + + // convert the hostent to addrinfo + if (h->h_addrtype == AF_INET && (hint->ai_family == AF_INET || hint->ai_family == AF_UNSPEC)) + len = sizeof(struct sockaddr_in); +# ifdef AF_INET6 + else if (h->h_addrtype == AF_INET6 && (hint->ai_family == AF_INET6 || + hint->ai_family == AF_UNSPEC)) + len = sizeof(struct sockaddr_in6); +# endif + else + { + // We don't know what to do with these addresses + // Or gethostbyname returned information we don't want + if (p != NULL) + { + *result = p; + return 0; + } + return EAI_NODATA; + } + + q->ai_flags = 0; + q->ai_family = h->h_addrtype; + q->ai_socktype = hint->ai_socktype; + q->ai_protocol = protonum; + q->ai_addrlen = len; + + q->ai_addr = (sockaddr*)malloc(len); + if (q->ai_addr == NULL) + { + free(q); + freeaddrinfo(p); + return EAI_MEMORY; + } + if (h->h_addrtype == AF_INET) + { + struct sockaddr_in *sin = (sockaddr_in*)q->ai_addr; + sin->sin_family = AF_INET; +# ifdef HAVE_STRUCT_SOCKADDR_SA_LEN + sin->sin_len = sizeof(*sin); +# endif + sin->sin_port = portnum; + memcpy(&sin->sin_addr, h->h_addr, h->h_length); + } +# ifdef AF_INET6 + else if (h->h_addrtype == AF_INET6) + { + struct sockaddr_in6 *sin6 = (sockaddr_in6*)q->ai_addr; + sin6->sin6_family = AF_INET6; +# ifdef HAVE_STRUCT_SOCKADDR_SA_LEN + sin6->sin6_len = sizeof(*sin6); +# endif + sin6->sin6_port = portnum; + sin6->sin6_flowinfo = 0; + memcpy(&sin6->sin6_addr, h->h_addr, h->h_length); + sin6->sin6_scope_id = 0; + } +# endif + + if (hint->ai_flags & AI_CANONNAME) + q->ai_canonname = strdup(h->h_name); + else + q->ai_canonname = NULL; + + q->ai_next = p; + p = q; + + // cycle through the rest of the hosts; + for (psa = (sockaddr**)h->h_addr_list + 1; *psa; psa++) + { + q = (addrinfo*)malloc(sizeof(*q)); + if (q == NULL) + { + freeaddrinfo(p); + return EAI_MEMORY; + } + memcpy(q, p, sizeof(*q)); + + q->ai_addr = (sockaddr*)malloc(h->h_length); + if (q->ai_addr == NULL) + { + freeaddrinfo(p); + free(q); + return EAI_MEMORY; + } + if (h->h_addrtype == AF_INET) + { + struct sockaddr_in *sin = (sockaddr_in*)q->ai_addr; + sin->sin_family = AF_INET; +# ifdef HAVE_STRUCT_SOCKADDR_SA_LEN + sin->sin_len = sizeof(*sin); +# endif + sin->sin_port = portnum; + memcpy(&sin->sin_addr, *psa, h->h_length); + } +# ifdef AF_INET6 + else if (h->h_addrtype == AF_INET6) + { + struct sockaddr_in6 *sin6 = (sockaddr_in6*)q->ai_addr; + sin6->sin6_family = AF_INET6; +# ifdef HAVE_STRUCT_SOCKADDR_SA_LEN + sin6->sin6_len = sizeof(*sin6); +# endif + sin6->sin6_port = portnum; + sin6->sin6_flowinfo = 0; + memcpy(&sin6->sin6_addr, *psa, h->h_length); + sin6->sin6_scope_id = 0; + } +# endif + + if (q->ai_canonname != NULL) + q->ai_canonname = strdup(q->ai_canonname); + + q->ai_next = p; + p = q; + } + + *result = p; + return 0; // Whew! Success! +} + +static int make_inet(const char *name, int portnum, int protonum, struct addrinfo *p, + const struct addrinfo *hint, struct addrinfo** result) +{ + struct addrinfo *q; + + do + { + // This 'do' is here just so that we can 'break' out of it + + if (name != NULL) + { + // first, try to use inet_pton before resolving + // it will catch IP addresses given without having to go to lookup + struct sockaddr_in *sin; + struct in_addr in; +# ifdef AF_INET6 + struct sockaddr_in6 *sin6; + struct in6_addr in6; + + if (hint->ai_family == AF_INET6 || (hint->ai_family == AF_UNSPEC && + strchr(name, ':') != NULL)) + { + // yes, this is IPv6 + if (inet_pton(AF_INET6, name, &in6) != 1) + { + if (hint->ai_flags & AI_NUMERICHOST) + { + freeaddrinfo(p); + return EAI_FAIL; + } + break; // not a numeric host + } + + sin6 = (sockaddr_in6*)malloc(sizeof(*sin6)); + if (sin6 == NULL) + { + freeaddrinfo(p); + return EAI_MEMORY; + } + memcpy(&sin6->sin6_addr, &in6, sizeof(in6)); + + if (strchr(name, '%') != NULL) + { + errno = 0; + sin6->sin6_scope_id = strtoul(strchr(name, '%') + 1, NULL, 10); + if (errno != 0) + sin6->sin6_scope_id = 0; // no interface + } + + q = (addrinfo*)malloc(sizeof(*q)); + if (q == NULL) + { + freeaddrinfo(p); + free(sin6); + return EAI_MEMORY; + } + + sin6->sin6_family = AF_INET6; +# ifdef HAVE_STRUCT_SOCKADDR_SA_LEN + sin6->sin6_len = sizeof(*sin6); +# endif + sin6->sin6_port = portnum; + sin6->sin6_flowinfo = 0; + + q->ai_flags = 0; + q->ai_family = AF_INET6; + q->ai_socktype = hint->ai_socktype; + q->ai_protocol = protonum; + q->ai_addrlen = sizeof(*sin6); + q->ai_canonname = NULL; + q->ai_addr = (sockaddr*)sin6; + q->ai_next = p; + + *result = q; + return 0; // success! + } +# endif // AF_INET6 + + if (hint->ai_family == AF_INET || hint->ai_family == AF_UNSPEC) + { + // This has to be IPv4 + if (inet_pton(AF_INET, name, &in) != 1) + { + if (hint->ai_flags & AI_NUMERICHOST) + { + freeaddrinfo(p); + return EAI_FAIL; // invalid, I guess + } + break; // not a numeric host, do lookup + } + + sin = (sockaddr_in*)malloc(sizeof(*sin)); + if (sin == NULL) + { + freeaddrinfo(p); + return EAI_MEMORY; + } + + q = (addrinfo*)malloc(sizeof(*q)); + if (q == NULL) + { + freeaddrinfo(p); + free(sin); + return EAI_MEMORY; + } + + sin->sin_family = AF_INET; +# ifdef HAVE_STRUCT_SOCKADDR_SA_LEN + sin->sin_len = sizeof(*sin); +# endif + sin->sin_port = portnum; + sin->sin_addr = in; + + q->ai_flags = 0; + q->ai_family = AF_INET; + q->ai_socktype = hint->ai_socktype; + q->ai_protocol = protonum; + q->ai_addrlen = sizeof(*sin); + q->ai_canonname = NULL; + q->ai_addr = (sockaddr*)sin; + q->ai_next = p; + *result = q; + return 0; + } + + // Eh, what!? + // One of the two above has to have matched + kdError() << "I wasn't supposed to get here!"; + } + } while (false); + + // This means localhost + if (name == NULL) + { + struct sockaddr_in *sin = (sockaddr_in*)malloc(sizeof(*sin)); +# ifdef AF_INET6 + struct sockaddr_in6 *sin6; +# endif + + if (hint->ai_family == AF_INET || hint->ai_family == AF_UNSPEC) + { + if (sin == NULL) + { + free(sin); + freeaddrinfo(p); + return EAI_MEMORY; + } + + // Do IPv4 first + q = (addrinfo*)malloc(sizeof(*q)); + if (q == NULL) + { + free(sin); + freeaddrinfo(p); + return EAI_MEMORY; + } + + sin->sin_family = AF_INET; +# ifdef HAVE_STRUCT_SOCKADDR_SA_LEN + sin->sin_len = sizeof(*sin); +# endif + sin->sin_port = portnum; + if (hint->ai_flags & AI_PASSIVE) + *(Q_UINT32*)&sin->sin_addr = INADDR_ANY; + else + *(Q_UINT32*)&sin->sin_addr = htonl(INADDR_LOOPBACK); + q->ai_flags = 0; + q->ai_family = AF_INET; + q->ai_socktype = hint->ai_socktype; + q->ai_protocol = protonum; + q->ai_addrlen = sizeof(*sin); + q->ai_canonname = NULL; + q->ai_addr = (sockaddr*)sin; + q->ai_next = p; + p = q; + } + +# ifdef AF_INET6 + // Try now IPv6 + + if (hint->ai_family == AF_INET6 || hint->ai_family == AF_UNSPEC) + { + sin6 = (sockaddr_in6*)malloc(sizeof(*sin6)); + q = (addrinfo*)malloc(sizeof(*q)); + if (q == NULL || sin6 == NULL) + { + free(sin6); + free(q); + freeaddrinfo(p); + return EAI_MEMORY; + } + + sin6->sin6_family = AF_INET6; +# ifdef HAVE_STRUCT_SOCKADDR_SA_LEN + sin6->sin6_len = sizeof(*sin6); +# endif + sin6->sin6_port = portnum; + sin6->sin6_flowinfo = 0; + sin6->sin6_scope_id = 0; + + // We don't want to use in6addr_loopback and in6addr_any + memset(&sin6->sin6_addr, 0, sizeof(sin6->sin6_addr)); + if ((hint->ai_flags & AI_PASSIVE) == 0) + ((char*)&sin6->sin6_addr)[15] = 1; + + q->ai_flags = 0; + q->ai_family = AF_INET6; + q->ai_socktype = hint->ai_socktype; + q->ai_protocol = protonum; + q->ai_addrlen = sizeof(*sin6); + q->ai_canonname = NULL; + q->ai_addr = (sockaddr*)sin6; + q->ai_next = p; + p = q; + } + +# endif // AF_INET6 + + *result = p; + return 0; // success! + } + + return inet_lookup(name, portnum, protonum, p, hint, result); +} + + +int getaddrinfo(const char *name, const char *serv, + const struct addrinfo* hint, + struct addrinfo** result) +{ + unsigned short portnum; // remember to store in network byte order + int protonum = IPPROTO_TCP; + const char *proto = "tcp"; + struct addrinfo *p = NULL; + + // Sanity checks: + if (hint == NULL || result == NULL) + return EAI_BADFLAGS; + if (hint->ai_family != AF_UNSPEC && hint->ai_family != AF_UNIX && + hint->ai_family != AF_INET +# ifdef AF_INET6 + && hint->ai_family != AF_INET6 +# endif + ) + return EAI_FAMILY; + if (hint->ai_socktype != 0 && hint->ai_socktype != SOCK_STREAM && + hint->ai_socktype != SOCK_DGRAM) + return EAI_SOCKTYPE; + + // Treat hostname of "*" as NULL, which means localhost + if (name != NULL && ((*name == '*' && name[1] == '\0') || *name == '\0')) + name = NULL; + // Treat service of "*" as NULL, which I guess means no port (0) + if (serv != NULL && ((*serv == '*' && serv[1] == '\0') || *serv == '\0')) + serv = NULL; + + if (name == NULL && serv == NULL) // what the hell do you want? + return EAI_NONAME; + + // This is just to make it easier + if (name != NULL && strcmp(name, "localhost") == 0) + name = NULL; + + // First, check for a Unix socket + // family must be either AF_UNIX or AF_UNSPEC + // either of name or serv must be set, the other must be NULL or empty + if (hint->ai_family == AF_UNIX || hint->ai_family == AF_UNSPEC) + { + if (name != NULL && serv != NULL) + { + // This is not allowed + if (hint->ai_family == AF_UNIX) + return EAI_BADFLAGS; + } + else + { + p = make_unix(name, serv); + if (p == NULL) + return EAI_MEMORY; + + p->ai_socktype = hint->ai_socktype; + // If the name/service started with a slash, then this *IS* + // only a Unix socket. Return. + if (hint->ai_family == AF_UNIX || ((name != NULL && *name == '/') || + (serv != NULL && *serv == '/'))) + { + *result = p; + return 0; // successful lookup + } + } + } + + // Lookup the service name, if required + if (serv != NULL) + { + char *tail; + struct servent *sent; + + portnum = htons((unsigned)strtoul(serv, &tail, 10)); + if (*tail != '\0') + { + // not a number. We have to do the lookup + if (hint->ai_socktype == SOCK_DGRAM) + { + proto = "udp"; + protonum = IPPROTO_UDP; + } + + sent = getservbyname(serv, proto); + if (sent == NULL) // no service? + { + if (p == NULL) + return EAI_NONAME; + else + return 0; // a Unix socket available + } + + portnum = sent->s_port; + } + } + else + portnum = 0; // no port number + + return make_inet(name, portnum, protonum, p, hint, result); +} + +void freeaddrinfo(struct addrinfo *p) +{ + dofreeaddrinfo(p); +} + +char *gai_strerror(int errorcode) +{ + static const char * const messages[] = + { + I18N_NOOP("no error"), // 0 + I18N_NOOP("address family for nodename not supported"), // EAI_ADDRFAMILY + I18N_NOOP("temporary failure in name resolution"), // EAI_AGAIN + I18N_NOOP("invalid value for 'ai_flags'"), // EAI_BADFLAGS + I18N_NOOP("non-recoverable failure in name resolution"), // EAI_FAIL + I18N_NOOP("'ai_family' not supported"), // EAI_FAMILY + I18N_NOOP("memory allocation failure"), // EAI_MEMORY + I18N_NOOP("no address associated with nodename"), // EAI_NODATA + I18N_NOOP("name or service not known"), // EAI_NONAME + I18N_NOOP("servname not supported for ai_socktype"), // EAI_SERVICE + I18N_NOOP("'ai_socktype' not supported"), // EAI_SOCKTYPE + I18N_NOOP("system error") // EAI_SYSTEM + }; + + if (errorcode > EAI_SYSTEM || errorcode < 0) + return NULL; + + static char buffer[200]; + strcpy(buffer, i18n(messages[errorcode]).local8Bit()); + return buffer; +} + +static void findport(unsigned short port, char *serv, size_t servlen, int flags) +{ + if (serv == NULL) + return; + + if ((flags & NI_NUMERICSERV) == 0) + { + struct servent *sent; + sent = getservbyport(ntohs(port), flags & NI_DGRAM ? "udp" : "tcp"); + if (sent != NULL && servlen > strlen(sent->s_name)) + { + strcpy(serv, sent->s_name); + return; + } + } + + snprintf(serv, servlen, "%u", ntohs(port)); +} + +int getnameinfo(const struct sockaddr *sa, ksocklen_t salen, + char *host, size_t hostlen, char *serv, size_t servlen, + int flags) +{ + union + { + const sockaddr *sa; + const sockaddr_un *_sun; + const sockaddr_in *sin; + const sockaddr_in6 *sin6; + } s; + + if ((host == NULL || hostlen == 0) && (serv == NULL || servlen == 0)) + return 1; + + s.sa = sa; + if (s.sa->sa_family == AF_UNIX) + { + if (salen < offsetof(struct sockaddr_un, sun_path) + strlen(s._sun->sun_path) + 1) + return 1; // invalid socket + + if (servlen && serv != NULL) + *serv = '\0'; + if (host != NULL && hostlen > strlen(s._sun->sun_path)) + strcpy(host, s._sun->sun_path); + + return 0; + } + else if (s.sa->sa_family == AF_INET) + { + if (salen < offsetof(struct sockaddr_in, sin_addr) + sizeof(s.sin->sin_addr)) + return 1; // invalid socket + + if (flags & NI_NUMERICHOST) + inet_ntop(AF_INET, &s.sin->sin_addr, host, hostlen); + else + { + // have to do lookup + struct hostent *h = gethostbyaddr((const char*)&s.sin->sin_addr, sizeof(s.sin->sin_addr), + AF_INET); + if (h == NULL && flags & NI_NAMEREQD) + return 1; + else if (h == NULL) + inet_ntop(AF_INET, &s.sin->sin_addr, host, hostlen); + else if (host != NULL && hostlen > strlen(h->h_name)) + strcpy(host, h->h_name); + else + return 1; // error + } + + findport(s.sin->sin_port, serv, servlen, flags); + } +# ifdef AF_INET6 + else if (s.sa->sa_family == AF_INET6) + { + if (salen < offsetof(struct sockaddr_in6, sin6_addr) + sizeof(s.sin6->sin6_addr)) + return 1; // invalid socket + + if (flags & NI_NUMERICHOST) + inet_ntop(AF_INET6, &s.sin6->sin6_addr, host, hostlen); + else + { + // have to do lookup + struct hostent *h = gethostbyaddr((const char*)&s.sin->sin_addr, sizeof(s.sin->sin_addr), + AF_INET6); + if (h == NULL && flags & NI_NAMEREQD) + return 1; + else if (h == NULL) + inet_ntop(AF_INET6, &s.sin6->sin6_addr, host, hostlen); + else if (host != NULL && hostlen > strlen(h->h_name)) + strcpy(host, h->h_name); + else + return 1; // error + } + + findport(s.sin6->sin6_port, serv, servlen, flags); + } +# endif // AF_INET6 + + return 1; // invalid family +} + +#endif // HAVE_GETADDRINFO + +#ifndef HAVE_INET_NTOP + +#define KRF_inet_ntop KRF_USING_OWN_INET_NTOP + +static void add_dwords(char *buf, Q_UINT16 *dw, int count) +{ + int i = 1; + sprintf(buf + strlen(buf), "%x", ntohs(dw[0])); + while (--count) + sprintf(buf + strlen(buf), ":%x", ntohs(dw[i++])); +} + +const char* inet_ntop(int af, const void *cp, char *buf, size_t len) +{ + char buf2[sizeof "1234:5678:9abc:def0:1234:5678:255.255.255.255" + 1]; + Q_UINT8 *data = (Q_UINT8*)cp; + + if (af == AF_INET) + { + sprintf(buf2, "%u.%u.%u.%u", data[0], data[1], data[2], data[3]); + + if (len > strlen(buf2)) + { + strcpy(buf, buf2); + return buf; + } + + errno = ENOSPC; + return NULL; // failed + } + +# ifdef AF_INET6 + if (af == AF_INET6) + { + Q_UINT16 *p = (Q_UINT16*)data; + Q_UINT16 *longest = NULL, *cur = NULL; + int longest_length = 0, cur_length; + int i; + + if (KDE_IN6_IS_ADDR_V4MAPPED(p) || KDE_IN6_IS_ADDR_V4COMPAT(p)) + sprintf(buf2, "::%s%u.%u.%u.%u", + KDE_IN6_IS_ADDR_V4MAPPED(p) ? "ffff:" : "", + buf[12], buf[13], buf[14], buf[15]); + else + { + // find the longest sequence of zeroes + for (i = 0; i < 8; i++) + if (cur == NULL && p[i] == 0) + { + // a zero, start the sequence + cur = p + i; + cur_length = 1; + } + else if (cur != NULL && p[i] == 0) + // part of the sequence + cur_length++; + else if (cur != NULL && p[i] != 0) + { + // end of the sequence + if (cur_length > longest_length) + { + longest_length = cur_length; + longest = cur; + } + cur = NULL; // restart sequence + } + if (cur != NULL && cur_length > longest_length) + { + longest_length = cur_length; + longest = cur; + } + + if (longest_length > 1) + { + // We have a candidate + buf2[0] = '\0'; + if (longest != p) + add_dwords(buf2, p, longest - p); + strcat(buf2, "::"); + if (longest + longest_length < p + 8) + add_dwords(buf2, longest + longest_length, 8 - (longest - p) - longest_length); + } + else + { + // Nope, no candidate + buf2[0] = '\0'; + add_dwords(buf2, p, 8); + } + } + + if (strlen(buf2) < len) + { + strcpy(buf, buf2); + return buf; + } + + errno = ENOSPC; + return NULL; + } +# endif + + errno = EAFNOSUPPORT; + return NULL; // a family we don't know about +} + +#else // HAVE_INET_NTOP + +#define KRF_inet_ntop 0 + +#endif // HAVE_INET_NTOP + +#ifndef HAVE_INET_PTON + +#define KRF_inet_pton KRF_USING_OWN_INET_PTON +int inet_pton(int af, const char *cp, void *buf) +{ + if (af == AF_INET) + { + // Piece of cake + unsigned p[4]; + unsigned char *q = (unsigned char*)buf; + if (sscanf(cp, "%u.%u.%u.%u", p, p + 1, p + 2, p + 3) != 4) + return 0; + + if (p[0] > 0xff || p[1] > 0xff || p[2] > 0xff || p[3] > 0xff) + return 0; + + q[0] = p[0]; + q[1] = p[1]; + q[2] = p[2]; + q[3] = p[3]; + + return 1; + } + +# ifdef AF_INET6 + else if (af == AF_INET6) + { + Q_UINT16 addr[8]; + const char *p = cp; + int n = 0, start = 8; + bool has_v4 = strchr(p, '.') != NULL; + + memset(addr, 0, sizeof(addr)); + + if (*p == '\0' || p[1] == '\0') + return 0; // less than 2 chars is not valid + + if (*p == ':' && p[1] == ':') + { + start = 0; + p += 2; + } + while (*p) + { + if (has_v4 && inet_pton(AF_INET, p, addr + n) != 0) + { + // successful v4 convertion + addr[n] = ntohs(addr[n]); + n++; + addr[n] = ntohs(addr[n]); + n++; + break; + } + if (sscanf(p, "%hx", addr + n++) != 1) + return 0; + + while (*p && *p != ':') + p++; + if (!*p) + break; + p++; + + if (*p == ':') // another ':'? + { + if (start != 8) + return 0; // two :: were found + start = n; + p++; + } + } + + // if start is not 8, then a "::" was found at word 'start' + // n is the number of converted words + // n == 8 means everything was converted and no moving is necessary + // n < 8 means that we have to move n - start words 8 - n words to the right + if (start == 8 && n != 8) + return 0; // bad conversion + memmove(addr + start + (8 - n), addr + start, (n - start) * sizeof(Q_UINT16)); + memset(addr + start, 0, (8 - n) * sizeof(Q_UINT16)); + + // check the byte order + // The compiler should optimise this out in big endian machines + if (htons(0x1234) != 0x1234) + for (n = 0; n < 8; n++) + addr[n] = htons(addr[n]); + + memcpy(buf, addr, sizeof(addr)); + return 1; + } +# endif + + errno = EAFNOSUPPORT; + return -1; // unknown family +} + +#else // HAVE_INET_PTON + +#define KRF_inet_pton 0 + +#endif // HAVE_INET_PTON + +#ifdef AF_INET6 +# define KRF_afinet6 KRF_KNOWS_AF_INET6 +#else +# define KRF_afinet6 0 +#endif + +namespace KDE +{ + /** @internal */ + extern const int KDE_EXPORT resolverFlags = KRF_getaddrinfo | KRF_resolver | KRF_afinet6 | KRF_inet_ntop | KRF_inet_pton; +} |