ares_query.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_SYS_SOCKET_H
  20 #  include <sys/socket.h>
  21 #endif
  22 #ifdef HAVE_NETINET_IN_H
  23 #  include <netinet/in.h>
  24 #endif
  25 #ifdef HAVE_ARPA_NAMESER_H
  26 #  include <arpa/nameser.h>
  27 #else
  28 #  include "nameser.h"
  29 #endif
  30 #ifdef HAVE_ARPA_NAMESER_COMPAT_H
  31 #  include <arpa/nameser_compat.h>
  32 #endif
  33
  34 #include <stdlib.h>
  35 #include "ares.h"
  36 #include "ares_dns.h"
  37 #include "ares_private.h"
  38
  39 struct qquery {
  40   ares_callback callback;
  41   void *arg;
  42 };
  43
  44 static void qcallback(void *arg, int status, int timeouts, unsigned char *abuf, int alen);
  45
  46 void ares__rc4(rc4_key* key, unsigned char *buffer_ptr, int buffer_len)
  47 {
  48   unsigned char x;
  49   unsigned char y;
  50   unsigned char* state;
  51   unsigned char xorIndex;
  52   short counter;
  53
  54   x = key->x;
  55   y = key->y;
  56
  57   state = &key->state[0];
  58   for(counter = 0; counter < buffer_len; counter ++)
  59   {
  60     x = (unsigned char)((x + 1) % 256);
  61     y = (unsigned char)((state[x] + y) % 256);
  62     ARES_SWAP_BYTE(&state[x], &state[y]);
  63
  64     xorIndex = (unsigned char)((state[x] + state[y]) % 256);
  65
  66     buffer_ptr[counter] = (unsigned char)(buffer_ptr[counter]^state[xorIndex]);
  67   }
  68   key->x = x;
  69   key->y = y;
  70 }
  71
  72 static struct query* find_query_by_id(ares_channel channel, unsigned short id)
  73 {
  74   unsigned short qid;
  75   struct list_node* list_head;
  76   struct list_node* list_node;
  77   DNS_HEADER_SET_QID(((unsigned char*)&qid), id);
  78
  79   /* Find the query corresponding to this packet. */
  80   list_head = &(channel->queries_by_qid[qid % ARES_QID_TABLE_SIZE]);
  81   for (list_node = list_head->next; list_node != list_head;
  82        list_node = list_node->next)
  83     {
  84        struct query *q = list_node->data;
  85        if (q->qid == qid)
  86           return q;
  87     }
  88   return NULL;
  89 }
  90
  91
  92 /* a unique query id is generated using an rc4 key. Since the id may already
  93    be used by a running query (as infrequent as it may be), a lookup is
  94    performed per id generation. In practice this search should happen only
  95    once per newly generated id
  96 */
  97 static unsigned short generate_unique_id(ares_channel channel)
  98 {
  99   unsigned short id;
 100
 101   do {
 102     id = ares__generate_new_id(&channel->id_key);
 103   } while (find_query_by_id(channel, id));
 104
 105   return (unsigned short)id;
 106 }
 107
 108 void ares_query(ares_channel channel, const char *name, int dnsclass,
 109                 int type, ares_callback callback, void *arg)
 110 {
 111   struct qquery *qquery;
 112   unsigned char *qbuf;
 113   int qlen, rd, status;
 114
 115   /* Compose the query. */
 116   rd = !(channel->flags & ARES_FLAG_NORECURSE);
 117   status = ares_mkquery(name, dnsclass, type, channel->next_id, rd, &qbuf,
 118                         &qlen);
 119   if (status != ARES_SUCCESS)
 120     {
 121       if (qbuf != NULL) free(qbuf);
 122       callback(arg, status, 0, NULL, 0);
 123       return;
 124     }
 125
 126   channel->next_id = generate_unique_id(channel);
 127
 128   /* Allocate and fill in the query structure. */
 129   qquery = malloc(sizeof(struct qquery));
 130   if (!qquery)
 131     {
 132       ares_free_string(qbuf);
 133       callback(arg, ARES_ENOMEM, 0, NULL, 0);
 134       return;
 135     }
 136   qquery->callback = callback;
 137   qquery->arg = arg;
 138
 139   /* Send it off.  qcallback will be called when we get an answer. */
 140   ares_send(channel, qbuf, qlen, qcallback, qquery);
 141   ares_free_string(qbuf);
 142 }
 143
 144 static void qcallback(void *arg, int status, int timeouts, unsigned char *abuf, int alen)
 145 {
 146   struct qquery *qquery = (struct qquery *) arg;
 147   unsigned int ancount;
 148   int rcode;
 149
 150   if (status != ARES_SUCCESS)
 151     qquery->callback(qquery->arg, status, timeouts, abuf, alen);
 152   else
 153     {
 154       /* Pull the response code and answer count from the packet. */
 155       rcode = DNS_HEADER_RCODE(abuf);
 156       ancount = DNS_HEADER_ANCOUNT(abuf);
 157
 158       /* Convert errors. */
 159       switch (rcode)
 160         {
 161         case NOERROR:
 162           status = (ancount > 0) ? ARES_SUCCESS : ARES_ENODATA;
 163           break;
 164         case FORMERR:
 165           status = ARES_EFORMERR;
 166           break;
 167         case SERVFAIL:
 168           status = ARES_ESERVFAIL;
 169           break;
 170         case NXDOMAIN:
 171           status = ARES_ENOTFOUND;
 172           break;
 173         case NOTIMP:
 174           status = ARES_ENOTIMP;
 175           break;
 176         case REFUSED:
 177           status = ARES_EREFUSED;
 178           break;
 179         }
 180       qquery->callback(qquery->arg, status, timeouts, abuf, alen);
 181     }
 182   free(qquery);
 183 }