/* * This file is part of the KDE libraries * Copyright (C) 2000,2001 Thiago Macieira * * 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 #include #include #include #include #include #include #include #include #include // 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 #include "config.h" #include "kdebug.h" #include "tdelocale.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 #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("TDE_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) *(TQ_UINT32*)&sin->sin_addr = INADDR_ANY; else *(TQ_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, TQ_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]; TQ_UINT8 *data = (TQ_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) { TQ_UINT16 *p = (TQ_UINT16*)data; TQ_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) { TQ_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(TQ_UINT16)); memset(addr + start, 0, (8 - n) * sizeof(TQ_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; }