X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Freply.c;h=c37bb4069683038b858fb99cd070f89f5c775472;hb=a719a4bedec2bc512b7f95f7446e02f6662ebbc7;hp=f98540cb7cc8785e131ad8746be615b8e3a149f8;hpb=61b923b38be853072bce998602c8921d469f189e;p=adns.git

diff --git a/src/reply.c b/src/reply.c
index f98540c..c37bb40 100644
--- a/src/reply.c
+++ b/src/reply.c
@@ -3,7 +3,7 @@
  * - main handling and parsing routine for received datagrams
  */
 /*
- *  This file is part of adns, which is Copyright (C) 1997, 1998 Ian Jackson
+ *  This file is part of adns, which is Copyright (C) 1997-1999 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
@@ -20,22 +20,26 @@
  *  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 
  */
 
-#include "internal.h"
+#include <stdlib.h>
+#include <string.h>
 
-static void cname_recurse(adns_query qu, adns_queryflags xflags) {
-  abort(); /* FIXME */
-}
+#include "internal.h"
     
 void adns__procdgram(adns_state ads, const byte *dgram, int dglen,
 		     int serv, struct timeval now) {
-  int cbyte, rrstart, wantedrrs, rri, foundsoa, foundns;
+  int cbyte, rrstart, wantedrrs, rri, foundsoa, foundns, cname_here;
   int id, f1, f2, qdcount, ancount, nscount, arcount;
   int flg_ra, flg_rd, flg_tc, flg_qr, opcode;
-  int rrtype, rrclass, rdlength, rdstart, ownermatched, l;
+  int rrtype, rrclass, rdlength, rdstart;
   int anstart, nsstart, arstart;
+  int ownermatched, l, nrrs;
+  const typeinfo *typei;
   adns_query qu, nqu;
   dns_rcode rcode;
   adns_status st;
+  vbuf tempvb;
+  byte *newquery, *rrsdata;
+  parseinfo pai;
   
   if (dglen<DNS_HDRSIZE) {
     adns__diag(ads,serv,0,"received datagram too short for message header (%d)",dglen);
@@ -53,14 +57,13 @@ void adns__procdgram(adns_state ads, const byte *dgram, int dglen,
 
   flg_qr= f1&0x80;
   opcode= (f1&0x78)>>3;
-  flg_tc= f1&0x20;
+  flg_tc= f1&0x02;
   flg_rd= f1&0x01;
   flg_ra= f2&0x80;
-  rcode= (f1&0x0f);
-  /* fixme: change this to f2 (which is where rcode really is), BUT
-   * not until we've figured out why the error code is wrong (bad format code 203)
-   */
+  rcode= (f2&0x0f);
 
+  cname_here= 0;
+  
   if (!flg_qr) {
     adns__diag(ads,serv,0,"server sent us a query, not a response");
     return;
@@ -87,11 +90,17 @@ void adns__procdgram(adns_state ads, const byte *dgram, int dglen,
       continue;
     break;
   }
-  anstart= qu->query_dglen;
   if (!qu) {
-    adns__debug(ads,serv,0,"reply not found (id=%02x)",id);
+    if (ads->iflags & adns_if_debug) {
+      adns__vbuf_init(&tempvb);
+      adns__debug(ads,serv,0,"reply not found, id %02x, query owner %s",
+		  id, adns__diag_domain(ads,serv,0,&tempvb,dgram,dglen,DNS_HDRSIZE));
+      adns__vbuf_free(&tempvb);
+    }
     return;
   }
+  anstart= qu->query_dglen;
+  arstart= -1;
 
   LIST_UNLINK(ads->timew,qu);
   /* We're definitely going to do something with this query now */
@@ -102,22 +111,22 @@ void adns__procdgram(adns_state ads, const byte *dgram, int dglen,
     break;
   case rcode_formaterror:
     adns__warn(ads,serv,qu,"server cannot understand our query (Format Error)");
-    adns__query_fail(qu,adns_s_serverfaulty);
+    adns__query_fail(qu,adns_s_rcodeformaterror);
     return;
   case rcode_servfail:
-    adns__query_fail(qu,adns_s_servfail);
+    adns__query_fail(qu,adns_s_rcodeservfail);
     return;
   case rcode_notimp:
     adns__warn(ads,serv,qu,"server claims not to implement our query");
-    adns__query_fail(qu,adns_s_notimplemented);
+    adns__query_fail(qu,adns_s_rcodenotimplemented);
     return;
   case rcode_refused:
     adns__warn(ads,serv,qu,"server refused our query");
-    adns__query_fail(qu,adns_s_refused);
+    adns__query_fail(qu,adns_s_rcoderefused);
     return;
   default:
     adns__warn(ads,serv,qu,"server gave unknown response code %d",rcode);
-    adns__query_fail(qu,adns_s_reasonunknown);
+    adns__query_fail(qu,adns_s_rcodeunknown);
     return;
   }
 
@@ -125,12 +134,13 @@ void adns__procdgram(adns_state ads, const byte *dgram, int dglen,
    * If it has any CNAMEs we stuff them in the answer.
    */
   wantedrrs= 0;
+  cbyte= anstart;
   for (rri= 0; rri<ancount; rri++) {
     rrstart= cbyte;
     st= adns__findrr(qu,serv, dgram,dglen,&cbyte,
 		     &rrtype,&rrclass,&rdlength,&rdstart,
 		     &ownermatched);
-    if (st) adns__query_fail(qu,st);
+    if (st) { adns__query_fail(qu,st); return; }
     if (rrtype == -1) goto x_truncated;
 
     if (rrclass != DNS_CLASS_IN) {
@@ -141,26 +151,32 @@ void adns__procdgram(adns_state ads, const byte *dgram, int dglen,
     if (!ownermatched) {
       if (ads->iflags & adns_if_debug) {
 	adns__debug(ads,serv,qu,"ignoring RR with an unexpected owner %s",
-		    adns__diag_domain(ads,serv,qu, &qu->vb,qu->flags,
-				      dgram,dglen,rrstart));
+		    adns__diag_domain(ads,serv,qu, &qu->vb, dgram,dglen,rrstart));
       }
       continue;
     }
-    if (rrtype == adns_r_cname &&
+    if (rrtype == adns_r_cname && /* fixme - implement adns_qf_nocname */
 	(qu->typei->type & adns__rrt_typemask) != adns_r_cname) {
-      if (!qu->cname_dgram) { /* Ignore second and subsequent CNAMEs */
-	qu->cname_dgram= adns__alloc_mine(qu,dglen);
-	if (!qu->cname_dgram) return;
+      if (qu->flags & adns_qf_cname_forbid) {
+	adns__query_fail(qu,adns_s_prohibitedcname);
+	return;
+      } else if (!qu->cname_dgram) { /* Ignore second and subsequent CNAMEs */
 	qu->cname_begin= rdstart;
 	qu->cname_dglen= dglen;
-	st= adns__parse_domain(ads,serv,qu, &qu->vb,qu->flags,
+	st= adns__parse_domain(ads,serv,qu, &qu->vb,
+			       qu->flags & adns_qf_quoteok_cname ? pdf_quoteok : 0,
 			       dgram,dglen, &rdstart,rdstart+rdlength);
 	if (!qu->vb.used) goto x_truncated;
 	if (st) { adns__query_fail(qu,st); return; }
 	l= strlen(qu->vb.buf)+1;
 	qu->answer->cname= adns__alloc_interim(qu,l);
-	if (!qu->answer->cname) return;
+	if (!qu->answer->cname) { adns__query_fail(qu,adns_s_nomemory); return; }
+
+	qu->cname_dgram= adns__alloc_mine(qu,dglen);
+	memcpy(qu->cname_dgram,dgram,dglen);
+
 	memcpy(qu->answer->cname,qu->vb.buf,l);
+	cname_here= 1;
 	/* If we find the answer section truncated after this point we restart
 	 * the query at the CNAME; if beforehand then we obviously have to use
 	 * TCP.  If there is no truncation we can use the whole answer if
@@ -168,8 +184,7 @@ void adns__procdgram(adns_state ads, const byte *dgram, int dglen,
 	 */
       } else {
 	adns__debug(ads,serv,qu,"ignoring duplicate CNAME (%s, as well as %s)",
-		    adns__diag_domain(ads,serv,qu, &qu->vb,qu->flags,
-				      dgram,dglen,rdstart),
+		    adns__diag_domain(ads,serv,qu, &qu->vb, dgram,dglen,rdstart),
 		    qu->answer->cname);
       }
     } else if (rrtype == (qu->typei->type & adns__rrt_typemask)) {
@@ -179,7 +194,11 @@ void adns__procdgram(adns_state ads, const byte *dgram, int dglen,
     }
   }
 
-  /* If we got here then the answer section is intact. */
+  /* We defer handling truncated responses here, in case there was a CNAME
+   * which we could use.
+   */
+  if (flg_tc) goto x_truncated;
+  
   nsstart= cbyte;
 
   if (!wantedrrs) {
@@ -219,7 +238,7 @@ void adns__procdgram(adns_state ads, const byte *dgram, int dglen,
      * a CNAME in this datagram then we should probably do our own CNAME
      * lookup now in the hope that we won't get a referral again.
      */
-    if (qu->cname_dgram == dgram) { cname_recurse(qu,0); return; }
+    if (cname_here) goto x_restartquery;
 
     /* Bloody hell, I thought we asked for recursion ? */
     if (flg_rd) {
@@ -230,7 +249,7 @@ void adns__procdgram(adns_state ads, const byte *dgram, int dglen,
       adns__query_fail(qu,adns_s_norecurse);
     } else {
       adns__diag(ads,serv,qu,"server claims to do recursion, but gave us a referral");
-      adns__query_fail(qu,adns_s_serverfaulty);
+      adns__query_fail(qu,adns_s_invalidresponse);
     }
     return;
   }
@@ -238,11 +257,23 @@ void adns__procdgram(adns_state ads, const byte *dgram, int dglen,
   /* Now, we have some RRs which we wanted. */
 
   qu->answer->rrs.untyped= adns__alloc_interim(qu,qu->typei->rrsz*wantedrrs);
-  if (!qu->answer->rrs.untyped) return;
+  if (!qu->answer->rrs.untyped) { adns__query_fail(qu,adns_s_nomemory); return; }
 
+  typei= qu->typei;
   cbyte= anstart;
-  arstart= -1;
-  for (rri=0; rri<ancount; rri++) {
+  rrsdata= qu->answer->rrs.bytes;
+
+  pai.ads= qu->ads;
+  pai.qu= qu;
+  pai.serv= serv;
+  pai.dgram= dgram;
+  pai.dglen= dglen;
+  pai.nsstart= nsstart;
+  pai.nscount= nscount;
+  pai.arcount= arcount;
+  pai.now= now;
+
+  for (rri=0, nrrs=0; rri<ancount; rri++) {
     st= adns__findrr(qu,serv, dgram,dglen,&cbyte,
 		     &rrtype,&rrclass,&rdlength,&rdstart,
 		     &ownermatched);
@@ -251,13 +282,13 @@ void adns__procdgram(adns_state ads, const byte *dgram, int dglen,
 	rrtype != (qu->typei->type & adns__rrt_typemask) ||
 	!ownermatched)
       continue;
-    assert(qu->answer->nrrs<wantedrrs);
-    st= qu->typei->parse(qu,serv,
-			 dgram,dglen, rdstart,rdstart+rdlength,
-			 qu->answer->rrs.bytes+qu->answer->nrrs*qu->typei->rrsz);
+    st= typei->parse(&pai, rdstart,rdstart+rdlength, rrsdata+nrrs*typei->rrsz);
     if (st) { adns__query_fail(qu,st); return; }
     if (rdstart==-1) goto x_truncated;
+    nrrs++;
   }
+  assert(nrrs==wantedrrs);
+  qu->answer->nrrs= nrrs;
 
   /* This may have generated some child queries ... */
   if (qu->children.head) {
@@ -270,13 +301,30 @@ void adns__procdgram(adns_state ads, const byte *dgram, int dglen,
   return;
 
  x_truncated:
+  
   if (!flg_tc) {
     adns__diag(ads,serv,qu,"server sent datagram which points outside itself");
-    adns__query_fail(qu,adns_s_serverfaulty);
+    adns__query_fail(qu,adns_s_invalidresponse);
     return;
   }
-  if (qu->cname_dgram) { cname_recurse(qu,adns_qf_usevc); return; }
-  adns__reset_cnameonly(qu);
   qu->flags |= adns_qf_usevc;
+  
+ x_restartquery:
+  
+  if (qu->cname_dgram) {
+    st= adns__mkquery_frdgram(qu->ads,&qu->vb,&qu->id,
+			      qu->cname_dgram, qu->cname_dglen, qu->cname_begin,
+			      qu->typei->type, qu->flags);
+    if (st) { adns__query_fail(qu,st); return; }
+    
+    newquery= realloc(qu->query_dgram,qu->vb.used);
+    if (!newquery) { adns__query_fail(qu,adns_s_nomemory); return; }
+    
+    qu->query_dgram= newquery;
+    qu->query_dglen= qu->vb.used;
+    memcpy(newquery,qu->vb.buf,qu->vb.used);
+  }
+  
+  adns__reset_cnameonly(qu);
   adns__query_udp(qu,now);
 }