[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;

/*
 * order of sections:
 *
 * _textdata, _qstring        (csp)
 * _str                       (mf,cs)
 * _intstr                    (mf,cs)
 * _manyistr                  (mf,cs)
 * _txt                       (pa)
 * _inaddr                    (pa,dip,di)
 * _addr                      (pa,di,csp,cs)
 * _domain                    (pap)
 * _host_raw                  (pa)
 * _hostaddr                  (pap,pa,dip,di,mfp,mf,csp,cs +pap_findaddrs)
 * _mx_raw                    (pa,di)
 * _mx                        (pa,di)
 * _inthostaddr               (mf,cs)
 * _flat                      (mf)
 *
 * within each section:
 *    pap_*
 *    pa_*
 *    dip_*
 *    di_*
 *    mfp_*
 *    mf_*
 *    csp_*
 *    cs_*
 */

/*
 * _textdata, _qstring   (csp)
 */

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));
}

/*
 * _str  (mf,cs)
 */

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

  adns__makefinal_str(qu,rrp);
}

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

  return csp_qstring(vb,*rrp);
}

/*
 * _intstr  (mf,cs)
 */

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

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

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);
}

/*
 * _manyistr   (mf,cs)
 */

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 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;
}

/*
 * _txt   (pa)
 */

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;
}

/*
 * _inaddr   (pa,dip,di)
 */

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 dip_inaddr(struct in_addr a, struct in_addr b) {
  /* fixme implement sortlist */
  return 0;
}

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;
}

/*
 * _addr   (pa,di,csp,cs)
 */

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);
}

/*
 * _domain  (pap)
 */

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;
}

/*
 * _host_raw   (pa)
 */

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;
}

/*
 * _hostaddr   (pap,pa,dip,di,mfp,mf,csp,cs +pap_findaddrs)
 */

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;
  qcontext ctx;
  int id;
  adns_query nqu;

  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;

  st= adns__mkquery_frdgram(pai->ads, &pai->qu->vb, &id,
			    pai->dgram, pai->dglen, dmstart,
			    adns_r_addr, adns_qf_quoteok_query);
  if (st) return st;
  
  ctx.hostaddr= rrp;
  st= adns__internal_submit(pai->ads, &nqu, adns__findtype(adns_r_addr),
			    &pai->qu->vb, id,
			    adns_qf_quoteok_query, pai->now, 0, &ctx);
  if (st) return st;

  nqu->parent= pai->qu;
  LIST_LINK_TAIL_PART(pai->qu->children,nqu,siblings.);

  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 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 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 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);
}

/*
 * _mx_raw   (pa,di)
 */

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 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;
}

/*
 * _mx   (pa,di)
 */

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 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);
}

/*
 * _inthostaddr  (mf,cs)
 */

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

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

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);
}

/*
 * _flat   (mf)
 */

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

/*
 * Now the table.
 */

#define TYPESZ_M(member)           (sizeof(*((adns_answer*)0)->rrs.member))

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

