/******************************************************************************
* ldns_rdata.i: LDNS record data
*
* 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.
******************************************************************************/
//automatic conversion of const ldns_rdf* parameter from string
%typemap(in,noblock=1) const ldns_rdf * (void* argp, $1_ltype tmp = 0, int res) {
if (PyString_Check($input)) {
tmp = ldns_dname_new_frm_str(PyString_AsString($input));
if (tmp == NULL) {
%argument_fail(SWIG_TypeError, "char *", $symname, $argnum);
}
$1 = ($1_ltype) tmp;
} else {
res = SWIG_ConvertPtr($input, &argp, SWIGTYPE_p_ldns_struct_rdf, 0 | 0 );
if (!SWIG_IsOK(res)) {
%argument_fail(res, "ldns_rdf const *", $symname, $argnum);
}
$1 = ($1_ltype) argp;
}
}
%typemap(in,numinputs=0,noblock=1) (ldns_rdf **)
{
ldns_rdf *$1_rdf;
$1 = &$1_rdf;
}
// result generation
%typemap(argout,noblock=1) (ldns_rdf **)
{
$result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(SWIG_as_voidptr($1_rdf), SWIGTYPE_p_ldns_struct_rdf, SWIG_POINTER_OWN | 0 ));
}
%nodefaultctor ldns_struct_rdf; //no default constructor & destructor
%nodefaultdtor ldns_struct_rdf;
%newobject ldns_dname_new;
%newobject ldns_dname_new_frm_str;
%newobject ldns_dname_new_frm_data;
%delobject ldns_rdf_deep_free;
%delobject ldns_rdf_free;
%rename(ldns_rdf) ldns_struct_rdf;
%inline %{
const char *ldns_rdf_type2str(const ldns_rdf *rdf)
{
if (rdf) {
switch(ldns_rdf_get_type(rdf)) {
case LDNS_RDF_TYPE_NONE: return 0;
case LDNS_RDF_TYPE_DNAME: return "DNAME";
case LDNS_RDF_TYPE_INT8: return "INT8";
case LDNS_RDF_TYPE_INT16: return "INT16";
case LDNS_RDF_TYPE_INT32: return "INT32";
case LDNS_RDF_TYPE_PERIOD: return "PERIOD";
case LDNS_RDF_TYPE_TSIGTIME: return "TSIGTIME";
case LDNS_RDF_TYPE_A: return "A";
case LDNS_RDF_TYPE_AAAA: return "AAAA";
case LDNS_RDF_TYPE_STR: return "STR";
case LDNS_RDF_TYPE_APL: return "APL";
case LDNS_RDF_TYPE_B32_EXT: return "B32_EXT";
case LDNS_RDF_TYPE_B64: return "B64";
case LDNS_RDF_TYPE_HEX: return "HEX";
case LDNS_RDF_TYPE_NSEC: return "NSEC";
case LDNS_RDF_TYPE_NSEC3_SALT: return "NSEC3_SALT";
case LDNS_RDF_TYPE_TYPE: return "TYPE";
case LDNS_RDF_TYPE_CLASS: return "CLASS";
case LDNS_RDF_TYPE_CERT_ALG: return "CER_ALG";
case LDNS_RDF_TYPE_ALG: return "ALG";
case LDNS_RDF_TYPE_UNKNOWN: return "UNKNOWN";
case LDNS_RDF_TYPE_TIME: return "TIME";
case LDNS_RDF_TYPE_LOC: return "LOC";
case LDNS_RDF_TYPE_WKS: return "WKS";
case LDNS_RDF_TYPE_SERVICE: return "SERVICE";
case LDNS_RDF_TYPE_NSAP: return "NSAP";
case LDNS_RDF_TYPE_ATMA: return "ATMA";
case LDNS_RDF_TYPE_IPSECKEY: return "IPSECKEY";
case LDNS_RDF_TYPE_TSIG: return "TSIG";
case LDNS_RDF_TYPE_INT16_DATA: return "INT16_DATA";
case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER: return "NSEC3_NEXT_OWNER";
}
}
return 0;
}
%}
#ifdef LDNS_DEBUG
%rename(__ldns_rdf_deep_free) ldns_rdf_deep_free;
%rename(__ldns_rdf_free) ldns_rdf_free;
%inline %{
void _ldns_rdf_free (ldns_rdf* r) {
printf("******** LDNS_RDF free 0x%lX ************\n", (long unsigned int)r);
ldns_rdf_free(r);
}
%}
#else
%rename(_ldns_rdf_deep_free) ldns_rdf_deep_free;
%rename(_ldns_rdf_free) ldns_rdf_free;
#endif
%newobject ldns_rdf2str;
%feature("docstring") ldns_struct_rdf "Resource record data field.
The data is a network ordered array of bytes, which size is specified by the (16-bit) size field. To correctly parse it, use the type specified in the (16-bit) type field with a value from ldns_rdf_type."
%extend ldns_struct_rdf {
%pythoncode %{
def __init__(self):
raise Exception("This class can't be created directly. Please use: ldns_rdf_new, ldns_rdf_new_frm_data, ldns_rdf_new_frm_str, ldns_rdf_new_frm_fp, ldns_rdf_new_frm_fp_l")
__swig_destroy__ = _ldns._ldns_rdf_free
#LDNS_RDF_CONSTRUCTORS_#
@staticmethod
def new_frm_str(str, rr_type, raiseException = True):
"""Creates a new rdf from a string of a given type.
:param str: string to use
:param rr_type: the type of RDF. See predefined `RDF_TYPE_` constants
:param raiseException: if True, an exception occurs in case a RDF object can't be created
:returns: RDF object or None. If the object can't be created and raiseException is True, an exception occurs.
**Usage**
>>> rdf = ldns.ldns_rdf.new_frm_str("74.125.43.99",ldns.LDNS_RDF_TYPE_A)
>>> print rdf, rdf.get_type_str()
A 74.125.43.99
>>> name = ldns.ldns_resolver.new_frm_file().get_name_by_addr(rdf)
>>> if (name): print name
99.43.125.74.in-addr.arpa. 85277 IN PTR bw-in-f99.google.com.
"""
rr = _ldns.ldns_rdf_new_frm_str(rr_type, str)
if not rr:
if (raiseException): raise Exception("Can't create query packet, error: %d" % status)
return rr
#_LDNS_RDF_CONSTRUCTORS#
def __str__(self):
"""Converts the rdata field to presentation format"""
return _ldns.ldns_rdf2str(self)
def __cmp__(self,other):
"""compares two rdf's on their wire formats.
(To order dnames according to rfc4034, use ldns_dname_compare)
:param other:
the second one RDF
:returns: (int) 0 if equal -1 if self comes before other +1 if other comes before self
"""
return _ldns.ldns_rdf_compare(self,other)
def print_to_file(self,output):
"""Prints the data in the rdata field to the given file stream (in presentation format)."""
_ldns.ldns_rdf_print(output,self)
def get_type_str(self):
"""Converts type to string"""
return ldns_rdf_type2str(self)
def write_to_buffer(self, buffer):
"""Copies the rdata data to the buffer in wire format.
:param buffer: buffer to append the result to
:returns: (ldns_status) ldns_status
"""
return _ldns.ldns_rdf2buffer_wire(buffer, self)
#parameters: ldns_buffer *,const ldns_rdf *,
#retvals: ldns_status
def write_to_buffer_canonical(self, buffer):
"""Copies the rdata data to the buffer in wire format If the rdata is a dname, the letters will be lowercased during the conversion.
:param buffer: LDNS buffer
:returns: (ldns_status) ldns_status
"""
return _ldns.ldns_rdf2buffer_wire_canonical(buffer, self)
#parameters: ldns_buffer *,const ldns_rdf *,
#retvals: ldns_status
#LDNS_RDF_METHODS_#
def address_reverse(self):
"""reverses an rdf, only actually useful for AAAA and A records.
The returned rdf has the type LDNS_RDF_TYPE_DNAME!
:returns: (ldns_rdf \*) the reversed rdf (a newly created rdf)
"""
return _ldns.ldns_rdf_address_reverse(self)
#parameters: ldns_rdf *,
#retvals: ldns_rdf *
def clone(self):
"""clones a rdf structure.
The data is copied.
:returns: (ldns_rdf \*) a new rdf structure
"""
return _ldns.ldns_rdf_clone(self)
#parameters: const ldns_rdf *,
#retvals: ldns_rdf *
def data(self):
"""returns the data of the rdf.
:returns: (uint8_t \*) uint8_t* pointer to the rdf's data
"""
return _ldns.ldns_rdf_data(self)
#parameters: const ldns_rdf *,
#retvals: uint8_t *
def get_type(self):
"""returns the type of the rdf.
We need to insert _get_ here to prevent conflict the the rdf_type TYPE.
:returns: (ldns_rdf_type) ldns_rdf_type with the type
"""
return _ldns.ldns_rdf_get_type(self)
#parameters: const ldns_rdf *,
#retvals: ldns_rdf_type
def set_data(self,data):
"""sets the size of the rdf.
:param data:
"""
_ldns.ldns_rdf_set_data(self,data)
#parameters: ldns_rdf *,void *,
#retvals:
def set_size(self,size):
"""sets the size of the rdf.
:param size:
the new size
"""
_ldns.ldns_rdf_set_size(self,size)
#parameters: ldns_rdf *,size_t,
#retvals:
def set_type(self,atype):
"""sets the size of the rdf.
:param atype:
"""
_ldns.ldns_rdf_set_type(self,atype)
#parameters: ldns_rdf *,ldns_rdf_type,
#retvals:
def size(self):
"""returns the size of the rdf.
:returns: (size_t) uint16_t with the size
"""
return _ldns.ldns_rdf_size(self)
#parameters: const ldns_rdf *,
#retvals: size_t
@staticmethod
def dname_new_frm_str(str):
"""Creates a new dname rdf instance from a string.
This static method is equivalent to using of default class constructor.
:parameter str: str string to use
"""
return _ldns.ldns_dname_new_frm_str(str)
def absolute(self):
"""Checks whether the given dname string is absolute (i.e. ends with a '.')
:returns: (bool) True or False
"""
return self.endswith(".")
def make_canonical(self):
"""Put a dname into canonical fmt - ie. lowercase it
"""
_ldns.ldns_dname2canonical(self)
def dname_compare(self,other):
"""Compares the two dname rdf's according to the algorithm for ordering in RFC4034 Section 6.
:param other:
the second dname rdf to compare
:returns: (int) -1 if dname comes before other, 1 if dname comes after other, and 0 if they are equal.
"""
return _ldns.ldns_dname_compare(self,other)
def cat(self,rd2):
"""concatenates rd2 after this dname (rd2 is copied, this dname is modified)
:param rd2:
the rightside
:returns: (ldns_status) LDNS_STATUS_OK on success
"""
return _ldns.ldns_dname_cat(self,rd2)
#parameters: ldns_rdf *,ldns_rdf *,
#retvals: ldns_status
def cat_clone(self,rd2):
"""concatenates two dnames together
:param rd2:
the rightside
:returns: (ldns_rdf \*) a new rdf with leftside/rightside
"""
return _ldns.ldns_dname_cat_clone(self,rd2)
#parameters: const ldns_rdf *,const ldns_rdf *,
#retvals: ldns_rdf *
def interval(self,middle,next):
"""check if middle lays in the interval defined by prev and next prev <= middle < next.
This is usefull for nsec checking
:param middle:
the dname to check
:param next:
the next dname return 0 on error or unknown, -1 when middle is in the interval, +1 when not
:returns: (int)
"""
return _ldns.ldns_dname_interval(self,middle,next)
#parameters: const ldns_rdf *,const ldns_rdf *,const ldns_rdf *,
#retvals: int
def is_subdomain(self,parent):
"""Tests wether the name sub falls under parent (i.e. is a subdomain of parent).
This function will return false if the given dnames are equal.
:param parent:
(ldns_rdf) the parent's name
:returns: (bool) true if sub falls under parent, otherwise false
"""
return _ldns.ldns_dname_is_subdomain(self,parent)
#parameters: const ldns_rdf *,const ldns_rdf *,
#retvals: bool
def label(self,labelpos):
"""look inside the rdf and if it is an LDNS_RDF_TYPE_DNAME try and retrieve a specific label.
The labels are numbered starting from 0 (left most).
:param labelpos:
return the label with this number
:returns: (ldns_rdf \*) a ldns_rdf* with the label as name or NULL on error
"""
return _ldns.ldns_dname_label(self,labelpos)
#parameters: const ldns_rdf *,uint8_t,
#retvals: ldns_rdf *
def label_count(self):
"""count the number of labels inside a LDNS_RDF_DNAME type rdf.
:returns: (uint8_t) the number of labels
"""
return _ldns.ldns_dname_label_count(self)
#parameters: const ldns_rdf *,
#retvals: uint8_t
def left_chop(self):
"""chop one label off the left side of a dname.
so wwww.nlnetlabs.nl, becomes nlnetlabs.nl
:returns: (ldns_rdf \*) the remaining dname
"""
return _ldns.ldns_dname_left_chop(self)
#parameters: const ldns_rdf *,
#retvals: ldns_rdf *
def reverse(self):
"""Returns a clone of the given dname with the labels reversed.
:returns: (ldns_rdf \*) clone of the dname with the labels reversed.
"""
return _ldns.ldns_dname_reverse(self)
#parameters: const ldns_rdf *,
#retvals: ldns_rdf *
#_LDNS_RDF_METHODS#
%}
}