[adns] / src / types.c

/*
 * types.c
 * - RR-type-specific code, and the machinery to call it
 */
/*
 *  This file is part of adns, which is Copyright (C) 1997, 1998 Ian Jackson
 *  
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2, or (at your option)
 *  any later version.
 *  
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software Foundation,
 *  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 
 */

#include <stdlib.h>
#include <string.h>

#include <arpa/inet.h>

#include "internal.h"

#define R_NOMEM           return adns_s_nolocalmem
#define CSP_ADDSTR(s)     if (!adns__vbuf_appendstr(vb,(s))) R_NOMEM; else;

static int dip_inaddr(struct in_addr a, struct in_addr b) {
  /* fixme implement sortlist */
  return 0;
}

static adns_status pa_inaddr(const parseinfo *pai, int cbyte, int max, void *datap) {
  struct in_addr *storeto= datap;
  
  if (max-cbyte != 4) return adns_s_invaliddata;
  memcpy(storeto, pai->dgram + cbyte, 4);
  return adns_s_ok;
}

static int di_inaddr(const void *datap_a, const void *datap_b) {
  const struct in_addr *ap= datap_a, *bp= datap_b;

  return dip_inaddr(*ap,*bp);
}

static adns_status cs_inaddr(vbuf *vb, const void *datap) {
  const struct in_addr *rrp= datap, rr= *rrp;
  const char *ia;

  ia= inet_ntoa(rr); assert(ia);
  CSP_ADDSTR(ia);
  return adns_s_ok;
}

static adns_status pa_addr(const parseinfo *pai, int cbyte, int max, void *datap) {
  adns_addr *storeto= datap;
  const byte *dgram= pai->dgram;

  if (max-cbyte != 4) return adns_s_invaliddata;
  storeto->len= sizeof(storeto->addr.inet);
  memset(&storeto->addr,0,sizeof(storeto->addr.inet));
  storeto->addr.inet.sin_family= AF_INET;
  storeto->addr.inet.sin_port= 0;
  memcpy(&storeto->addr.inet.sin_addr,dgram+cbyte,4);
  return adns_s_ok;
}

static int di_addr(const void *datap_a, const void *datap_b) {
  const adns_addr *ap= datap_a, *bp= datap_b;

  assert(ap->addr.sa.sa_family == AF_INET);
  return dip_inaddr(ap->addr.inet.sin_addr,bp->addr.inet.sin_addr);
}

static adns_status csp_addr(vbuf *vb, const adns_addr *rrp) {
  const char *ia;
  static char buf[30];

  switch (rrp->addr.inet.sin_family) {
  case AF_INET:
    CSP_ADDSTR("AF_INET ");
    ia= inet_ntoa(rrp->addr.inet.sin_addr); assert(ia);
    CSP_ADDSTR(ia);
    break;
  default:
    sprintf(buf,"AF=%u",rrp->addr.sa.sa_family);
    CSP_ADDSTR(buf);
    break;
  }
  return adns_s_ok;
}

static adns_status cs_addr(vbuf *vb, const void *datap) {
  const adns_addr *rrp= datap;

  return csp_addr(vb,rrp);
}

static adns_status pap_domain(const parseinfo *pai, int *cbyte_io, int max,
			      char **domain_r, parsedomain_flags flags) {
  adns_status st;
  char *dm;
  
  st= adns__parse_domain(pai->qu->ads, pai->serv, pai->qu, &pai->qu->vb, flags,
			 pai->dgram,pai->dglen, cbyte_io, max);
  if (st) return st;
  if (!pai->qu->vb.used) return adns_s_invaliddata;

  dm= adns__alloc_interim(pai->qu, pai->qu->vb.used+1);
  if (!dm) R_NOMEM;

  dm[pai->qu->vb.used]= 0;
  memcpy(dm,pai->qu->vb.buf,pai->qu->vb.used);
  
  *domain_r= dm;
  return adns_s_ok;
}

