* - comments regarding library data structures
*/
/*
- * This file is part of adns, which is Copyright (C) 1997-1999 Ian Jackson
+ * This file is
+ * Copyright (C) 1997-1999 Ian Jackson <ian@davenant.greenend.org.uk>
+ *
+ * It is part of adns, which is
+ * Copyright (C) 1997-1999 Ian Jackson <ian@davenant.greenend.org.uk>
+ * Copyright (C) 1999 Tony Finch <dot@dotat.at>
*
* 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
#include <unistd.h>
#include <signal.h>
#include <errno.h>
+#include <string.h>
#include <sys/time.h>
#define MAX_POLLFDS ADNS_POLLFDS_RECOMMENDED
+typedef enum {
+ cc_user,
+ cc_entex,
+ cc_freq
+} consistency_checks;
+
typedef enum {
rcode_noerror,
rcode_formaterror,
struct adns__query {
adns_state ads;
- enum { query_udp, query_tcpwait, query_tcpsent, query_child, query_done } state;
+ enum { query_tosend, query_tcpwait, query_tcpsent, query_child, query_done } state;
adns_query back, next, parent;
struct { adns_query head, tail; } children;
struct { adns_query back, next; } siblings;
struct { allocnode *head, *tail; } allocations;
- int interim_allocd;
+ int interim_allocd, preserved_allocd;
void *final_allocspace;
const typeinfo *typei;
/* Possible states:
*
- * state Queue child id nextudpserver sentudp failedtcp
+ * state Queue child id nextudpserver udpsent tcpfailed
*
- * udp NONE null >=0 0 zero zero
- * udp timew null >=0 any nonzero zero
- * udp NONE null >=0 any nonzero zero
+ * tosend NONE null >=0 0 zero zero
+ * tosend timew null >=0 any nonzero zero
+ * tosend NONE null >=0 any nonzero zero
*
- * tcpwait timew null >=0 irrelevant zero any
- * tcpsent timew null >=0 irrelevant zero any
+ * tcpwait timew null >=0 irrelevant any any
+ * tcpsent timew null >=0 irrelevant any any
*
* child childw set >=0 irrelevant irrelevant irrelevant
* child NONE null >=0 irrelevant irrelevant irrelevant
/* From setup.c: */
int adns__setnonblock(adns_state ads, int fd); /* => errno value */
+void adns__checkqueues(adns_state ads); /* expensive walk, for checking */
/* From general.c: */
* reestablishment and retry.
*/
-void adns__query_udp(adns_query qu, struct timeval now);
-/* Query must be in state udp/NONE; it will be moved to a new state,
+void adns__query_send(adns_query qu, struct timeval now);
+/* Query must be in state tosend/NONE; it will be moved to a new state,
* and no further processing can be done on it for now.
* (Resulting state is one of udp/timew, tcpwait/timew (if server not connected),
* tcpsent/timew, child/childw or done/output.)
+ * __query_send may decide to use either UDP or TCP depending whether
+ * _qf_usevc is set (or has become set) and whether the query is too
+ * large.
*/
/* From query.c: */
* child will already have been taken off both the global list of
* queries in ads and the list of children in the parent. The child
* will be freed when the callback returns. The parent will have been
- * taken off the global childw queue iff this is the last child for
- * that parent. If there is no error detected in the callback, then
- * it should call adns__query_done if and only if there are no more
- * children (by checking parent->children.head). If an error is
- * detected in the callback it should call adns__query_fail and any
- * remaining children will automatically be cancelled.
+ * taken off the global childw queue.
+ *
+ * The callback should either call adns__query_done, if it is
+ * complete, or adns__query_fail, if an error has occurred, in which
+ * case the other children (if any) will be cancelled. If the parent
+ * has more unfinished children (or has just submitted more) then the
+ * callback may choose to wait for them - it must then put the parent
+ * back on the childw queue.
*/
void adns__search_next(adns_state ads, adns_query qu, struct timeval now);
*/
void *adns__alloc_interim(adns_query qu, size_t sz);
+void *adns__alloc_preserved(adns_query qu, size_t sz);
/* Allocates some memory, and records which query it came from
* and how much there was.
*
- * If an error occurs in the query, all its memory is simply freed.
- *
- * If the query succeeds, one large buffer will be made which is
- * big enough for all these allocations, and then adns__alloc_final
- * will get memory from this buffer.
+ * If an error occurs in the query, all the memory from _interim is
+ * simply freed. If the query succeeds, one large buffer will be made
+ * which is big enough for all these allocations, and then
+ * adns__alloc_final will get memory from this buffer.
*
* _alloc_interim can fail (and return 0).
* The caller must ensure that the query is failed.
*
- * adns__alloc_interim_{only,fail}(qu,0) will not return 0,
- * but it will not necessarily return a distinct pointer each time.
+ * The memory from _preserved is is kept and transferred into the
+ * larger buffer - unless we run out of memory, in which case it too
+ * is freed. When you use _preserved you have to add code to the
+ * x_nomem error exit case in adns__makefinal_query to clear out the
+ * pointers you made to those allocations, because that's when they're
+ * thrown away; you should also make a note in the declaration of
+ * those pointer variables, to note that they are _preserved rather
+ * than _interim. If they're in the answer, note it here:
+ * answer->cname and answer->owner are _preserved.
*/
void adns__transfer_interim(adns_query from, adns_query to, void *block, size_t sz);
void adns__makefinal_block(adns_query qu, void **blpp, size_t sz);
void adns__makefinal_str(adns_query qu, char **strp);
-void adns__reset_cnameonly(adns_query qu);
-/* Resets all of the memory management stuff etc. to
- * take account of only the CNAME. Used when we find an error somewhere
- * and want to just report the error (with perhaps CNAME info), and also
- * when we're halfway through RRs in a datagram and discover that we
- * need to retry the query.
+void adns__reset_preserved(adns_query qu);
+/* Resets all of the memory management stuff etc. to take account of
+ * only the _preserved stuff from _alloc_preserved. Used when we find
+ * an error somewhere and want to just report the error (with perhaps
+ * CNAME, owner, etc. info), and also when we're halfway through RRs
+ * in a datagram and discover that we need to retry the query.
*/
void adns__query_done(adns_query qu);
/* From reply.c: */
void adns__procdgram(adns_state ads, const byte *dgram, int len,
- int serv, struct timeval now);
+ int serv, int viatcp, struct timeval now);
/* From types.c: */
int maxfd, const fd_set *readfds,
const fd_set *writefds, const fd_set *exceptfds,
struct timeval now, int *r_r);
+int adns__internal_check(adns_state ads,
+ adns_query *query_io,
+ adns_answer **answer,
+ void **context_r);
+
+/* From check.c: */
+
+void adns__consistency(adns_state ads, adns_query qu, consistency_checks cc);
/* Useful static inline functions: */
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 errno_resources(int e) { return e==ENOMEM || e==ENOBUFS; }
~mdw / adns / blobdiff