[fusl] Update fusl

fusl/src/network/lookup_name.c

 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <netdb.h>
 #include <net/if.h>
 #include <arpa/inet.h>
 #include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
 #include <fcntl.h>
 #include <unistd.h>
@@ skipping 75 matching lines @@
 
 struct dpc_ctx {
         struct address *addrs;
         char *canon;
         int cnt;
 };
 
 int __dns_parse(const unsigned char *, int, int (*)(void *, int, const void *, int, const void *), void *);
 int __dn_expand(const unsigned char *, const unsigned char *, const unsigned char *, char *, int);
 int __res_mkquery(int, const char *, int, int, const unsigned char *, int, const unsigned char*, unsigned char *, int);
-int __res_msend(int, const unsigned char *const *, const int *, unsigned char *const *, int *, int);
+int __res_msend_rc(int, const unsigned char *const *, const int *, unsigned char *const *, int *, int, const struct resolvconf *);
 
 #define RR_A 1
 #define RR_CNAME 5
 #define RR_AAAA 28
 
 static int dns_parse_callback(void *c, int rr, const void *data, int len, const void *packet)
 {
         char tmp[256];
         struct dpc_ctx *ctx = c;
         switch (rr) {
@@ skipping 11 matching lines @@
                 break;
         case RR_CNAME:
                 if (__dn_expand(packet, (const unsigned char *)packet + 512,
                     data, tmp, sizeof tmp) > 0 && is_valid_hostname(tmp))
                         strcpy(ctx->canon, tmp);
                 break;
         }
         return 0;
 }
 
-static int name_from_dns(struct address buf[static MAXADDRS], char canon[static 256], const char *name, int family)
+static int name_from_dns(struct address buf[static MAXADDRS], char canon[static 256], const char *name, int family, const struct resolvconf *conf)
 {
         unsigned char qbuf[2][280], abuf[2][512];
         const unsigned char *qp[2] = { qbuf[0], qbuf[1] };
         unsigned char *ap[2] = { abuf[0], abuf[1] };
         int qlens[2], alens[2];
         int i, nq = 0;
         struct dpc_ctx ctx = { .addrs = buf, .canon = canon };
 
         if (family != AF_INET6) {
                 qlens[nq] = __res_mkquery(0, name, 1, RR_A, 0, 0, 0,
                         qbuf[nq], sizeof *qbuf);
                 nq++;
         }
         if (family != AF_INET) {
                 qlens[nq] = __res_mkquery(0, name, 1, RR_AAAA, 0, 0, 0,
                         qbuf[nq], sizeof *qbuf);
                 nq++;
         }
 
-        if (__res_msend(nq, qp, qlens, ap, alens, sizeof *abuf) < 0) return EAI_SYSTEM;
+        if (__res_msend_rc(nq, qp, qlens, ap, alens, sizeof *abuf, conf) < 0)
+                return EAI_SYSTEM;
 
         for (i=0; i<nq; i++)
                 __dns_parse(abuf[i], alens[i], dns_parse_callback, &ctx);
 
         if (ctx.cnt) return ctx.cnt;
         if (alens[0] < 4 || (abuf[0][3] & 15) == 2) return EAI_AGAIN;
-        if ((abuf[0][3] & 15) == 3) return EAI_NONAME;
+        if ((abuf[0][3] & 15) == 0) return EAI_NONAME;
+        if ((abuf[0][3] & 15) == 3) return 0;
         return EAI_FAIL;
 }
 
+static int name_from_dns_search(struct address buf[static MAXADDRS], char canon[static 256], const char *name, int family)
+{
+        char search[256];
+        struct resolvconf conf;
+        size_t l, dots;
+        char *p, *z;
+
+        if (__get_resolv_conf(&conf, search, sizeof search) < 0) return -1;
+
+        /* Count dots, suppress search when >=ndots or name ends in
+         * a dot, which is an explicit request for global scope. */
+        for (dots=l=0; name[l]; l++) if (name[l]=='.') dots++;
+        if (dots >= conf.ndots || name[l-1]=='.') *search = 0;
+
+        /* This can never happen; the caller already checked length. */
+        if (l >= 256) return EAI_NONAME;
+
+        /* Name with search domain appended is setup in canon[]. This both
+         * provides the desired default canonical name (if the requested
+         * name is not a CNAME record) and serves as a buffer for passing
+         * the full requested name to name_from_dns. */
+        memcpy(canon, name, l);
+        canon[l] = '.';
+
+        for (p=search; *p; p=z) {
+                for (; isspace(*p); p++);
+                for (z=p; *z && !isspace(*z); z++);
+                if (z==p) break;
+                if (z-p < 256 - l - 1) {
+                        memcpy(canon+l+1, p, z-p);
+                        canon[z-p+1+l] = 0;
+                        int cnt = name_from_dns(buf, canon, canon, family, &conf);
+                        if (cnt) return cnt;
+                }
+        }
+
+        canon[l] = 0;
+        return name_from_dns(buf, canon, name, family, &conf);
+}
+
 static const struct policy {
         unsigned char addr[16];
         unsigned char len, mask;
         unsigned char prec, label;
 } defpolicy[] = {
         { "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1", 15, 0xff, 50, 0 },
         { "\0\0\0\0\0\0\0\0\0\0\xff\xff", 11, 0xff, 35, 4 },
         { "\x20\2", 1, 0xff, 30, 2 },
         { "\x20\1", 3, 0xff, 5, 5 },
         { "\xfc", 0, 0xfe, 3, 13 },
@@ skipping 80 matching lines @@
         if (flags & AI_V4MAPPED) {
                 if (family == AF_INET6) family = AF_UNSPEC;
                 else flags -= AI_V4MAPPED;
         }
 
         /* Try each backend until there's at least one result. */
         cnt = name_from_null(buf, name, family, flags);
         if (!cnt) cnt = name_from_numeric(buf, name, family);
         if (!cnt && !(flags & AI_NUMERICHOST)) {
                 cnt = name_from_hosts(buf, canon, name, family);
-                if (!cnt) cnt = name_from_dns(buf, canon, name, family);
+                if (!cnt) cnt = name_from_dns_search(buf, canon, name, family);
         }
         if (cnt<=0) return cnt ? cnt : EAI_NONAME;
 
         /* Filter/transform results for v4-mapped lookup, if requested. */
         if (flags & AI_V4MAPPED) {
                 if (!(flags & AI_ALL)) {
                         /* If any v6 results exist, remove v4 results. */
                         for (i=0; i<cnt && buf[i].family != AF_INET6; i++);
                         if (i<cnt) {
                                 for (j=0; i<cnt; i++) {
@@ skipping 66 matching lines @@
                 key |= prefixlen << DAS_PREFIX_SHIFT;
                 key |= (MAXADDRS-i) << DAS_ORDER_SHIFT;
                 buf[i].sortkey = key;
         }
         qsort(buf, cnt, sizeof *buf, addrcmp);
 
         pthread_setcancelstate(cs, 0);
 
         return cnt;
 }