static adns_status pa_host_raw(const parseinfo *pai, int cbyte, int max, void *datap) {
  char **rrp= datap;
  adns_status st;

  st= pap_domain(pai, &cbyte, max, rrp,
		 pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
  if (st) return st;
  
  if (cbyte != max) return adns_s_invaliddata;
  return adns_s_ok;
}

static adns_status pa_mx_raw(const parseinfo *pai, int cbyte, int max, void *datap) {
  const byte *dgram= pai->dgram;
  adns_rr_intstr *rrp= datap;
  adns_status st;
  int pref;

  if (cbyte+2 > max) return adns_s_invaliddata;
  GET_W(cbyte,pref);
  rrp->i= pref;
  st= pap_domain(pai, &cbyte, max, &rrp->str,
		 pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
  if (st) return st;
  
  if (cbyte != max) return adns_s_invaliddata;
  return adns_s_ok;
}


static adns_status pap_findaddrs(const parseinfo *pai, adns_rr_hostaddr *ha,
				 int *cbyte_io, int count, int dmstart) {
  int rri, naddrs;
  int type, class, rdlen, rdstart, ownermatched;
  adns_status st;
  
  for (rri=0, naddrs=-1; rri<count; rri++) {
    st= adns__findrr_anychk(pai->qu, pai->serv, pai->dgram, pai->dglen, cbyte_io,
			    &type, &class, &rdlen, &rdstart,
			    pai->dgram, pai->dglen, dmstart, &ownermatched);
    if (st) return st;
    if (!ownermatched || class != DNS_CLASS_IN || type != adns_r_a) {
      if (naddrs>0) break; else continue;
    }
    if (naddrs == -1) {
      naddrs= 0;
    }
    if (!adns__vbuf_ensure(&pai->qu->vb, (naddrs+1)*sizeof(adns_addr))) R_NOMEM;
    st= pa_addr(pai, rdstart,rdstart+rdlen, pai->qu->vb.buf + naddrs*sizeof(adns_addr));
    if (st) return st;
    naddrs++;
  }
  if (naddrs >= 0) {
    ha->addrs= adns__alloc_interim(pai->qu, naddrs*sizeof(adns_addr));
    if (!ha->addrs) R_NOMEM;
    memcpy(ha->addrs, pai->qu->vb.buf, naddrs*sizeof(adns_addr));
    ha->naddrs= naddrs;
    ha->astatus= adns_s_ok;

    adns__isort(ha->addrs, naddrs, sizeof(adns_addr), pai->qu->vb.buf, di_addr);
  }
  return adns_s_ok;
}

static adns_status pap_hostaddr(const parseinfo *pai, int *cbyte_io,
				int max, adns_rr_hostaddr *rrp) {
  adns_status st;
  int dmstart, cbyte;

  dmstart= cbyte= *cbyte_io;
  st= pap_domain(pai, &cbyte, max, &rrp->host,
		 pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
  if (st) return st;
  *cbyte_io= cbyte;

  rrp->astatus= adns_s_ok;
  rrp->naddrs= -1;
  rrp->addrs= 0;

  cbyte= pai->nsstart;

  st= pap_findaddrs(pai, rrp, &cbyte, pai->nscount, dmstart);
  if (st) return st;
  if (rrp->naddrs != -1) return adns_s_ok;

  st= pap_findaddrs(pai, rrp, &cbyte, pai->arcount, dmstart);
  if (st) return st;
  if (rrp->naddrs != -1) return adns_s_ok;

  rrp->naddrs= 0; /* fixme additional section didn't have required data */
  rrp->astatus= adns_s_notimplemented;

  return adns_s_ok;
}

static adns_status pa_hostaddr(const parseinfo *pai, int cbyte, int max, void *datap) {
  adns_rr_hostaddr *rrp= datap;
  adns_status st;

  st= pap_hostaddr(pai, &cbyte, max, rrp);
  if (st) return st;
  if (cbyte != max) return adns_s_invaliddata;

  return adns_s_ok;
}

static adns_status pa_mx(const parseinfo *pai, int cbyte, int max, void *datap) {
  const byte *dgram= pai->dgram;
  adns_rr_inthostaddr *rrp= datap;
  adns_status st;
  int pref;

  if (cbyte+2 > max) return adns_s_invaliddata;
  GET_W(cbyte,pref);
  rrp->i= pref;
  st= pap_hostaddr(pai, &cbyte, max, &rrp->ha);
  if (st) return st;
  
  if (cbyte != max) return adns_s_invaliddata;
  return adns_s_ok;
}

static int dip_hostaddr(const adns_rr_hostaddr *ap, const adns_rr_hostaddr *bp) {
  if (ap->astatus != bp->astatus) return ap->astatus;
  if (ap->astatus) return 0;

  assert(ap->addrs[0].addr.sa.sa_family == AF_INET);
  assert(bp->addrs[0].addr.sa.sa_family == AF_INET);
  return dip_inaddr(ap->addrs[0].addr.inet.sin_addr, bp->addrs[0].addr.inet.sin_addr);
}

static int di_hostaddr(const void *datap_a, const void *datap_b) {
  const adns_rr_hostaddr *ap= datap_a, *bp= datap_b;

  return dip_hostaddr(ap,bp);
}

static int di_mx_raw(const void *datap_a, const void *datap_b) {
  const adns_rr_intstr *ap= datap_a, *bp= datap_b;

  if (ap->i < bp->i) return 0;
  if (ap->i > bp->i) return 1;
  return 0;
}

static int di_mx(const void *datap_a, const void *datap_b) {
  const adns_rr_inthostaddr *ap= datap_a, *bp= datap_b;

  if (ap->i < bp->i) return 0;
  if (ap->i > bp->i) return 1;
  return dip_hostaddr(&ap->ha,&bp->ha);
}

static adns_status pa_txt(const parseinfo *pai, int cbyte, int max, void *datap) {
  adns_rr_intstr **rrp= datap, *table, *te;
  const byte *dgram= pai->dgram;
  int ti, tc, l, startbyte;

  startbyte= cbyte;
  if (cbyte >= max) return adns_s_invaliddata;
  tc= 0;
  while (cbyte < max) {
    GET_B(cbyte,l);
    cbyte+= l;
  }
  if (cbyte != max) return adns_s_invaliddata;

  table= adns__alloc_interim(pai->qu,sizeof(*table)*(tc+1));
  if (!table) R_NOMEM;

  for (cbyte=startbyte, ti=0, te=table; ti<tc; ti++, te++) {
    GET_B(cbyte,l);
    te->str= adns__alloc_interim(pai->qu, l+1);
    if (!te->str) R_NOMEM;
    te->str[l]= 0;
    memcpy(te->str,dgram+cbyte,l);
    te->i= l;
  }
  assert(cbyte == max);

  te->i= -1;
  te->str= 0;
  
  *rrp= table;
  return adns_s_ok;
}

static adns_status csp_textdata(vbuf *vb, const char *dp, int len) {
  unsigned char ch;
  char buf[10];
  int cn;

  CSP_ADDSTR("\"");
  for (cn=0; cn<len; cn++) {
    ch= *dp++;
    if (ch >= 32 && ch <= 126 && ch != '"' && ch != '\\') {
      if (!adns__vbuf_append(vb,&ch,1)) R_NOMEM;
    } else {
      sprintf(buf,"\\%02x",ch);
      CSP_ADDSTR(buf);
    }
  }
  CSP_ADDSTR("\"");
  
  return adns_s_ok;
}

static adns_status csp_qstring(vbuf *vb, const char *dp) {
  return csp_textdata(vb, dp, strlen(dp));
}

static adns_status cs_str(vbuf *vb, const void *datap) {
  const char *const *rrp= datap;

  return csp_qstring(vb,*rrp);
}

static adns_status cs_intstr(vbuf *vb, const void *datap) {
  const adns_rr_intstr *rrp= datap;
  char buf[10];

  sprintf(buf,"%u ",rrp->i);
  CSP_ADDSTR(buf);
  return csp_qstring(vb,rrp->str);
}

static adns_status cs_manyistr(vbuf *vb, const void *datap) {
  const adns_rr_intstr *const *rrp= datap;
  const adns_rr_intstr *current;
  adns_status st;
  int spc;

  for (spc=0, current= *rrp; current->i >= 0; current++) {
    if (spc) CSP_ADDSTR(" ");
    st= csp_textdata(vb,current->str,current->i); if (st) return st;
  }
  return adns_s_ok;
}

static void mf_str(adns_query qu, void *datap) {
  char **rrp= datap;

  adns__makefinal_str(qu,rrp);
}

static void mf_intstr(adns_query qu, void *datap) {
  adns_rr_intstr *rrp= datap;

  adns__makefinal_str(qu,&rrp->str);
}

static adns_status csp_hostaddr(vbuf *vb, const adns_rr_hostaddr *rrp) {
  const char *to_add;
  adns_status st;
  int i;

  st= csp_qstring(vb,rrp->host); if (st) return st;

  if (rrp->astatus) {
    CSP_ADDSTR(" - ");
    CSP_ADDSTR(adns_strerror(rrp->astatus));
  } else {
    assert(rrp->naddrs > 0);
    for (i=0, to_add= ": "; i<rrp->naddrs; i++, to_add= ", ") {
      CSP_ADDSTR(to_add);
      st= csp_addr(vb,&rrp->addrs[i]);
    }
  }
  return adns_s_ok;
}

static adns_status cs_hostaddr(vbuf *vb, const void *datap) {
  const adns_rr_hostaddr *rrp= datap;

  return csp_hostaddr(vb,rrp);
}

static adns_status cs_inthostaddr(vbuf *vb, const void *datap) {
  const adns_rr_inthostaddr *rrp= datap;
  char buf[10];

  sprintf(buf,"%u ",rrp->i);
  CSP_ADDSTR(buf);

  return csp_hostaddr(vb,&rrp->ha);
}
  
static void mfp_hostaddr(adns_query qu, adns_rr_hostaddr *rrp) {
  void *tablev;

  adns__makefinal_str(qu,&rrp->host);
  tablev= rrp->addrs;
  adns__makefinal_block(qu, &tablev, rrp->naddrs*sizeof(*rrp->addrs));
  rrp->addrs= tablev;
}

static void mf_hostaddr(adns_query qu, void *datap) {
  adns_rr_hostaddr *rrp= datap;

  mfp_hostaddr(qu,rrp);
}

static void mf_inthostaddr(adns_query qu, void *datap) {
  adns_rr_inthostaddr *rrp= datap;

  mfp_hostaddr(qu,&rrp->ha);
}

static void mf_manyistr(adns_query qu, void *datap) {
  adns_rr_intstr **rrp= datap;
  adns_rr_intstr *te, *table;
  void *tablev;
  int tc;

  for (tc=0, te= *rrp; te->i >= 0; te++, tc++);
  tablev= *rrp;
  adns__makefinal_block(qu,&tablev,sizeof(*te)*(tc+1));
  *rrp= table= tablev;
  for (te= *rrp; te->i >= 0; te++)
    adns__makefinal_str(qu,&te->str);
}

static void mf_flat(adns_query qu, void *data) { }

#define TYPE_SF(size,func,cp,free) size, pa_##func, mf_##free, cs_##cp
#define TYPE_SN(size,func,cp)      size, pa_##func, mf_flat, cs_##cp
#define TYPESZ_M(member)           (sizeof(*((adns_answer*)0)->rrs.member))
#define TYPE_MF(memb,parse)        TYPE_SF(TYPESZ_M(memb),parse,memb,memb)
#define TYPE_MN(memb,parse)        TYPE_SN(TYPESZ_M(memb),parse,memb)

#define DEEP_MEMB(memb) TYPESZ_M(memb), mf_##memb, cs_##memb
#define FLAT_MEMB(memb) TYPESZ_M(memb), mf_flat, cs_##memb

/* TYPE_<ms><nf>
 *  ms is M  specify member name
 *     or S  specify size explicitly
 *  nf is F  full memory management, dependent on member name or specified func
 *        N  no memory management required
 */

static const typeinfo typeinfos[] = {
  /* Must be in ascending order of rrtype ! */
  /* rr type code   rrt     fmt      mem.mgmt  member        parser         comparer */
  							     
  { adns_r_a,       "A",     0,      FLAT_MEMB(inaddr),      pa_inaddr,    di_inaddr   },
  { adns_r_ns_raw,  "NS",   "raw",   DEEP_MEMB(str),         pa_host_raw,  0           },
  { adns_r_cname,   "CNAME", 0,      DEEP_MEMB(str),         pa_host_raw,  0           },
#if 0 /*fixme*/	    	                    	       	     		  	     
  { adns_r_soa_raw, "SOA",  "raw",   DEEP_MEMB(soa),         pa_soa,       0           },
#endif							     		 	     
  { adns_r_ptr_raw, "PTR",  "raw",   DEEP_MEMB(str),         pa_host_raw,  0           },
#if 0 /*fixme*/	    	                    	       	     		  	     
  { adns_r_hinfo,   "HINFO", 0,      DEEP_MEMB(strpair),     pa_hinfo,     0           },
#endif							     		 	     
  { adns_r_mx_raw,  "MX",   "raw",   DEEP_MEMB(intstr),      pa_mx_raw,    di_mx_raw   },
  { adns_r_txt,     "TXT",   0,      DEEP_MEMB(manyistr),    pa_txt,       0           },
#if 0 /*fixme*/	    	                    	       	     		  	     
  { adns_r_rp_raw,  "RP",   "raw",   DEEP_MEMB(strpair),     pa_rp,        0           },
#endif							     		 	     
   		      	                                     		  	     
  { adns_r_addr,    "A",  "addr",    FLAT_MEMB(addr),        pa_addr,      di_addr     },
  { adns_r_ns,      "NS", "+addr",   DEEP_MEMB(hostaddr),    pa_hostaddr,  di_hostaddr },
#if 0 /*fixme*/	    	                    	       	     		  	     
  { adns_r_ptr,     "PTR","checked", DEEP_MEMB(str),         pa_ptr,       0           },
#endif
  { adns_r_mx,      "MX", "+addr",   DEEP_MEMB(inthostaddr), pa_mx,        di_mx       },
   		      	                                  		   
#if 0 /*fixme*/
  { adns_r_soa,     "SOA","822",     DEEP_MEMB(soa),         pa_soa,        0          },
  { adns_r_rp,      "RP", "822",     DEEP_MEMB(strpair),     pa_rp,         0          },
#endif
};

const typeinfo *adns__findtype(adns_rrtype type) {
  const typeinfo *begin, *end, *mid;

  begin= typeinfos;  end= typeinfos+(sizeof(typeinfos)/sizeof(typeinfo));

  while (begin < end) {
    mid= begin + ((end-begin)>>1);
    if (mid->type == type) return mid;
    if (type > mid->type) begin= mid+1;
    else end= mid;
  }
  return 0;
}
Commit	Line	Data
e576be50	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	*/
98a3f706	22
1b644113	23	#include <stdlib.h>
828d89bd	24	#include <string.h>
1b644113	25
86e7b8d9	26	#include <arpa/inet.h>
86e7b8d9	27
98a3f706	28	#include "internal.h"
98a3f706	29
1dfe95d8	30	#define R_NOMEM return adns_s_nolocalmem
	31	#define CSP_ADDSTR(s) if (!adns__vbuf_appendstr(vb,(s))) R_NOMEM; else;
	32
828d89bd	33	static int dip_inaddr(struct in_addr a, struct in_addr b) {
	34	/* fixme implement sortlist */
	35	return 0;
	36	}
	37
1dfe95d8	38	static adns_status pa_inaddr(const parseinfo pai, int cbyte, int max, void datap) {
e062dcae	39	struct in_addr *storeto= datap;
e7a9ca47	40
e7a9ca47	41	if (max-cbyte != 4) return adns_s_invaliddata;
1dfe95d8	42	memcpy(storeto, pai->dgram + cbyte, 4);
e7a9ca47	43	return adns_s_ok;
	44	}
	45
e062dcae	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;
86e7b8d9	54	const char *ia;
86e7b8d9	55
e062dcae	56	ia= inet_ntoa(rr); assert(ia);
1dfe95d8	57	CSP_ADDSTR(ia);
1dfe95d8	58	return adns_s_ok;
86e7b8d9	59	}
e7a9ca47	60
1dfe95d8	61	static adns_status pa_addr(const parseinfo pai, int cbyte, int max, void datap) {
828d89bd	62	adns_addr *storeto= datap;
1dfe95d8	63	const byte *dgram= pai->dgram;
c7836bc9	64
828d89bd	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
1dfe95d8	77	assert(ap->addr.sa.sa_family == AF_INET);
828d89bd	78	return dip_inaddr(ap->addr.inet.sin_addr,bp->addr.inet.sin_addr);
	79	}
	80
1dfe95d8	81	static adns_status csp_addr(vbuf vb, const adns_addr rrp) {
828d89bd	82	const char *ia;
	83	static char buf[30];
	84
	85	switch (rrp->addr.inet.sin_family) {
	86	case AF_INET:
1dfe95d8	87	CSP_ADDSTR("AF_INET ");
828d89bd	88	ia= inet_ntoa(rrp->addr.inet.sin_addr); assert(ia);
1dfe95d8	89	CSP_ADDSTR(ia);
828d89bd	90	break;
	91	default:
	92	sprintf(buf,"AF=%u",rrp->addr.sa.sa_family);
1dfe95d8	93	CSP_ADDSTR(buf);
828d89bd	94	break;
	95	}
	96	return adns_s_ok;
	97	}
	98
1dfe95d8	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) {
e062dcae	107	adns_status st;
	108	char *dm;
	109
1dfe95d8	110	st= adns__parse_domain(pai->qu->ads, pai->serv, pai->qu, &pai->qu->vb, flags,
1dfe95d8	111	pai->dgram,pai->dglen, cbyte_io, max);
e062dcae	112	if (st) return st;
1dfe95d8	113	if (!pai->qu->vb.used) return adns_s_invaliddata;
e062dcae	114
1dfe95d8	115	dm= adns__alloc_interim(pai->qu, pai->qu->vb.used+1);
1dfe95d8	116	if (!dm) R_NOMEM;
e062dcae	117
1dfe95d8	118	dm[pai->qu->vb.used]= 0;
1dfe95d8	119	memcpy(dm,pai->qu->vb.buf,pai->qu->vb.used);
e062dcae	120
	121	*domain_r= dm;
	122	return adns_s_ok;
	123	}
	124
1dfe95d8	125	static adns_status pa_host_raw(const parseinfo pai, int cbyte, int max, void datap) {
e062dcae	126	char **rrp= datap;
ffbda80c	127	adns_status st;
86e7b8d9	128
1dfe95d8	129	st= pap_domain(pai, &cbyte, max, rrp,
1dfe95d8	130	pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
e062dcae	131	if (st) return st;
	132
	133	if (cbyte != max) return adns_s_invaliddata;
	134	return adns_s_ok;
	135	}
ffbda80c	136
1dfe95d8	137	static adns_status pa_mx_raw(const parseinfo pai, int cbyte, int max, void datap) {
1dfe95d8	138	const byte *dgram= pai->dgram;
e062dcae	139	adns_rr_intstr *rrp= datap;
	140	adns_status st;
	141	int pref;
ffbda80c	142
e062dcae	143	if (cbyte+2 > max) return adns_s_invaliddata;
	144	GET_W(cbyte,pref);
	145	rrp->i= pref;
1dfe95d8	146	st= pap_domain(pai, &cbyte, max, &rrp->str,
1dfe95d8	147	pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
e062dcae	148	if (st) return st;
	149
	150	if (cbyte != max) return adns_s_invaliddata;
	151	return adns_s_ok;
	152	}
ffbda80c	153
c7836bc9	154
1dfe95d8	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;
c7836bc9	158	int type, class, rdlen, rdstart, ownermatched;
1dfe95d8	159	adns_status st;
c7836bc9	160
1dfe95d8	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);
c7836bc9	165	if (st) return st;
1dfe95d8	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;
c7836bc9	171	}
1dfe95d8	172	if (!adns__vbuf_ensure(&pai->qu->vb, (naddrs+1)*sizeof(adns_addr))) R_NOMEM;
1dfe95d8	173	st= pa_addr(pai, rdstart,rdstart+rdlen, pai->qu->vb.buf + naddrs*sizeof(adns_addr));
c7836bc9	174	if (st) return st;
1dfe95d8	175	naddrs++;
c7836bc9	176	}
1dfe95d8	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;
c7836bc9	182	ha->astatus= adns_s_ok;
1dfe95d8	183
1dfe95d8	184	adns__isort(ha->addrs, naddrs, sizeof(adns_addr), pai->qu->vb.buf, di_addr);
c7836bc9	185	}
	186	return adns_s_ok;
	187	}
	188
