Finished CNAME handling. Except that there's no testing, and it

[adns] / src / internal.h

diff --git a/src/internal.h b/src/internal.h
index 7cf4cec9daa94f190f63fd94ba149eaee6fdec3d..40da52d5bda5ffd05343b8e24a6780969d6cda3c 100644 (file)
--- a/src/internal.h
+++ b/src/internal.h
@@ -42,6 +42,7 @@ typedef unsigned char byte;
 
 #include <sys/time.h>
 
+#define ADNS_FEATURE_MANYAF
 #include "adns.h"
 #include "dlist.h"
 
@@ -71,6 +72,9 @@ typedef unsigned char byte;
 #define DNS_INADDR_ARPA "in-addr", "arpa"
 #define DNS_IP6_ARPA "ip6", "arpa"
 
+#define STRINGIFY(x) REALLY_STRINGIFY(x)
+#define REALLY_STRINGIFY(x) #x
+
 #define MAX_POLLFDS  ADNS_POLLFDS_RECOMMENDED
 
 typedef enum {
@@ -88,6 +92,13 @@ typedef enum {
   rcode_refused
 } dns_rcode;
 
+enum {
+  adns__qf_senddirect = 0x00100000,/* don't call the `query_send' type hook */
+  adns__qf_nosend     = 0x00200000,/* don't send the query when submitting */
+  adns__qf_addr_answer= 0x01000000,/* addr query received an answer */
+  adns__qf_addr_cname = 0x02000000 /* addr subquery performed on cname */
+};
+
 /* Shared data structures */
 
 typedef union {
@@ -125,14 +136,16 @@ typedef struct {
   int nrevcomp;
   int revcompwd;
   adns_rrtype rrtype;
-  void *(*sockaddr_to_inaddr)(struct sockaddr *sa);
+  const void *(*sockaddr_to_inaddr)(const struct sockaddr *sa);
+  int (*sockaddr_equalp)(const struct sockaddr *sa,
+                        const struct sockaddr *sb);
   void (*prefix_mask)(int len, union gen_addr *a);
   int (*guess_len)(const union gen_addr *a);
   int (*matchp)(const union gen_addr *addr,
                const union gen_addr *base, const union gen_addr *mask);
   int (*rev_parsecomp)(const char *p, size_t n);
   void (*rev_mkaddr)(union gen_addr *addr, const byte *ipv);
-  char *(*rev_mkname)(struct sockaddr *sa, char *buf);
+  char *(*rev_mkname)(const struct sockaddr *sa, char *buf);
 } afinfo;
 
 struct afinfo_addr { const afinfo *ai; union gen_addr addr; };
@@ -189,6 +202,12 @@ typedef struct typeinfo {
    * them.  (This is really for the benefit of SRV's bizarre weighting
    * stuff.)  May be 0 to mean nothing needs to be done.
    */
+
+  void (*query_send)(adns_query qu, struct timeval now);
+  /* Send the query to nameservers, and hook it into the appropriate queue.
+   * Normal behaviour is to call adns__query_send, but this can be overridden
+   * for special effects.
+   */
 } typeinfo;
 
 adns_status adns__qdpl_normal(adns_state ads,
@@ -201,6 +220,7 @@ adns_status adns__qdpl_normal(adns_state ads,
 
 typedef struct allocnode {
   struct allocnode *next, *back;
+  size_t sz;
 } allocnode;
 
 union maxalign {
@@ -331,6 +351,8 @@ struct adns__query {
 
 struct query_queue { adns_query head, tail; };
 
+#define MAXUDP 2
+
 struct adns__state {
   adns_initflags iflags;
   adns_logcallbackfn *logfn;
@@ -338,7 +360,9 @@ struct adns__state {
   int configerrno;
   struct query_queue udpw, tcpw, childw, output;
   adns_query forallnext;
-  int nextid, udpsocket, tcpsocket;
+  int nextid, tcpsocket;
+  struct udpsocket { const afinfo *ai; int fd; } udpsocket[MAXUDP];
+  int nudp;
   vbuf tcpsend, tcprecv;
   int nservers, nsortlist, nsearchlist, searchndots, tcpserver, tcprecv_skip;
   enum adns__tcpstate {
@@ -354,9 +378,7 @@ struct adns__state {
   struct sigaction stdsigpipe;
   sigset_t stdsigmask;
   struct pollfd pollfds_buf[MAX_POLLFDS];
-  struct server {
-    struct in_addr addr;
-  } servers[MAXSERVERS];
+  adns_rr_addr servers[MAXSERVERS];
   struct sortlist {
     const afinfo *ai;
     union gen_addr base, mask;
@@ -375,6 +397,7 @@ int adns__setnonblock(adns_state ads, int fd); /* => errno value */
 
 /* From general.c: */
 
+const char *adns__sockaddr_ntoa(struct sockaddr *sa, size_t n);
 void adns__vlprintf(adns_state ads, const char *fmt, va_list al);
 void adns__lprintf(adns_state ads, const char *fmt,
                   ...) PRINTFFORMAT(2,3);
@@ -465,8 +488,8 @@ void adns__query_send(adns_query qu, struct timeval now);
 /* From query.c: */
 
 adns_status adns__internal_submit(adns_state ads, adns_query *query_r,
-                                 const typeinfo *typei, vbuf *qumsg_vb,
-                                 int id,
+                                 const typeinfo *typei, adns_rrtype,
+                                 vbuf *qumsg_vb, int id,
                                  adns_queryflags flags, struct timeval now,
                                  const qcontext *ctx);
 /* Submits a query (for internal use, called during external submits).
@@ -477,6 +500,10 @@ adns_status adns__internal_submit(adns_state ads, adns_query *query_r,
  * the memory for it is _taken over_ by this routine whether it
  * succeeds or fails (if it succeeds, the vbuf is reused for qu->vb).
  *
+ * If adns__qf_nosend is set in flags, then the query is not sent: doing
+ * whatever is necessary to send the query and link it onto the appropriate
+ * queue is left as the caller's responsibility.
+ *
  * *ctx is copied byte-for-byte into the query.
  *
  * When the child query is done, ctx->callback will be called.  The
@@ -527,8 +554,7 @@ void *adns__alloc_preserved(adns_query qu, size_t sz);
  *  answer->cname and answer->owner are _preserved.
  */
 
-void adns__transfer_interim(adns_query from, adns_query to,
-                           void *block, size_t sz);
+void adns__transfer_interim(adns_query from, adns_query to, void *block);
 /* Transfers an interim allocation from one query to another, so that
  * the `to' query will have room for the data when we get to makefinal
  * and so that the free will happen when the `to' query is freed
@@ -542,6 +568,10 @@ void adns__transfer_interim(adns_query from, adns_query to,
  * TTLs get inherited by their parents.
  */
 
+void adns__free_interim(adns_query qu, void *p);
+/* Forget about a block allocated by adns__alloc_interim.
+ */
+
 void *adns__alloc_mine(adns_query qu, size_t sz);
 /* Like _interim, but does not record the length for later
  * copying into the answer.  This just ensures that the memory
@@ -565,6 +595,7 @@ void adns__reset_preserved(adns_query qu);
 
 void adns__query_done(adns_query qu);
 void adns__query_fail(adns_query qu, adns_status stat);
+void adns__cancel_children(adns_query qu);
 
 /* From reply.c: */