X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=adns.git;a=blobdiff_plain;f=src%2Finternal.h;h=7faa2123c4abe4bffec95183ed607c0ed1551536;hp=5f8892e40b07bd58d776ca7cbeb6d1a73034d111;hb=11a38eb17bbedce089254ff65f8c01f9d78004d3;hpb=e8e5aeacbdaf5654974626d548f30a4c86e5ced6 diff --git a/src/internal.h b/src/internal.h index 5f8892e..7faa212 100644 --- a/src/internal.h +++ b/src/internal.h @@ -69,6 +69,7 @@ typedef unsigned char byte; #define DNS_CLASS_IN 1 #define DNS_INADDR_ARPA "in-addr", "arpa" +#define DNS_IP6_ARPA "ip6", "arpa" #define MAX_POLLFDS ADNS_POLLFDS_RECOMMENDED @@ -124,8 +125,21 @@ typedef struct { struct timeval now; } parseinfo; +union gen_addr { + struct in_addr v4; + struct in6_addr v6; +}; + +struct af_addr { int af; union gen_addr addr; }; + +#define NREVDOMAINS 2 /* keep in sync with addrfam! */ +struct revparse_state { + unsigned map; /* which domains are still live */ + byte ipv[NREVDOMAINS][32]; /* address components so far */ +}; + union checklabel_state { - int dummy; + struct revparse_state ptr; }; typedef struct { @@ -133,7 +147,10 @@ typedef struct { void (*callback)(adns_query parent, adns_query child); union { - adns_rr_addr ptr_addr; + struct { + adns_rrtype rev_rrtype; + struct af_addr addr; + } ptr; } tinfo; /* type-specific state for the query itself: zero-init if you * don't know better. */ @@ -146,7 +163,7 @@ typedef struct typeinfo { adns_rrtype typekey; const char *rrtname; const char *fmtname; - int rrsz; + int fixed_rrsz; void (*makefinal)(adns_query qu, void *data); /* Change memory management of *data. @@ -164,7 +181,7 @@ typedef struct typeinfo { /* Parse one RR, in dgram of length dglen, starting at cbyte and * extending until at most max. * - * The RR should be stored at *store_r, of length qu->typei->rrsz. + * The RR should be stored at *store_r, of length qu->typei->getrrsz(). * * If there is an overrun which might indicate truncation, it should set * *rdstart to -1; otherwise it may set it to anything else positive. @@ -189,12 +206,17 @@ typedef struct typeinfo { * because lablen is zero. */ - void (*postsort)(adns_state ads, void *array, int nrrs, + void (*postsort)(adns_state ads, void *array, int nrrs,int rrsz, const struct typeinfo *typei); /* Called immediately after the RRs have been sorted, and may rearrange * them. (This is really for the benefit of SRV's bizarre weighting * stuff.) May be 0 to mean nothing needs to be done. */ + + int (*getrrsz)(const struct typeinfo *typei, adns_rrtype type); + /* Return the output resource-record element size; if this is null, then + * the rrsz member can be used. + */ } typeinfo; adns_status adns__ckl_hostname(adns_state ads, adns_queryflags flags, @@ -207,6 +229,7 @@ adns_status adns__ckl_hostname(adns_state ads, adns_queryflags flags, typedef struct allocnode { struct allocnode *next, *back; + size_t sz; } allocnode; union maxalign { @@ -328,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; @@ -335,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 { int af; int fd; } udpsocket[MAXUDP]; + int nudp; vbuf tcpsend, tcprecv; int nservers, nsortlist, nsearchlist, searchndots, tcpserver, tcprecv_skip; enum adns__tcpstate { @@ -351,16 +378,113 @@ 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 { - struct in_addr base, mask; + int af; + union gen_addr base, mask; } sortlist[MAXSORTLIST]; char **searchlist; unsigned short rand48xsubi[3]; }; +/* From addrfam.c: */ + +extern int adns__af_supported_p(int af); +/* Return nonzero if the address family af known to the library and supported + * by the other addrfam operations. Note that the other operations will + * abort on an unrecognized address family rather than returning an error + * code. + */ + +extern int adns__genaddr_equal_p(int af, const union gen_addr *a, + int bf, const void *b); +/* b should point to a `struct in_addr' or equivalent for the address family + * bf. Returns nonzero if the two addresses are equal. + */ + +extern int adns__sockaddr_equal_p(const struct sockaddr *sa, + const struct sockaddr *sb); +/* Return nonzero if the two socket addresses are equal (in all significant + * respects). + */ + +extern int adns__addr_width(int af); +/* Return the width of addresses of family af, in bits. */ + +extern void adns__prefix_mask(int af, int len, union gen_addr *mask_r); +/* Store in mask_r an address mask for address family af, whose first len + * bits are set and the remainder are clear. This is what you want for + * converting a prefix length into a netmask. + */ + +extern int adns__guess_prefix_length(int af, const union gen_addr *addr); +/* Given a network base address, guess the appropriate prefix length based on + * the appropriate rules for the address family (e.g., for IPv4, this uses + * the old address classes). + */ + +extern int adns__addr_match_p(int addraf, const union gen_addr *addr, + int netaf, const union gen_addr *base, + const union gen_addr *mask); +/* Given an address af (with family addraf) and a network (with family netaf, + * base address base, and netmask mask), return nonzero if the address lies + * within the network. + */ + +extern void adns__sockaddr_extract(const struct sockaddr *sa, + union gen_addr *a_r, int *port_r); +/* Extract fields from the socket address, filling in *a_r and *port_r with + * the address and (integer, host byte-order) port number, respectively. + * Either (or, pointlessly, both) of a_r and port_r may be null to mean + * `don't care'. + */ + +extern void adns__sockaddr_inject(const union gen_addr *a, int port, + struct sockaddr *sa); +/* Inject fields into the socket adress sa. If a is not null, copy the + * address in; if port is not -1, then copy the port (converting from host + * byte-order). Assumes that sa->sa_family is already set correctly. + */ + +char *adns__sockaddr_ntoa(const struct sockaddr *sa, char *buf); +/* Convert sa to a string, and write it to buf, which must be at least + * ADNS_ADDR2TEXT_BUFLEN bytes long (unchecked). Return buf; can't fail. + */ + +extern int adns__make_reverse_domain(const struct sockaddr *sa, + const char *zone, + char **buf_io, size_t bufsz, + char **buf_free_r); +/* Construct a reverse domain string, given a socket address and a parent + * zone. If zone is null, then use the standard reverse-lookup zone for the + * address family. If the length of the resulting string is no larger than + * bufsz, then the result is stored starting at *buf_io; otherwise a new + * buffer is allocated is used, and a pointer to it is stored in both *buf_io + * and *buf_free_r (the latter of which should be null on entry). If + * something goes wrong, then an errno value is returned: ENOSYS if the + * address family of sa isn't recognized, or ENOMEM if the attempt to + * allocate an output buffer failed. + */ + +extern int adns__revparse_label(struct revparse_state *rps, int labnum, + const char *label, int lablen); +/* Parse a label in a reverse-domain name, given its index labnum (starting + * from zero), a pointer to its contents (which need not be null-terminated), + * and its length. The state in *rps is initialized implicitly when labnum + * is zero. + * + * Returns zero if the parse was successful, nonzero if the domain name is + * definitely invalid and the parse must be abandoned. + */ + +extern int adns__revparse_done(struct revparse_state *rps, int nlabels, + adns_rrtype *rrtype_r, struct af_addr *addr_r); +/* Finishes parsing a reverse-domain name, given the total number of labels + * in the name. On success, fills in the address in *addr_r, and the forward + * query type in *rrtype_r (because that turns out to be useful). Returns + * nonzero if the parse must be abandoned. + */ + /* From setup.c: */ int adns__setnonblock(adns_state ads, int fd); /* => errno value */ @@ -403,6 +527,11 @@ const char *adns__diag_domain(adns_state ads, int serv, adns_query qu, * vb before using the return value. */ +int adns__getrrsz_default(const typeinfo *typei, adns_rrtype type); +/* Default function for the `getrrsz' type hook; returns the `fixed_rrsz' + * value from the typeinfo entry. + */ + void adns__isort(void *array, int nobjs, int sz, void *tempbuf, int (*needswap)(void *context, const void *a, const void *b), void *context); @@ -444,6 +573,15 @@ void adns__querysend_tcp(adns_query qu, struct timeval now); * might be broken, but no reconnect will be attempted. */ +struct udpsocket *adns__udpsocket_by_af(adns_state ads, int af); +/* Find the UDP socket structure in ads which has the given address family. + * Return null if there isn't one. + * + * This is used during initialization, so ads is only partially filled in. + * The requirements are that nudp is set, and that udpsocket[i].af are + * defined for 0<=icname 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