1dfe95d8	189	static adns_status pap_hostaddr(const parseinfo pai, int cbyte_io,
1dfe95d8	190	int max, adns_rr_hostaddr *rrp) {
c7836bc9	191	adns_status st;
	192	int dmstart, cbyte;
	193
	194	dmstart= cbyte= *cbyte_io;
1dfe95d8	195	st= pap_domain(pai, &cbyte, max, &rrp->host,
1dfe95d8	196	pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
c7836bc9	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
1dfe95d8	204	cbyte= pai->nsstart;
c7836bc9	205
1dfe95d8	206	st= pap_findaddrs(pai, rrp, &cbyte, pai->nscount, dmstart);
c7836bc9	207	if (st) return st;
	208	if (rrp->naddrs != -1) return adns_s_ok;
	209
1dfe95d8	210	st= pap_findaddrs(pai, rrp, &cbyte, pai->arcount, dmstart);
c7836bc9	211	if (st) return st;
c7836bc9	212	if (rrp->naddrs != -1) return adns_s_ok;
1dfe95d8	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;
c7836bc9	218	}
c7836bc9	219
1dfe95d8	220	static adns_status pa_hostaddr(const parseinfo pai, int cbyte, int max, void datap) {
1dfe95d8	221	adns_rr_hostaddr *rrp= datap;
c7836bc9	222	adns_status st;
c7836bc9	223
1dfe95d8	224	st= pap_hostaddr(pai, &cbyte, max, rrp);
c7836bc9	225	if (st) return st;
	226	if (cbyte != max) return adns_s_invaliddata;
	227
1dfe95d8	228	return adns_s_ok;
1dfe95d8	229	}
c7836bc9	230
1dfe95d8	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;
c7836bc9	236
1dfe95d8	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);
c7836bc9	241	if (st) return st;
1dfe95d8	242
	243	if (cbyte != max) return adns_s_invaliddata;
	244	return adns_s_ok;
	245	}
