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
39struct qquery {
40  ares_callback callback;
41  void *arg;
42};
43
44static void qcallback(void *arg, int status, int timeouts, unsigned char *abuf, int alen);
45
46void 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
72static 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*/
97static 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
108void 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
144static 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}
184