cname_loose/cname_forbid implemented; production timeout

[adns.git] / src / types.c

diff --git a/src/types.c b/src/types.c
index 2803d11e8690dc445da683a9a5718565d0c7275b..9f7dbd336a6b01333432c3823ee271ed209163a2 100644 (file)
--- a/src/types.c
+++ b/src/types.c
@@ -27,7 +27,7 @@
 
 #include "internal.h"
 
-#define R_NOMEM           return adns_s_nolocalmem
+#define R_NOMEM           return adns_s_nomemory
 #define CSP_ADDSTR(s)     if (!adns__vbuf_appendstr(vb,(s))) R_NOMEM; else;
 
 /*
@@ -245,15 +245,30 @@ static adns_status pa_inaddr(const parseinfo *pai, int cbyte, int max, void *dat
   return adns_s_ok;
 }
 
-static int dip_inaddr(struct in_addr a, struct in_addr b) {
-  /* fixme implement sortlist */
-  return 0;
+static int search_sortlist(adns_state ads, struct in_addr ad) {
+  const struct sortlist *slp;
+  int i;
+  
+  for (i=0, slp=ads->sortlist;
+       i<ads->nsortlist && !((ad.s_addr & slp->mask.s_addr) == slp->base.s_addr);
+       i++, slp++);
+  return i;
+}
+
+static int dip_inaddr(adns_state ads, struct in_addr a, struct in_addr b) {
+  int ai, bi;
+  
+  if (!ads->nsortlist) return 0;
+
+  ai= search_sortlist(ads,a);
+  bi= search_sortlist(ads,b);
+  return bi<ai;
 }
 
