chiark - git - mdw - qmail/blob - dns.c

   1 #include <stdio.h>
   2 #include <netdb.h>
   3 #include <sys/types.h>
   4 #include <netinet/in.h>
   5 #include <arpa/nameser.h>
   6 #include <resolv.h>
   7 #include <errno.h>
   8 extern int res_query();
   9 extern int res_search();
  10 extern int errno;
  11 extern int h_errno;
  12 #include "ip.h"
  13 #include "ipalloc.h"
  14 #include "fmt.h"
  15 #include "alloc.h"
  16 #include "str.h"
  17 #include "stralloc.h"
  18 #include "dns.h"
  19 #include "case.h"
  20
  21 static unsigned short getshort(c) unsigned char *c;
  22 { unsigned short u; u = c[0]; return (u << 8) + c[1]; }
  23
  24 static union { HEADER hdr; unsigned char buf[PACKETSZ]; } response;
  25 static int responselen;
  26 static unsigned char *responseend;
  27 static unsigned char *responsepos;
  28
  29 static int numanswers;
  30 static char name[MAXDNAME];
  31 static struct ip_address ip;
  32 unsigned short pref;
  33
  34 static stralloc glue = {0};
  35
  36 static int (*lookup)() = res_query;
  37
  38 static int resolve(domain,type)
  39 stralloc *domain;
  40 int type;
  41 {
  42  int n;
  43  int i;
  44
  45  errno = 0;
  46  if (!stralloc_copy(&glue,domain)) return DNS_MEM;
  47  if (!stralloc_0(&glue)) return DNS_MEM;
  48  responselen = lookup(glue.s,C_IN,type,response.buf,sizeof(response));
  49  if (responselen <= 0)
  50   {
  51    if (errno == ECONNREFUSED) return DNS_SOFT;
  52    if (h_errno == TRY_AGAIN) return DNS_SOFT;
  53    return DNS_HARD;
  54   }
  55  if (responselen >= sizeof(response))
  56    responselen = sizeof(response);
  57  responseend = response.buf + responselen;
  58  responsepos = response.buf + sizeof(HEADER);
  59  n = ntohs(response.hdr.qdcount);
  60  while (n-- > 0)
  61   {
  62    i = dn_expand(response.buf,responseend,responsepos,name,MAXDNAME);
  63    if (i < 0) return DNS_SOFT;
  64    responsepos += i;
  65    i = responseend - responsepos;
  66    if (i < QFIXEDSZ) return DNS_SOFT;
  67    responsepos += QFIXEDSZ;
  68   }
  69  numanswers = ntohs(response.hdr.ancount);
  70  return 0;
  71 }
  72
  73 static int findname(wanttype)
  74 int wanttype;
  75 {
  76  unsigned short rrtype;
  77  unsigned short rrdlen;
  78  int i;
  79
  80  if (numanswers <= 0) return 2;
  81  --numanswers;
  82  if (responsepos == responseend) return DNS_SOFT;
  83
  84  i = dn_expand(response.buf,responseend,responsepos,name,MAXDNAME);
  85  if (i < 0) return DNS_SOFT;
  86  responsepos += i;
  87
  88  i = responseend - responsepos;
  89  if (i < 4 + 3 * 2) return DNS_SOFT;
  90
  91  rrtype = getshort(responsepos);
  92  rrdlen = getshort(responsepos + 8);
  93  responsepos += 10;
  94
  95  if (rrtype == wanttype)
  96   {
  97    if (dn_expand(response.buf,responseend,responsepos,name,MAXDNAME) < 0)
  98      return DNS_SOFT;
  99    responsepos += rrdlen;
 100    return 1;
 101   }
 102
 103  responsepos += rrdlen;
 104  return 0;
 105 }
 106
 107 static int findip(wanttype)
 108 int wanttype;
 109 {
 110  unsigned short rrtype;
 111  unsigned short rrdlen;
 112  int i;
 113
 114  if (numanswers <= 0) return 2;
 115  --numanswers;
 116  if (responsepos == responseend) return DNS_SOFT;
 117
 118  i = dn_expand(response.buf,responseend,responsepos,name,MAXDNAME);
 119  if (i < 0) return DNS_SOFT;
 120  responsepos += i;
 121
 122  i = responseend - responsepos;
 123  if (i < 4 + 3 * 2) return DNS_SOFT;
 124
 125  rrtype = getshort(responsepos);
 126  rrdlen = getshort(responsepos + 8);
 127  responsepos += 10;
 128
 129  if (rrtype == wanttype)
 130   {
 131    if (rrdlen < 4)
 132      return DNS_SOFT;
 133    ip.d[0] = responsepos[0];
 134    ip.d[1] = responsepos[1];
 135    ip.d[2] = responsepos[2];
 136    ip.d[3] = responsepos[3];
 137    responsepos += rrdlen;
 138    return 1;
 139   }
 140
 141  responsepos += rrdlen;
 142  return 0;
 143 }
 144
 145 static int findmx(wanttype)
 146 int wanttype;
 147 {
 148  unsigned short rrtype;
 149  unsigned short rrdlen;
 150  int i;
 151
 152  if (numanswers <= 0) return 2;
 153  --numanswers;
 154  if (responsepos == responseend) return DNS_SOFT;
 155
 156  i = dn_expand(response.buf,responseend,responsepos,name,MAXDNAME);
 157  if (i < 0) return DNS_SOFT;
 158  responsepos += i;
 159
 160  i = responseend - responsepos;
 161  if (i < 4 + 3 * 2) return DNS_SOFT;
 162
 163  rrtype = getshort(responsepos);
 164  rrdlen = getshort(responsepos + 8);
 165  responsepos += 10;
 166
 167  if (rrtype == wanttype)
 168   {
 169    if (rrdlen < 3)
 170      return DNS_SOFT;
 171    pref = (responsepos[0] << 8) + responsepos[1];
 172    if (dn_expand(response.buf,responseend,responsepos + 2,name,MAXDNAME) < 0)
 173      return DNS_SOFT;
 174    responsepos += rrdlen;
 175    return 1;
 176   }
 177
 178  responsepos += rrdlen;
 179  return 0;
 180 }
 181
 182 void dns_init(flagsearch)
 183 int flagsearch;
 184 {
 185  res_init();
 186  if (flagsearch) lookup = res_search;
 187 }
 188
 189 int dns_cname(sa)
 190 stralloc *sa;
 191 {
 192  int r;
 193  int loop;
 194  for (loop = 0;loop < 10;++loop)
 195   {
 196    if (!sa->len) return loop;
 197    if (sa->s[sa->len - 1] == ']') return loop;
 198    if (sa->s[sa->len - 1] == '.') { --sa->len; continue; }
 199    switch(resolve(sa,T_ANY))
 200     {
 201      case DNS_MEM: return DNS_MEM;
 202      case DNS_SOFT: return DNS_SOFT;
 203      case DNS_HARD: return loop;
 204      default:
 205        while ((r = findname(T_CNAME)) != 2)
 206         {
 207          if (r == DNS_SOFT) return DNS_SOFT;
 208          if (r == 1)
 209           {
 210            if (!stralloc_copys(sa,name)) return DNS_MEM;
 211            break;
 212           }
 213         }
 214        if (r == 2) return loop;
 215     }
 216   }
 217  return DNS_HARD; /* alias loop */
 218 }
 219
 220 #define FMT_IAA 40
 221
 222 static int iaafmt(s,ip)
 223 char *s;
 224 struct ip_address *ip;
 225 {
 226  unsigned int i;
 227  unsigned int len;
 228  len = 0;
 229  i = fmt_ulong(s,(unsigned long) ip->d[3]); len += i; if (s) s += i;
 230  i = fmt_str(s,"."); len += i; if (s) s += i;
 231  i = fmt_ulong(s,(unsigned long) ip->d[2]); len += i; if (s) s += i;
 232  i = fmt_str(s,"."); len += i; if (s) s += i;
 233  i = fmt_ulong(s,(unsigned long) ip->d[1]); len += i; if (s) s += i;
 234  i = fmt_str(s,"."); len += i; if (s) s += i;
 235  i = fmt_ulong(s,(unsigned long) ip->d[0]); len += i; if (s) s += i;
 236  i = fmt_str(s,".in-addr.arpa."); len += i; if (s) s += i;
 237  return len;
 238 }
 239
 240 int dns_ptr(sa,ip)
 241 stralloc *sa;
 242 struct ip_address *ip;
 243 {
 244  int r;
 245
 246  if (!stralloc_ready(sa,iaafmt((char *) 0,ip))) return DNS_MEM;
 247  sa->len = iaafmt(sa->s,ip);
 248  switch(resolve(sa,T_PTR))
 249   {
 250    case DNS_MEM: return DNS_MEM;
 251    case DNS_SOFT: return DNS_SOFT;
 252    case DNS_HARD: return DNS_HARD;
 253   }
 254  while ((r = findname(T_PTR)) != 2)
 255   {
 256    if (r == DNS_SOFT) return DNS_SOFT;
 257    if (r == 1)
 258     {
 259      if (!stralloc_copys(sa,name)) return DNS_MEM;
 260      return 0;
 261     }
 262   }
 263  return DNS_HARD;
 264 }
 265
 266 static int dns_ipplus(ia,sa,pref)
 267 ipalloc *ia;
 268 stralloc *sa;
 269 int pref;
 270 {
 271  int r;
 272  struct ip_mx ix;
 273
 274  if (!stralloc_copy(&glue,sa)) return DNS_MEM;
 275  if (!stralloc_0(&glue)) return DNS_MEM;
 276  if (glue.s[0]) {
 277    ix.pref = 0;
 278    if (!glue.s[ip_scan(glue.s,&ix.ip)] || !glue.s[ip_scanbracket(glue.s,&ix.ip)])
 279     {
 280      if (!ipalloc_append(ia,&ix)) return DNS_MEM;
 281      return 0;
 282     }
 283  }
 284
 285  switch(resolve(sa,T_A))
 286   {
 287    case DNS_MEM: return DNS_MEM;
 288    case DNS_SOFT: return DNS_SOFT;
 289    case DNS_HARD: return DNS_HARD;
 290   }
 291  while ((r = findip(T_A)) != 2)
 292   {
 293    ix.ip = ip;
 294    ix.pref = pref;
 295    if (r == DNS_SOFT) return DNS_SOFT;
 296    if (r == 1)
 297      if (!ipalloc_append(ia,&ix)) return DNS_MEM;
 298   }
 299  return 0;
 300 }
 301
 302 int dns_ip(ia,sa)
 303 ipalloc *ia;
 304 stralloc *sa;
 305 {
 306  if (!ipalloc_readyplus(ia,0)) return DNS_MEM;
 307  ia->len = 0;
 308  return dns_ipplus(ia,sa,0);
 309 }
 310
 311 int dns_mxip(ia,sa,random)
 312 ipalloc *ia;
 313 stralloc *sa;
 314 unsigned long random;
 315 {
 316  int r;
 317  struct mx { stralloc sa; unsigned short p; } *mx;
 318  struct ip_mx ix;
 319  int nummx;
 320  int i;
 321  int j;
 322  int flagsoft;
 323
 324  if (!ipalloc_readyplus(ia,0)) return DNS_MEM;
 325  ia->len = 0;
 326
 327  if (!stralloc_copy(&glue,sa)) return DNS_MEM;
 328  if (!stralloc_0(&glue)) return DNS_MEM;
 329  if (glue.s[0]) {
 330    ix.pref = 0;
 331    if (!glue.s[ip_scan(glue.s,&ix.ip)] || !glue.s[ip_scanbracket(glue.s,&ix.ip)])
 332     {
 333      if (!ipalloc_append(ia,&ix)) return DNS_MEM;
 334      return 0;
 335     }
 336  }
 337
 338  switch(resolve(sa,T_MX))
 339   {
 340    case DNS_MEM: return DNS_MEM;
 341    case DNS_SOFT: return DNS_SOFT;
 342    case DNS_HARD: return dns_ip(ia,sa);
 343   }
 344
 345  mx = (struct mx *) alloc(numanswers * sizeof(struct mx));
 346  if (!mx) return DNS_MEM;
 347  nummx = 0;
 348
 349  while ((r = findmx(T_MX)) != 2)
 350   {
 351    if (r == DNS_SOFT) { alloc_free(mx); return DNS_SOFT; }
 352    if (r == 1)
 353     {
 354      mx[nummx].p = pref;
 355      mx[nummx].sa.s = 0;
 356      if (!stralloc_copys(&mx[nummx].sa,name))
 357       {
 358        while (nummx > 0) alloc_free(mx[--nummx].sa.s);
 359        alloc_free(mx); return DNS_MEM;
 360       }
 361      ++nummx;
 362     }
 363   }
 364
 365  if (!nummx) return dns_ip(ia,sa); /* e.g., CNAME -> A */
 366
 367  flagsoft = 0;
 368  while (nummx > 0)
 369   {
 370    unsigned long numsame;
 371
 372    i = 0;
 373    numsame = 1;
 374    for (j = 1;j < nummx;++j)
 375      if (mx[j].p < mx[i].p)
 376       {
 377        i = j;
 378        numsame = 1;
 379       }
 380      else if (mx[j].p == mx[i].p)
 381       {
 382        ++numsame;
 383        random = random * 69069 + 1;
 384        if ((random / 2) < (2147483647 / numsame))
 385          i = j;
 386       }
 387
 388    switch(dns_ipplus(ia,&mx[i].sa,mx[i].p))
 389     {
 390      case DNS_MEM: case DNS_SOFT:
 391        flagsoft = 1; break;
 392     }
 393
 394    alloc_free(mx[i].sa.s);
 395    mx[i] = mx[--nummx];
 396   }
 397
 398  alloc_free(mx);
 399  return flagsoft;
 400 }