X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=adns.git;a=blobdiff_plain;f=src%2Finternal.h;h=24c5c829f69162094a67c121337bc179eb5050f8;hp=4caa9de6031c8177ffb73880f6b6bd07add6ccbc;hb=c0af047b137721acff216e6d5665433ff2a366cb;hpb=239d2e4dfb6fcfc26fe3f740efae8f6944b99799 diff --git a/src/internal.h b/src/internal.h index 4caa9de..24c5c82 100644 --- a/src/internal.h +++ b/src/internal.h @@ -5,12 +5,11 @@ * - comments regarding library data structures */ /* - * This file is - * Copyright (C) 1997-2000 Ian Jackson - * - * It is part of adns, which is - * Copyright (C) 1997-2000 Ian Jackson - * Copyright (C) 1999-2000 Tony Finch + * This file is part of adns, which is + * Copyright (C) 1997-2000,2003,2006 Ian Jackson + * Copyright (C) 1999-2000,2003,2006 Tony Finch + * Copyright (C) 1991 Massachusetts Institute of Technology + * (See the file INSTALL for full details.) * * 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 @@ -39,9 +38,12 @@ typedef unsigned char byte; #include #include #include +#include +#include #include +#define ADNS_FEATURE_MANYAF #include "adns.h" #include "dlist.h" @@ -68,10 +70,29 @@ typedef unsigned char byte; #define DNS_IDOFFSET 0 #define DNS_CLASS_IN 1 -#define DNS_INADDR_ARPA "in-addr", "arpa" - #define MAX_POLLFDS ADNS_POLLFDS_RECOMMENDED +/* Some preprocessor hackery */ + +#define GLUE(x, y) GLUE_(x, y) +#define GLUE_(x, y) x##y + +/* C99 macro `...' must match at least one argument, so the naive definition + * `#define CAR(car, ...) car' won't work. But it's easy to arrange for the + * tail to be nonempty if we're just going to discard it anyway. */ +#define CAR(...) CAR_(__VA_ARGS__, _) +#define CAR_(car, ...) car + +/* Extracting the tail of an argument list is rather more difficult. The + * following trick is based on one by Laurent Deniau to count the number of + * arguments to a macro, simplified in two ways: (a) it only handles up to + * eight arguments, and (b) it only needs to distinguish the one-argument + * case from many arguments. */ +#define CDR(...) CDR_(__VA_ARGS__, m, m, m, m, m, m, m, 1, _)(__VA_ARGS__) +#define CDR_(_1, _2, _3, _4, _5, _6, _7, _8, n, ...) CDR_##n +#define CDR_1(_) +#define CDR_m(_, ...) __VA_ARGS__ + typedef enum { cc_user, cc_entex, @@ -87,16 +108,12 @@ typedef enum { rcode_refused } dns_rcode; -/* Shared data structures */ +enum { + adns__qf_addr_answer= 0x01000000,/* addr query received an answer */ + adns__qf_addr_cname = 0x02000000 /* addr subquery performed on cname */ +}; -typedef union { - adns_status status; - char *cp; - adns_rrtype type; - int i; - struct in_addr ia; - unsigned long ul; -} rr_align; +/* Shared data structures */ typedef struct { int used, avail; @@ -112,11 +129,41 @@ typedef struct { struct timeval now; } parseinfo; +#define MAXREVLABELS 34 /* keep in sync with addrfam! */ +struct revparse_state { + uint16_t labstart[MAXREVLABELS]; + uint8_t lablen[MAXREVLABELS]; +}; + +union checklabel_state { + struct revparse_state ptr; +}; + typedef struct { - adns_rrtype type; + void *ext; + void (*callback)(adns_query parent, adns_query child); + + union { + struct { + adns_rrtype rev_rrtype; + adns_sockaddr addr; + } ptr; + struct { + unsigned want, have; + } addr; + } tinfo; /* type-specific state for the query itself: zero-init if you + * don't know better. */ + + union { + adns_rr_hostaddr *hostaddr; + } pinfo; /* state for use by parent's callback function */ +} qcontext; + +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. @@ -129,11 +176,12 @@ typedef struct { * and will not be null-terminated by convstring. */ - adns_status (*parse)(const parseinfo *pai, int cbyte, int max, void *store_r); + adns_status (*parse)(const parseinfo *pai, int cbyte, + int max, void *store_r); /* 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. @@ -141,14 +189,54 @@ typedef struct { * nsstart is the offset of the authority section. */ - int (*diff_needswap)(adns_state ads, const void *datap_a, const void *datap_b); + int (*diff_needswap)(adns_state ads,const void *datap_a,const void *datap_b); /* Returns !0 if RR a should be strictly after RR b in the sort order, * 0 otherwise. Must not fail. */ + + adns_status (*checklabel)(adns_state ads, adns_queryflags flags, + union checklabel_state *cls, qcontext *ctx, + int labnum, const char *dgram, + int labstart, int lablen); + /* Check a label from the query domain string. The label is not + * necessarily null-terminated. The hook can refuse the query's submission + * by returning a nonzero status. State can be stored in *cls between + * calls, and useful information can be stashed in ctx->tinfo, to be stored + * with the query (e.g., it will be available to the parse hook). This + * hook can detect a first call because labnum is zero, and a final call + * because lablen is zero. + */ + + 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. + */ + + 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__ckl_hostname(adns_state ads, adns_queryflags flags, + union checklabel_state *cls, + qcontext *ctx, int labnum, + const char *dgram, int labstart, int lablen); + /* implemented in query.c, used by types.c as default + * and as part of implementation for some fancier types + * doesn't require any state */ + typedef struct allocnode { struct allocnode *next, *back; + size_t sz; } allocnode; union maxalign { @@ -160,15 +248,6 @@ union maxalign { union maxalign *up; } data; -typedef struct { - void *ext; - void (*callback)(adns_query parent, adns_query child); - union { - adns_rr_addr ptr_parent_addr; - adns_rr_hostaddr *hostaddr; - } info; -} qcontext; - struct adns__query { adns_state ads; enum { query_tosend, query_tcpw, query_childw, query_done } state; @@ -241,6 +320,10 @@ struct adns__query { * Queries in state tcpw/tcpw have been sent (or are in the to-send buffer) * iff the tcp connection is in state server_ok. * + * Internal queries (from adns__submit_internal) end up on intdone + * instead of output, and the callbacks are made on the way out of + * adns, to avoid reentrancy hazards. + * * +------------------------+ * START -----> | tosend/NONE | * +------------------------+ @@ -279,13 +362,18 @@ struct adns__query { struct query_queue { adns_query head, tail; }; +#define MAXUDP 2 + struct adns__state { adns_initflags iflags; - FILE *diagfile; + adns_logcallbackfn *logfn; + void *logfndata; int configerrno; - struct query_queue udpw, tcpw, childw, output; + struct query_queue udpw, tcpw, childw, output, intdone; 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 { @@ -301,21 +389,118 @@ 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; + adns_sockaddr base, mask; } sortlist[MAXSORTLIST]; char **searchlist; + unsigned short rand48xsubi[3]; }; +/* From addrfam.c: */ + +extern int adns__addrs_equal_raw(const struct sockaddr *a, + int bf, const void *b); +/* Returns nonzero a's family is bf and a's protocol address field + * refers to the same protocol address as that stored at ba. + */ + +extern int adns__addrs_equal(const adns_sockaddr *a, + const adns_sockaddr *b); +/* Returns nonzero if the two refer to the same protocol address + * (disregarding port, IPv6 scope, etc). + */ + +extern int adns__sockaddrs_equal(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(adns_sockaddr *sa, int len); +/* Stores in sa's protocol address field an address mask for address + * family af, whose first len bits are set and the remainder are + * clear. On entry, sa's af field must be set. This is what you want + * for converting a prefix length into a netmask. + */ + +extern int adns__guess_prefix_length(const adns_sockaddr *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_matches(int af, const void *addr, + const adns_sockaddr *base, + const adns_sockaddr *mask); +/* Return nonzero if the protocol address specified by af and addr + * lies within the network specified by base and mask. + */ + +extern void adns__addr_inject(const void *a, adns_sockaddr *sa); +/* Injects the protocol address *a into the socket adress sa. Assumes + * that sa->sa_family is already set correctly. + */ + +extern const void *adns__sockaddr_addr(const struct sockaddr *sa); +/* Returns the address of the protocol address field in sa. + */ + +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 bool adns__revparse_label(struct revparse_state *rps, int labnum, + const char *dgram, + int labstart, 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 1 if the parse is proceeding successfully, 0 if the domain + * name is definitely invalid and the parse must be abandoned. + */ + +extern bool adns__revparse_done(struct revparse_state *rps, + const char *dgram, int nlabels, + adns_rrtype *rrtype_r, adns_sockaddr *addr_r); +/* Finishes parsing a reverse-domain name, given the total number of + * labels in the name. On success, fills in the af and protocol + * address in *addr_r, and the forward query type in *rrtype_r + * (because that turns out to be useful). Returns 1 if the parse + * was successful. + */ + /* From setup.c: */ int adns__setnonblock(adns_state ads, int fd); /* => errno value */ /* From general.c: */ +void adns__vlprintf(adns_state ads, const char *fmt, va_list al); +void adns__lprintf(adns_state ads, const char *fmt, + ...) PRINTFFORMAT(2,3); + void adns__vdiag(adns_state ads, const char *pfx, adns_initflags prevent, int serv, adns_query qu, const char *fmt, va_list al); @@ -327,7 +512,7 @@ void adns__diag(adns_state ads, int serv, adns_query qu, const char *fmt, ...) PRINTFFORMAT(4,5); int adns__vbuf_ensure(vbuf *vb, int want); -int adns__vbuf_appendstr(vbuf *vb, const char *data); /* does not include nul */ +int adns__vbuf_appendstr(vbuf *vb, const char *data); /* doesn't include nul */ int adns__vbuf_append(vbuf *vb, const byte *data, int len); /* 1=>success, 0=>realloc failed */ void adns__vbuf_appendq(vbuf *vb, const byte *data, int len); @@ -335,7 +520,8 @@ void adns__vbuf_init(vbuf *vb); void adns__vbuf_free(vbuf *vb); const char *adns__diag_domain(adns_state ads, int serv, adns_query qu, - vbuf *vb, const byte *dgram, int dglen, int cbyte); + vbuf *vb, + const byte *dgram, int dglen, int cbyte); /* Unpicks a domain in a datagram and returns a string suitable for * printing it as. Never fails - if an error occurs, it will * return some kind of string describing the error. @@ -347,6 +533,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); @@ -369,12 +560,14 @@ void adns__sigpipe_unprotect(adns_state); adns_status adns__mkquery(adns_state ads, vbuf *vb, int *id_r, const char *owner, int ol, - const typeinfo *typei, adns_queryflags flags); + const typeinfo *typei, adns_rrtype type, + adns_queryflags flags); /* Assembles a query packet in vb. A new id is allocated and returned. */ adns_status adns__mkquery_frdgram(adns_state ads, vbuf *vb, int *id_r, - const byte *qd_dgram, int qd_dglen, int qd_begin, + const byte *qd_dgram, int qd_dglen, + int qd_begin, adns_rrtype type, adns_queryflags flags); /* Same as adns__mkquery, but takes the owner domain from an existing datagram. * That domain must be correct and untruncated. @@ -386,11 +579,20 @@ 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<=ivb). * - * *ctx is copied byte-for-byte into the query. + * *ctx is copied byte-for-byte into the query. Before doing this, its tinfo + * field may be modified by type hooks. * * When the child query is done, ctx->callback will be called. The * child will already have been taken off both the global list of @@ -460,7 +665,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 @@ -474,6 +679,10 @@ void adns__transfer_interim(adns_query from, adns_query to, void *block, size_t * 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 @@ -495,8 +704,18 @@ void adns__reset_preserved(adns_query qu); * in a datagram and discover that we need to retry the query. */ +void adns__cancel(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); + +void adns__returning(adns_state ads, adns_query qu); +/* Must be called before returning from adns any time that we have + * progressed (including made, finished or destroyed) queries. + * + * Might reenter adns via internal query callbacks, so + * external-faciing functions which call adns__returning should + * normally be avoided in internal code. */ /* From reply.c: */ @@ -537,7 +756,8 @@ void adns__findlabel_start(findlabel_state *fls, adns_state ads, * serv may be -1, qu may be null - they are for error reporting. */ -adns_status adns__findlabel_next(findlabel_state *fls, int *lablen_r, int *labstart_r); +adns_status adns__findlabel_next(findlabel_state *fls, + int *lablen_r, int *labstart_r); /* Then, call this one repeatedly. * * It will return adns_s_ok if all is well, and tell you the length @@ -568,7 +788,8 @@ typedef enum { adns_status adns__parse_domain(adns_state ads, int serv, adns_query qu, vbuf *vb, parsedomain_flags flags, - const byte *dgram, int dglen, int *cbyte_io, int max); + const byte *dgram, int dglen, int *cbyte_io, + int max); /* vb must already have been initialised; it will be reset if necessary. * If there is truncation, vb->used will be set to 0; otherwise * (if there is no error) vb will be null-terminated. @@ -578,7 +799,8 @@ adns_status adns__parse_domain(adns_state ads, int serv, adns_query qu, */ adns_status adns__parse_domain_more(findlabel_state *fls, adns_state ads, - adns_query qu, vbuf *vb, parsedomain_flags flags, + adns_query qu, vbuf *vb, + parsedomain_flags flags, const byte *dgram); /* Like adns__parse_domain, but you pass it a pre-initialised findlabel_state, * for continuing an existing domain or some such of some kind. Also, unlike @@ -617,10 +839,11 @@ adns_status adns__findrr(adns_query qu, int serv, adns_status adns__findrr_anychk(adns_query qu, int serv, const byte *dgram, int dglen, int *cbyte_io, - int *type_r, int *class_r, unsigned long *ttl_r, + int *type_r, int *class_r, + unsigned long *ttl_r, int *rdlen_r, int *rdstart_r, - const byte *eo_dgram, int eo_dglen, int eo_cbyte, - int *eo_matched_r); + const byte *eo_dgram, int eo_dglen, + int eo_cbyte, int *eo_matched_r); /* Like adns__findrr_checked, except that the datagram and * owner to compare with can be specified explicitly. * @@ -635,13 +858,16 @@ adns_status adns__findrr_anychk(adns_query qu, int serv, * untruncated. */ -void adns__update_expires(adns_query qu, unsigned long ttl, struct timeval now); +void adns__update_expires(adns_query qu, unsigned long ttl, + struct timeval now); /* Updates the `expires' field in the query, so that it doesn't exceed * now + ttl. */ int vbuf__append_quoted1035(vbuf *vb, const byte *buf, int len); +bool adns__labels_equal(const byte *a, int al, const byte *b, int bl); + /* From event.c: */ void adns__tcp_broken(adns_state ads, const char *what, const char *why); @@ -657,6 +883,7 @@ void adns__autosys(adns_state ads, struct timeval now); void adns__must_gettimeofday(adns_state ads, const struct timeval **now_io, struct timeval *tv_buf); +/* Call with care - might reentrantly cause queries to be completed! */ int adns__pollfds(adns_state ads, struct pollfd pollfds_buf[MAX_POLLFDS]); void adns__fdevents(adns_state ads, @@ -682,12 +909,19 @@ void adns__consistency(adns_state ads, adns_query qu, consistency_checks cc); /* Useful static inline functions: */ -static inline int ctype_whitespace(int c) { return c==' ' || c=='\n' || c=='\t'; } +static inline int ctype_whitespace(int c) { + return c==' ' || c=='\n' || c=='\t'; +} static inline int ctype_digit(int c) { return c>='0' && c<='9'; } static inline int ctype_alpha(int c) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); } -static inline int ctype_822special(int c) { return strchr("()<>@,;:\\\".[]",c) != 0; } +static inline int ctype_toupper(int c) { + return ctype_alpha(c) ? (c & ~32) : c; +} +static inline int ctype_822special(int c) { + return strchr("()<>@,;:\\\".[]",c) != 0; +} static inline int ctype_domainunquoted(int c) { return ctype_alpha(c) || ctype_digit(c) || (strchr("-_/+",c) != 0); } @@ -696,18 +930,18 @@ static inline int errno_resources(int e) { return e==ENOMEM || e==ENOBUFS; } /* Useful macros */ -#define MEM_ROUND(sz) \ - (( ((sz)+sizeof(union maxalign)-1) / sizeof(union maxalign) ) \ +#define MEM_ROUND(sz) \ + (( ((sz)+sizeof(union maxalign)-1) / sizeof(union maxalign) ) \ * sizeof(union maxalign) ) #define GETIL_B(cb) (((dgram)[(cb)++]) & 0x0ff) #define GET_B(cb,tv) ((tv)= GETIL_B((cb))) -#define GET_W(cb,tv) ((tv)=0, (tv)|=(GETIL_B((cb))<<8), (tv)|=GETIL_B(cb), (tv)) -#define GET_L(cb,tv) ( (tv)=0, \ - (tv)|=(GETIL_B((cb))<<24), \ - (tv)|=(GETIL_B((cb))<<16), \ - (tv)|=(GETIL_B((cb))<<8), \ - (tv)|=GETIL_B(cb), \ +#define GET_W(cb,tv) ((tv)=0,(tv)|=(GETIL_B((cb))<<8), (tv)|=GETIL_B(cb), (tv)) +#define GET_L(cb,tv) ( (tv)=0, \ + (tv)|=(GETIL_B((cb))<<24), \ + (tv)|=(GETIL_B((cb))<<16), \ + (tv)|=(GETIL_B((cb))<<8), \ + (tv)|=GETIL_B(cb), \ (tv) ) #endif