legacy-libs/grpc-cloned/deps/grpc/third_party/cares/cares/ares_search.c

   1
   2 /* Copyright 1998 by the Massachusetts Institute of Technology.
   3  *
   4  * Permission to use, copy, modify, and distribute this
   5  * software and its documentation for any purpose and without
   6  * fee is hereby granted, provided that the above copyright
   7  * notice appear in all copies and that both that copyright
   8  * notice and this permission notice appear in supporting
   9  * documentation, and that the name of M.I.T. not be used in
  10  * advertising or publicity pertaining to distribution of the
  11  * software without specific, written prior permission.
  12  * M.I.T. makes no representations about the suitability of
  13  * this software for any purpose.  It is provided "as is"
  14  * without express or implied warranty.
  15  */
  16
  17 #include "ares_setup.h"
  18
  19 #ifdef HAVE_STRINGS_H
  20 #  include <strings.h>
  21 #endif
  22
  23 #include "ares.h"
  24 #include "ares_private.h"
  25
  26 struct search_query {
  27   /* Arguments passed to ares_search */
  28   ares_channel channel;
  29   char *name;                   /* copied into an allocated buffer */
  30   int dnsclass;
  31   int type;
  32   ares_callback callback;
  33   void *arg;
  34
  35   int status_as_is;             /* error status from trying as-is */
  36   int next_domain;              /* next search domain to try */
  37   int trying_as_is;             /* current query is for name as-is */
  38   int timeouts;                 /* number of timeouts we saw for this request */
  39   int ever_got_nodata;          /* did we ever get ARES_ENODATA along the way? */
  40 };
  41
  42 static void search_callback(void *arg, int status, int timeouts,
  43                             unsigned char *abuf, int alen);
  44 static void end_squery(struct search_query *squery, int status,
  45                        unsigned char *abuf, int alen);
  46 static int cat_domain(const char *name, const char *domain, char **s);
  47 STATIC_TESTABLE int single_domain(ares_channel channel, const char *name, char **s);
  48
  49 void ares_search(ares_channel channel, const char *name, int dnsclass,
  50                  int type, ares_callback callback, void *arg)
  51 {
  52   struct search_query *squery;
  53   char *s;
  54   const char *p;
  55   int status, ndots;
  56
  57   /* Per RFC 7686, reject queries for ".onion" domain names with NXDOMAIN. */
  58   if (ares__is_onion_domain(name))
  59     {
  60       callback(arg, ARES_ENOTFOUND, 0, NULL, 0);
  61       return;
  62     }
  63
  64   /* If name only yields one domain to search, then we don't have
  65    * to keep extra state, so just do an ares_query().
  66    */
  67   status = single_domain(channel, name, &s);
  68   if (status != ARES_SUCCESS)
  69     {
  70       callback(arg, status, 0, NULL, 0);
  71       return;
  72     }
  73   if (s)
  74     {
  75       ares_query(channel, s, dnsclass, type, callback, arg);
  76       ares_free(s);
  77       return;
  78     }
  79
  80   /* Allocate a search_query structure to hold the state necessary for
  81    * doing multiple lookups.
  82    */
  83   squery = ares_malloc(sizeof(struct search_query));
  84   if (!squery)
  85     {
  86       callback(arg, ARES_ENOMEM, 0, NULL, 0);
  87       return;
  88     }
  89   squery->channel = channel;
  90   squery->name = ares_strdup(name);
  91   if (!squery->name)
  92     {
  93       ares_free(squery);
  94       callback(arg, ARES_ENOMEM, 0, NULL, 0);
  95       return;
  96     }
  97   squery->dnsclass = dnsclass;
  98   squery->type = type;
  99   squery->status_as_is = -1;
 100   squery->callback = callback;
 101   squery->arg = arg;
 102   squery->timeouts = 0;
 103   squery->ever_got_nodata = 0;
 104
 105   /* Count the number of dots in name. */
 106   ndots = 0;
 107   for (p = name; *p; p++)
 108     {
 109       if (*p == '.')
 110         ndots++;
 111     }
 112
 113   /* If ndots is at least the channel ndots threshold (usually 1),
 114    * then we try the name as-is first.  Otherwise, we try the name
 115    * as-is last.
 116    */
 117   if (ndots >= channel->ndots)
 118     {
 119       /* Try the name as-is first. */
 120       squery->next_domain = 0;
 121       squery->trying_as_is = 1;
 122       ares_query(channel, name, dnsclass, type, search_callback, squery);
 123     }
 124   else
 125     {
 126       /* Try the name as-is last; start with the first search domain. */
 127       squery->next_domain = 1;
 128       squery->trying_as_is = 0;
 129       status = cat_domain(name, channel->domains[0], &s);
 130       if (status == ARES_SUCCESS)
 131         {
 132           ares_query(channel, s, dnsclass, type, search_callback, squery);
 133           ares_free(s);
 134         }
 135       else
 136       {
 137         /* failed, free the malloc()ed memory */
 138         ares_free(squery->name);
 139         ares_free(squery);
 140         callback(arg, status, 0, NULL, 0);
 141       }
 142     }
 143 }
 144
 145 static void search_callback(void *arg, int status, int timeouts,
 146                             unsigned char *abuf, int alen)
 147 {
 148   struct search_query *squery = (struct search_query *) arg;
 149   ares_channel channel = squery->channel;
 150   char *s;
 151
 152   squery->timeouts += timeouts;
 153
 154   /* Stop searching unless we got a non-fatal error. */
 155   if (status != ARES_ENODATA && status != ARES_ESERVFAIL
 156       && status != ARES_ENOTFOUND)
 157     end_squery(squery, status, abuf, alen);
 158   else
 159     {
 160       /* Save the status if we were trying as-is. */
 161       if (squery->trying_as_is)
 162         squery->status_as_is = status;
 163
 164       /*
 165        * If we ever get ARES_ENODATA along the way, record that; if the search
 166        * should run to the very end and we got at least one ARES_ENODATA,
 167        * then callers like ares_gethostbyname() may want to try a T_A search
 168        * even if the last domain we queried for T_AAAA resource records
 169        * returned ARES_ENOTFOUND.
 170        */
 171       if (status == ARES_ENODATA)
 172         squery->ever_got_nodata = 1;
 173
 174       if (squery->next_domain < channel->ndomains)
 175         {
 176           /* Try the next domain. */
 177           status = cat_domain(squery->name,
 178                               channel->domains[squery->next_domain], &s);
 179           if (status != ARES_SUCCESS)
 180             end_squery(squery, status, NULL, 0);
 181           else
 182             {
 183               squery->trying_as_is = 0;
 184               squery->next_domain++;
 185               ares_query(channel, s, squery->dnsclass, squery->type,
 186                          search_callback, squery);
 187               ares_free(s);
 188             }
 189         }
 190       else if (squery->status_as_is == -1)
 191         {
 192           /* Try the name as-is at the end. */
 193           squery->trying_as_is = 1;
 194           ares_query(channel, squery->name, squery->dnsclass, squery->type,
 195                      search_callback, squery);
 196         }
 197       else {
 198         if (squery->status_as_is == ARES_ENOTFOUND && squery->ever_got_nodata) {
 199           end_squery(squery, ARES_ENODATA, NULL, 0);
 200         }
 201         else
 202           end_squery(squery, squery->status_as_is, NULL, 0);
 203       }
 204     }
 205 }
 206
 207 static void end_squery(struct search_query *squery, int status,
 208                        unsigned char *abuf, int alen)
 209 {
 210   squery->callback(squery->arg, status, squery->timeouts, abuf, alen);
 211   ares_free(squery->name);
 212   ares_free(squery);
 213 }
 214
 215 /* Concatenate two domains. */
 216 static int cat_domain(const char *name, const char *domain, char **s)
 217 {
 218   size_t nlen = strlen(name);
 219   size_t dlen = strlen(domain);
 220
 221   *s = ares_malloc(nlen + 1 + dlen + 1);
 222   if (!*s)
 223     return ARES_ENOMEM;
 224   memcpy(*s, name, nlen);
 225   (*s)[nlen] = '.';
 226   memcpy(*s + nlen + 1, domain, dlen);
 227   (*s)[nlen + 1 + dlen] = 0;
 228   return ARES_SUCCESS;
 229 }
 230
 231 /* Determine if this name only yields one query.  If it does, set *s to
 232  * the string we should query, in an allocated buffer.  If not, set *s
 233  * to NULL.
 234  */
 235 STATIC_TESTABLE int single_domain(ares_channel channel, const char *name, char **s)
 236 {
 237   size_t len = strlen(name);
 238   const char *hostaliases;
 239   FILE *fp;
 240   char *line = NULL;
 241   int status;
 242   size_t linesize;
 243   const char *p, *q;
 244   int error;
 245
 246   /* If the name contains a trailing dot, then the single query is the name
 247    * sans the trailing dot.
 248    */
 249   if ((len > 0) && (name[len - 1] == '.'))
 250     {
 251       *s = ares_strdup(name);
 252       return (*s) ? ARES_SUCCESS : ARES_ENOMEM;
 253     }
 254
 255   if (!(channel->flags & ARES_FLAG_NOALIASES) && !strchr(name, '.'))
 256     {
 257       /* The name might be a host alias. */
 258       hostaliases = getenv("HOSTALIASES");
 259       if (hostaliases)
 260         {
 261           fp = fopen(hostaliases, "r");
 262           if (fp)
 263             {
 264               while ((status = ares__read_line(fp, &line, &linesize))
 265                      == ARES_SUCCESS)
 266                 {
 267                   if (strncasecmp(line, name, len) != 0 ||
 268                       !ISSPACE(line[len]))
 269                     continue;
 270                   p = line + len;
 271                   while (ISSPACE(*p))
 272                     p++;
 273                   if (*p)
 274                     {
 275                       q = p + 1;
 276                       while (*q && !ISSPACE(*q))
 277                         q++;
 278                       *s = ares_malloc(q - p + 1);
 279                       if (*s)
 280                         {
 281                           memcpy(*s, p, q - p);
 282                           (*s)[q - p] = 0;
 283                         }
 284                       ares_free(line);
 285                       fclose(fp);
 286                       return (*s) ? ARES_SUCCESS : ARES_ENOMEM;
 287                     }
 288                 }
 289               ares_free(line);
 290               fclose(fp);
 291               if (status != ARES_SUCCESS && status != ARES_EOF)
 292                 return status;
 293             }
 294           else
 295             {
 296               error = ERRNO;
 297               switch(error)
 298                 {
 299                 case ENOENT:
 300                 case ESRCH:
 301                   break;
 302                 default:
 303                   DEBUGF(fprintf(stderr, "fopen() failed with error: %d %s\n",
 304                                  error, strerror(error)));
 305                   DEBUGF(fprintf(stderr, "Error opening file: %s\n",
 306                                  hostaliases));
 307                   *s = NULL;
 308                   return ARES_EFILE;
 309                 }
 310             }
 311         }
 312     }
 313
 314   if (channel->flags & ARES_FLAG_NOSEARCH || channel->ndomains == 0)
 315     {
 316       /* No domain search to do; just try the name as-is. */
 317       *s = ares_strdup(name);
 318       return (*s) ? ARES_SUCCESS : ARES_ENOMEM;
 319     }
 320
 321   *s = NULL;
 322   return ARES_SUCCESS;
 323 }