Reran autoheader.
[adns] / src / internal.h
CommitLineData
e576be50 1/*
2 * internal.h
3 * - declarations of private objects with external linkage (adns__*)
4 * - definitons of internal macros
5 * - comments regarding library data structures
6 */
7/*
a719a4be 8 * This file is part of adns, which is Copyright (C) 1997-1999 Ian Jackson
e576be50 9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2, or (at your option)
13 * any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software Foundation,
22 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23 */
37e28fde 24
25#ifndef ADNS_INTERNAL_H_INCLUDED
26#define ADNS_INTERNAL_H_INCLUDED
27
11b35193 28#include "config.h"
4353a5c4 29typedef unsigned char byte;
30
31#include <stdarg.h>
32#include <assert.h>
33#include <unistd.h>
ac868fa8 34#include <signal.h>
620c146d 35#include <errno.h>
4353a5c4 36
37e28fde 37#include <sys/time.h>
38
39#include "adns.h"
40
41/* Configuration and constants */
42
43#define MAXSERVERS 5
09957b1c 44#define MAXSORTLIST 15
4b707d8b 45#define UDPMAXRETRIES 15
37e28fde 46#define UDPRETRYMS 2000
47#define TCPMS 30000
73dba56e 48#define MAXTTLBELIEVE (7*86400) /* any TTL > 7 days is capped */
b9de380c 49
98a3f706 50#define DNS_PORT 53
b9de380c 51#define DNS_MAXUDP 512
52#define DNS_MAXDOMAIN 255
53#define DNS_HDRSIZE 12
660d7d3b 54#define DNS_IDOFFSET 0
b9de380c 55#define DNS_CLASS_IN 1
37e28fde 56
a6536d8b 57#define DNS_INADDR_ARPA "in-addr", "arpa"
58
620c146d 59#define MAX_POLLFDS ADNS_POLLFDS_RECOMMENDED
60
98a3f706 61typedef enum {
62 rcode_noerror,
63 rcode_formaterror,
64 rcode_servfail,
65 rcode_nxdomain,
66 rcode_notimp,
67 rcode_refused
68} dns_rcode;
69
37e28fde 70/* Shared data structures */
71
4353a5c4 72typedef union {
37e28fde 73 adns_status status;
74 char *cp;
75 adns_rrtype type;
4353a5c4 76 int i;
37e28fde 77 struct in_addr ia;
78 unsigned long ul;
4353a5c4 79} rr_align;
80
81typedef struct {
82 int used, avail;
83 byte *buf;
84} vbuf;
85
0ba0614a 86typedef struct {
1dfe95d8 87 adns_state ads;
c7836bc9 88 adns_query qu;
1dfe95d8 89 int serv;
c7836bc9 90 const byte *dgram;
1dfe95d8 91 int dglen, nsstart, nscount, arcount;
7da21070 92 struct timeval now;
c7836bc9 93} parseinfo;
94
95typedef struct {
0ba0614a 96 adns_rrtype type;
86e7b8d9 97 const char *rrtname;
98 const char *fmtname;
98a3f706 99 int rrsz;
8e5b0abb 100
86e7b8d9 101 void (*makefinal)(adns_query qu, void *data);
102 /* Change memory management of *data.
103 * Previously, used alloc_interim, now use alloc_final.
104 */
105
106 adns_status (*convstring)(vbuf *vb, const void *data);
107 /* Converts the RR data to a string representation in vbuf.
108 * vbuf will be appended to (it must have been initialised),
109 * and will not be null-terminated by convstring.
110 */
111
1dfe95d8 112 adns_status (*parse)(const parseinfo *pai, int cbyte, int max, void *store_r);
31144a72 113 /* Parse one RR, in dgram of length dglen, starting at cbyte and
114 * extending until at most max.
115 *
116 * The RR should be stored at *store_r, of length qu->typei->rrsz.
117 *
118 * If there is an overrun which might indicate truncation, it should set
119 * *rdstart to -1; otherwise it may set it to anything else positive.
88372443 120 *
c7836bc9 121 * nsstart is the offset of the authority section.
8e5b0abb 122 */
e062dcae 123
09957b1c 124 int (*diff_needswap)(adns_state ads, const void *datap_a, const void *datap_b);
88372443 125 /* Returns !0 if RR a should be strictly after RR b in the sort order,
e062dcae 126 * 0 otherwise. Must not fail.
127 */
0ba0614a 128} typeinfo;
129
8e5b0abb 130typedef struct allocnode {
551ff40f 131 struct allocnode *next, *back;
8e5b0abb 132} allocnode;
133
134union maxalign {
135 byte d[1];
136 struct in_addr ia;
137 long l;
138 void *p;
139 void (*fp)(void);
140 union maxalign *up;
141} data;
142
a6536d8b 143typedef struct {
144 void *ext;
145 void (*callback)(adns_query parent, adns_query child);
146 union {
147 adns_rr_addr ptr_parent_addr;
148 adns_rr_hostaddr *hostaddr;
149 } info;
150} qcontext;
151
37e28fde 152struct adns__query {
3955725c 153 adns_state ads;
d8c062fa 154 enum { query_tosend, query_tcpwait, query_tcpsent, query_child, query_done } state;
4353a5c4 155 adns_query back, next, parent;
37e28fde 156 struct { adns_query head, tail; } children;
157 struct { adns_query back, next; } siblings;
551ff40f 158 struct { allocnode *head, *tail; } allocations;
8b3d55e3 159 int interim_allocd, preserved_allocd;
68442019 160 void *final_allocspace;
8ce38e76 161
0ba0614a 162 const typeinfo *typei;
e062dcae 163 byte *query_dgram;
8e5b0abb 164 int query_dglen;
31144a72 165
8e5b0abb 166 vbuf vb;
167 /* General-purpose messing-about buffer.
168 * Wherever a `big' interface is crossed, this may be corrupted/changed
169 * unless otherwise specified.
170 */
171
172 adns_answer *answer;
173 /* This is allocated when a query is submitted, to avoid being unable
174 * to relate errors to queries if we run out of memory. During
175 * query processing status, rrs is 0. cname is set if
176 * we found a cname (this corresponds to cname_dgram in the query
177 * structure). type is set from the word go. nrrs and rrs
178 * are set together, when we find how many rrs there are.
22181a31 179 * owner is set during querying unless we're doing searchlist,
180 * in which case it is set only when we find an answer.
8e5b0abb 181 */
31144a72 182
31144a72 183 byte *cname_dgram;
184 int cname_dglen, cname_begin;
3955725c 185 /* If non-0, has been allocated using . */
32af6b2a 186
187 vbuf search_vb;
188 int search_origlen, search_pos, search_doneabs;
189 /* Used by the searching algorithm. The query domain in textual form
190 * is copied into the vbuf, and _origlen set to its length. Then
191 * we walk the searchlist, if we want to. _pos says where we are
192 * (next entry to try), and _doneabs says whether we've done the
660d7d3b 193 * absolute query yet (0=not yet, 1=done, -1=must do straight away,
194 * but not done yet). If flags doesn't have adns_qf_search then
32af6b2a 195 * the vbuf is initialised but empty and everything else is zero.
32af6b2a 196 */
31144a72 197
ddfda861 198 int id, flags, udpretries;
4353a5c4 199 int udpnextserver;
200 unsigned long udpsent, tcpfailed; /* bitmap indexed by server */
37e28fde 201 struct timeval timeout;
73dba56e 202 time_t expires; /* Earliest expiry time of any record we used. */
a6536d8b 203
204 qcontext ctx;
ddfda861 205
37e28fde 206 /* Possible states:
ddfda861 207 *
8e5b0abb 208 * state Queue child id nextudpserver sentudp failedtcp
209 *
d8c062fa 210 * tosend NONE null >=0 0 zero zero
211 * tosend timew null >=0 any nonzero zero
212 * tosend NONE null >=0 any nonzero zero
8e5b0abb 213 *
214 * tcpwait timew null >=0 irrelevant zero any
215 * tcpsent timew null >=0 irrelevant zero any
216 *
217 * child childw set >=0 irrelevant irrelevant irrelevant
dcc8e442 218 * child NONE null >=0 irrelevant irrelevant irrelevant
8e5b0abb 219 * done output null -1 irrelevant irrelevant irrelevant
ddfda861 220 *
dcc8e442 221 * Queries are only not on a queue when they are actually being processed.
222 *
ddfda861 223 * +------------------------+
224 * START -----> | udp/NONE |
225 * +------------------------+
226 * / |\ \
227 * too big for UDP / UDP timeout \ \ send via UDP
228 * do this ASAP! / more retries \ \ do this ASAP!
229 * |_ desired \ _|
230 * +---------------+ +-----------+
231 * | tcpwait/timew | ____ | udp/timew |
232 * +---------------+ \ +-----------+
233 * | ^ | | |
234 * TCP conn'd; | | TCP died | | |
235 * send via TCP | | more | UDP timeout | |
236 * do this ASAP! | | servers | no more | |
237 * v | to try | retries | |
238 * +---------------+ | desired | |
239 * | tcpsent/timew | ____ | | |
240 * +---------------+ \| | |
241 * \ \ TCP died | TCP | |
242 * \ \ no more | timeout / |
243 * \ \ servers | / |
244 * \ \ to try | / |
245 * got \ \ v |_ / got
246 * reply \ _| +------------------+ / reply
247 * \ | done/output FAIL | /
248 * \ +------------------+ /
249 * \ /
250 * _| |_
251 * (..... got reply ....)
252 * / \
253 * need child query/ies / \ no child query
254 * / \
255 * |_ _|
256 * +--------------+ +----------------+
257 * | child/childw | ----------------> | done/output OK |
258 * +--------------+ children done +----------------+
37e28fde 259 */
260};
261
37e28fde 262struct adns__state {
37e28fde 263 adns_initflags iflags;
264 FILE *diagfile;
36369543 265 int configerrno;
ddfda861 266 struct { adns_query head, tail; } timew, childw, output;
8ce38e76 267 adns_query forallnext;
4353a5c4 268 int nextid, udpsocket, tcpsocket;
8e5b0abb 269 vbuf tcpsend, tcprecv;
660d7d3b 270 int nservers, nsortlist, nsearchlist, searchndots, tcpserver;
8402e34c 271 enum adns__tcpstate { server_disconnected, server_connecting, server_ok } tcpstate;
37e28fde 272 struct timeval tcptimeout;
ac868fa8 273 struct sigaction stdsigpipe;
274 sigset_t stdsigmask;
620c146d 275 struct pollfd pollfds_buf[MAX_POLLFDS];
37e28fde 276 struct server {
277 struct in_addr addr;
278 } servers[MAXSERVERS];
09957b1c 279 struct sortlist {
280 struct in_addr base, mask;
281 } sortlist[MAXSORTLIST];
32af6b2a 282 char **searchlist;
37e28fde 283};
284
285/* From setup.c: */
286
e576be50 287int adns__setnonblock(adns_state ads, int fd); /* => errno value */
4218fb9a 288void adns__checkqueues(adns_state ads); /* expensive walk, for checking */
e576be50 289
290/* From general.c: */
291
4353a5c4 292void adns__vdiag(adns_state ads, const char *pfx, adns_initflags prevent,
68442019 293 int serv, adns_query qu, const char *fmt, va_list al);
31144a72 294
295void adns__debug(adns_state ads, int serv, adns_query qu,
68442019 296 const char *fmt, ...) PRINTFFORMAT(4,5);
31144a72 297void adns__warn(adns_state ads, int serv, adns_query qu,
68442019 298 const char *fmt, ...) PRINTFFORMAT(4,5);
31144a72 299void adns__diag(adns_state ads, int serv, adns_query qu,
68442019 300 const char *fmt, ...) PRINTFFORMAT(4,5);
37e28fde 301
4353a5c4 302int adns__vbuf_ensure(vbuf *vb, int want);
9557e604 303int adns__vbuf_appendstr(vbuf *vb, const char *data); /* does not include nul */
4353a5c4 304int adns__vbuf_append(vbuf *vb, const byte *data, int len);
ddfda861 305/* 1=>success, 0=>realloc failed */
4353a5c4 306void adns__vbuf_appendq(vbuf *vb, const byte *data, int len);
307void adns__vbuf_init(vbuf *vb);
8e5b0abb 308void adns__vbuf_free(vbuf *vb);
4353a5c4 309
828d89bd 310const char *adns__diag_domain(adns_state ads, int serv, adns_query qu,
311 vbuf *vb, const byte *dgram, int dglen, int cbyte);
e576be50 312/* Unpicks a domain in a datagram and returns a string suitable for
313 * printing it as. Never fails - if an error occurs, it will
314 * return some kind of string describing the error.
315 *
3955725c 316 * serv may be -1 and qu may be 0. vb must have been initialised,
e576be50 317 * and will be left in an arbitrary consistent state.
318 *
319 * Returns either vb->buf, or a pointer to a string literal. Do not modify
320 * vb before using the return value.
321 */
322
88372443 323void adns__isort(void *array, int nobjs, int sz, void *tempbuf,
09957b1c 324 int (*needswap)(void *context, const void *a, const void *b),
325 void *context);
88372443 326/* Does an insertion sort of array which must contain nobjs objects
327 * each sz bytes long. tempbuf must point to a buffer at least
328 * sz bytes long. needswap should return !0 if a>b (strictly, ie
329 * wrong order) 0 if a<=b (ie, order is fine).
330 */
ac868fa8 331
332void adns__sigpipe_protect(adns_state);
333void adns__sigpipe_unprotect(adns_state);
334/* If SIGPIPE protection is not disabled, will block all signals except
335 * SIGPIPE, and set SIGPIPE's disposition to SIG_IGN. (And then restore.)
336 * Each call to _protect must be followed by a call to _unprotect before
337 * any significant amount of code gets to run.
338 */
339
e576be50 340/* From transmit.c: */
ddfda861 341
3955725c 342adns_status adns__mkquery(adns_state ads, vbuf *vb, int *id_r,
343 const char *owner, int ol,
e576be50 344 const typeinfo *typei, adns_queryflags flags);
660d7d3b 345/* Assembles a query packet in vb. A new id is allocated and returned.
346 */
e576be50 347
e062dcae 348adns_status adns__mkquery_frdgram(adns_state ads, vbuf *vb, int *id_r,
349 const byte *qd_dgram, int qd_dglen, int qd_begin,
350 adns_rrtype type, adns_queryflags flags);
351/* Same as adns__mkquery, but takes the owner domain from an existing datagram.
352 * That domain must be correct and untruncated.
353 */
354
3955725c 355void adns__query_tcp(adns_query qu, struct timeval now);
e576be50 356/* Query must be in state tcpwait/timew; it will be moved to a new state
357 * if possible and no further processing can be done on it for now.
358 * (Resulting state is one of tcpwait/timew (if server not connected),
359 * tcpsent/timew, child/childw or done/output.)
360 *
361 * adns__tcp_tryconnect should already have been called - _tcp
362 * will only use an existing connection (if there is one), which it
363 * may break. If the conn list lost then the caller is responsible for any
364 * reestablishment and retry.
365 */
366
d8c062fa 367void adns__query_send(adns_query qu, struct timeval now);
368/* Query must be in state tosend/NONE; it will be moved to a new state,
e576be50 369 * and no further processing can be done on it for now.
370 * (Resulting state is one of udp/timew, tcpwait/timew (if server not connected),
371 * tcpsent/timew, child/childw or done/output.)
d8c062fa 372 * __query_send may decide to use either UDP or TCP depending whether
373 * _qf_usevc is set (or has become set) and whether the query is too
374 * large.
e576be50 375 */
376
377/* From query.c: */
37e28fde 378
660d7d3b 379adns_status adns__internal_submit(adns_state ads, adns_query *query_r,
380 const typeinfo *typei, vbuf *qumsg_vb, int id,
381 adns_queryflags flags, struct timeval now,
382 const qcontext *ctx);
8e5b0abb 383/* Submits a query (for internal use, called during external submits).
384 *
385 * The new query is returned in *query_r, or we return adns_s_nomemory.
386 *
68442019 387 * The query datagram should already have been assembled in qumsg_vb;
388 * the memory for it is _taken over_ by this routine whether it
389 * succeeds or fails (if it succeeds, the vbuf is reused for qu->vb).
8e5b0abb 390 *
7da21070 391 * *ctx is copied byte-for-byte into the query.
dcc8e442 392 *
393 * When the child query is done, ctx->callback will be called. The
394 * child will already have been taken off both the global list of
395 * queries in ads and the list of children in the parent. The child
396 * will be freed when the callback returns. The parent will have been
4218fb9a 397 * taken off the global childw queue.
398 *
399 * The callback should either call adns__query_done, if it is
400 * complete, or adns__query_fail, if an error has occurred, in which
401 * case the other children (if any) will be cancelled. If the parent
402 * has more unfinished children (or has just submitted more) then the
403 * callback may choose to wait for them - it must then put the parent
404 * back on the childw queue.
8e5b0abb 405 */
406
660d7d3b 407void adns__search_next(adns_state ads, adns_query qu, struct timeval now);
408/* Walks down the searchlist for a query with adns_qf_search.
409 * The query should have just had a negative response, or not had
410 * any queries sent yet, and should not be on any queue.
411 * The query_dgram if any will be freed and forgotten and a new
412 * one constructed from the search_* members of the query.
413 *
414 * Cannot fail (in case of error, calls adns__query_fail).
415 */
416
8e5b0abb 417void *adns__alloc_interim(adns_query qu, size_t sz);
8b3d55e3 418void *adns__alloc_preserved(adns_query qu, size_t sz);
8e5b0abb 419/* Allocates some memory, and records which query it came from
420 * and how much there was.
421 *
8b3d55e3 422 * If an error occurs in the query, all the memory from _interim is
423 * simply freed. If the query succeeds, one large buffer will be made
424 * which is big enough for all these allocations, and then
425 * adns__alloc_final will get memory from this buffer.
8e5b0abb 426 *
e062dcae 427 * _alloc_interim can fail (and return 0).
428 * The caller must ensure that the query is failed.
a49a6d7b 429 *
8b3d55e3 430 * The memory from _preserved is is kept and transferred into the
431 * larger buffer - unless we run out of memory, in which case it too
432 * is freed. When you use _preserved you have to add code to the
433 * x_nomem error exit case in adns__makefinal_query to clear out the
434 * pointers you made to those allocations, because that's when they're
435 * thrown away; you should also make a note in the declaration of
436 * those pointer variables, to note that they are _preserved rather
437 * than _interim. If they're in the answer, note it here:
438 * answer->cname and answer->owner are _preserved.
8e5b0abb 439 */
440
551ff40f 441void adns__transfer_interim(adns_query from, adns_query to, void *block, size_t sz);
442/* Transfers an interim allocation from one query to another, so that
443 * the `to' query will have room for the data when we get to makefinal
444 * and so that the free will happen when the `to' query is freed
445 * rather than the `from' query.
446 *
447 * It is legal to call adns__transfer_interim with a null pointer; this
448 * has no effect.
73dba56e 449 *
450 * _transfer_interim also ensures that the expiry time of the `to' query
451 * is no later than that of the `from' query, so that child queries'
452 * TTLs get inherited by their parents.
551ff40f 453 */
454
3955725c 455void *adns__alloc_mine(adns_query qu, size_t sz);
456/* Like _interim, but does not record the length for later
457 * copying into the answer. This just ensures that the memory
458 * will be freed when we're done with the query.
459 */
460
8e5b0abb 461void *adns__alloc_final(adns_query qu, size_t sz);
a49a6d7b 462/* Cannot fail, and cannot return 0.
8e5b0abb 463 */
37e28fde 464
68442019 465void adns__makefinal_block(adns_query qu, void **blpp, size_t sz);
466void adns__makefinal_str(adns_query qu, char **strp);
467
8b3d55e3 468void adns__reset_preserved(adns_query qu);
469/* Resets all of the memory management stuff etc. to take account of
470 * only the _preserved stuff from _alloc_preserved. Used when we find
471 * an error somewhere and want to just report the error (with perhaps
472 * CNAME, owner, etc. info), and also when we're halfway through RRs
473 * in a datagram and discover that we need to retry the query.
68442019 474 */
e576be50 475
3955725c 476void adns__query_done(adns_query qu);
477void adns__query_fail(adns_query qu, adns_status stat);
68442019 478
4353a5c4 479/* From reply.c: */
480
98a3f706 481void adns__procdgram(adns_state ads, const byte *dgram, int len,
482 int serv, struct timeval now);
483
484/* From types.c: */
485
486const typeinfo *adns__findtype(adns_rrtype type);
487
488/* From parse.c: */
489
f1e474dd 490typedef struct {
68442019 491 adns_state ads;
3955725c 492 adns_query qu;
68442019 493 int serv;
f1e474dd 494 const byte *dgram;
495 int dglen, max, cbyte, namelen;
3955725c 496 int *dmend_r;
f1e474dd 497} findlabel_state;
498
3955725c 499void adns__findlabel_start(findlabel_state *fls, adns_state ads,
500 int serv, adns_query qu,
f1e474dd 501 const byte *dgram, int dglen, int max,
502 int dmbegin, int *dmend_rlater);
503/* Finds labels in a domain in a datagram.
504 *
505 * Call this routine first.
3955725c 506 * dmend_rlater may be null. ads (and of course fls) may not be.
507 * serv may be -1, qu may be null - they are for error reporting.
f1e474dd 508 */
509
3955725c 510adns_status adns__findlabel_next(findlabel_state *fls, int *lablen_r, int *labstart_r);
f1e474dd 511/* Then, call this one repeatedly.
512 *
513 * It will return adns_s_ok if all is well, and tell you the length
514 * and start of successive labels. labstart_r may be null, but
515 * lablen_r must not be.
516 *
517 * After the last label, it will return with *lablen_r zero.
518 * Do not then call it again; instead, just throw away the findlabel_state.
519 *
520 * *dmend_rlater will have been set to point to the next part of
521 * the datagram after the label (or after the uncompressed part,
522 * if compression was used). *namelen_rlater will have been set
523 * to the length of the domain name (total length of labels plus
524 * 1 for each intervening dot).
525 *
526 * If the datagram appears to be truncated, *lablen_r will be -1.
527 * *dmend_rlater, *labstart_r and *namelen_r may contain garbage.
528 * Do not call _next again.
529 *
530 * There may also be errors, in which case *dmend_rlater,
531 * *namelen_rlater, *lablen_r and *labstart_r may contain garbage.
532 * Do not then call findlabel_next again.
533 */
534
828d89bd 535typedef enum {
536 pdf_quoteok= 0x001
537} parsedomain_flags;
538
3955725c 539adns_status adns__parse_domain(adns_state ads, int serv, adns_query qu,
828d89bd 540 vbuf *vb, parsedomain_flags flags,
3955725c 541 const byte *dgram, int dglen, int *cbyte_io, int max);
f1e474dd 542/* vb must already have been initialised; it will be reset if necessary.
543 * If there is truncation, vb->used will be set to 0; otherwise
544 * (if there is no error) vb will be null-terminated.
545 * If there is an error vb and *cbyte_io may be left indeterminate.
3955725c 546 *
547 * serv may be -1 and qu may be 0 - they are used for error reporting only.
f1e474dd 548 */
549
eaa44731 550adns_status adns__parse_domain_more(findlabel_state *fls, adns_state ads,
551 adns_query qu, vbuf *vb, parsedomain_flags flags,
552 const byte *dgram);
553/* Like adns__parse_domain, but you pass it a pre-initialised findlabel_state,
554 * for continuing an existing domain or some such of some kind. Also, unlike
555 * _parse_domain, the domain data will be appended to vb, rather than replacing
556 * the existing contents.
557 */
558
3955725c 559adns_status adns__findrr(adns_query qu, int serv,
f1e474dd 560 const byte *dgram, int dglen, int *cbyte_io,
73dba56e 561 int *type_r, int *class_r, unsigned long *ttl_r,
562 int *rdlen_r, int *rdstart_r,
3955725c 563 int *ownermatchedquery_r);
c7836bc9 564/* Finds the extent and some of the contents of an RR in a datagram
565 * and does some checks. The datagram is *dgram, length dglen, and
566 * the RR starts at *cbyte_io (which is updated afterwards to point
567 * to the end of the RR).
568 *
73dba56e 569 * The type, class, TTL and RRdata length and start are returned iff
570 * the corresponding pointer variables are not null. type_r, class_r
571 * and ttl_r may not be null. The TTL will be capped.
c7836bc9 572 *
573 * If ownermatchedquery_r != 0 then the owner domain of this
574 * RR will be compared with that in the query (or, if the query
575 * has gone to a CNAME lookup, with the canonical name).
576 * In this case, *ownermatchedquery_r will be set to 0 or 1.
577 * The query datagram (or CNAME datagram) MUST be valid and not truncated.
578 *
579 * If there is truncation then *type_r will be set to -1 and
580 * *cbyte_io, *class_r, *rdlen_r, *rdstart_r and *eo_matched_r will be
581 * undefined.
582 *
583 * qu must obviously be non-null.
584 *
585 * If an error is returned then *type_r will be undefined too.
586 */
587
1dfe95d8 588adns_status adns__findrr_anychk(adns_query qu, int serv,
589 const byte *dgram, int dglen, int *cbyte_io,
73dba56e 590 int *type_r, int *class_r, unsigned long *ttl_r,
591 int *rdlen_r, int *rdstart_r,
1dfe95d8 592 const byte *eo_dgram, int eo_dglen, int eo_cbyte,
593 int *eo_matched_r);
c7836bc9 594/* Like adns__findrr_checked, except that the datagram and
595 * owner to compare with can be specified explicitly.
596 *
597 * If the caller thinks they know what the owner of the RR ought to
598 * be they can pass in details in eo_*: this is another (or perhaps
599 * the same datagram), and a pointer to where the putative owner
600 * starts in that datagram. In this case *eo_matched_r will be set
601 * to 1 if the datagram matched or 0 if it did not. Either
602 * both eo_dgram and eo_matched_r must both be non-null, or they
603 * must both be null (in which case eo_dglen and eo_cbyte will be ignored).
604 * The eo datagram and contained owner domain MUST be valid and
605 * untruncated.
606 */
98a3f706 607
73dba56e 608void adns__update_expires(adns_query qu, unsigned long ttl, struct timeval now);
609/* Updates the `expires' field in the query, so that it doesn't exceed
610 * now + ttl.
611 */
612
f1e474dd 613int vbuf__append_quoted1035(vbuf *vb, const byte *buf, int len);
8402e34c 614
615/* From event.c: */
4353a5c4 616
8402e34c 617void adns__tcp_broken(adns_state ads, const char *what, const char *why);
620c146d 618void adns__tcp_closenext(adns_state ads);
4353a5c4 619void adns__tcp_tryconnect(adns_state ads, struct timeval now);
e576be50 620
4353a5c4 621void adns__autosys(adns_state ads, struct timeval now);
e576be50 622/* Make all the system calls we want to if the application wants us to. */
37e28fde 623
620c146d 624void adns__must_gettimeofday(adns_state ads, const struct timeval **now_io,
625 struct timeval *tv_buf);
626void adns__timeouts(adns_state ads, int act,
627 struct timeval **tv_io, struct timeval *tvbuf,
628 struct timeval now);
629int adns__pollfds(adns_state ads, struct pollfd pollfds_buf[MAX_POLLFDS]);
630void adns__fdevents(adns_state ads,
631 const struct pollfd *pollfds, int npollfds,
632 int maxfd, const fd_set *readfds,
633 const fd_set *writefds, const fd_set *exceptfds,
634 struct timeval now, int *r_r);
635
37e28fde 636/* Useful static inline functions: */
637
638static inline void timevaladd(struct timeval *tv_io, long ms) {
639 struct timeval tmp;
640 assert(ms>=0);
641 tmp= *tv_io;
94436798 642 tmp.tv_usec += (ms%1000)*1000000;
37e28fde 643 tmp.tv_sec += ms/1000;
94436798 644 if (tmp.tv_usec >= 1000000) { tmp.tv_sec++; tmp.tv_usec -= 1000; }
37e28fde 645 *tv_io= tmp;
ddfda861 646}
37e28fde 647
648static inline int ctype_whitespace(int c) { return c==' ' || c=='\n' || c=='\t'; }
649static inline int ctype_digit(int c) { return c>='0' && c<='9'; }
98a3f706 650static inline int ctype_alpha(int c) {
9da4a044 651 return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
98a3f706 652}
37e28fde 653
620c146d 654static inline int errno_resources(int e) { return e==ENOMEM || e==ENOBUFS; }
655
37e28fde 656/* Useful macros */
657
8e5b0abb 658#define MEM_ROUND(sz) \
659 (( ((sz)+sizeof(union maxalign)-1) / sizeof(union maxalign) ) \
660 * sizeof(union maxalign) )
661
4353a5c4 662#define LIST_INIT(list) ((list).head= (list).tail= 0)
660d7d3b 663#define LINK_INIT(link) ((link).next= (link).back= 0)
4353a5c4 664
37e28fde 665#define LIST_UNLINK_PART(list,node,part) \
666 do { \
551ff40f 667 if ((node)->part back) (node)->part back->part next= (node)->part next; \
668 else (list).head= (node)->part next; \
669 if ((node)->part next) (node)->part next->part back= (node)->part back; \
670 else (list).tail= (node)->part back; \
37e28fde 671 } while(0)
672
673#define LIST_LINK_TAIL_PART(list,node,part) \
674 do { \
86e7b8d9 675 (node)->part next= 0; \
676 (node)->part back= (list).tail; \
7da21070 677 if ((list).tail) (list).tail->part next= (node); else (list).head= (node); \
37e28fde 678 (list).tail= (node); \
679 } while(0)
680
681#define LIST_UNLINK(list,node) LIST_UNLINK_PART(list,node,)
4353a5c4 682#define LIST_LINK_TAIL(list,node) LIST_LINK_TAIL_PART(list,node,)
37e28fde 683
86e7b8d9 684#define GETIL_B(cb) (((dgram)[(cb)++]) & 0x0ff)
98a3f706 685#define GET_B(cb,tv) ((tv)= GETIL_B((cb)))
686#define GET_W(cb,tv) ((tv)=0, (tv)|=(GETIL_B((cb))<<8), (tv)|=GETIL_B(cb), (tv))
73dba56e 687#define GET_L(cb,tv) ( (tv)=0, \
688 (tv)|=(GETIL_B((cb))<<24), \
689 (tv)|=(GETIL_B((cb))<<16), \
690 (tv)|=(GETIL_B((cb))<<8), \
691 (tv)|=GETIL_B(cb), \
692 (tv) )
98a3f706 693
37e28fde 694#endif