146 if (!r || !keys) {
return false; }
150 if (!trust_anchors) {
return false; }
262 if (ns_count == 0 || !nameservers) {
266 pop = nameservers[ns_count - 1];
452 ldns_resolver_set_searchlist_count(
ldns_resolver *r,
size_t c)
553 r->
_timeout.tv_sec = timeout.tv_sec;
554 r->
_timeout.tv_usec = timeout.tv_usec;
575 ldns_resolver_set_searchlist_count(r, list_count + 1);
622 ldns_resolver_set_searchlist_count(r, 0);
685 int lnr = 0, oldline;
687 if(!line_nr) line_nr = &lnr;
690 myfp = fopen(
"/etc/resolv.conf",
"r");
714 if(!fp) fclose(myfp);
724 if (word[0] ==
'#') {
726 if(oldline == *line_nr) {
731 }
while(c != EOF && c !=
'\n');
732 if(c==
'\n') (*line_nr)++;
744 if(word[0] ==
'#')
continue;
746 if (strcasecmp(keyword[i], word) == 0) {
769 if(!fp) fclose(myfp);
779 if(!fp) fclose(myfp);
791 if(!fp) fclose(myfp);
798 if(strchr(word,
'%')) {
801 strchr(word,
'%')[0]=0;
811 if(!fp) fclose(myfp);
824 if(!fp) fclose(myfp);
832 if(!fp) fclose(myfp);
846 if(!fp) fclose(myfp);
877 if(!fp) fclose(myfp);
918 fp = fopen(filename,
"r");
1008 new_name, t, c, flags);
1077 memcpy(new_rtt, old_rtt,
sizeof(
size_t)
1086 ldns_resolver_restore_rtt(
ldns_resolver *r,
size_t *old_rtt)
1128 rtt = ldns_resolver_backup_rtt(r);
1131 ldns_resolver_restore_rtt(r, rtt);
1138 stat =
ldns_send(&answer_pkt, r, query_pkt);
1146 *answer = answer_pkt;
1188 now.tv_sec = time(NULL);
1215 assert(name != NULL);
1268 *answer = answer_pkt;
1277 uint8_t *packet_wire;
1278 size_t packet_wire_size;
1283 if (!resolver || resolver->
_socket == 0) {
1303 closesocket(resolver->
_socket);
1333 closesocket(resolver->
_socket);
1342 fprintf(stderr,
"Error in AXFR: %s\n",
1345 fprintf(stderr,
"Error in AXFR: %d\n",
1357 closesocket(resolver->
_socket);
1384 closesocket(resolver->
_socket);
1409 size_t *rtt, tmprtt;
ldns_rdf * ldns_rr_rdf(const ldns_rr *rr, size_t nr)
returns the rdata field member counter.
uint8_t ldns_resolver_ip6(const ldns_resolver *r)
Does the resolver use ip6 or ip4.
implementation of buffers to ease operations
void ldns_resolver_free(ldns_resolver *res)
Frees the allocated space for this resolver.
void ldns_resolver_set_domain(ldns_resolver *r, ldns_rdf *d)
Set the resolver's default domain.
void ldns_resolver_set_source(ldns_resolver *r, ldns_rdf *s)
Set the source rdf (address) the resolver should use.
#define LDNS_PARSE_NORMAL
bool ldns_resolver_dnsrch(const ldns_resolver *r)
Does the resolver apply search list.
ldns_rr * ldns_rr_clone(const ldns_rr *rr)
clones a rr and all its data
char * ldns_resolver_tsig_algorithm(const ldns_resolver *r)
Return the tsig algorithm as used by the nameserver.
uint8_t ldns_resolver_retry(const ldns_resolver *r)
Get the number of retries.
void ldns_rdf_deep_free(ldns_rdf *rd)
frees a rdf structure and frees the data.
ldns_status ldns_resolver_search_status(ldns_pkt **pkt, ldns_resolver *r, const ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, uint16_t flags)
Send the query for using the resolver and take the search list into account The search algorithm is a...
ldns_status ldns_resolver_prepare_query_pkt(ldns_pkt **query_pkt, ldns_resolver *r, const ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, uint16_t flags)
Form a query packet from a resolver and name/type/class combo.
ldns_rr_list * _dnssec_anchors
Optional trust anchors for complete DNSSEC validation.
DNS stub resolver structure.
signed char _fail
Only try the first nameserver, and return with an error directly if it fails.
uint16_t _port
Port to send queries to.
enum ldns_enum_rr_class ldns_rr_class
bool ldns_rr_list_push_rr(ldns_rr_list *rr_list, const ldns_rr *rr)
pushes an rr to an rrlist.
ldns_pkt * ldns_resolver_query(const ldns_resolver *r, const ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, uint16_t flags)
Send a query to a nameserver.
size_t ldns_resolver_searchlist_count(const ldns_resolver *r)
Return the resolver's searchlist count.
bool ldns_rr_list_contains_rr(const ldns_rr_list *rr_list, ldns_rr *rr)
returns true if the given rr is one of the rrs in the list, or if it is equal to one ...
List or Set of Resource Records.
void ldns_resolver_set_rtt(ldns_resolver *r, size_t *rtt)
Set round trip time for all nameservers.
size_t _searchlist_count
Number of entries in the searchlist array.
bool ldns_pkt_tc(const ldns_pkt *packet)
Read the packet's tc bit.
ldns_pkt_rcode ldns_pkt_get_rcode(const ldns_pkt *packet)
Return the packet's respons code.
uint8_t _retrans
Time to wait before retrying.
void ldns_resolver_deep_free(ldns_resolver *res)
Frees the allocated space for this resolver and all it's data.
signed char _dnssec
Whether to do DNSSEC.
#define LDNS_RESOLV_DEFDOMAIN
bool ldns_resolver_dnssec(const ldns_resolver *r)
Does the resolver do DNSSEC.
#define LDNS_RESOLV_SEARCH
ldns_status ldns_resolver_push_nameserver_rr_list(ldns_resolver *r, ldns_rr_list *rrlist)
Push a new nameserver rr_list to the resolver.
void ldns_resolver_set_nameserver_rtt(ldns_resolver *r, size_t pos, size_t value)
Set round trip time for a specific nameserver.
uint16_t ldns_pkt_id(const ldns_pkt *packet)
Read the packet id.
void ldns_resolver_set_tsig_keyname(ldns_resolver *r, char *tsig_keyname)
Set the tsig key name.
#define LDNS_XMALLOC(type, count)
void ldns_resolver_set_nameservers(ldns_resolver *r, ldns_rdf **n)
Set the resolver's nameserver count directly by using an rdf list.
void ldns_resolver_push_searchlist(ldns_resolver *r, ldns_rdf *d)
Push a new rd to the resolver's searchlist.
#define LDNS_RESOLV_KEYWORDS
ldns_lookup_table ldns_rcodes[]
Response codes.
#define LDNS_RESOLV_ANCHOR
void ldns_rr_list_deep_free(ldns_rr_list *rr_list)
frees an rr_list structure and all rrs contained therein.
void ldns_buffer_free(ldns_buffer *buffer)
frees the buffer.
#define LDNS_RESOLV_NAMESERVER
ldns_rdf * ldns_rdf_clone(const ldns_rdf *rd)
clones a rdf structure.
void ldns_resolver_set_tsig_algorithm(ldns_resolver *r, char *tsig_algorithm)
Set the tsig algorithm.
size_t * _rtt
Round trip time; 0 -> infinity.
void ldns_rr_free(ldns_rr *rr)
frees an RR structure
void ldns_resolver_set_timeout(ldns_resolver *r, struct timeval timeout)
Set the resolver's socket time out when talking to remote hosts.
ssize_t ldns_bget_token(ldns_buffer *b, char *token, const char *delim, size_t limit)
returns a token/char from the buffer b.
uint16_t ldns_resolver_port(const ldns_resolver *r)
Get the port the resolver should use.
ldns_rdf ** ldns_resolver_searchlist(const ldns_resolver *r)
What is the searchlist as used by the resolver.
ldns_status ldns_resolver_push_dnssec_anchor(ldns_resolver *r, ldns_rr *rr)
Push a new trust anchor to the resolver.
ldns_rr_list * ldns_resolver_dnssec_anchors(const ldns_resolver *r)
Get the resolver's DNSSEC anchors.
void ldns_pkt_set_edns_udp_size(ldns_pkt *packet, uint16_t s)
Set the packet's edns udp size.
ldns_pkt * ldns_pkt_query_new(ldns_rdf *rr_name, ldns_rr_type rr_type, ldns_rr_class rr_class, uint16_t flags)
creates a packet with a query in it for the given name, type and class.
bool ldns_resolver_dnssec_cd(const ldns_resolver *r)
Does the resolver set the CD bit.
ldns_pkt * ldns_axfr_last_pkt(const ldns_resolver *res)
Returns a pointer to the last ldns_pkt that was sent by the server in the AXFR transfer uasable for i...
#define LDNS_XREALLOC(ptr, type, count)
bool ldns_resolver_igntc(const ldns_resolver *r)
Does the resolver ignore the TC bit (truncated)
void ldns_resolver_set_igntc(ldns_resolver *r, bool i)
signed char _usevc
Whether to use tcp or udp (tcp if the value is true)
bool ldns_axfr_complete(const ldns_resolver *res)
Returns true if the axfr transfer has completed (i.e.
size_t ldns_resolver_nameserver_rtt(const ldns_resolver *r, size_t pos)
Return the used round trip time for a specific nameserver.
#define LDNS_RESOLV_RTT_MIN
void ldns_rdf_free(ldns_rdf *rd)
frees a rdf structure, leaving the data pointer intact.
char * _tsig_algorithm
TSIG signing algorithm.
ldns_status ldns_send(ldns_pkt **result_packet, ldns_resolver *r, const ldns_pkt *query_pkt)
Sends ptk to the nameserver at the resolver object.
void ldns_resolver_set_dnssec(ldns_resolver *r, bool d)
bool ldns_resolver_defnames(const ldns_resolver *r)
Does the resolver apply default domain name.
Including this file will include all ldns files, and define some lookup tables.
bool ldns_resolver_fallback(const ldns_resolver *r)
Get the truncation fallback status.
marks the start of a zone of authority
size_t _nameserver_count
Number of nameservers in _nameservers.
uint16_t ldns_get_random(void)
Get random number.
uint8_t _retry
Number of times to retry before giving up.
void ldns_resolver_set_recursive(ldns_resolver *r, bool re)
signed char _debug
Print debug information.
ldns_rr * ldns_rr_list_rr(const ldns_rr_list *rr_list, size_t nr)
returns a specific rr of an rrlist.
void ldns_resolver_set_defnames(ldns_resolver *r, bool d)
#define LDNS_RESOLV_CONF
Default location of the resolv.conf file.
ldns_rr * ldns_axfr_next(ldns_resolver *resolver)
Get the next stream of RRs in a AXFR.
bool ldns_resolver_trusted_key(const ldns_resolver *r, ldns_rr_list *keys, ldns_rr_list *trusted_keys)
Returns true if at least one of the provided keys is a trust anchor.
ldns_rr * ldns_read_anchor_file(const char *filename)
Instantiates a DNSKEY or DS RR from file.
ldns_status ldns_wire2pkt(ldns_pkt **packet_p, const uint8_t *wire, size_t max)
converts the data on the uint8_t bytearray (in wire format) to a DNS packet.
ldns_status ldns_resolver_query_status(ldns_pkt **pkt, ldns_resolver *r, const ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, uint16_t flags)
Send a query to a nameserver.
void ldns_resolver_nameservers_randomize(ldns_resolver *r)
Randomize the nameserver list in the resolver.
void ldns_resolver_set_nameserver_count(ldns_resolver *r, size_t c)
Set the resolver's nameserver count directly.
void ldns_resolver_set_fallback(ldns_resolver *r, bool fallback)
uint16_t ldns_pkt_ancount(const ldns_pkt *packet)
Return the packet's an count.
bool ldns_resolver_usevc(const ldns_resolver *r)
Does the resolver use tcp or udp.
ldns_pkt * ldns_resolver_search(const ldns_resolver *r, const ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, uint16_t flags)
Send the query for using the resolver and take the search list into account The search algorithm is a...
size_t ldns_resolver_nameserver_count(const ldns_resolver *r)
How many nameserver are configured in the resolver.
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)
Send the query for name as-is.
int _axfr_soa_count
Count the number of LDNS_RR_TYPE_SOA RRs we have seen so far (the second one signifies the end of the...
ldns_rr_list * ldns_rr_list_new(void)
creates a new rr_list structure.
uint16_t ldns_resolver_edns_udp_size(const ldns_resolver *r)
Get the resolver's udp size.
void ldns_resolver_incr_nameserver_count(ldns_resolver *r)
Incremental the resolver's nameserver count.
void ldns_resolver_set_random(ldns_resolver *r, bool b)
#define LDNS_DEFAULT_TIMEOUT_SEC
ldns_lookup_table * ldns_lookup_by_id(ldns_lookup_table *table, int id)
#define LDNS_RESOLV_SORTLIST
ldns_pkt * _cur_axfr_pkt
Packet currently handled when doing part of an AXFR.
struct timeval _timeout
Timeout for socket connections.
ldns_rdf ** _nameservers
Array of nameservers to query (IP addresses or dnames)
#define LDNS_RESOLV_KEYWORD
ldns_rdf * ldns_rdf_new_frm_str(ldns_rdf_type type, const char *str)
creates a new rdf from a string.
ldns_rdf * ldns_dname_cat_clone(const ldns_rdf *rd1, const ldns_rdf *rd2)
concatenates two dnames together
void ldns_resolver_set_fail(ldns_resolver *r, bool f)
uint16_t _axfr_i
Counter for within the AXFR packets.
ldns_resolver * ldns_resolver_new(void)
Create a new resolver structure.
bool ldns_resolver_debug(const ldns_resolver *r)
Get the debug status of the resolver.
signed char _recursive
Wether or not to be recursive.
signed char _defnames
If true append the default domain.
ssize_t ldns_fget_token_l(FILE *f, char *token, const char *delim, size_t limit, int *line_nr)
returns a token/char from the stream F.
ldns_status ldns_resolver_push_nameserver_rr(ldns_resolver *r, ldns_rr *rr)
Push a new nameserver to the resolver.
ldns_rdf_type ldns_rdf_get_type(const ldns_rdf *rd)
returns the type of the rdf.
ldns_pkt * ldns_pkt_ixfr_request_new(ldns_rdf *rr_name, ldns_rr_class rr_class, uint16_t flags, ldns_rr *soa)
creates an IXFR request packet for the given name, type and class.
void ldns_resolver_set_port(ldns_resolver *r, uint16_t p)
Set the port the resolver should use.
void ldns_pkt_set_edns_do(ldns_pkt *packet, bool value)
char * _tsig_keyname
Name of the key to use with TSIG, if _tsig_keyname and _tsig_keydata both contain values...
char * ldns_resolver_tsig_keydata(const ldns_resolver *r)
Return the tsig keydata as used by the nameserver.
ldns_rr_type ldns_rr_get_type(const ldns_rr *rr)
returns the type of the rr.
uint8_t * ldns_tcp_read_wire(int sockfd, size_t *size)
This routine may block.
bool ldns_resolver_random(const ldns_resolver *r)
Does the resolver randomize the nameserver before usage.
ldns_rdf * _domain
Default domain to add to non fully qualified domain names.
enum ldns_enum_status ldns_status
ldns_status ldns_resolver_new_frm_file(ldns_resolver **res, const char *filename)
Configure a resolver by means of a resolv.conf file The file may be NULL in which case there will be ...
void ldns_pkt_set_cd(ldns_pkt *packet, bool cd)
#define LDNS_MALLOC(type)
Memory management macros.
ldns_status ldns_resolver_new_frm_fp_l(ldns_resolver **res, FILE *fp, int *line_nr)
Create a resolver structure from a file like /etc/resolv.conf.
A general purpose lookup table.
uint8_t ldns_resolver_retrans(const ldns_resolver *r)
Get the retransmit interval.
signed char _igntc
Whether to ignore the tc bit.
ldns_status ldns_pkt_tsig_sign(ldns_pkt *pkt, const char *key_name, const char *key_data, uint16_t fudge, const char *algorithm_name, ldns_rdf *query_mac)
creates a tsig rr for the given packet and key.
#define LDNS_PARSE_SKIP_SPACE
ldns_rdf * ldns_resolver_pop_nameserver(ldns_resolver *r)
pop the last nameserver from the resolver.
void ldns_resolver_set_debug(ldns_resolver *r, bool d)
size_t * ldns_resolver_rtt(const ldns_resolver *r)
Return the used round trip times for the nameservers.
uint16_t ldns_pkt_edns_udp_size(const ldns_pkt *packet)
return the packet's edns udp size
void ldns_resolver_set_usevc(ldns_resolver *r, bool vc)
bool ldns_resolver_fail(const ldns_resolver *r)
Does the resolver only try the first nameserver.
ldns_rdf * ldns_resolver_source(const ldns_resolver *r)
Get the source address the resolver should use.
ldns_rdf ** _searchlist
Searchlist array, add the names in this array if a query cannot be found.
#define LDNS_RESOLV_OPTIONS
void ldns_resolver_set_edns_udp_size(ldns_resolver *r, uint16_t s)
Set maximum udp size.
signed char _dnssec_cd
Whether to set the CD bit on DNSSEC requests.
signed char _random
Randomly choose a nameserver.
ldns_rdf * _source
Source address to query from.
void ldns_pkt_print(FILE *output, const ldns_pkt *pkt)
Prints the data in the DNS packet to the given file stream (in presentation format) ...
ldns_status ldns_resolver_push_nameserver(ldns_resolver *r, ldns_rdf *n)
Push a new nameserver to the resolver.
ldns_rdf ** ldns_resolver_nameservers(const ldns_resolver *r)
Return the configured nameserver ip address.
ldns_status ldns_resolver_send_pkt(ldns_pkt **answer, ldns_resolver *r, ldns_pkt *query_pkt)
Send the given packet to a nameserver.
char * ldns_resolver_tsig_keyname(const ldns_resolver *r)
Return the tsig keyname as used by the nameserver.
Resource record data field.
uint8_t _ip6
Whether to use ip6, 0->does not matter, 1 is IPv4, 2 is IPv6.
void ldns_resolver_set_retry(ldns_resolver *r, uint8_t retry)
Set the number of times a resolver should retry a nameserver before the next one is tried...
#define LDNS_RESOLV_INETANY
size_t ldns_rr_list_rr_count(const ldns_rr_list *rr_list)
returns the number of rr's in an rr_list.
void ldns_resolver_set_dnssec_anchors(ldns_resolver *r, ldns_rr_list *l)
Set the resolver's DNSSEC anchor list directly.
enum ldns_enum_rr_type ldns_rr_type
void ldns_resolver_set_retrans(ldns_resolver *r, uint8_t retrans)
Set the resolver retrans timeout (in seconds)
signed char _dnsrch
If true apply the search list.
bool ldns_resolver_recursive(const ldns_resolver *r)
Is the resolver set to recurse.
void ldns_pkt_set_random_id(ldns_pkt *packet)
Set the packet's id to a random value.
void ldns_resolver_set_ip6(ldns_resolver *r, uint8_t ip6)
Whether the resolver uses ip6.
bool ldns_dname_absolute(const ldns_rdf *rdf)
Checks whether the given dname is absolute (i.e.
void ldns_resolver_set_dnssec_cd(ldns_resolver *r, bool d)
const char * ldns_get_errorstr_by_id(ldns_status err)
look up a descriptive text by each error.
ldns_status ldns_resolver_new_frm_fp(ldns_resolver **res, FILE *fp)
Create a resolver structure from a file like /etc/resolv.conf.
int _socket
Keep some things to make AXFR possible.
void ldns_axfr_abort(ldns_resolver *resolver)
void ldns_resolver_set_dnsrch(ldns_resolver *r, bool d)
void ldns_buffer_new_frm_data(ldns_buffer *buffer, void *data, size_t size)
creates a buffer with the specified data.
ldns_rr_list * ldns_pkt_answer(const ldns_pkt *packet)
Return the packet's answer section.
void ldns_resolver_set_tsig_keydata(ldns_resolver *r, char *tsig_keydata)
Set the tsig key data.
char * _tsig_keydata
Secret key data to use with TSIG, if _tsig_keyname and _tsig_keydata both contain values...
void ldns_pkt_free(ldns_pkt *packet)
frees the packet structure and all data that it contains.
#define LDNS_DEFAULT_TIMEOUT_USEC
void ldns_resolver_dec_nameserver_count(ldns_resolver *r)
Decrement the resolver's nameserver count.
ldns_rdf * ldns_resolver_domain(const ldns_resolver *r)
What is the default dname to add to relative queries.
struct timeval ldns_resolver_timeout(const ldns_resolver *r)
What is the timeout on socket connections.
signed char _fallback
Use new fallback mechanism (try EDNS, then do TCP)
void ldns_pkt_set_timestamp(ldns_pkt *packet, struct timeval timeval)
Set the packet's timestamp.