text: 
  /* Copyright 1998 by the Massachusetts Institute of Technology.
   *
   * Permission to use, copy, modify, and distribute this
   * software and its documentation for any purpose and without
   * fee is hereby granted, provided that the above copyright
   * notice appear in all copies and that both that copyright
   * notice and this permission notice appear in supporting
   * documentation, and that the name of M.I.T. not be used in
   * advertising or publicity pertaining to distribution of the
   * software without specific, written prior permission.
   * M.I.T. makes no representations about the suitability of
   * this software for any purpose.  It is provided "as is"
   * without express or implied warranty.
   */
  
  #include "hns_setup.h"
  
  #ifdef HAVE_STRINGS_H
  #  include <strings.h>
  #endif
  
  #include "hns.h"
  #include "hns_private.h"
  
  struct search_query {
    /* Arguments passed to hns_search */
    hns_channel channel;
    char *name;                   /* copied into an allocated buffer */
    int dnsclass;
    int type;
    hns_callback callback;
    void *arg;
  
    int status_as_is;             /* error status from trying as-is */
    int next_domain;              /* next search domain to try */
    int trying_as_is;             /* current query is for name as-is */
    int timeouts;                 /* number of timeouts we saw for this request */
    int ever_got_nodata;          /* did we ever get HNS_ENODATA along the way? */
  };
  
  static void search_callback(void *arg, int status, int timeouts,
                              unsigned char *abuf, int alen);
  static void end_squery(struct search_query *squery, int status,
                         unsigned char *abuf, int alen);
  static int cat_domain(const char *name, const char *domain, char **s);
  STATIC_TESTABLE int single_domain(hns_channel channel, const char *name, char **s);
  
  void hns_search(hns_channel channel, const char *name, int dnsclass,
                   int type, hns_callback callback, void *arg)
  {
    struct search_query *squery;
    char *s;
    const char *p;
    int status, ndots;
  
    /* If name only yields one domain to search, then we don't have
     * to keep extra state, so just do an hns_query().
     */
    status = single_domain(channel, name, &s);
    if (status != HNS_SUCCESS)
      {
        callback(arg, status, 0, NULL, 0);
        return;
      }
    if (s)
      {
        hns_query(channel, s, dnsclass, type, callback, arg);
        hns_free(s);
        return;
      }
  
    /* Allocate a search_query structure to hold the state necessary for
     * doing multiple lookups.
     */
    squery = hns_malloc(sizeof(struct search_query));
    if (!squery)
      {
        callback(arg, HNS_ENOMEM, 0, NULL, 0);
        return;
      }
    squery->channel = channel;
    squery->name = hns_strdup(name);
    if (!squery->name)
      {
        hns_free(squery);
        callback(arg, HNS_ENOMEM, 0, NULL, 0);
        return;
      }
    squery->dnsclass = dnsclass;
    squery->type = type;
    squery->status_as_is = -1;
    squery->callback = callback;
    squery->arg = arg;
    squery->timeouts = 0;
    squery->ever_got_nodata = 0;
  
    /* Count the number of dots in name. */
    ndots = 0;
    for (p = name; *p; p++)
      {
        if (*p == '.')
          ndots++;
      }
  
    /* If ndots is at least the channel ndots threshold (usually 1),
     * then we try the name as-is first.  Otherwise, we try the name
     * as-is last.
     */
    if (ndots >= channel->ndots)
      {
        /* Try the name as-is first. */
        squery->next_domain = 0;
        squery->trying_as_is = 1;
        hns_query(channel, name, dnsclass, type, search_callback, squery);
      }
    else
      {
        /* Try the name as-is last; start with the first search domain. */
        squery->next_domain = 1;
        squery->trying_as_is = 0;
        status = cat_domain(name, channel->domains[0], &s);
        if (status == HNS_SUCCESS)
          {
            hns_query(channel, s, dnsclass, type, search_callback, squery);
            hns_free(s);
          }
        else
        {
          /* failed, free the malloc()ed memory */
          hns_free(squery->name);
          hns_free(squery);
          callback(arg, status, 0, NULL, 0);
        }
      }
  }
  
  static void search_callback(void *arg, int status, int timeouts,
                              unsigned char *abuf, int alen)
  {
    struct search_query *squery = (struct search_query *) arg;
    hns_channel channel = squery->channel;
    char *s;
  
    squery->timeouts += timeouts;
  
    /* Stop searching unless we got a non-fatal error. */
    if (status != HNS_ENODATA && status != HNS_ESERVFAIL
        && status != HNS_ENOTFOUND)
      end_squery(squery, status, abuf, alen);
    else
      {
        /* Save the status if we were trying as-is. */
        if (squery->trying_as_is)
          squery->status_as_is = status;
  
        /*
         * If we ever get HNS_ENODATA along the way, record that; if the search
         * should run to the very end and we got at least one HNS_ENODATA,
         * then callers like hns_gethostbyname() may want to try a T_A search
         * even if the last domain we queried for T_AAAA resource records
         * returned HNS_ENOTFOUND.
         */
        if (status == HNS_ENODATA)
          squery->ever_got_nodata = 1;
  
        if (squery->next_domain < channel->ndomains)
          {
            /* Try the next domain. */
            status = cat_domain(squery->name,
                                channel->domains[squery->next_domain], &s);
            if (status != HNS_SUCCESS)
              end_squery(squery, status, NULL, 0);
            else
              {
                squery->trying_as_is = 0;
                squery->next_domain++;
                hns_query(channel, s, squery->dnsclass, squery->type,
                           search_callback, squery);
                hns_free(s);
              }
          }
        else if (squery->status_as_is == -1)
          {
            /* Try the name as-is at the end. */
            squery->trying_as_is = 1;
            hns_query(channel, squery->name, squery->dnsclass, squery->type,
                       search_callback, squery);
          }
        else {
          if (squery->status_as_is == HNS_ENOTFOUND && squery->ever_got_nodata) {
            end_squery(squery, HNS_ENODATA, NULL, 0);
          }
          else
            end_squery(squery, squery->status_as_is, NULL, 0);
        }
      }
  }
  
  static void end_squery(struct search_query *squery, int status,
                         unsigned char *abuf, int alen)
  {
    squery->callback(squery->arg, status, squery->timeouts, abuf, alen);
    hns_free(squery->name);
    hns_free(squery);
  }
  
  /* Concatenate two domains. */
  static int cat_domain(const char *name, const char *domain, char **s)
  {
    size_t nlen = strlen(name);
    size_t dlen = strlen(domain);
  
    *s = hns_malloc(nlen + 1 + dlen + 1);
    if (!*s)
      return HNS_ENOMEM;
    memcpy(*s, name, nlen);
    (*s)[nlen] = '.';
    memcpy(*s + nlen + 1, domain, dlen);
    (*s)[nlen + 1 + dlen] = 0;
    return HNS_SUCCESS;
  }
  
  /* Determine if this name only yields one query.  If it does, set *s to
   * the string we should query, in an allocated buffer.  If not, set *s
   * to NULL.
   */
  STATIC_TESTABLE int single_domain(hns_channel channel, const char *name, char **s)
  {
    size_t len = strlen(name);
    const char *hostaliases;
    FILE *fp;
    char *line = NULL;
    int status;
    size_t linesize;
    const char *p, *q;
    int error;
  
    /* If the name contains a trailing dot, then the single query is the name
     * sans the trailing dot.
     */
    if ((len > 0) && (name[len - 1] == '.'))
      {
        *s = hns_strdup(name);
        return (*s) ? HNS_SUCCESS : HNS_ENOMEM;
      }
  
    if (!(channel->flags & HNS_FLAG_NOALIASES) && !strchr(name, '.'))
      {
        /* The name might be a host alias. */
        hostaliases = getenv("HOSTALIASES");
        if (hostaliases)
          {
            fp = fopen(hostaliases, "r");
            if (fp)
              {
                while ((status = hns__read_line(fp, &line, &linesize))
                       == HNS_SUCCESS)
                  {
                    if (strncasecmp(line, name, len) != 0 ||
                        !ISSPACE(line[len]))
                      continue;
                    p = line + len;
                    while (ISSPACE(*p))
                      p++;
                    if (*p)
                      {
                        q = p + 1;
                        while (*q && !ISSPACE(*q))
                          q++;
                        *s = hns_malloc(q - p + 1);
                        if (*s)
                          {
                            memcpy(*s, p, q - p);
                            (*s)[q - p] = 0;
                          }
                        hns_free(line);
                        fclose(fp);
                        return (*s) ? HNS_SUCCESS : HNS_ENOMEM;
                      }
                  }
                hns_free(line);
                fclose(fp);
                if (status != HNS_SUCCESS && status != HNS_EOF)
                  return status;
              }
            else
              {
                error = ERRNO;
                switch(error)
                  {
                  case ENOENT:
                  case ESRCH:
                    break;
                  default:
                    DEBUGF(fprintf(stderr, "fopen() failed with error: %d %s\n",
                                   error, strerror(error)));
                    DEBUGF(fprintf(stderr, "Error opening file: %s\n",
                                   hostaliases));
                    *s = NULL;
                    return HNS_EFILE;
                  }
              }
          }
      }
  
    if (channel->flags & HNS_FLAG_NOSEARCH || channel->ndomains == 0)
      {
        /* No domain search to do; just try the name as-is. */
        *s = hns_strdup(name);
        return (*s) ? HNS_SUCCESS : HNS_ENOMEM;
      }
  
    *s = NULL;
    return HNS_SUCCESS;
  }
  