-static int di_inaddr(const void *datap_a, const void *datap_b) {
+static int di_inaddr(adns_state ads, const void *datap_a, const void *datap_b) {
   const struct in_addr *ap= datap_a, *bp= datap_b;
 
-  return dip_inaddr(*ap,*bp);
+  return dip_inaddr(ads,*ap,*bp);
 }
 
 static adns_status cs_inaddr(vbuf *vb, const void *datap) {
@@ -281,13 +296,19 @@ static adns_status pa_addr(const parseinfo *pai, int cbyte, int max, void *datap
   return adns_s_ok;
 }
 
-static int di_addr(const void *datap_a, const void *datap_b) {
+static int di_addr(adns_state ads, const void *datap_a, const void *datap_b) {
   const adns_rr_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);
+  return dip_inaddr(ads, ap->addr.inet.sin_addr, bp->addr.inet.sin_addr);
 }
 
+static int div_addr(void *context, const void *datap_a, const void *datap_b) {
+  const adns_state ads= context;
+
+  return di_addr(ads, datap_a, datap_b);
+}                   
+
 static adns_status csp_addr(vbuf *vb, const adns_rr_addr *rrp) {
   const char *ia;
   static char buf[30];
@@ -386,7 +407,8 @@ static adns_status pap_findaddrs(const parseinfo *pai, adns_rr_hostaddr *ha,
     ha->naddrs= naddrs;
     ha->astatus= adns_s_ok;
 
-    adns__isort(ha->addrs, naddrs, sizeof(adns_rr_addr), pai->qu->vb.buf, di_addr);
+    adns__isort(ha->addrs, naddrs, sizeof(adns_rr_addr), pai->qu->vb.buf,
+               div_addr, pai->ads);
   }
   return adns_s_ok;
 }
@@ -410,6 +432,7 @@ static adns_status pap_hostaddr(const parseinfo *pai, int *cbyte_io,
   qcontext ctx;
   int id;
   adns_query nqu;
+  adns_queryflags nflags;
 
   dmstart= cbyte= *cbyte_io;
   st= pap_domain(pai, &cbyte, max, &rrp->host,
@@ -439,9 +462,12 @@ static adns_status pap_hostaddr(const parseinfo *pai, int *cbyte_io,
   ctx.ext= 0;
   ctx.callback= icb_hostaddr;
   ctx.info.hostaddr= rrp;
+  
+  nflags= adns_qf_quoteok_query;
+  if (!(pai->qu->flags & adns_qf_cname_loose)) nflags |= adns_qf_cname_forbid;
+  
   st= adns__internal_submit(pai->ads, &nqu, adns__findtype(adns_r_addr),
-                           &pai->qu->vb, id,
-                           adns_qf_quoteok_query, pai->now, 0, &ctx);
+                           &pai->qu->vb, id, nflags, pai->now, 0, &ctx);
   if (st) return st;
 
   nqu->parent= pai->qu;
@@ -461,19 +487,21 @@ static adns_status pa_hostaddr(const parseinfo *pai, int cbyte, int max, void *d
   return adns_s_ok;
 }
 
-static int dip_hostaddr(const adns_rr_hostaddr *ap, const adns_rr_hostaddr *bp) {
+static int dip_hostaddr(adns_state ads, 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);
+  return dip_inaddr(ads,
+                   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) {
+static int di_hostaddr(adns_state ads, const void *datap_a, const void *datap_b) {
   const adns_rr_hostaddr *ap= datap_a, *bp= datap_b;
 
-  return dip_hostaddr(ap,bp);
+  return dip_hostaddr(ads, ap,bp);
 }
 
 static void mfp_hostaddr(adns_query qu, adns_rr_hostaddr *rrp) {
@@ -538,7 +566,7 @@ static adns_status pa_mx_raw(const parseinfo *pai, int cbyte, int max, void *dat
   return adns_s_ok;
 }
 
-static int di_mx_raw(const void *datap_a, const void *datap_b) {
+static int di_mx_raw(adns_state ads, 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;
@@ -566,12 +594,12 @@ static adns_status pa_mx(const parseinfo *pai, int cbyte, int max, void *datap)
   return adns_s_ok;
 }
 
-static int di_mx(const void *datap_a, const void *datap_b) {
+static int di_mx(adns_state ads, 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);
+  return dip_hostaddr(ads, &ap->ha, &bp->ha);
 }
 
 /*
@@ -650,20 +678,20 @@ static adns_status pa_ptr(const parseinfo *pai, int dmstart, int max, void *data
                          pai->qu->query_dglen, DNS_HDRSIZE, 0);
     for (i=0; i<4; i++) {
       st= adns__findlabel_next(&fls,&lablen,&labstart); assert(!st);
-      if (lablen<=0 || lablen>3) return adns_s_invalidquerydomain;
+      if (lablen<=0 || lablen>3) return adns_s_querydomainwrong;
       memcpy(labbuf, pai->qu->query_dgram + labstart, lablen);  labbuf[lablen]= 0;
-      ipv[3-i]= strtoul(labbuf,&ep,10);  if (*ep) return adns_s_invalidquerydomain;
+      ipv[3-i]= strtoul(labbuf,&ep,10);  if (*ep) return adns_s_querydomainwrong;
       if (lablen>1 && pai->qu->query_dgram[labstart]=='0')
-       return adns_s_invalidquerydomain;
+       return adns_s_querydomainwrong;
     }
     for (i=0; i<sizeof(expectdomain)/sizeof(*expectdomain); i++) {
       st= adns__findlabel_next(&fls,&lablen,&labstart); assert(!st);
       l= strlen(expectdomain[i]);
       if (lablen != l || memcmp(pai->qu->query_dgram + labstart, expectdomain[i], l))
-       return adns_s_invalidquerydomain;
+       return adns_s_querydomainwrong;
     }
     st= adns__findlabel_next(&fls,&lablen,0); assert(!st);
-    if (lablen) return adns_s_invalidquerydomain;
+    if (lablen) return adns_s_querydomainwrong;
     
     ap->len= sizeof(struct sockaddr_in);
     memset(&ap->addr,0,sizeof(ap->addr.inet));