941 lines
35 KiB
OpenEdge ABL
941 lines
35 KiB
OpenEdge ABL
/******************************************************************************
|
|
* ldns_resolver.i: LDNS resolver class
|
|
*
|
|
* Copyright (c) 2009, Zdenek Vasicek (vasicek AT fit.vutbr.cz)
|
|
* Karel Slany (slany AT fit.vutbr.cz)
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of the organization nor the names of its
|
|
* contributors may be used to endorse or promote products derived from this
|
|
* software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
******************************************************************************/
|
|
|
|
%typemap(in,numinputs=0,noblock=1) (ldns_resolver **r)
|
|
{
|
|
ldns_resolver *$1_res;
|
|
$1 = &$1_res;
|
|
}
|
|
|
|
/* result generation */
|
|
%typemap(argout,noblock=1) (ldns_resolver **r)
|
|
{
|
|
$result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(SWIG_as_voidptr($1_res), SWIGTYPE_p_ldns_struct_resolver, SWIG_POINTER_OWN | 0 ));
|
|
}
|
|
|
|
//TODO: pop_nameserver a podobne funkce musi predat objekt do spravy PYTHONU!!
|
|
%newobject ldns_resolver_pop_nameserver;
|
|
%newobject ldns_resolver_query;
|
|
%newobject ldns_axfr_next;
|
|
|
|
%delobject ldns_resolver_deep_free;
|
|
%delobject ldns_resolver_free;
|
|
|
|
%nodefaultctor ldns_struct_resolver; //no default constructor & destructor
|
|
%nodefaultdtor ldns_struct_resolver;
|
|
|
|
%ignore ldns_struct_resolver::_searchlist;
|
|
%ignore ldns_struct_resolver::_nameservers;
|
|
%ignore ldns_resolver_set_nameservers;
|
|
|
|
%rename(ldns_resolver) ldns_struct_resolver;
|
|
|
|
#ifdef LDNS_DEBUG
|
|
%rename(__ldns_resolver_deep_free) ldns_resolver_deep_free;
|
|
%rename(__ldns_resolver_free) ldns_resolver_free;
|
|
%inline %{
|
|
void _ldns_resolver_free (ldns_resolver* r) {
|
|
printf("******** LDNS_RESOLVER deep free 0x%lX ************\n", (long unsigned int)r);
|
|
ldns_resolver_deep_free(r);
|
|
}
|
|
%}
|
|
#else
|
|
%rename(_ldns_resolver_deep_free) ldns_resolver_deep_free;
|
|
%rename(_ldns_resolver_free) ldns_resolver_free;
|
|
#endif
|
|
|
|
%feature("docstring") ldns_struct_resolver "LDNS resolver object.
|
|
|
|
The ldns_resolver object keeps a list of nameservers and can perform queries.
|
|
|
|
**Usage**
|
|
|
|
>>> import ldns
|
|
>>> resolver = ldns.ldns_resolver.new_frm_file(\"/etc/resolv.conf\")
|
|
>>> pkt = resolver.query(\"www.nic.cz\", ldns.LDNS_RR_TYPE_A,ldns.LDNS_RR_CLASS_IN)
|
|
>>> if (pkt) and (pkt.answer()):
|
|
>>> print pkt.answer()
|
|
www.nic.cz. 1757 IN A 217.31.205.50
|
|
|
|
This simple example instances a resolver in order to resolve www.nic.cz record of A type.
|
|
"
|
|
|
|
%extend ldns_struct_resolver {
|
|
|
|
%pythoncode %{
|
|
def __init__(self):
|
|
raise Exception("This class can't be created directly. Please use: new_frm_file(filename), new_frm_fp(file) or new_frm_fp_l(file,line)")
|
|
|
|
__swig_destroy__ = _ldns._ldns_resolver_free
|
|
|
|
#LDNS_RESOLVER_CONSTRUCTORS_#
|
|
@staticmethod
|
|
def new_frm_file(filename = "/etc/resolv.conf", raiseException=True):
|
|
"""Creates a resolver object from given filename
|
|
|
|
:param filename: name of file which contains informations (usually /etc/resolv.conf)
|
|
:param raiseException: if True, an exception occurs in case a resolver object can't be created
|
|
:returns: resolver object or None. If the object can't be created and raiseException is True, an exception occurs.
|
|
"""
|
|
status, resolver = _ldns.ldns_resolver_new_frm_file(filename)
|
|
if status != LDNS_STATUS_OK:
|
|
if (raiseException): raise Exception("Can't create resolver, error: %d" % status)
|
|
return None
|
|
return resolver
|
|
|
|
@staticmethod
|
|
def new_frm_fp(file, raiseException=True):
|
|
"""Creates a resolver object from file
|
|
|
|
:param file: a file object
|
|
:param raiseException: if True, an exception occurs in case a resolver object can't be created
|
|
:returns: resolver object or None. If the object can't be created and raiseException is True, an exception occurs.
|
|
"""
|
|
status, resolver = _ldns.ldns_resolver_new_frm_fp(file)
|
|
if status != LDNS_STATUS_OK:
|
|
if (raiseException): raise Exception("Can't create resolver, error: %d" % status)
|
|
return None
|
|
return resolver
|
|
|
|
@staticmethod
|
|
def new_frm_fp_l(file, raiseException=True):
|
|
"""Creates a resolver object from file
|
|
|
|
:param file: a file object
|
|
:param raiseException: if True, an exception occurs in case a resolver instance can't be created
|
|
:returns:
|
|
* resolver - resolver instance or None. If an instance can't be created and raiseException is True, an exception occurs.
|
|
|
|
* line - the line number (for debugging)
|
|
"""
|
|
status, resolver, line = _ldns.ldns_resolver_new_frm_fp_l(file)
|
|
if status != LDNS_STATUS_OK:
|
|
if (raiseException): raise Exception("Can't create resolver, error: %d" % status)
|
|
return None
|
|
return resolver, line
|
|
|
|
#_LDNS_RESOLVER_CONSTRUCTORS#
|
|
|
|
# High level functions
|
|
def get_addr_by_name(self, name, aclass = _ldns.LDNS_RR_CLASS_IN, flags = _ldns.LDNS_RD):
|
|
"""Ask the resolver about name and return all address records
|
|
|
|
:param name: (ldns_rdf) the name to look for
|
|
:param aclass: the class to use
|
|
:param flags: give some optional flags to the query
|
|
|
|
:returns: RR List object or None
|
|
|
|
**Usage**
|
|
>>> addr = resolver.get_addr_by_name("www.google.com", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD)
|
|
>>> if (not addr): raise Exception("Can't retrieve server address")
|
|
>>> for rr in addr.rrs():
|
|
>>> print rr
|
|
www.l.google.com. 300 IN A 74.125.43.99
|
|
www.l.google.com. 300 IN A 74.125.43.103
|
|
www.l.google.com. 300 IN A 74.125.43.104
|
|
www.l.google.com. 300 IN A 74.125.43.147
|
|
|
|
"""
|
|
return _ldns.ldns_get_rr_list_addr_by_name(self, name, aclass, flags)
|
|
|
|
def get_name_by_addr(self, addr, aclass = _ldns.LDNS_RR_CLASS_IN, flags = _ldns.LDNS_RD):
|
|
"""Ask the resolver about the address and return the name
|
|
|
|
:param name: (ldns_rdf of A or AAAA type) the addr to look for. If a string is given, A or AAAA type is identified automatically
|
|
:param aclass: the class to use
|
|
:param flags: give some optional flags to the query
|
|
|
|
:returns: RR List object or None
|
|
|
|
**Usage**
|
|
>>> addr = resolver.get_name_by_addr("74.125.43.99", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD)
|
|
>>> if (not addr): raise Exception("Can't retrieve server address")
|
|
>>> for rr in addr.rrs():
|
|
>>> print rr
|
|
99.43.125.74.in-addr.arpa. 85641 IN PTR bw-in-f99.google.com.
|
|
|
|
"""
|
|
rdf = addr
|
|
if isinstance(addr, str):
|
|
if (addr.find("::") >= 0): #IPv6
|
|
rdf = _ldns.ldns_rdf_new_frm_str(_ldns.LDNS_RDF_TYPE_AAAA, addr)
|
|
else:
|
|
rdf = _ldns.ldns_rdf_new_frm_str(_ldns.LDNS_RDF_TYPE_A, addr)
|
|
return _ldns.ldns_get_rr_list_name_by_addr(self, rdf, aclass, flags)
|
|
|
|
def print_to_file(self,output):
|
|
"""Print a resolver (in sofar that is possible) state to output."""
|
|
_ldns.ldns_resolver_print(output,self)
|
|
|
|
def axfr_start(self, domain, aclass):
|
|
"""Prepares the resolver for an axfr query. The query is sent and the answers can be read with axfr_next
|
|
|
|
**Usage**
|
|
::
|
|
|
|
status = resolver.axfr_start("nic.cz", ldns.LDNS_RR_CLASS_IN)
|
|
if (status != ldns.LDNS_STATUS_OK): raise Exception("Can't start AXFR, error: %s" % ldns.ldns_get_errorstr_by_id(status))
|
|
#Print the results
|
|
while True:
|
|
rr = resolver.axfr_next()
|
|
if not rr:
|
|
break
|
|
|
|
print rr
|
|
|
|
"""
|
|
return _ldns.ldns_axfr_start(self, domain, aclass)
|
|
#parameters: ldns_resolver *resolver, ldns_rdf *domain, ldns_rr_class c
|
|
#retvals: int
|
|
|
|
def axfr_complete(self):
|
|
"""returns true if the axfr transfer has completed (i.e. 2 SOA RRs and no errors were encountered)"""
|
|
return _ldns.ldns_axfr_complete(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: bool
|
|
|
|
def axfr_last_pkt(self):
|
|
"""returns a pointer to the last ldns_pkt that was sent by the server in the AXFR transfer uasable for instance to get the error code on failure"""
|
|
return _ldns.ldns_axfr_last_pkt(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: ldns_pkt *
|
|
|
|
def axfr_next(self):
|
|
"""get the next stream of RRs in a AXFR"""
|
|
return _ldns.ldns_axfr_next(self)
|
|
#parameters: ldns_resolver *,
|
|
#retvals: ldns_rr *
|
|
|
|
#LDNS_RESOLVER_METHODS_#
|
|
def debug(self):
|
|
"""Get the debug status of the resolver.
|
|
|
|
:returns: (bool) true if so, otherwise false
|
|
"""
|
|
return _ldns.ldns_resolver_debug(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: bool
|
|
|
|
def dec_nameserver_count(self):
|
|
"""Decrement the resolver's nameserver count.
|
|
"""
|
|
_ldns.ldns_resolver_dec_nameserver_count(self)
|
|
#parameters: ldns_resolver *,
|
|
#retvals:
|
|
|
|
def defnames(self):
|
|
return _ldns.ldns_resolver_defnames(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: bool
|
|
|
|
def dnsrch(self):
|
|
return _ldns.ldns_resolver_dnsrch(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: bool
|
|
|
|
def dnssec(self):
|
|
"""Does the resolver do DNSSEC.
|
|
|
|
:returns: (bool) true: yes, false: no
|
|
"""
|
|
return _ldns.ldns_resolver_dnssec(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: bool
|
|
|
|
def dnssec_anchors(self):
|
|
"""Get the resolver's DNSSEC anchors.
|
|
|
|
:returns: (ldns_rr_list \*) an rr_list containg trusted DNSSEC anchors
|
|
"""
|
|
return _ldns.ldns_resolver_dnssec_anchors(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: ldns_rr_list *
|
|
|
|
def dnssec_cd(self):
|
|
"""Does the resolver set the CD bit.
|
|
|
|
:returns: (bool) true: yes, false: no
|
|
"""
|
|
return _ldns.ldns_resolver_dnssec_cd(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: bool
|
|
|
|
def domain(self):
|
|
"""What is the default dname to add to relative queries.
|
|
|
|
:returns: (ldns_rdf \*) the dname which is added
|
|
"""
|
|
return _ldns.ldns_resolver_domain(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: ldns_rdf *
|
|
|
|
def edns_udp_size(self):
|
|
"""Get the resolver's udp size.
|
|
|
|
:returns: (uint16_t) the udp mesg size
|
|
"""
|
|
return _ldns.ldns_resolver_edns_udp_size(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: uint16_t
|
|
|
|
def fail(self):
|
|
"""Does the resolver only try the first nameserver.
|
|
|
|
:returns: (bool) true: yes, fail, false: no, try the others
|
|
"""
|
|
return _ldns.ldns_resolver_fail(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: bool
|
|
|
|
def fallback(self):
|
|
"""Get the truncation fallback status.
|
|
|
|
:returns: (bool) whether the truncation fallback mechanism is used
|
|
"""
|
|
return _ldns.ldns_resolver_fallback(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: bool
|
|
|
|
def igntc(self):
|
|
"""Does the resolver ignore the TC bit (truncated).
|
|
|
|
:returns: (bool) true: yes, false: no
|
|
"""
|
|
return _ldns.ldns_resolver_igntc(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: bool
|
|
|
|
def incr_nameserver_count(self):
|
|
"""Incremental the resolver's nameserver count.
|
|
"""
|
|
_ldns.ldns_resolver_incr_nameserver_count(self)
|
|
#parameters: ldns_resolver *,
|
|
#retvals:
|
|
|
|
def ip6(self):
|
|
"""Does the resolver use ip6 or ip4.
|
|
|
|
:returns: (uint8_t) 0: both, 1: ip4, 2:ip6
|
|
"""
|
|
return _ldns.ldns_resolver_ip6(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: uint8_t
|
|
|
|
def nameserver_count(self):
|
|
"""How many nameserver are configured in the resolver.
|
|
|
|
:returns: (size_t) number of nameservers
|
|
"""
|
|
return _ldns.ldns_resolver_nameserver_count(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: size_t
|
|
|
|
def nameserver_rtt(self,pos):
|
|
"""Return the used round trip time for a specific nameserver.
|
|
|
|
:param pos:
|
|
the index to the nameserver
|
|
:returns: (size_t) the rrt, 0: infinite, >0: undefined (as of * yet)
|
|
"""
|
|
return _ldns.ldns_resolver_nameserver_rtt(self,pos)
|
|
#parameters: const ldns_resolver *,size_t,
|
|
#retvals: size_t
|
|
|
|
def nameservers(self):
|
|
"""Return the configured nameserver ip address.
|
|
|
|
:returns: (ldns_rdf \*\*) a ldns_rdf pointer to a list of the addresses
|
|
"""
|
|
return _ldns.ldns_resolver_nameservers(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: ldns_rdf **
|
|
|
|
def nameservers_randomize(self):
|
|
"""randomize the nameserver list in the resolver
|
|
"""
|
|
_ldns.ldns_resolver_nameservers_randomize(self)
|
|
#parameters: ldns_resolver *,
|
|
#retvals:
|
|
|
|
def pop_nameserver(self):
|
|
"""pop the last nameserver from the resolver.
|
|
|
|
:returns: (ldns_rdf \*) the popped address or NULL if empty
|
|
"""
|
|
return _ldns.ldns_resolver_pop_nameserver(self)
|
|
#parameters: ldns_resolver *,
|
|
#retvals: ldns_rdf *
|
|
|
|
def port(self):
|
|
"""Get the port the resolver should use.
|
|
|
|
:returns: (uint16_t) the port number
|
|
"""
|
|
return _ldns.ldns_resolver_port(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: uint16_t
|
|
|
|
def prepare_query_pkt(self,name,t,c,f):
|
|
"""Form a query packet from a resolver and name/type/class combo.
|
|
|
|
:param name:
|
|
:param t:
|
|
query for this type (may be 0, defaults to A)
|
|
:param c:
|
|
query for this class (may be 0, default to IN)
|
|
:param f:
|
|
the query flags
|
|
:returns: * (ldns_status) ldns_pkt* a packet with the reply from the nameserver
|
|
* (ldns_pkt \*\*) query packet class
|
|
"""
|
|
return _ldns.ldns_resolver_prepare_query_pkt(self,name,t,c,f)
|
|
#parameters: ldns_resolver *,const ldns_rdf *,ldns_rr_type,ldns_rr_class,uint16_t,
|
|
#retvals: ldns_status,ldns_pkt **
|
|
|
|
def push_dnssec_anchor(self,rr):
|
|
"""Push a new trust anchor to the resolver.
|
|
|
|
It must be a DS or DNSKEY rr
|
|
|
|
:param rr:
|
|
the RR to add as a trust anchor.
|
|
:returns: (ldns_status) a status
|
|
"""
|
|
return _ldns.ldns_resolver_push_dnssec_anchor(self,rr)
|
|
#parameters: ldns_resolver *,ldns_rr *,
|
|
#retvals: ldns_status
|
|
|
|
def push_nameserver(self,n):
|
|
"""push a new nameserver to the resolver.
|
|
|
|
It must be an IP address v4 or v6.
|
|
|
|
:param n:
|
|
the ip address
|
|
:returns: (ldns_status) ldns_status a status
|
|
"""
|
|
return _ldns.ldns_resolver_push_nameserver(self,n)
|
|
#parameters: ldns_resolver *,ldns_rdf *,
|
|
#retvals: ldns_status
|
|
|
|
def push_nameserver_rr(self,rr):
|
|
"""push a new nameserver to the resolver.
|
|
|
|
It must be an A or AAAA RR record type
|
|
|
|
:param rr:
|
|
the resource record
|
|
:returns: (ldns_status) ldns_status a status
|
|
"""
|
|
return _ldns.ldns_resolver_push_nameserver_rr(self,rr)
|
|
#parameters: ldns_resolver *,ldns_rr *,
|
|
#retvals: ldns_status
|
|
|
|
def push_nameserver_rr_list(self,rrlist):
|
|
"""push a new nameserver rr_list to the resolver.
|
|
|
|
:param rrlist:
|
|
the rr_list to push
|
|
:returns: (ldns_status) ldns_status a status
|
|
"""
|
|
return _ldns.ldns_resolver_push_nameserver_rr_list(self,rrlist)
|
|
#parameters: ldns_resolver *,ldns_rr_list *,
|
|
#retvals: ldns_status
|
|
|
|
def push_searchlist(self,rd):
|
|
"""Push a new rd to the resolver's searchlist.
|
|
|
|
:param rd:
|
|
to push
|
|
"""
|
|
_ldns.ldns_resolver_push_searchlist(self,rd)
|
|
#parameters: ldns_resolver *,ldns_rdf *,
|
|
#retvals:
|
|
|
|
def query(self,name,atype=_ldns.LDNS_RR_TYPE_A,aclass=_ldns.LDNS_RR_CLASS_IN,flags=_ldns.LDNS_RD):
|
|
"""Send a query to a nameserver.
|
|
|
|
:param name: (ldns_rdf) the name to look for
|
|
:param atype: the RR type to use
|
|
:param aclass: the RR class to use
|
|
:param flags: give some optional flags to the query
|
|
:returns: (ldns_pkt) a packet with the reply from the nameserver if _defnames is true the default domain will be added
|
|
"""
|
|
return _ldns.ldns_resolver_query(self,name,atype,aclass,flags)
|
|
#parameters: const ldns_resolver *,const ldns_rdf *,ldns_rr_type,ldns_rr_class,uint16_t,
|
|
#retvals: ldns_pkt *
|
|
|
|
def random(self):
|
|
"""Does the resolver randomize the nameserver before usage.
|
|
|
|
:returns: (bool) true: yes, false: no
|
|
"""
|
|
return _ldns.ldns_resolver_random(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: bool
|
|
|
|
def recursive(self):
|
|
"""Is the resolver set to recurse.
|
|
|
|
:returns: (bool) true if so, otherwise false
|
|
"""
|
|
return _ldns.ldns_resolver_recursive(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: bool
|
|
|
|
def retrans(self):
|
|
"""Get the retransmit interval.
|
|
|
|
:returns: (uint8_t) the retransmit interval
|
|
"""
|
|
return _ldns.ldns_resolver_retrans(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: uint8_t
|
|
|
|
def retry(self):
|
|
"""Get the number of retries.
|
|
|
|
:returns: (uint8_t) the number of retries
|
|
"""
|
|
return _ldns.ldns_resolver_retry(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: uint8_t
|
|
|
|
def rtt(self):
|
|
"""Return the used round trip times for the nameservers.
|
|
|
|
:returns: (size_t \*) a size_t* pointer to the list. yet)
|
|
"""
|
|
return _ldns.ldns_resolver_rtt(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: size_t *
|
|
|
|
def search(self,rdf,t,c,flags):
|
|
"""Send the query for using the resolver and take the search list into account The search algorithm is as follows: If the name is absolute, try it as-is, otherwise apply the search list.
|
|
|
|
:param rdf:
|
|
:param t:
|
|
query for this type (may be 0, defaults to A)
|
|
:param c:
|
|
query for this class (may be 0, default to IN)
|
|
:param flags:
|
|
the query flags
|
|
:returns: (ldns_pkt \*) ldns_pkt* a packet with the reply from the nameserver
|
|
"""
|
|
return _ldns.ldns_resolver_search(self,rdf,t,c,flags)
|
|
#parameters: const ldns_resolver *,const ldns_rdf *,ldns_rr_type,ldns_rr_class,uint16_t,
|
|
#retvals: ldns_pkt *
|
|
|
|
def searchlist(self):
|
|
"""What is the searchlist as used by the resolver.
|
|
|
|
:returns: (ldns_rdf \*\*) a ldns_rdf pointer to a list of the addresses
|
|
"""
|
|
return _ldns.ldns_resolver_searchlist(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: ldns_rdf \*\*
|
|
|
|
def searchlist_count(self):
|
|
"""Return the resolver's searchlist count.
|
|
|
|
:returns: (size_t) the searchlist count
|
|
"""
|
|
return _ldns.ldns_resolver_searchlist_count(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: size_t
|
|
|
|
def send(self,name,t,c,flags):
|
|
"""Send the query for name as-is.
|
|
|
|
:param name:
|
|
:param t:
|
|
query for this type (may be 0, defaults to A)
|
|
:param c:
|
|
query for this class (may be 0, default to IN)
|
|
:param flags:
|
|
the query flags
|
|
:returns: * (ldns_status) ldns_pkt* a packet with the reply from the nameserver
|
|
* (ldns_pkt \*\*)
|
|
"""
|
|
return _ldns.ldns_resolver_send(self,name,t,c,flags)
|
|
#parameters: ldns_resolver *,const ldns_rdf *,ldns_rr_type,ldns_rr_class,uint16_t,
|
|
#retvals: ldns_status,ldns_pkt **
|
|
|
|
def send_pkt(self,query_pkt):
|
|
"""Send the given packet to a nameserver.
|
|
|
|
:param query_pkt:
|
|
:returns: * (ldns_status)
|
|
* (ldns_pkt \*\*)
|
|
"""
|
|
return _ldns.ldns_resolver_send_pkt(self,query_pkt)
|
|
#parameters: ldns_resolver *,ldns_pkt *,
|
|
#retvals: ldns_status,ldns_pkt **
|
|
|
|
def set_debug(self,b):
|
|
"""Set the resolver debugging.
|
|
|
|
:param b:
|
|
true: debug on: false debug off
|
|
"""
|
|
_ldns.ldns_resolver_set_debug(self,b)
|
|
#parameters: ldns_resolver *,bool,
|
|
#retvals:
|
|
|
|
def set_defnames(self,b):
|
|
"""Whether the resolver uses the name set with _set_domain.
|
|
|
|
:param b:
|
|
true: use the defaults, false: don't use them
|
|
"""
|
|
_ldns.ldns_resolver_set_defnames(self,b)
|
|
#parameters: ldns_resolver *,bool,
|
|
#retvals:
|
|
|
|
def set_dnsrch(self,b):
|
|
"""Whether the resolver uses the searchlist.
|
|
|
|
:param b:
|
|
true: use the list, false: don't use the list
|
|
"""
|
|
_ldns.ldns_resolver_set_dnsrch(self,b)
|
|
#parameters: ldns_resolver *,bool,
|
|
#retvals:
|
|
|
|
def set_dnssec(self,b):
|
|
"""Whether the resolver uses DNSSEC.
|
|
|
|
:param b:
|
|
true: use DNSSEC, false: don't use DNSSEC
|
|
"""
|
|
_ldns.ldns_resolver_set_dnssec(self,b)
|
|
#parameters: ldns_resolver *,bool,
|
|
#retvals:
|
|
|
|
def set_dnssec_anchors(self,l):
|
|
"""Set the resolver's DNSSEC anchor list directly.
|
|
|
|
RRs should be of type DS or DNSKEY.
|
|
|
|
:param l:
|
|
the list of RRs to use as trust anchors
|
|
"""
|
|
_ldns.ldns_resolver_set_dnssec_anchors(self,l)
|
|
#parameters: ldns_resolver *,ldns_rr_list *,
|
|
#retvals:
|
|
|
|
def set_dnssec_cd(self,b):
|
|
"""Whether the resolver uses the checking disable bit.
|
|
|
|
:param b:
|
|
true: enable , false: don't use TCP
|
|
"""
|
|
_ldns.ldns_resolver_set_dnssec_cd(self,b)
|
|
#parameters: ldns_resolver *,bool,
|
|
#retvals:
|
|
|
|
def set_domain(self,rd):
|
|
"""Set the resolver's default domain.
|
|
|
|
This gets appended when no absolute name is given
|
|
|
|
:param rd:
|
|
the name to append
|
|
"""
|
|
_ldns.ldns_resolver_set_domain(self,rd)
|
|
#parameters: ldns_resolver *,ldns_rdf *,
|
|
#retvals:
|
|
|
|
def set_edns_udp_size(self,s):
|
|
"""Set maximum udp size.
|
|
|
|
:param s:
|
|
the udp max size
|
|
"""
|
|
_ldns.ldns_resolver_set_edns_udp_size(self,s)
|
|
#parameters: ldns_resolver *,uint16_t,
|
|
#retvals:
|
|
|
|
def set_fail(self,b):
|
|
"""Whether or not to fail after one failed query.
|
|
|
|
:param b:
|
|
true: yes fail, false: continue with next nameserver
|
|
"""
|
|
_ldns.ldns_resolver_set_fail(self,b)
|
|
#parameters: ldns_resolver *,bool,
|
|
#retvals:
|
|
|
|
def set_fallback(self,fallback):
|
|
"""Set whether the resolvers truncation fallback mechanism is used when ldns_resolver_query() is called.
|
|
|
|
:param fallback:
|
|
whether to use the fallback mechanism
|
|
"""
|
|
_ldns.ldns_resolver_set_fallback(self,fallback)
|
|
#parameters: ldns_resolver *,bool,
|
|
#retvals:
|
|
|
|
def set_igntc(self,b):
|
|
"""Whether or not to ignore the TC bit.
|
|
|
|
:param b:
|
|
true: yes ignore, false: don't ignore
|
|
"""
|
|
_ldns.ldns_resolver_set_igntc(self,b)
|
|
#parameters: ldns_resolver *,bool,
|
|
#retvals:
|
|
|
|
def set_ip6(self,i):
|
|
"""Whether the resolver uses ip6.
|
|
|
|
:param i:
|
|
0: no pref, 1: ip4, 2: ip6
|
|
"""
|
|
_ldns.ldns_resolver_set_ip6(self,i)
|
|
#parameters: ldns_resolver *,uint8_t,
|
|
#retvals:
|
|
|
|
def set_nameserver_count(self,c):
|
|
"""Set the resolver's nameserver count directly.
|
|
|
|
:param c:
|
|
the nameserver count
|
|
"""
|
|
_ldns.ldns_resolver_set_nameserver_count(self,c)
|
|
#parameters: ldns_resolver *,size_t,
|
|
#retvals:
|
|
|
|
def set_nameserver_rtt(self,pos,value):
|
|
"""Set round trip time for a specific nameserver.
|
|
|
|
Note this currently differentiates between: unreachable and reachable.
|
|
|
|
:param pos:
|
|
the nameserver position
|
|
:param value:
|
|
the rtt
|
|
"""
|
|
_ldns.ldns_resolver_set_nameserver_rtt(self,pos,value)
|
|
#parameters: ldns_resolver *,size_t,size_t,
|
|
#retvals:
|
|
|
|
def set_nameservers(self,rd):
|
|
"""Set the resolver's nameserver count directly by using an rdf list.
|
|
|
|
:param rd:
|
|
the resolver addresses
|
|
"""
|
|
_ldns.ldns_resolver_set_nameservers(self,rd)
|
|
#parameters: ldns_resolver *,ldns_rdf **,
|
|
#retvals:
|
|
|
|
def set_port(self,p):
|
|
"""Set the port the resolver should use.
|
|
|
|
:param p:
|
|
the port number
|
|
"""
|
|
_ldns.ldns_resolver_set_port(self,p)
|
|
#parameters: ldns_resolver *,uint16_t,
|
|
#retvals:
|
|
|
|
def set_random(self,b):
|
|
"""Should the nameserver list be randomized before each use.
|
|
|
|
:param b:
|
|
true: randomize, false: don't
|
|
"""
|
|
_ldns.ldns_resolver_set_random(self,b)
|
|
#parameters: ldns_resolver *,bool,
|
|
#retvals:
|
|
|
|
def set_recursive(self,b):
|
|
"""Set the resolver recursion.
|
|
|
|
:param b:
|
|
true: set to recurse, false: unset
|
|
"""
|
|
_ldns.ldns_resolver_set_recursive(self,b)
|
|
#parameters: ldns_resolver *,bool,
|
|
#retvals:
|
|
|
|
def set_retrans(self,re):
|
|
"""Set the resolver retrans timeout (in seconds).
|
|
|
|
:param re:
|
|
the retransmission interval in seconds
|
|
"""
|
|
_ldns.ldns_resolver_set_retrans(self,re)
|
|
#parameters: ldns_resolver *,uint8_t,
|
|
#retvals:
|
|
|
|
def set_retry(self,re):
|
|
"""Set the resolver retry interval (in seconds).
|
|
|
|
:param re:
|
|
the retry interval
|
|
"""
|
|
_ldns.ldns_resolver_set_retry(self,re)
|
|
#parameters: ldns_resolver *,uint8_t,
|
|
#retvals:
|
|
|
|
def set_rtt(self,rtt):
|
|
"""Set round trip time for all nameservers.
|
|
|
|
Note this currently differentiates between: unreachable and reachable.
|
|
|
|
:param rtt:
|
|
a list with the times
|
|
"""
|
|
_ldns.ldns_resolver_set_rtt(self,rtt)
|
|
#parameters: ldns_resolver *,size_t *,
|
|
#retvals:
|
|
|
|
def set_searchlist_count(self,c):
|
|
_ldns.ldns_resolver_set_searchlist_count(self,c)
|
|
#parameters: ldns_resolver *,size_t,
|
|
#retvals:
|
|
|
|
def set_timeout(self,timeout):
|
|
"""Set the resolver's socket time out when talking to remote hosts.
|
|
|
|
:param timeout:
|
|
the timeout to use
|
|
"""
|
|
_ldns.ldns_resolver_set_timeout(self,timeout)
|
|
#parameters: ldns_resolver *,struct timeval,
|
|
#retvals:
|
|
|
|
def set_tsig_algorithm(self,tsig_algorithm):
|
|
"""Set the tsig algorithm.
|
|
|
|
:param tsig_algorithm:
|
|
the tsig algorithm
|
|
"""
|
|
_ldns.ldns_resolver_set_tsig_algorithm(self,tsig_algorithm)
|
|
#parameters: ldns_resolver *,char *,
|
|
#retvals:
|
|
|
|
def set_tsig_keydata(self,tsig_keydata):
|
|
"""Set the tsig key data.
|
|
|
|
:param tsig_keydata:
|
|
the key data
|
|
"""
|
|
_ldns.ldns_resolver_set_tsig_keydata(self,tsig_keydata)
|
|
#parameters: ldns_resolver *,char *,
|
|
#retvals:
|
|
|
|
def set_tsig_keyname(self,tsig_keyname):
|
|
"""Set the tsig key name.
|
|
|
|
:param tsig_keyname:
|
|
the tsig key name
|
|
"""
|
|
_ldns.ldns_resolver_set_tsig_keyname(self,tsig_keyname)
|
|
#parameters: ldns_resolver *,char *,
|
|
#retvals:
|
|
|
|
def set_usevc(self,b):
|
|
"""Whether the resolver uses a virtual circuit (TCP).
|
|
|
|
:param b:
|
|
true: use TCP, false: don't use TCP
|
|
"""
|
|
_ldns.ldns_resolver_set_usevc(self,b)
|
|
#parameters: ldns_resolver *,bool,
|
|
#retvals:
|
|
|
|
def timeout(self):
|
|
"""What is the timeout on socket connections.
|
|
|
|
:returns: (struct timeval) the timeout as struct timeval
|
|
"""
|
|
return _ldns.ldns_resolver_timeout(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: struct timeval
|
|
|
|
def trusted_key(self,keys,trusted_keys):
|
|
"""Returns true if at least one of the provided keys is a trust anchor.
|
|
|
|
:param keys:
|
|
the keyset to check
|
|
:param trusted_keys:
|
|
the subset of trusted keys in the 'keys' rrset
|
|
:returns: (bool) true if at least one of the provided keys is a configured trust anchor
|
|
"""
|
|
return _ldns.ldns_resolver_trusted_key(self,keys,trusted_keys)
|
|
#parameters: const ldns_resolver *,ldns_rr_list *,ldns_rr_list *,
|
|
#retvals: bool
|
|
|
|
def tsig_algorithm(self):
|
|
"""Return the tsig algorithm as used by the nameserver.
|
|
|
|
:returns: (char \*) the algorithm used.
|
|
"""
|
|
return _ldns.ldns_resolver_tsig_algorithm(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: char *
|
|
|
|
def tsig_keydata(self):
|
|
"""Return the tsig keydata as used by the nameserver.
|
|
|
|
:returns: (char \*) the keydata used.
|
|
"""
|
|
return _ldns.ldns_resolver_tsig_keydata(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: char *
|
|
|
|
def tsig_keyname(self):
|
|
"""Return the tsig keyname as used by the nameserver.
|
|
|
|
:returns: (char \*) the name used.
|
|
"""
|
|
return _ldns.ldns_resolver_tsig_keyname(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: char *
|
|
|
|
def usevc(self):
|
|
"""Does the resolver use tcp or udp.
|
|
|
|
:returns: (bool) true: tcp, false: udp
|
|
"""
|
|
return _ldns.ldns_resolver_usevc(self)
|
|
#parameters: const ldns_resolver *,
|
|
#retvals: bool
|
|
|
|
#_LDNS_RESOLVER_METHODS#
|
|
%}
|
|
}
|