Initial vendor import of ldns-1.6.4 into contrib.
[dragonfly.git] / contrib / ldns / ldns / resolver.h
1 /*
2  * resolver.h
3  *
4  * DNS Resolver definitions
5  *
6  * a Net::DNS like library for C
7  *
8  * (c) NLnet Labs, 2005-2006
9  *
10  * See the file LICENSE for the license
11  */
12
13 /**
14  * \file
15  *
16  * Defines the  ldns_resolver structure, a stub resolver that can send queries and parse answers.
17  * 
18  */
19
20 #ifndef LDNS_RESOLVER_H
21 #define LDNS_RESOLVER_H
22
23 #include <ldns/error.h>
24 #include <ldns/common.h>
25 #include <ldns/rr.h>
26 #include <ldns/tsig.h>
27 #include <ldns/rdata.h>
28 #include <ldns/packet.h>
29 #include <sys/time.h>
30
31 /** Default location of the resolv.conf file */
32 #define LDNS_RESOLV_CONF        "/etc/resolv.conf"
33 /** Default location of the hosts file */
34 #define LDNS_RESOLV_HOSTS       "/etc/hosts"
35
36 #define LDNS_RESOLV_KEYWORD     -1      
37 #define LDNS_RESOLV_DEFDOMAIN   0
38 #define LDNS_RESOLV_NAMESERVER  1
39 #define LDNS_RESOLV_SEARCH      2
40 #define LDNS_RESOLV_SORTLIST    3
41 #define LDNS_RESOLV_OPTIONS     4
42 #define LDNS_RESOLV_ANCHOR      5
43 #define LDNS_RESOLV_KEYWORDS    6
44
45 #define LDNS_RESOLV_INETANY             0
46 #define LDNS_RESOLV_INET                1
47 #define LDNS_RESOLV_INET6               2
48
49 #define LDNS_RESOLV_RTT_INF             0       /* infinity */
50 #define LDNS_RESOLV_RTT_MIN             1       /* reachable */
51
52 /**
53  * DNS stub resolver structure
54  */
55 struct ldns_struct_resolver
56 {
57         /**  Port to send queries to */
58         uint16_t _port;
59
60         /** Array of nameservers to query (IP addresses or dnames) */
61         ldns_rdf **_nameservers; 
62         /** Number of nameservers in \c _nameservers */
63         size_t _nameserver_count; /* how many do we have */
64
65         /**  Round trip time; 0 -> infinity. Unit: ms? */
66         size_t *_rtt;
67
68         /**  Wether or not to be recursive */
69         bool _recursive;
70
71         /**  Print debug information */
72         bool _debug;
73         
74         /**  Default domain to add to non fully qualified domain names */
75         ldns_rdf *_domain; 
76
77         /**  Searchlist array, add the names in this array if a query cannot be found */
78         ldns_rdf **_searchlist;
79
80         /** Number of entries in the searchlist array */
81         size_t _searchlist_count;
82
83         /**  Number of times to retry before giving up */
84         uint8_t _retry;
85         /**  Time to wait before retrying */
86         uint8_t _retrans;
87         /**  Use new fallback mechanism (try EDNS, then do TCP) */
88         bool _fallback;
89
90         /**  Whether to do DNSSEC */
91         bool _dnssec;
92         /**  Whether to set the CD bit on DNSSEC requests */
93         bool _dnssec_cd;
94         /** Optional trust anchors for complete DNSSEC validation */
95         ldns_rr_list * _dnssec_anchors;
96         /**  Whether to use tcp or udp (tcp if the value is true)*/
97         bool _usevc;
98         /**  Whether to ignore the tc bit */
99         bool _igntc;
100         /**  Whether to use ip6, 0->does not matter, 1 is IPv4, 2 is IPv6 */
101         uint8_t _ip6;
102         /**  If true append the default domain */
103         bool _defnames;
104         /**  If true apply the search list */
105         bool _dnsrch;
106         /**  Timeout for socket connections */
107         struct timeval _timeout;
108         /**  Only try the first nameserver, and return with an error directly if it fails */
109         bool _fail;
110         /**  Randomly choose a nameserver */
111         bool _random;
112         /** Keep some things to make AXFR possible */
113         int _socket;
114         /** Count the number of LDNS_RR_TYPE_SOA RRs we have seen so far
115          * (the second one signifies the end of the AXFR)
116          */
117         int _axfr_soa_count;
118         /* when axfring we get complete packets from the server
119            but we want to give the caller 1 rr at a time, so
120            keep the current pkt */
121         /** Packet currently handled when doing part of an AXFR */
122         ldns_pkt *_cur_axfr_pkt;
123         /** Counter for within the AXFR packets */
124         uint16_t _axfr_i;
125         /* EDNS0 available buffer size */
126         uint16_t _edns_udp_size;
127         
128         /* Optional tsig key for signing queries,
129         outgoing messages are signed if and only if both are set
130         */
131         /** Name of the key to use with TSIG, if _tsig_keyname and _tsig_keydata both contain values, outgoing messages are automatically signed with TSIG. */
132         char *_tsig_keyname;
133         /** Secret key data to use with TSIG, if _tsig_keyname and _tsig_keydata both contain values, outgoing messages are automatically signed with TSIG. */
134         char *_tsig_keydata;
135         /** TSIG signing algorithm */
136         char *_tsig_algorithm;
137 };
138 typedef struct ldns_struct_resolver ldns_resolver;
139
140 /* prototypes */
141 /* read access functions */
142
143 /**
144  * Get the port the resolver should use
145  * \param[in] r the resolver
146  * \return the port number 
147  */
148 uint16_t ldns_resolver_port(const ldns_resolver *r);
149
150 /**
151  * Is the resolver set to recurse
152  * \param[in] r the resolver
153  * \return true if so, otherwise false
154  */
155 bool ldns_resolver_recursive(const ldns_resolver *r);
156
157 /**
158  * Get the debug status of the resolver
159  * \param[in] r the resolver
160  * \return true if so, otherwise false
161  */
162 bool ldns_resolver_debug(const ldns_resolver *r);
163
164 /**
165  * Get the number of retries
166  * \param[in] r the resolver
167  * \return the number of retries
168  */
169 uint8_t ldns_resolver_retry(const ldns_resolver *r);
170
171 /**
172  * Get the retransmit interval
173  * \param[in] r the resolver
174  * \return the retransmit interval
175  */
176 uint8_t ldns_resolver_retrans(const ldns_resolver *r);
177
178 /**
179  * Get the truncation fallback status
180  * \param[in] r the resolver
181  * \return whether the truncation fallback mechanism is used
182  */
183 bool ldns_resolver_fallback(const ldns_resolver *r);
184
185 /**
186  * Does the resolver use ip6 or ip4
187  * \param[in] r the resolver
188  * \return 0: both, 1: ip4, 2:ip6
189  */
190 uint8_t ldns_resolver_ip6(const ldns_resolver *r);
191
192 /**
193  * Get the resolver's udp size
194  * \param[in] r the resolver
195  * \return the udp mesg size
196  */
197 uint16_t ldns_resolver_edns_udp_size(const ldns_resolver *r);
198 /**
199  * Does the resolver use tcp or udp
200  * \param[in] r the resolver
201  * \return true: tcp, false: udp
202  */
203 bool ldns_resolver_usevc(const ldns_resolver *r);
204 /**
205  * Does the resolver only try the first nameserver
206  * \param[in] r the resolver
207  * \return true: yes, fail, false: no, try the others
208  */
209 bool ldns_resolver_fail(const ldns_resolver *r);
210 /**
211  * Does the resolver do DNSSEC
212  * \param[in] r the resolver
213  * \return true: yes, false: no
214  */
215 bool ldns_resolver_dnssec(const ldns_resolver *r);
216 /**
217  * Does the resolver set the CD bit 
218  * \param[in] r the resolver
219  * \return true: yes, false: no
220  */
221 bool ldns_resolver_dnssec_cd(const ldns_resolver *r);
222 /**
223  * Get the resolver's DNSSEC anchors
224  * \param[in] r the resolver
225  * \return an rr_list containg trusted DNSSEC anchors
226  */
227 ldns_rr_list * ldns_resolver_dnssec_anchors(const ldns_resolver *r);
228 /**
229  * Does the resolver ignore the TC bit (truncated)
230  * \param[in] r the resolver
231  * \return true: yes, false: no
232  */
233 bool ldns_resolver_igntc(const ldns_resolver *r);
234 /**
235  * Does the resolver randomize the nameserver before usage
236  * \param[in] r the resolver
237  * \return true: yes, false: no
238  */
239 bool ldns_resolver_random(const ldns_resolver *r);
240 /**
241  * How many nameserver are configured in the resolver
242  * \param[in] r the resolver
243  * \return number of nameservers
244  */
245 size_t ldns_resolver_nameserver_count(const ldns_resolver *r);
246 /**
247  * What is the default dname to add to relative queries
248  * \param[in] r the resolver
249  * \return the dname which is added
250  */
251 ldns_rdf *ldns_resolver_domain(const ldns_resolver *r);
252 /**
253  * What is the timeout on socket connections
254  * \param[in] r the resolver
255  * \return the timeout as struct timeval
256  */
257 struct timeval ldns_resolver_timeout(const ldns_resolver *r);
258 /**
259  * What is the searchlist as used by the resolver
260  * \param[in] r the resolver
261  * \return a ldns_rdf pointer to a list of the addresses
262  */
263 ldns_rdf** ldns_resolver_searchlist(const ldns_resolver *r);
264 /**
265  * Return the configured nameserver ip address
266  * \param[in] r the resolver
267  * \return a ldns_rdf pointer to a list of the addresses
268  */
269 ldns_rdf** ldns_resolver_nameservers(const ldns_resolver *r);
270 /**
271  * Return the used round trip times for the nameservers
272  * \param[in] r the resolver
273  * \return a size_t* pointer to the list.
274  * yet)
275  */
276 size_t * ldns_resolver_rtt(const ldns_resolver *r);
277 /**
278  * Return the used round trip time for a specific nameserver
279  * \param[in] r the resolver
280  * \param[in] pos the index to the nameserver
281  * \return the rrt, 0: infinite, >0: undefined (as of * yet)
282  */
283 size_t ldns_resolver_nameserver_rtt(const ldns_resolver *r, size_t pos);
284 /**
285  * Return the tsig keyname as used by the nameserver
286  * \param[in] r the resolver
287  * \return the name used.
288  */
289 char *ldns_resolver_tsig_keyname(const ldns_resolver *r);
290 /**
291  * Return the tsig algorithm as used by the nameserver
292  * \param[in] r the resolver
293  * \return the algorithm used.
294  */
295 char *ldns_resolver_tsig_algorithm(const ldns_resolver *r);
296 /**
297  * Return the tsig keydata as used by the nameserver
298  * \param[in] r the resolver
299  * \return the keydata used.
300  */
301 char *ldns_resolver_tsig_keydata(const ldns_resolver *r);
302 /**
303  * pop the last nameserver from the resolver.
304  * \param[in] r the resolver
305  * \return the popped address or NULL if empty
306  */
307 ldns_rdf* ldns_resolver_pop_nameserver(ldns_resolver *r);
308
309 /**
310  * Return the resolver's searchlist count
311  * \param[in] r the resolver
312  * \return the searchlist count
313  */
314 size_t ldns_resolver_searchlist_count(const ldns_resolver *r);
315
316 /* write access function */
317 /**
318  * Set the port the resolver should use
319  * \param[in] r the resolver
320  * \param[in] p the port number
321  */
322 void ldns_resolver_set_port(ldns_resolver *r, uint16_t p);
323
324 /**
325  * Set the resolver recursion
326  * \param[in] r the resolver
327  * \param[in] b true: set to recurse, false: unset
328  */
329 void ldns_resolver_set_recursive(ldns_resolver *r, bool b);
330
331 /**
332  * Set the resolver debugging
333  * \param[in] r the resolver
334  * \param[in] b true: debug on: false debug off
335  */
336 void ldns_resolver_set_debug(ldns_resolver *r, bool b);
337
338 /**
339  * Incremental the resolver's nameserver count.
340  * \param[in] r the resolver
341  */
342 void ldns_resolver_incr_nameserver_count(ldns_resolver *r);
343
344 /**
345  * Decrement the resolver's nameserver count.
346  * \param[in] r the resolver
347  */
348 void ldns_resolver_dec_nameserver_count(ldns_resolver *r);
349
350 /**
351  * Set the resolver's nameserver count directly.
352  * \param[in] r the resolver
353  * \param[in] c the nameserver count
354  */
355 void ldns_resolver_set_nameserver_count(ldns_resolver *r, size_t c);
356
357 /**
358  * Set the resolver's nameserver count directly by using an rdf list
359  * \param[in] r the resolver
360  * \param[in] rd the resolver addresses
361  */
362 void ldns_resolver_set_nameservers(ldns_resolver *r, ldns_rdf **rd);
363
364 /**
365  * Set the resolver's default domain. This gets appended when no 
366  * absolute name is given
367  * \param[in] r the resolver
368  * \param[in] rd the name to append
369  */
370 void ldns_resolver_set_domain(ldns_resolver *r, ldns_rdf *rd);
371
372 /**
373  * Set the resolver's socket time out when talking to remote hosts
374  * \param[in] r the resolver
375  * \param[in] timeout the timeout to use
376  */
377 void ldns_resolver_set_timeout(ldns_resolver *r, struct timeval timeout);
378
379 /**
380  * Push a new rd to the resolver's searchlist
381  * \param[in] r the resolver
382  * \param[in] rd to push
383  */
384 void ldns_resolver_push_searchlist(ldns_resolver *r, ldns_rdf *rd);
385
386 /**
387  * Whether the resolver uses the name set with _set_domain
388  * \param[in] r the resolver
389  * \param[in] b true: use the defaults, false: don't use them
390  */
391 void ldns_resolver_set_defnames(ldns_resolver *r, bool b);
392
393 /**
394  * Whether the resolver uses a virtual circuit (TCP)
395  * \param[in] r the resolver
396  * \param[in] b true: use TCP, false: don't use TCP
397  */
398 void ldns_resolver_set_usevc(ldns_resolver *r, bool b);
399
400 /**
401  * Whether the resolver uses the searchlist
402  * \param[in] r the resolver
403  * \param[in] b true: use the list, false: don't use the list
404  */
405 void ldns_resolver_set_dnsrch(ldns_resolver *r, bool b);
406
407 /**
408  * Whether the resolver uses DNSSEC
409  * \param[in] r the resolver
410  * \param[in] b true: use DNSSEC, false: don't use DNSSEC
411  */
412 void ldns_resolver_set_dnssec(ldns_resolver *r, bool b);
413
414 /**
415  * Whether the resolver uses the checking disable bit
416  * \param[in] r the resolver
417  * \param[in] b true: enable , false: don't use TCP
418  */
419 void ldns_resolver_set_dnssec_cd(ldns_resolver *r, bool b);
420 /**
421  * Set the resolver's DNSSEC anchor list directly. RRs should be of type DS or DNSKEY.
422  * \param[in] r the resolver
423  * \param[in] l the list of RRs to use as trust anchors
424  */
425 void ldns_resolver_set_dnssec_anchors(ldns_resolver *r, ldns_rr_list * l);
426
427 /**
428  * Push a new trust anchor to the resolver. It must be a DS or DNSKEY rr
429  * \param[in] r the resolver.
430  * \param[in] rr the RR to add as a trust anchor.
431  * \return a status
432  */
433 ldns_status ldns_resolver_push_dnssec_anchor(ldns_resolver *r, ldns_rr *rr);
434
435 /**
436  * Set the resolver retrans timeout (in seconds)
437  * \param[in] r the resolver
438  * \param[in] re the retransmission interval in seconds
439  */
440 void ldns_resolver_set_retrans(ldns_resolver *r, uint8_t re);
441
442 /**
443  * Set whether the resolvers truncation fallback mechanism is used
444  * when ldns_resolver_query() is called.
445  * \param[in] r the resolver
446  * \param[in] fallback whether to use the fallback mechanism
447  */
448 void ldns_resolver_set_fallback(ldns_resolver *r, bool fallback);
449
450 /**
451  * Set the resolver retry interval (in seconds)
452  * \param[in] r the resolver
453  * \param[in] re the retry interval
454  */
455 void ldns_resolver_set_retry(ldns_resolver *r, uint8_t re);
456
457 /**
458  * Whether the resolver uses ip6
459  * \param[in] r the resolver
460  * \param[in] i 0: no pref, 1: ip4, 2: ip6
461  */
462 void ldns_resolver_set_ip6(ldns_resolver *r, uint8_t i);
463
464 /**
465  * Whether or not to fail after one failed query
466  * \param[in] r the resolver
467  * \param[in] b true: yes fail, false: continue with next nameserver
468  */
469 void ldns_resolver_set_fail(ldns_resolver *r, bool b);
470
471 /**
472  * Whether or not to ignore the TC bit
473  * \param[in] r the resolver
474  * \param[in] b true: yes ignore, false: don't ignore
475  */
476 void ldns_resolver_set_igntc(ldns_resolver *r, bool b);
477
478 /**
479  * Set maximum udp size
480  * \param[in] r the resolver
481  * \param[in] s the udp max size
482  */
483 void ldns_resolver_set_edns_udp_size(ldns_resolver *r, uint16_t s);
484
485 /**
486  * Set the tsig key name
487  * \param[in] r the resolver
488  * \param[in] tsig_keyname the tsig key name
489  */
490 void ldns_resolver_set_tsig_keyname(ldns_resolver *r, char *tsig_keyname);
491
492 /**
493  * Set the tsig algorithm
494  * \param[in] r the resolver
495  * \param[in] tsig_algorithm the tsig algorithm
496  */
497 void ldns_resolver_set_tsig_algorithm(ldns_resolver *r, char *tsig_algorithm);
498
499 /**
500  * Set the tsig key data
501  * \param[in] r the resolver
502  * \param[in] tsig_keydata the key data
503  */
504 void ldns_resolver_set_tsig_keydata(ldns_resolver *r, char *tsig_keydata);
505
506 /**
507  * Set round trip time for all nameservers. Note this currently
508  * differentiates between: unreachable and reachable.
509  * \param[in] r the resolver
510  * \param[in] rtt a list with the times
511  */
512 void ldns_resolver_set_rtt(ldns_resolver *r, size_t *rtt);
513
514 /**
515  * Set round trip time for a specific nameserver. Note this
516  * currently differentiates between: unreachable and reachable.
517  * \param[in] r the resolver
518  * \param[in] pos the nameserver position
519  * \param[in] value the rtt
520  */
521 void ldns_resolver_set_nameserver_rtt(ldns_resolver *r, size_t pos, size_t value);
522
523 /**
524  * Should the nameserver list be randomized before each use
525  * \param[in] r the resolver
526  * \param[in] b: true: randomize, false: don't
527  */
528 void ldns_resolver_set_random(ldns_resolver *r, bool b);
529
530 /**
531  * push a new nameserver to the resolver. It must be an IP
532  * address v4 or v6.
533  * \param[in] r the resolver
534  * \param[in] n the ip address
535  * \return ldns_status a status
536  */
537 ldns_status ldns_resolver_push_nameserver(ldns_resolver *r, ldns_rdf *n);
538
539 /**
540  * push a new nameserver to the resolver. It must be an 
541  * A or AAAA RR record type
542  * \param[in] r the resolver
543  * \param[in] rr the resource record 
544  * \return ldns_status a status
545  */
546 ldns_status ldns_resolver_push_nameserver_rr(ldns_resolver *r, ldns_rr *rr);
547
548 /**
549  * push a new nameserver rr_list to the resolver.
550  * \param[in] r the resolver
551  * \param[in] rrlist the rr_list to push
552  * \return ldns_status a status
553  */
554 ldns_status ldns_resolver_push_nameserver_rr_list(ldns_resolver *r, ldns_rr_list *rrlist);
555
556 /**
557  * Send the query for using the resolver and take the search list into account
558  * The search algorithm is as follows:
559  * If the name is absolute, try it as-is, otherwise apply the search list
560  * \param[in] *r operate using this resolver
561  * \param[in] *rdf query for this name
562  * \param[in] t query for this type (may be 0, defaults to A)
563  * \param[in] c query for this class (may be 0, default to IN)
564  * \param[in] flags the query flags
565  * \return ldns_pkt* a packet with the reply from the nameserver
566  */
567 ldns_pkt* ldns_resolver_search(const ldns_resolver *r, const ldns_rdf *rdf, ldns_rr_type t, ldns_rr_class c, uint16_t flags);
568
569 /**
570  * Form a query packet from a resolver and name/type/class combo
571  * \param[out] **q a pointer to a ldns_pkt pointer (initialized by this function)
572  * \param[in] *r operate using this resolver
573  * \param[in] *name query for this name
574  * \param[in] t query for this type (may be 0, defaults to A)
575  * \param[in] c query for this class (may be 0, default to IN)
576  * \param[in] f the query flags
577  * \return ldns_pkt* a packet with the reply from the nameserver
578  */
579 ldns_status ldns_resolver_prepare_query_pkt(ldns_pkt **q, ldns_resolver *r, const  ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, uint16_t f);
580
581 /**
582  * Send the query for name as-is 
583  * \param[out] **answer a pointer to a ldns_pkt pointer (initialized by this function)
584  * \param[in] *r operate using this resolver
585  * \param[in] *name query for this name
586  * \param[in] t query for this type (may be 0, defaults to A)
587  * \param[in] c query for this class (may be 0, default to IN)
588  * \param[in] flags the query flags
589  * \return ldns_pkt* a packet with the reply from the nameserver
590  */
591 ldns_status ldns_resolver_send(ldns_pkt **answer, ldns_resolver *r, const ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, uint16_t flags);
592
593 /**
594  * Send the given packet to a nameserver
595  * \param[out] **answer a pointer to a ldns_pkt pointer (initialized by this function)
596  * \param[in] *r operate using this resolver
597  * \param[in] *query_pkt query
598  */
599 ldns_status ldns_resolver_send_pkt(ldns_pkt **answer, ldns_resolver *r, ldns_pkt *query_pkt);
600
601 /**
602  * Send a query to a nameserver
603  * \param[in] *r operate using this resolver
604  * \param[in] *name query for this name
605  * \param[in] *t query for this type (may be 0, defaults to A)
606  * \param[in] *c query for this class (may be 0, default to IN)
607  * \param[in] flags the query flags
608  * \return ldns_pkt* a packet with the reply from the nameserver
609  * if _defnames is true the default domain will be added
610  */
611 ldns_pkt* ldns_resolver_query(const ldns_resolver *r, const ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, uint16_t flags);
612
613
614 /** 
615  * Create a new resolver structure 
616  * \return ldns_resolver* pointer to new strcture
617  */
618 ldns_resolver* ldns_resolver_new(void);
619
620 /**
621  * Create a resolver structure from a file like /etc/resolv.conf
622  * \param[out] r the new resolver
623  * \param[in] fp file pointer to create new resolver from
624  *      if NULL use /etc/resolv.conf
625  * \return LDNS_STATUS_OK or the error
626  */
627 ldns_status ldns_resolver_new_frm_fp(ldns_resolver **r, FILE *fp);
628
629 /**
630  * Create a resolver structure from a file like /etc/resolv.conf
631  * \param[out] r the new resolver
632  * \param[in] fp file pointer to create new resolver from
633  *      if NULL use /etc/resolv.conf
634  * \param[in] line_nr pointer to an integer containing the current line number (for debugging purposes)
635  * \return LDNS_STATUS_OK or the error
636  */
637 ldns_status ldns_resolver_new_frm_fp_l(ldns_resolver **r, FILE *fp, int *line_nr);
638
639 /**
640  * configure a resolver by means of a resolv.conf file 
641  * The file may be NULL in which case there will  be
642  * looked the RESOLV_CONF (defaults to /etc/resolv.conf
643  * \param[out] r the new resolver
644  * \param[in] filename the filename to use
645  * \return LDNS_STATUS_OK or the error
646  */                             
647 ldns_status ldns_resolver_new_frm_file(ldns_resolver **r, const char *filename);
648
649 /**                             
650  * Frees the allocated space for this resolver. Only frees the resolver pionter! You should probably be using _deep_free.
651  * \param res resolver to free  
652  */     
653 void ldns_resolver_free(ldns_resolver *res);
654
655 /**                             
656  * Frees the allocated space for this resolver and all it's data
657  * \param res resolver to free  
658  */     
659 void ldns_resolver_deep_free(ldns_resolver *res);
660
661 /**
662  *  get the next stream of RRs in a AXFR 
663  * \param[in] resolver the resolver to use. First ldns_axfr_start() must be
664  * called
665  * \return ldns_rr the next RR from the AXFR stream
666  */
667 ldns_rr* ldns_axfr_next(ldns_resolver *resolver);
668
669 /**
670  * returns true if the axfr transfer has completed (i.e. 2 SOA RRs and no errors were encountered 
671  * \param[in] resolver the resolver that is used
672  * \return bool true if axfr transfer was completed without error
673  */
674 bool ldns_axfr_complete(const ldns_resolver *resolver);
675
676 /**
677  * returns a pointer to the last ldns_pkt that was sent by the server in the AXFR transfer
678  * uasable for instance to get the error code on failure
679  * \param[in] res the resolver that was used in the axfr transfer
680  * \return ldns_pkt the last packet sent
681  */
682 ldns_pkt *ldns_axfr_last_pkt(const ldns_resolver *res);
683
684 /**
685  * randomize the nameserver list in the resolver
686  * \param[in] r the resolver
687  */
688 void ldns_resolver_nameservers_randomize(ldns_resolver *r);
689
690 /** 
691  * Returns true if at least one of the provided keys is a trust anchor
692  * \param[in] r the current resolver
693  * \param[in] keys the keyset to check
694  * \param[out] trusted_keys the subset of trusted keys in the 'keys' rrset
695  * \return true if at least one of the provided keys is a configured trust anchor
696  */
697 bool ldns_resolver_trusted_key(const ldns_resolver *r, ldns_rr_list * keys, ldns_rr_list * trusted_keys);
698
699 #endif  /* LDNS_RESOLVER_H */