src/types.c

   1 /*
   2  * types.c
   3  * - RR-type-specific code, and the machinery to call it
   4  */
   5 /*
   6  *  This file is part of adns, which is Copyright (C) 1997, 1998 Ian Jackson
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2, or (at your option)
  11  *  any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software Foundation,
  20  *  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  21  */
  22
  23 #include <stdlib.h>
  24 #include <string.h>
  25
  26 #include <arpa/inet.h>
  27
  28 #include "internal.h"
  29
  30 #define R_NOMEM           return adns_s_nolocalmem
  31 #define CSP_ADDSTR(s)     if (!adns__vbuf_appendstr(vb,(s))) R_NOMEM; else;
  32
  33 static int dip_inaddr(struct in_addr a, struct in_addr b) {
  34   /* fixme implement sortlist */
  35   return 0;
  36 }
  37
  38 static adns_status pa_inaddr(const parseinfo *pai, int cbyte, int max, void *datap) {
  39   struct in_addr *storeto= datap;
  40
  41   if (max-cbyte != 4) return adns_s_invaliddata;
  42   memcpy(storeto, pai->dgram + cbyte, 4);
  43   return adns_s_ok;
  44 }
  45
  46 static int di_inaddr(const void *datap_a, const void *datap_b) {
  47   const struct in_addr *ap= datap_a, *bp= datap_b;
  48
  49   return dip_inaddr(*ap,*bp);
  50 }
  51
  52 static adns_status cs_inaddr(vbuf *vb, const void *datap) {
  53   const struct in_addr *rrp= datap, rr= *rrp;
  54   const char *ia;
  55
  56   ia= inet_ntoa(rr); assert(ia);
  57   CSP_ADDSTR(ia);
  58   return adns_s_ok;
  59 }
  60
  61 static adns_status pa_addr(const parseinfo *pai, int cbyte, int max, void *datap) {
  62   adns_addr *storeto= datap;
  63   const byte *dgram= pai->dgram;
  64
  65   if (max-cbyte != 4) return adns_s_invaliddata;
  66   storeto->len= sizeof(storeto->addr.inet);
  67   memset(&storeto->addr,0,sizeof(storeto->addr.inet));
  68   storeto->addr.inet.sin_family= AF_INET;
  69   storeto->addr.inet.sin_port= 0;
  70   memcpy(&storeto->addr.inet.sin_addr,dgram+cbyte,4);
  71   return adns_s_ok;
  72 }
  73
  74 static int di_addr(const void *datap_a, const void *datap_b) {
  75   const adns_addr *ap= datap_a, *bp= datap_b;
  76
  77   assert(ap->addr.sa.sa_family == AF_INET);
  78   return dip_inaddr(ap->addr.inet.sin_addr,bp->addr.inet.sin_addr);
  79 }
  80
  81 static adns_status csp_addr(vbuf *vb, const adns_addr *rrp) {
  82   const char *ia;
  83   static char buf[30];
  84
  85   switch (rrp->addr.inet.sin_family) {
  86   case AF_INET:
  87     CSP_ADDSTR("AF_INET ");
  88     ia= inet_ntoa(rrp->addr.inet.sin_addr); assert(ia);
  89     CSP_ADDSTR(ia);
  90     break;
  91   default:
  92     sprintf(buf,"AF=%u",rrp->addr.sa.sa_family);
  93     CSP_ADDSTR(buf);
  94     break;
  95   }
  96   return adns_s_ok;
  97 }
  98
  99 static adns_status cs_addr(vbuf *vb, const void *datap) {
 100   const adns_addr *rrp= datap;
 101
 102   return csp_addr(vb,rrp);
 103 }
 104
 105 static adns_status pap_domain(const parseinfo *pai, int *cbyte_io, int max,
 106                               char **domain_r, parsedomain_flags flags) {
 107   adns_status st;
 108   char *dm;
 109
 110   st= adns__parse_domain(pai->qu->ads, pai->serv, pai->qu, &pai->qu->vb, flags,
 111                          pai->dgram,pai->dglen, cbyte_io, max);
 112   if (st) return st;
 113   if (!pai->qu->vb.used) return adns_s_invaliddata;
 114
 115   dm= adns__alloc_interim(pai->qu, pai->qu->vb.used+1);
 116   if (!dm) R_NOMEM;
 117
 118   dm[pai->qu->vb.used]= 0;
 119   memcpy(dm,pai->qu->vb.buf,pai->qu->vb.used);
 120
 121   *domain_r= dm;
 122   return adns_s_ok;
 123 }
 124
 125 static adns_status pa_host_raw(const parseinfo *pai, int cbyte, int max, void *datap) {
 126   char **rrp= datap;
 127   adns_status st;
 128
 129   st= pap_domain(pai, &cbyte, max, rrp,
 130                  pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
 131   if (st) return st;
 132
 133   if (cbyte != max) return adns_s_invaliddata;
 134   return adns_s_ok;
 135 }
 136
 137 static adns_status pa_mx_raw(const parseinfo *pai, int cbyte, int max, void *datap) {
 138   const byte *dgram= pai->dgram;
 139   adns_rr_intstr *rrp= datap;
 140   adns_status st;
 141   int pref;
 142
 143   if (cbyte+2 > max) return adns_s_invaliddata;
 144   GET_W(cbyte,pref);
 145   rrp->i= pref;
 146   st= pap_domain(pai, &cbyte, max, &rrp->str,
 147                  pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
 148   if (st) return st;
 149
 150   if (cbyte != max) return adns_s_invaliddata;
 151   return adns_s_ok;
 152 }
 153
 154
 155 static adns_status pap_findaddrs(const parseinfo *pai, adns_rr_hostaddr *ha,
 156                                  int *cbyte_io, int count, int dmstart) {
 157   int rri, naddrs;
 158   int type, class, rdlen, rdstart, ownermatched;
 159   adns_status st;
 160
 161   for (rri=0, naddrs=-1; rri<count; rri++) {
 162     st= adns__findrr_anychk(pai->qu, pai->serv, pai->dgram, pai->dglen, cbyte_io,
 163                             &type, &class, &rdlen, &rdstart,
 164                             pai->dgram, pai->dglen, dmstart, &ownermatched);
 165     if (st) return st;
 166     if (!ownermatched || class != DNS_CLASS_IN || type != adns_r_a) {
 167       if (naddrs>0) break; else continue;
 168     }
 169     if (naddrs == -1) {
 170       naddrs= 0;
 171     }
 172     if (!adns__vbuf_ensure(&pai->qu->vb, (naddrs+1)*sizeof(adns_addr))) R_NOMEM;
 173     st= pa_addr(pai, rdstart,rdstart+rdlen, pai->qu->vb.buf + naddrs*sizeof(adns_addr));
 174     if (st) return st;
 175     naddrs++;
 176   }
 177   if (naddrs >= 0) {
 178     ha->addrs= adns__alloc_interim(pai->qu, naddrs*sizeof(adns_addr));
 179     if (!ha->addrs) R_NOMEM;
 180     memcpy(ha->addrs, pai->qu->vb.buf, naddrs*sizeof(adns_addr));
 181     ha->naddrs= naddrs;
 182     ha->astatus= adns_s_ok;
 183
 184     adns__isort(ha->addrs, naddrs, sizeof(adns_addr), pai->qu->vb.buf, di_addr);
 185   }
 186   return adns_s_ok;
 187 }
 188
 189 static adns_status pap_hostaddr(const parseinfo *pai, int *cbyte_io,
 190                                 int max, adns_rr_hostaddr *rrp) {
 191   adns_status st;
 192   int dmstart, cbyte;
 193
 194   dmstart= cbyte= *cbyte_io;
 195   st= pap_domain(pai, &cbyte, max, &rrp->host,
 196                  pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
 197   if (st) return st;
 198   *cbyte_io= cbyte;
 199
 200   rrp->astatus= adns_s_ok;
 201   rrp->naddrs= -1;
 202   rrp->addrs= 0;
 203
 204   cbyte= pai->nsstart;
 205
 206   st= pap_findaddrs(pai, rrp, &cbyte, pai->nscount, dmstart);
 207   if (st) return st;
 208   if (rrp->naddrs != -1) return adns_s_ok;
 209
 210   st= pap_findaddrs(pai, rrp, &cbyte, pai->arcount, dmstart);
 211   if (st) return st;
 212   if (rrp->naddrs != -1) return adns_s_ok;
 213
 214   rrp->naddrs= 0; /* fixme additional section didn't have required data */
 215   rrp->astatus= adns_s_notimplemented;
 216
 217   return adns_s_ok;
 218 }
 219
 220 static adns_status pa_hostaddr(const parseinfo *pai, int cbyte, int max, void *datap) {
 221   adns_rr_hostaddr *rrp= datap;
 222   adns_status st;
 223
 224   st= pap_hostaddr(pai, &cbyte, max, rrp);
 225   if (st) return st;
 226   if (cbyte != max) return adns_s_invaliddata;
 227
 228   return adns_s_ok;
 229 }
 230
 231 static adns_status pa_mx(const parseinfo *pai, int cbyte, int max, void *datap) {
 232   const byte *dgram= pai->dgram;
 233   adns_rr_inthostaddr *rrp= datap;
 234   adns_status st;
 235   int pref;
 236
 237   if (cbyte+2 > max) return adns_s_invaliddata;
 238   GET_W(cbyte,pref);
 239   rrp->i= pref;
 240   st= pap_hostaddr(pai, &cbyte, max, &rrp->ha);
 241   if (st) return st;
 242
 243   if (cbyte != max) return adns_s_invaliddata;
 244   return adns_s_ok;
 245 }
 246
 247 static int dip_hostaddr(const adns_rr_hostaddr *ap, const adns_rr_hostaddr *bp) {
 248   if (ap->astatus != bp->astatus) return ap->astatus;
 249   if (ap->astatus) return 0;
 250
 251   assert(ap->addrs[0].addr.sa.sa_family == AF_INET);
 252   assert(bp->addrs[0].addr.sa.sa_family == AF_INET);
 253   return dip_inaddr(ap->addrs[0].addr.inet.sin_addr, bp->addrs[0].addr.inet.sin_addr);
 254 }
 255
 256 static int di_hostaddr(const void *datap_a, const void *datap_b) {
 257   const adns_rr_hostaddr *ap= datap_a, *bp= datap_b;
 258
 259   return dip_hostaddr(ap,bp);
 260 }
 261
 262 static int di_mx_raw(const void *datap_a, const void *datap_b) {
 263   const adns_rr_intstr *ap= datap_a, *bp= datap_b;
 264
 265   if (ap->i < bp->i) return 0;
 266   if (ap->i > bp->i) return 1;
 267   return 0;
 268 }
 269
 270 static int di_mx(const void *datap_a, const void *datap_b) {
 271   const adns_rr_inthostaddr *ap= datap_a, *bp= datap_b;
 272
 273   if (ap->i < bp->i) return 0;
 274   if (ap->i > bp->i) return 1;
 275   return dip_hostaddr(&ap->ha,&bp->ha);
 276 }
 277
 278 static adns_status pa_txt(const parseinfo *pai, int cbyte, int max, void *datap) {
 279   adns_rr_intstr **rrp= datap, *table, *te;
 280   const byte *dgram= pai->dgram;
 281   int ti, tc, l, startbyte;
 282
 283   startbyte= cbyte;
 284   if (cbyte >= max) return adns_s_invaliddata;
 285   tc= 0;
 286   while (cbyte < max) {
 287     GET_B(cbyte,l);
 288     cbyte+= l;
 289   }
 290   if (cbyte != max) return adns_s_invaliddata;
 291
 292   table= adns__alloc_interim(pai->qu,sizeof(*table)*(tc+1));
 293   if (!table) R_NOMEM;
 294
 295   for (cbyte=startbyte, ti=0, te=table; ti<tc; ti++, te++) {
 296     GET_B(cbyte,l);
 297     te->str= adns__alloc_interim(pai->qu, l+1);
 298     if (!te->str) R_NOMEM;
 299     te->str[l]= 0;
 300     memcpy(te->str,dgram+cbyte,l);
 301     te->i= l;
 302   }
 303   assert(cbyte == max);
 304
 305   te->i= -1;
 306   te->str= 0;
 307
 308   *rrp= table;
 309   return adns_s_ok;
 310 }
 311
 312 static adns_status csp_textdata(vbuf *vb, const char *dp, int len) {
 313   unsigned char ch;
 314   char buf[10];
 315   int cn;
 316
 317   CSP_ADDSTR("\"");
 318   for (cn=0; cn<len; cn++) {
 319     ch= *dp++;
 320     if (ch >= 32 && ch <= 126 && ch != '"' && ch != '\\') {
 321       if (!adns__vbuf_append(vb,&ch,1)) R_NOMEM;
 322     } else {
 323       sprintf(buf,"\\%02x",ch);
 324       CSP_ADDSTR(buf);
 325     }
 326   }
 327   CSP_ADDSTR("\"");
 328
 329   return adns_s_ok;
 330 }
 331
 332 static adns_status csp_qstring(vbuf *vb, const char *dp) {
 333   return csp_textdata(vb, dp, strlen(dp));
 334 }
 335
 336 static adns_status cs_str(vbuf *vb, const void *datap) {
 337   const char *const *rrp= datap;
 338
 339   return csp_qstring(vb,*rrp);
 340 }
 341
 342 static adns_status cs_intstr(vbuf *vb, const void *datap) {
 343   const adns_rr_intstr *rrp= datap;
 344   char buf[10];
 345
 346   sprintf(buf,"%u ",rrp->i);
 347   CSP_ADDSTR(buf);
 348   return csp_qstring(vb,rrp->str);
 349 }
 350
 351 static adns_status cs_manyistr(vbuf *vb, const void *datap) {
 352   const adns_rr_intstr *const *rrp= datap;
 353   const adns_rr_intstr *current;
 354   adns_status st;
 355   int spc;
 356
 357   for (spc=0, current= *rrp; current->i >= 0; current++) {
 358     if (spc) CSP_ADDSTR(" ");
 359     st= csp_textdata(vb,current->str,current->i); if (st) return st;
 360   }
 361   return adns_s_ok;
 362 }
 363
 364 static void mf_str(adns_query qu, void *datap) {
 365   char **rrp= datap;
 366
 367   adns__makefinal_str(qu,rrp);
 368 }
 369
 370 static void mf_intstr(adns_query qu, void *datap) {
 371   adns_rr_intstr *rrp= datap;
 372
 373   adns__makefinal_str(qu,&rrp->str);
 374 }
 375
 376 static adns_status csp_hostaddr(vbuf *vb, const adns_rr_hostaddr *rrp) {
 377   const char *to_add;
 378   adns_status st;
 379   int i;
 380
 381   st= csp_qstring(vb,rrp->host); if (st) return st;
 382
 383   if (rrp->astatus) {
 384     CSP_ADDSTR(" - ");
 385     CSP_ADDSTR(adns_strerror(rrp->astatus));
 386   } else {
 387     assert(rrp->naddrs > 0);
 388     for (i=0, to_add= ": "; i<rrp->naddrs; i++, to_add= ", ") {
 389       CSP_ADDSTR(to_add);
 390       st= csp_addr(vb,&rrp->addrs[i]);
 391     }
 392   }
 393   return adns_s_ok;
 394 }
 395
 396 static adns_status cs_hostaddr(vbuf *vb, const void *datap) {
 397   const adns_rr_hostaddr *rrp= datap;
 398
 399   return csp_hostaddr(vb,rrp);
 400 }
 401
 402 static adns_status cs_inthostaddr(vbuf *vb, const void *datap) {
 403   const adns_rr_inthostaddr *rrp= datap;
 404   char buf[10];
 405
 406   sprintf(buf,"%u ",rrp->i);
 407   CSP_ADDSTR(buf);
 408
 409   return csp_hostaddr(vb,&rrp->ha);
 410 }
 411
 412 static void mfp_hostaddr(adns_query qu, adns_rr_hostaddr *rrp) {
 413   void *tablev;
 414
 415   adns__makefinal_str(qu,&rrp->host);
 416   tablev= rrp->addrs;
 417   adns__makefinal_block(qu, &tablev, rrp->naddrs*sizeof(*rrp->addrs));
 418   rrp->addrs= tablev;
 419 }
 420
 421 static void mf_hostaddr(adns_query qu, void *datap) {
 422   adns_rr_hostaddr *rrp= datap;
 423
 424   mfp_hostaddr(qu,rrp);
 425 }
 426
 427 static void mf_inthostaddr(adns_query qu, void *datap) {
 428   adns_rr_inthostaddr *rrp= datap;
 429
 430   mfp_hostaddr(qu,&rrp->ha);
 431 }
 432
 433 static void mf_manyistr(adns_query qu, void *datap) {
 434   adns_rr_intstr **rrp= datap;
 435   adns_rr_intstr *te, *table;
 436   void *tablev;
 437   int tc;
 438
 439   for (tc=0, te= *rrp; te->i >= 0; te++, tc++);
 440   tablev= *rrp;
 441   adns__makefinal_block(qu,&tablev,sizeof(*te)*(tc+1));
 442   *rrp= table= tablev;
 443   for (te= *rrp; te->i >= 0; te++)
 444     adns__makefinal_str(qu,&te->str);
 445 }
 446
 447 static void mf_flat(adns_query qu, void *data) { }
 448
 449 #define TYPE_SF(size,func,cp,free) size, pa_##func, mf_##free, cs_##cp
 450 #define TYPE_SN(size,func,cp)      size, pa_##func, mf_flat, cs_##cp
 451 #define TYPESZ_M(member)           (sizeof(*((adns_answer*)0)->rrs.member))
 452 #define TYPE_MF(memb,parse)        TYPE_SF(TYPESZ_M(memb),parse,memb,memb)
 453 #define TYPE_MN(memb,parse)        TYPE_SN(TYPESZ_M(memb),parse,memb)
 454
 455 #define DEEP_MEMB(memb) TYPESZ_M(memb), mf_##memb, cs_##memb
 456 #define FLAT_MEMB(memb) TYPESZ_M(memb), mf_flat, cs_##memb
 457
 458 /* TYPE_<ms><nf>
 459  *  ms is M  specify member name
 460  *     or S  specify size explicitly
 461  *  nf is F  full memory management, dependent on member name or specified func
 462  *        N  no memory management required
 463  */
 464
 465 static const typeinfo typeinfos[] = {
 466   /* Must be in ascending order of rrtype ! */
 467   /* rr type code   rrt     fmt      mem.mgmt  member        parser         comparer */
 468
 469   { adns_r_a,       "A",     0,      FLAT_MEMB(inaddr),      pa_inaddr,    di_inaddr   },
 470   { adns_r_ns_raw,  "NS",   "raw",   DEEP_MEMB(str),         pa_host_raw,  0           },
 471   { adns_r_cname,   "CNAME", 0,      DEEP_MEMB(str),         pa_host_raw,  0           },
 472 #if 0 /*fixme*/
 473   { adns_r_soa_raw, "SOA",  "raw",   DEEP_MEMB(soa),         pa_soa,       0           },
 474 #endif
 475   { adns_r_ptr_raw, "PTR",  "raw",   DEEP_MEMB(str),         pa_host_raw,  0           },
 476 #if 0 /*fixme*/
 477   { adns_r_hinfo,   "HINFO", 0,      DEEP_MEMB(strpair),     pa_hinfo,     0           },
 478 #endif
 479   { adns_r_mx_raw,  "MX",   "raw",   DEEP_MEMB(intstr),      pa_mx_raw,    di_mx_raw   },
 480   { adns_r_txt,     "TXT",   0,      DEEP_MEMB(manyistr),    pa_txt,       0           },
 481 #if 0 /*fixme*/
 482   { adns_r_rp_raw,  "RP",   "raw",   DEEP_MEMB(strpair),     pa_rp,        0           },
 483 #endif
 484
 485   { adns_r_addr,    "A",  "addr",    FLAT_MEMB(addr),        pa_addr,      di_addr     },
 486   { adns_r_ns,      "NS", "+addr",   DEEP_MEMB(hostaddr),    pa_hostaddr,  di_hostaddr },
 487 #if 0 /*fixme*/
 488   { adns_r_ptr,     "PTR","checked", DEEP_MEMB(str),         pa_ptr,       0           },
 489 #endif
 490   { adns_r_mx,      "MX", "+addr",   DEEP_MEMB(inthostaddr), pa_mx,        di_mx       },
 491
 492 #if 0 /*fixme*/
 493   { adns_r_soa,     "SOA","822",     DEEP_MEMB(soa),         pa_soa,        0          },
 494   { adns_r_rp,      "RP", "822",     DEEP_MEMB(strpair),     pa_rp,         0          },
 495 #endif
 496 };
 497
 498 const typeinfo *adns__findtype(adns_rrtype type) {
 499   const typeinfo *begin, *end, *mid;
 500
 501   begin= typeinfos;  end= typeinfos+(sizeof(typeinfos)/sizeof(typeinfo));
 502
 503   while (begin < end) {
 504     mid= begin + ((end-begin)>>1);
 505     if (mid->type == type) return mid;
 506     if (type > mid->type) begin= mid+1;
 507     else end= mid;
 508   }
 509   return 0;
 510 }