c7836bc9	246
1dfe95d8	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;
c7836bc9	250
1dfe95d8	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);
c7836bc9	260	}
c7836bc9	261
e062dcae	262	static int di_mx_raw(const void datap_a, const void datap_b) {
e062dcae	263	const adns_rr_intstr ap= datap_a, bp= datap_b;
ffbda80c	264
e062dcae	265	if (ap->i < bp->i) return 0;
	266	if (ap->i > bp->i) return 1;
	267	return 0;
ffbda80c	268	}
ffbda80c	269
1dfe95d8	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) {
e062dcae	279	adns_rr_intstr *rrp= datap, table, *te;
1dfe95d8	280	const byte *dgram= pai->dgram;
1dfe95d8	281	int ti, tc, l, startbyte;
ffbda80c	282
1dfe95d8	283	startbyte= cbyte;
e062dcae	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
1dfe95d8	292	table= adns__alloc_interim(pai->qu,sizeof(table)(tc+1));
1dfe95d8	293	if (!table) R_NOMEM;
e062dcae	294
	295	for (cbyte=startbyte, ti=0, te=table; ti<tc; ti++, te++) {
	296	GET_B(cbyte,l);
1dfe95d8	297	te->str= adns__alloc_interim(pai->qu, l+1);
1dfe95d8	298	if (!te->str) R_NOMEM;
e062dcae	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;
ffbda80c	310	}
ffbda80c	311
1dfe95d8	312	static adns_status csp_textdata(vbuf vb, const char dp, int len) {
1b644113	313	unsigned char ch;
1b644113	314	char buf[10];
e062dcae	315	int cn;
1b644113	316
1dfe95d8	317	CSP_ADDSTR("\"");
e062dcae	318	for (cn=0; cn<len; cn++) {
e062dcae	319	ch= *dp++;
1b644113	320	if (ch >= 32 && ch <= 126 && ch != '"' && ch != '\\') {
1dfe95d8	321	if (!adns__vbuf_append(vb,&ch,1)) R_NOMEM;
1b644113	322	} else {
1b644113	323	sprintf(buf,"\\%02x",ch);
1dfe95d8	324	CSP_ADDSTR(buf);
1b644113	325	}
1b644113	326	}
1dfe95d8	327	CSP_ADDSTR("\"");
ffbda80c	328
1dfe95d8	329	return adns_s_ok;
1b644113	330	}
1b644113	331
1dfe95d8	332	static adns_status csp_qstring(vbuf vb, const char dp) {
e062dcae	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
1dfe95d8	339	return csp_qstring(vb,*rrp);
e062dcae	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);
1dfe95d8	347	CSP_ADDSTR(buf);
1dfe95d8	348	return csp_qstring(vb,rrp->str);
e062dcae	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;
1dfe95d8	354	adns_status st;
e062dcae	355	int spc;
	356
	357	for (spc=0, current= *rrp; current->i >= 0; current++) {
1dfe95d8	358	if (spc) CSP_ADDSTR(" ");
1dfe95d8	359	st= csp_textdata(vb,current->str,current->i); if (st) return st;
e062dcae	360	}
e062dcae	361	return adns_s_ok;
e062dcae	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
1dfe95d8	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->naddrssizeof(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
e062dcae	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);
ffbda80c	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
e062dcae	451	#define TYPESZ_M(member) (sizeof(((adns_answer)0)->rrs.member))
86e7b8d9	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
ffbda80c	455	#define DEEP_MEMB(memb) TYPESZ_M(memb), mf_##memb, cs_##memb
ffbda80c	456	#define FLAT_MEMB(memb) TYPESZ_M(memb), mf_flat, cs_##memb
98a3f706	457
e7a9ca47	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	*/
98a3f706	464
	465	static const typeinfo typeinfos[] = {
	466	/* Must be in ascending order of rrtype ! */
1dfe95d8	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 },
e062dcae	489	#endif
1dfe95d8	490	{ adns_r_mx, "MX", "+addr", DEEP_MEMB(inthostaddr), pa_mx, di_mx },
1dfe95d8	491
e062dcae	492	#if 0 /fixme/
1dfe95d8	493	{ adns_r_soa, "SOA","822", DEEP_MEMB(soa), pa_soa, 0 },
1dfe95d8	494	{ adns_r_rp, "RP", "822", DEEP_MEMB(strpair), pa_rp, 0 },
e7a9ca47	495	#endif
98a3f706	496	};
98a3f706	497
f759e52e	498	const typeinfo *adns__findtype(adns_rrtype type) {
f759e52e	499	const typeinfo begin, end, *mid;
98a3f706	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	}