adapt res_msend DNS query core for working with multiple sockets

[musl] / src / network / getaddrinfo.c

diff --git a/src/network/getaddrinfo.c b/src/network/getaddrinfo.c
index d991344..64ad259 100644 (file)
--- a/src/network/getaddrinfo.c
+++ b/src/network/getaddrinfo.c
@@ -3,6 +3,10 @@
 #include <netinet/in.h>
 #include <netdb.h>
 #include <string.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <endian.h>
+#include <errno.h>
 #include "lookup.h"
 
 int getaddrinfo(const char *restrict host, const char *restrict serv, const struct addrinfo *restrict hint, struct addrinfo **restrict res)
@@ -11,19 +15,17 @@ int getaddrinfo(const char *restrict host, const char *restrict serv, const stru
        struct address addrs[MAXADDRS];
        char canon[256], *outcanon;
        int nservs, naddrs, nais, canon_len, i, j, k;
-       int family = AF_UNSPEC, flags = 0, proto = 0;
-       struct aibuf {
-               struct addrinfo ai;
-               union sa {
-                       struct sockaddr_in sin;
-                       struct sockaddr_in6 sin6;
-               } sa;
-       } *out;
+       int family = AF_UNSPEC, flags = 0, proto = 0, socktype = 0;
+       int no_family = 0;
+       struct aibuf *out;
+
+       if (!host && !serv) return EAI_NONAME;
 
        if (hint) {
                family = hint->ai_family;
                flags = hint->ai_flags;
                proto = hint->ai_protocol;
+               socktype = hint->ai_socktype;
 
                const int mask = AI_PASSIVE | AI_CANONNAME | AI_NUMERICHOST |
                        AI_V4MAPPED | AI_ALL | AI_ADDRCONFIG | AI_NUMERICSERV;
@@ -38,40 +40,62 @@ int getaddrinfo(const char *restrict host, const char *restrict serv, const stru
                default:
                        return EAI_FAMILY;
                }
+       }
 
-               switch (hint->ai_socktype) {
-               case SOCK_STREAM:
-                       switch (proto) {
-                       case 0:
-                               proto = IPPROTO_TCP;
-                       case IPPROTO_TCP:
-                               break;
-                       default:
-                               return EAI_SERVICE;
+       if (flags & AI_ADDRCONFIG) {
+               /* Define the "an address is configured" condition for address
+                * families via ability to create a socket for the family plus
+                * routability of the loopback address for the family. */
+               static const struct sockaddr_in lo4 = {
+                       .sin_family = AF_INET, .sin_port = 65535,
+                       .sin_addr.s_addr = __BYTE_ORDER == __BIG_ENDIAN
+                               ? 0x7f000001 : 0x0100007f
+               };
+               static const struct sockaddr_in6 lo6 = {
+                       .sin6_family = AF_INET6, .sin6_port = 65535,
+                       .sin6_addr = IN6ADDR_LOOPBACK_INIT
+               };
+               int tf[2] = { AF_INET, AF_INET6 };
+               const void *ta[2] = { &lo4, &lo6 };
+               socklen_t tl[2] = { sizeof lo4, sizeof lo6 };
+               for (i=0; i<2; i++) {
+                       if (family==tf[1-i]) continue;
+                       int s = socket(tf[i], SOCK_CLOEXEC|SOCK_DGRAM,
+                               IPPROTO_UDP);
+                       if (s>=0) {
+                               int cs;
+                               pthread_setcancelstate(
+                                       PTHREAD_CANCEL_DISABLE, &cs);
+                               int r = connect(s, ta[i], tl[i]);
+                               int saved_errno = errno;
+                               pthread_setcancelstate(cs, 0);
+                               close(s);
+                               if (!r) continue;
+                               errno = saved_errno;
                        }
-                       break;
-               case SOCK_DGRAM:
-                       switch (proto) {
-                       case 0:
-                               proto = IPPROTO_UDP;
-                       case IPPROTO_UDP:
+                       switch (errno) {
+                       case EADDRNOTAVAIL:
+                       case EAFNOSUPPORT:
+                       case EHOSTUNREACH:
+                       case ENETDOWN:
+                       case ENETUNREACH:
                                break;
                        default:
-                               return EAI_SERVICE;
+                               return EAI_SYSTEM;
                        }
-               case 0:
-                       break;
-               default:
-                       return EAI_SOCKTYPE;
+                       if (family == tf[i]) no_family = 1;
+                       family = tf[1-i];
                }
        }
 
-       nservs = __lookup_serv(ports, serv, proto, flags);
+       nservs = __lookup_serv(ports, serv, proto, socktype, flags);
        if (nservs < 0) return nservs;
 
        naddrs = __lookup_name(addrs, canon, host, family, flags);
        if (naddrs < 0) return naddrs;
 
+       if (no_family) return EAI_NODATA;
+
        nais = nservs * naddrs;
        canon_len = strlen(canon);
        out = calloc(1, nais * sizeof(*out) + canon_len + 1);
@@ -85,17 +109,17 @@ int getaddrinfo(const char *restrict host, const char *restrict serv, const stru
        }
 
        for (k=i=0; i<naddrs; i++) for (j=0; j<nservs; j++, k++) {
+               out[k].slot = k;
                out[k].ai = (struct addrinfo){
                        .ai_family = addrs[i].family,
-                       .ai_socktype = ports[j].proto == IPPROTO_TCP
-                               ? SOCK_STREAM : SOCK_DGRAM,
+                       .ai_socktype = ports[j].socktype,
                        .ai_protocol = ports[j].proto,
                        .ai_addrlen = addrs[i].family == AF_INET
                                ? sizeof(struct sockaddr_in)
                                : sizeof(struct sockaddr_in6),
                        .ai_addr = (void *)&out[k].sa,
-                       .ai_canonname = outcanon,
-                       .ai_next = &out[k+1].ai };
+                       .ai_canonname = outcanon };
+               if (k) out[k-1].ai.ai_next = &out[k].ai;
                switch (addrs[i].family) {
                case AF_INET:
                        out[k].sa.sin.sin_family = AF_INET;
@@ -110,7 +134,7 @@ int getaddrinfo(const char *restrict host, const char *restrict serv, const stru
                        break;                  
                }
        }
-       out[nais-1].ai.ai_next = 0;
+       out[0].ref = nais;
        *res = &out->ai;
        return 0;
 }