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