#define DEEP_TYPE(code,rrt,fmt,memb,parser,comparer) \
 { adns_r_##code, rrt, fmt, TYPESZ_M(memb), mf_##memb, cs_##memb, parser, comparer }
#define FLAT_TYPE(code,rrt,fmt,memb,parser,comparer) \
 { adns_r_##code, rrt, fmt, TYPESZ_M(memb), mf_flat, cs_##memb, parser, comparer }

static const typeinfo typeinfos[] = {
/* Must be in ascending order of rrtype ! */
/* mem-mgmt code     rrt     fmt      member       parser        comparer    */
  							     
  FLAT_TYPE(a,       "A",     0,      inaddr,      pa_inaddr,    di_inaddr   ),
  DEEP_TYPE(ns_raw,  "NS",   "raw",   str,         pa_host_raw,  0           ),
  DEEP_TYPE(cname,   "CNAME", 0,      str,         pa_host_raw,  0           ),
#if 0
  DEEP_TYPE(soa_raw, "SOA",  "raw",   soa,         pa_soa,       0           ),
#endif							     		 	     
  DEEP_TYPE(ptr_raw, "PTR",  "raw",   str,         pa_host_raw,  0           ),
#if 0
  DEEP_TYPE(hinfo,   "HINFO", 0,      strpair,     pa_hinfo,     0           ),
#endif							     		 	     
  DEEP_TYPE(mx_raw,  "MX",   "raw",   intstr,      pa_mx_raw,    di_mx_raw   ),
  DEEP_TYPE(txt,     "TXT",   0,      manyistr,    pa_txt,       0           ),
#if 0
  DEEP_TYPE(rp_raw,  "RP",   "raw",   strpair,     pa_rp,        0           ),
#endif							     		 	     
   		      	                                     		  	     
  FLAT_TYPE(addr,    "A",  "addr",    addr,        pa_addr,      di_addr     ),
  DEEP_TYPE(ns,      "NS", "+addr",   hostaddr,    pa_hostaddr,  di_hostaddr ),
#if 0
  DEEP_TYPE(ptr,     "PTR","checked", str,         pa_ptr,       0           ),
#endif
  DEEP_TYPE(mx,      "MX", "+addr",   inthostaddr, pa_mx,        di_mx       ),
   		      	                                  		   
#if 0
  DEEP_TYPE(soa,     "SOA","822",     soa,         pa_soa,        0          ),
  DEEP_TYPE(rp,      "RP", "822",     strpair,     pa_rp,         0          ),
#endif /* fixme - implement all types */
};

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
eb81d633	33	/*
	34	* order of sections:
	35	*
	36	* _textdata, _qstring (csp)
	37	* _str (mf,cs)
	38	* _intstr (mf,cs)
	39	* _manyistr (mf,cs)
	40	* _txt (pa)
	41	* _inaddr (pa,dip,di)
	42	* _addr (pa,di,csp,cs)
	43	* _domain (pap)
	44	* _host_raw (pa)
	45	* _hostaddr (pap,pa,dip,di,mfp,mf,csp,cs +pap_findaddrs)
	46	* _mx_raw (pa,di)
	47	* _mx (pa,di)
	48	* _inthostaddr (mf,cs)
	49	* _flat (mf)
	50	*
	51	* within each section:
	52	* pap_*
	53	* pa_*
	54	* dip_*
	55	* di_*
	56	* mfp_*
	57	* mf_*
	58	* csp_*
	59	* cs_*
	60	*/
	61
	62	/*
	63	* _textdata, _qstring (csp)
	64	*/
	65
	66	static adns_status csp_textdata(vbuf vb, const char dp, int len) {
	67	unsigned char ch;
	68	char buf[10];
	69	int cn;
	70
	71	CSP_ADDSTR("\"");
	72	for (cn=0; cn<len; cn++) {
	73	ch= *dp++;
	74	if (ch >= 32 && ch <= 126 && ch != '"' && ch != '\\') {
	75	if (!adns__vbuf_append(vb,&ch,1)) R_NOMEM;
	76	} else {
	77	sprintf(buf,"\\%02x",ch);
	78	CSP_ADDSTR(buf);
	79	}
	80	}
	81	CSP_ADDSTR("\"");
	82
	83	return adns_s_ok;
	84	}
	85
	86	static adns_status csp_qstring(vbuf vb, const char dp) {
	87	return csp_textdata(vb, dp, strlen(dp));
	88	}
	89
	90	/*
	91	* _str (mf,cs)
	92	*/
	93
	94	static void mf_str(adns_query qu, void *datap) {
	95	char **rrp= datap;
	96
97	adns__makefinal_str(qu,rrp);
98	}
99
100	static adns_status cs_str(vbuf vb, const void datap) {
101	const char const rrp= datap;
102
103	return csp_qstring(vb,*rrp);
104	}
105
106	/*
107	* _intstr (mf,cs)
108	*/
109
110	static void mf_intstr(adns_query qu, void *datap) {
111	adns_rr_intstr *rrp= datap;
112
113	adns__makefinal_str(qu,&rrp->str);
114	}
115
116	static adns_status cs_intstr(vbuf vb, const void datap) {
117	const adns_rr_intstr *rrp= datap;
118	char buf[10];
119
120	sprintf(buf,"%u ",rrp->i);
121	CSP_ADDSTR(buf);
122	return csp_qstring(vb,rrp->str);
123	}
124
125	/*
126	* _manyistr (mf,cs)
127	*/
128
129	static void mf_manyistr(adns_query qu, void *datap) {
130	adns_rr_intstr **rrp= datap;
131	adns_rr_intstr te, table;
132	void *tablev;
133	int tc;
134
135	for (tc=0, te= *rrp; te->i >= 0; te++, tc++);
136	tablev= *rrp;
137	adns__makefinal_block(qu,&tablev,sizeof(te)(tc+1));
138	*rrp= table= tablev;
139	for (te= *rrp; te->i >= 0; te++)
140	adns__makefinal_str(qu,&te->str);
141	}
142
143	static adns_status cs_manyistr(vbuf vb, const void datap) {
144	const adns_rr_intstr const rrp= datap;
145	const adns_rr_intstr *current;
146	adns_status st;
147	int spc;
148
149	for (spc=0, current= *rrp; current->i >= 0; current++) {
150	if (spc) CSP_ADDSTR(" ");
151	st= csp_textdata(vb,current->str,current->i); if (st) return st;
152	}
153	return adns_s_ok;
154	}
155
156	/*
157	* _txt (pa)
158	*/
159
160	static adns_status pa_txt(const parseinfo pai, int cbyte, int max, void datap) {
161	adns_rr_intstr *rrp= datap, table, *te;
162	const byte *dgram= pai->dgram;
163	int ti, tc, l, startbyte;
164
165	startbyte= cbyte;
166	if (cbyte >= max) return adns_s_invaliddata;
167	tc= 0;
168	while (cbyte < max) {
169	GET_B(cbyte,l);
170	cbyte+= l;
171	}
172	if (cbyte != max) return adns_s_invaliddata;
173
174	table= adns__alloc_interim(pai->qu,sizeof(table)(tc+1));
175	if (!table) R_NOMEM;
176
177	for (cbyte=startbyte, ti=0, te=table; ti<tc; ti++, te++) {
178	GET_B(cbyte,l);
179	te->str= adns__alloc_interim(pai->qu, l+1);
180	if (!te->str) R_NOMEM;
181	te->str[l]= 0;
182	memcpy(te->str,dgram+cbyte,l);
183	te->i= l;
184	}
185	assert(cbyte == max);
186
187	te->i= -1;
188	te->str= 0;
189
190	*rrp= table;
191	return adns_s_ok;
828d89bd	192	}
828d89bd	193
eb81d633	194	/*
	195	* _inaddr (pa,dip,di)
	196	*/
	197
1dfe95d8	198	static adns_status pa_inaddr(const parseinfo pai, int cbyte, int max, void datap) {
e062dcae	199	struct in_addr *storeto= datap;
e7a9ca47	200
e7a9ca47	201	if (max-cbyte != 4) return adns_s_invaliddata;
1dfe95d8	202	memcpy(storeto, pai->dgram + cbyte, 4);
e7a9ca47	203	return adns_s_ok;
	204	}
	205
eb81d633	206	static int dip_inaddr(struct in_addr a, struct in_addr b) {
	207	/* fixme implement sortlist */
	208	return 0;
	209	}
	210
e062dcae	211	static int di_inaddr(const void datap_a, const void datap_b) {
	212	const struct in_addr ap= datap_a, bp= datap_b;
	213
	214	return dip_inaddr(ap,bp);
	215	}
	216
	217	static adns_status cs_inaddr(vbuf vb, const void datap) {
	218	const struct in_addr rrp= datap, rr= rrp;
86e7b8d9	219	const char *ia;
86e7b8d9	220
e062dcae	221	ia= inet_ntoa(rr); assert(ia);
1dfe95d8	222	CSP_ADDSTR(ia);
1dfe95d8	223	return adns_s_ok;
86e7b8d9	224	}
e7a9ca47	225
eb81d633	226	/*
	227	* _addr (pa,di,csp,cs)
	228	*/
	229
1dfe95d8	230	static adns_status pa_addr(const parseinfo pai, int cbyte, int max, void datap) {
828d89bd	231	adns_addr *storeto= datap;
1dfe95d8	232	const byte *dgram= pai->dgram;
c7836bc9	233
828d89bd	234	if (max-cbyte != 4) return adns_s_invaliddata;
	235	storeto->len= sizeof(storeto->addr.inet);
	236	memset(&storeto->addr,0,sizeof(storeto->addr.inet));
	237	storeto->addr.inet.sin_family= AF_INET;
	238	storeto->addr.inet.sin_port= 0;
	239	memcpy(&storeto->addr.inet.sin_addr,dgram+cbyte,4);
	240	return adns_s_ok;
	241	}
	242
	243	static int di_addr(const void datap_a, const void datap_b) {
	244	const adns_addr ap= datap_a, bp= datap_b;
	245
1dfe95d8	246	assert(ap->addr.sa.sa_family == AF_INET);
828d89bd	247	return dip_inaddr(ap->addr.inet.sin_addr,bp->addr.inet.sin_addr);
	248	}
	249
1dfe95d8	250	static adns_status csp_addr(vbuf vb, const adns_addr rrp) {
828d89bd	251	const char *ia;
	252	static char buf[30];
	253
	254	switch (rrp->addr.inet.sin_family) {
	255	case AF_INET:
1dfe95d8	256	CSP_ADDSTR("AF_INET ");
828d89bd	257	ia= inet_ntoa(rrp->addr.inet.sin_addr); assert(ia);
1dfe95d8	258	CSP_ADDSTR(ia);
828d89bd	259	break;
	260	default:
	261	sprintf(buf,"AF=%u",rrp->addr.sa.sa_family);
1dfe95d8	262	CSP_ADDSTR(buf);
828d89bd	263	break;
	264	}
	265	return adns_s_ok;
	266	}
	267
1dfe95d8	268	static adns_status cs_addr(vbuf vb, const void datap) {
	269	const adns_addr *rrp= datap;
	270
	271	return csp_addr(vb,rrp);
	272	}
	273
eb81d633	274	/*
	275	* _domain (pap)
	276	*/
	277
1dfe95d8	278	static adns_status pap_domain(const parseinfo pai, int cbyte_io, int max,
1dfe95d8	279	char **domain_r, parsedomain_flags flags) {
e062dcae	280	adns_status st;
	281	char *dm;
	282
1dfe95d8	283	st= adns__parse_domain(pai->qu->ads, pai->serv, pai->qu, &pai->qu->vb, flags,
1dfe95d8	284	pai->dgram,pai->dglen, cbyte_io, max);
e062dcae	285	if (st) return st;
1dfe95d8	286	if (!pai->qu->vb.used) return adns_s_invaliddata;
e062dcae	287
1dfe95d8	288	dm= adns__alloc_interim(pai->qu, pai->qu->vb.used+1);
1dfe95d8	289	if (!dm) R_NOMEM;
e062dcae	290
1dfe95d8	291	dm[pai->qu->vb.used]= 0;
1dfe95d8	292	memcpy(dm,pai->qu->vb.buf,pai->qu->vb.used);
e062dcae	293
	294	*domain_r= dm;
	295	return adns_s_ok;
	296	}
	297
eb81d633	298	/*
	299	* _host_raw (pa)
	300	*/
	301
1dfe95d8	302	static adns_status pa_host_raw(const parseinfo pai, int cbyte, int max, void datap) {
e062dcae	303	char **rrp= datap;
ffbda80c	304	adns_status st;
86e7b8d9	305
1dfe95d8	306	st= pap_domain(pai, &cbyte, max, rrp,
1dfe95d8	307	pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
e062dcae	308	if (st) return st;
	309
	310	if (cbyte != max) return adns_s_invaliddata;
	311	return adns_s_ok;
	312	}
ffbda80c	313
eb81d633	314	/*
	315	* _hostaddr (pap,pa,dip,di,mfp,mf,csp,cs +pap_findaddrs)
	316	*/
c7836bc9	317
1dfe95d8	318	static adns_status pap_findaddrs(const parseinfo pai, adns_rr_hostaddr ha,
	319	int *cbyte_io, int count, int dmstart) {
	320	int rri, naddrs;
c7836bc9	321	int type, class, rdlen, rdstart, ownermatched;
1dfe95d8	322	adns_status st;
c7836bc9	323
1dfe95d8	324	for (rri=0, naddrs=-1; rri<count; rri++) {
	325	st= adns__findrr_anychk(pai->qu, pai->serv, pai->dgram, pai->dglen, cbyte_io,
	326	&type, &class, &rdlen, &rdstart,
	327	pai->dgram, pai->dglen, dmstart, &ownermatched);
c7836bc9	328	if (st) return st;
1dfe95d8	329	if (!ownermatched \|\| class != DNS_CLASS_IN \|\| type != adns_r_a) {
	330	if (naddrs>0) break; else continue;
	331	}
	332	if (naddrs == -1) {
	333	naddrs= 0;
c7836bc9	334	}
1dfe95d8	335	if (!adns__vbuf_ensure(&pai->qu->vb, (naddrs+1)*sizeof(adns_addr))) R_NOMEM;
1dfe95d8	336	st= pa_addr(pai, rdstart,rdstart+rdlen, pai->qu->vb.buf + naddrs*sizeof(adns_addr));
c7836bc9	337	if (st) return st;
1dfe95d8	338	naddrs++;
c7836bc9	339	}
1dfe95d8	340	if (naddrs >= 0) {
	341	ha->addrs= adns__alloc_interim(pai->qu, naddrs*sizeof(adns_addr));
	342	if (!ha->addrs) R_NOMEM;
	343	memcpy(ha->addrs, pai->qu->vb.buf, naddrs*sizeof(adns_addr));
	344	ha->naddrs= naddrs;
c7836bc9	345	ha->astatus= adns_s_ok;
1dfe95d8	346
1dfe95d8	347	adns__isort(ha->addrs, naddrs, sizeof(adns_addr), pai->qu->vb.buf, di_addr);
c7836bc9	348	}
	349	return adns_s_ok;
	350	}
	351
1dfe95d8	352	static adns_status pap_hostaddr(const parseinfo pai, int cbyte_io,
1dfe95d8	353	int max, adns_rr_hostaddr *rrp) {
c7836bc9	354	adns_status st;
c7836bc9	355	int dmstart, cbyte;
7da21070	356	qcontext ctx;
	357	int id;
	358	adns_query nqu;
c7836bc9	359
c7836bc9	360	dmstart= cbyte= *cbyte_io;
1dfe95d8	361	st= pap_domain(pai, &cbyte, max, &rrp->host,
1dfe95d8	362	pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
c7836bc9	363	if (st) return st;
	364	*cbyte_io= cbyte;
	365
	366	rrp->astatus= adns_s_ok;
	367	rrp->naddrs= -1;
	368	rrp->addrs= 0;
	369
1dfe95d8	370	cbyte= pai->nsstart;
c7836bc9	371
1dfe95d8	372	st= pap_findaddrs(pai, rrp, &cbyte, pai->nscount, dmstart);
c7836bc9	373	if (st) return st;
	374	if (rrp->naddrs != -1) return adns_s_ok;
	375
1dfe95d8	376	st= pap_findaddrs(pai, rrp, &cbyte, pai->arcount, dmstart);
c7836bc9	377	if (st) return st;
c7836bc9	378	if (rrp->naddrs != -1) return adns_s_ok;
1dfe95d8	379
7da21070	380	st= adns__mkquery_frdgram(pai->ads, &pai->qu->vb, &id,
	381	pai->dgram, pai->dglen, dmstart,
	382	adns_r_addr, adns_qf_quoteok_query);
	383	if (st) return st;
	384
	385	ctx.hostaddr= rrp;
	386	st= adns__internal_submit(pai->ads, &nqu, adns__findtype(adns_r_addr),
	387	&pai->qu->vb, id,
	388	adns_qf_quoteok_query, pai->now, 0, &ctx);
	389	if (st) return st;
	390
	391	nqu->parent= pai->qu;
	392	LIST_LINK_TAIL_PART(pai->qu->children,nqu,siblings.);
1dfe95d8	393
1dfe95d8	394	return adns_s_ok;
c7836bc9	395	}
c7836bc9	396
1dfe95d8	397	static adns_status pa_hostaddr(const parseinfo pai, int cbyte, int max, void datap) {
1dfe95d8	398	adns_rr_hostaddr *rrp= datap;
c7836bc9	399	adns_status st;
c7836bc9	400
1dfe95d8	401	st= pap_hostaddr(pai, &cbyte, max, rrp);
c7836bc9	402	if (st) return st;
	403	if (cbyte != max) return adns_s_invaliddata;
	404
1dfe95d8	405	return adns_s_ok;
1dfe95d8	406	}
c7836bc9	407
1dfe95d8	408	static int dip_hostaddr(const adns_rr_hostaddr ap, const adns_rr_hostaddr bp) {
	409	if (ap->astatus != bp->astatus) return ap->astatus;
	410	if (ap->astatus) return 0;
c7836bc9	411
1dfe95d8	412	assert(ap->addrs[0].addr.sa.sa_family == AF_INET);
	413	assert(bp->addrs[0].addr.sa.sa_family == AF_INET);
	414	return dip_inaddr(ap->addrs[0].addr.inet.sin_addr, bp->addrs[0].addr.inet.sin_addr);
	415	}
	416
	417	static int di_hostaddr(const void datap_a, const void datap_b) {
	418	const adns_rr_hostaddr ap= datap_a, bp= datap_b;
	419
	420	return dip_hostaddr(ap,bp);
c7836bc9	421	}
c7836bc9	422
eb81d633	423	static void mfp_hostaddr(adns_query qu, adns_rr_hostaddr *rrp) {
eb81d633	424	void *tablev;
e062dcae	425
eb81d633	426	adns__makefinal_str(qu,&rrp->host);
	427	tablev= rrp->addrs;
	428	adns__makefinal_block(qu, &tablev, rrp->naddrssizeof(rrp->addrs));
	429	rrp->addrs= tablev;
e062dcae	430	}
e062dcae	431
eb81d633	432	static void mf_hostaddr(adns_query qu, void *datap) {
eb81d633	433	adns_rr_hostaddr *rrp= datap;
e062dcae	434
eb81d633	435	mfp_hostaddr(qu,rrp);
e062dcae	436	}
e062dcae	437
1dfe95d8	438	static adns_status csp_hostaddr(vbuf vb, const adns_rr_hostaddr rrp) {
	439	const char *to_add;
	440	adns_status st;
	441	int i;
	442
	443	st= csp_qstring(vb,rrp->host); if (st) return st;
	444
	445	if (rrp->astatus) {
	446	CSP_ADDSTR(" - ");
	447	CSP_ADDSTR(adns_strerror(rrp->astatus));
	448	} else {
	449	assert(rrp->naddrs > 0);
	450	for (i=0, to_add= ": "; i<rrp->naddrs; i++, to_add= ", ") {
	451	CSP_ADDSTR(to_add);
	452	st= csp_addr(vb,&rrp->addrs[i]);
	453	}
	454	}
	455	return adns_s_ok;
	456	}
	457
	458	static adns_status cs_hostaddr(vbuf vb, const void datap) {
	459	const adns_rr_hostaddr *rrp= datap;
	460
	461	return csp_hostaddr(vb,rrp);
	462	}
	463
eb81d633	464	/*
	465	* _mx_raw (pa,di)
	466	*/
1dfe95d8	467
eb81d633	468	static adns_status pa_mx_raw(const parseinfo pai, int cbyte, int max, void datap) {
	469	const byte *dgram= pai->dgram;
	470	adns_rr_intstr *rrp= datap;
	471	adns_status st;
	472	int pref;
1dfe95d8	473
eb81d633	474	if (cbyte+2 > max) return adns_s_invaliddata;
	475	GET_W(cbyte,pref);
	476	rrp->i= pref;
	477	st= pap_domain(pai, &cbyte, max, &rrp->str,
	478	pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
	479	if (st) return st;
1dfe95d8	480
eb81d633	481	if (cbyte != max) return adns_s_invaliddata;
	482	return adns_s_ok;
	483	}
1dfe95d8	484
eb81d633	485	static int di_mx_raw(const void datap_a, const void datap_b) {
	486	const adns_rr_intstr ap= datap_a, bp= datap_b;
	487
	488	if (ap->i < bp->i) return 0;
	489	if (ap->i > bp->i) return 1;
	490	return 0;
1dfe95d8	491	}
1dfe95d8	492
eb81d633	493	/*
	494	* _mx (pa,di)
	495	*/
1dfe95d8	496
eb81d633	497	static adns_status pa_mx(const parseinfo pai, int cbyte, int max, void datap) {
	498	const byte *dgram= pai->dgram;
	499	adns_rr_inthostaddr *rrp= datap;
	500	adns_status st;
	501	int pref;
	502
	503	if (cbyte+2 > max) return adns_s_invaliddata;
	504	GET_W(cbyte,pref);
	505	rrp->i= pref;
	506	st= pap_hostaddr(pai, &cbyte, max, &rrp->ha);
	507	if (st) return st;
	508
	509	if (cbyte != max) return adns_s_invaliddata;
	510	return adns_s_ok;
	511	}
	512
	513	static int di_mx(const void datap_a, const void datap_b) {
	514	const adns_rr_inthostaddr ap= datap_a, bp= datap_b;
	515
	516	if (ap->i < bp->i) return 0;
	517	if (ap->i > bp->i) return 1;
	518	return dip_hostaddr(&ap->ha,&bp->ha);
1dfe95d8	519	}
1dfe95d8	520
eb81d633	521	/*
	522	* _inthostaddr (mf,cs)
	523	*/
	524
1dfe95d8	525	static void mf_inthostaddr(adns_query qu, void *datap) {
	526	adns_rr_inthostaddr *rrp= datap;
	527
	528	mfp_hostaddr(qu,&rrp->ha);
	529	}
	530
eb81d633	531	static adns_status cs_inthostaddr(vbuf vb, const void datap) {
	532	const adns_rr_inthostaddr *rrp= datap;
	533	char buf[10];
e062dcae	534
eb81d633	535	sprintf(buf,"%u ",rrp->i);
	536	CSP_ADDSTR(buf);
	537
	538	return csp_hostaddr(vb,&rrp->ha);
ffbda80c	539	}
ffbda80c	540
eb81d633	541	/*
	542	* _flat (mf)
	543	*/
	544
ffbda80c	545	static void mf_flat(adns_query qu, void *data) { }
ffbda80c	546
eb81d633	547	/*
	548	* Now the table.
	549	*/
	550
e062dcae	551	#define TYPESZ_M(member) (sizeof(((adns_answer)0)->rrs.member))
86e7b8d9	552
ffbda80c	553	#define DEEP_MEMB(memb) TYPESZ_M(memb), mf_##memb, cs_##memb
ffbda80c	554	#define FLAT_MEMB(memb) TYPESZ_M(memb), mf_flat, cs_##memb
98a3f706	555
eb81d633	556	#define DEEP_TYPE(code,rrt,fmt,memb,parser,comparer) \
	557	{ adns_r_##code, rrt, fmt, TYPESZ_M(memb), mf_##memb, cs_##memb, parser, comparer }
	558	#define FLAT_TYPE(code,rrt,fmt,memb,parser,comparer) \
	559	{ adns_r_##code, rrt, fmt, TYPESZ_M(memb), mf_flat, cs_##memb, parser, comparer }
98a3f706	560
98a3f706	561	static const typeinfo typeinfos[] = {
eb81d633	562	/* Must be in ascending order of rrtype ! */
eb81d633	563	/* mem-mgmt code rrt fmt member parser comparer */
1dfe95d8	564
eb81d633	565	FLAT_TYPE(a, "A", 0, inaddr, pa_inaddr, di_inaddr ),
	566	DEEP_TYPE(ns_raw, "NS", "raw", str, pa_host_raw, 0 ),
	567	DEEP_TYPE(cname, "CNAME", 0, str, pa_host_raw, 0 ),
	568	#if 0
	569	DEEP_TYPE(soa_raw, "SOA", "raw", soa, pa_soa, 0 ),
1dfe95d8	570	#endif
eb81d633	571	DEEP_TYPE(ptr_raw, "PTR", "raw", str, pa_host_raw, 0 ),
	572	#if 0
	573	DEEP_TYPE(hinfo, "HINFO", 0, strpair, pa_hinfo, 0 ),
1dfe95d8	574	#endif
eb81d633	575	DEEP_TYPE(mx_raw, "MX", "raw", intstr, pa_mx_raw, di_mx_raw ),
	576	DEEP_TYPE(txt, "TXT", 0, manyistr, pa_txt, 0 ),
	577	#if 0
	578	DEEP_TYPE(rp_raw, "RP", "raw", strpair, pa_rp, 0 ),
1dfe95d8	579	#endif
1dfe95d8	580
eb81d633	581	FLAT_TYPE(addr, "A", "addr", addr, pa_addr, di_addr ),
	582	DEEP_TYPE(ns, "NS", "+addr", hostaddr, pa_hostaddr, di_hostaddr ),
	583	#if 0
	584	DEEP_TYPE(ptr, "PTR","checked", str, pa_ptr, 0 ),
e062dcae	585	#endif
eb81d633	586	DEEP_TYPE(mx, "MX", "+addr", inthostaddr, pa_mx, di_mx ),
1dfe95d8	587
eb81d633	588	#if 0
	589	DEEP_TYPE(soa, "SOA","822", soa, pa_soa, 0 ),
	590	DEEP_TYPE(rp, "RP", "822", strpair, pa_rp, 0 ),
	591	#endif /* fixme - implement all types */
98a3f706	592	};
98a3f706	593
f759e52e	594	const typeinfo *adns__findtype(adns_rrtype type) {
f759e52e	595	const typeinfo begin, end, *mid;
98a3f706	596
	597	begin= typeinfos; end= typeinfos+(sizeof(typeinfos)/sizeof(typeinfo));
	598
	599	while (begin < end) {
	600	mid= begin + ((end-begin)>>1);
	601	if (mid->type == type) return mid;
	602	if (type > mid->type) begin= mid+1;
	603	else end= mid;
	604	}
	605	return 0;
	606	}