path: root/contrib/python/ldns_zone.i

/******************************************************************************
 * ldns_zone.i: LDNS zone 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_zone **)
{
 ldns_zone *$1_zone;
 $1 = &$1_zone;
}
          
/* result generation */
%typemap(argout,noblock=1) (ldns_zone **)
{
 $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(SWIG_as_voidptr($1_zone), SWIGTYPE_p_ldns_struct_zone, SWIG_POINTER_OWN |  0 ));
}

%nodefaultctor ldns_struct_zone; //no default constructor & destructor
%nodefaultdtor ldns_struct_zone;

%newobject ldns_zone_new_frm_fp;
%newobject ldns_zone_new_frm_fp_l;
%newobject ldns_zone_new;
%delobject ldns_zone_free;
%delobject ldns_zone_deep_free;
%delobject ldns_zone_push_rr;
%delobject ldns_zone_push_rr_list;

%ignore ldns_struct_zone::_soa;
%ignore ldns_struct_zone::_rrs;

%rename(ldns_zone) ldns_struct_zone;

#ifdef LDNS_DEBUG
%rename(__ldns_zone_free) ldns_zone_free;
%rename(__ldns_zone_deep_free) ldns_zone_deep_free;
%inline %{
void _ldns_zone_free (ldns_zone* z) {
   printf("******** LDNS_ZONE free 0x%lX ************\n", (long unsigned int)z);
   ldns_zone_deep_free(z);
}
%}
#else
%rename(__ldns_zone_free) ldns_zone_free;
%rename(_ldns_zone_free) ldns_zone_deep_free;
#endif
%feature("docstring") ldns_struct_zone "Zone definitions

**Usage**

This class is able to read and parse the content of zone file by doing:

>>> import ldns
>>> zone = ldns.ldns_zone.new_frm_fp(open(\"zone.txt\",\"r\"), None, 0, ldns.LDNS_RR_CLASS_IN)
>>> print zone.soa()
example.	600	IN	SOA	example. admin.example. 2008022501 28800 7200 604800 18000
>>> print zone.rrs()
example.	600	IN	MX	10 mail.example.
example.	600	IN	NS	ns1.example.
example.	600	IN	NS	ns2.example.
example.	600	IN	A	192.168.1.1

The ``zone.txt`` file contains the following records::

   $ORIGIN example.
   $TTL 600
   
   example.        IN SOA  example. admin.example. (
                                   2008022501 ; serial
                                   28800      ; refresh (8 hours)
                                   7200       ; retry (2 hours)
                                   604800     ; expire (1 week)
                                   18000      ; minimum (5 hours)
                                   )
   
   @       IN      MX      10 mail.example.
   @       IN      NS      ns1
   @       IN      NS      ns2
   @       IN      A       192.168.1.1
"

%extend ldns_struct_zone {
 
 %pythoncode %{
        def __init__(self):
            self.this = _ldns.ldns_zone_new()
            if not self.this:
                raise Exception("Can't create zone.")
       
        __swig_destroy__ = _ldns._ldns_zone_free

        def __str__(self):
            return str(self.soa()) + "\n" + str(self.rrs())

        def print_to_file(self,output):
            """Prints the data in the zone to the given file stream (in presentation format)."""
            _ldns.ldns_zone_print(output,self)
            #parameters: FILE *,const ldns_zone *,

        #LDNS_ZONE_CONSTRUCTORS_#
        @staticmethod
        def new_frm_fp(file, origin, ttl, rr_class=_ldns.LDNS_RR_CLASS_IN, raiseException=True):
            """Creates a new zone object from given file pointer
               
               :param file: a file object
               :param origin: (ldns_rdf) the zones' origin
               :param ttl: default ttl to use
               :param rr_class: efault class to use (IN)
               :param raiseException: if True, an exception occurs in case a zone instance can't be created
               :returns: zone instance or None. If an instance can't be created and raiseException is True, an exception occurs.
            """
            status, zone = _ldns.ldns_zone_new_frm_fp(file, origin, ttl, rr_class)
            if status != LDNS_STATUS_OK:
                if (raiseException): raise Exception("Can't create zone, error: %s (%d)" % (_ldns.ldns_get_errorstr_by_id(status),status))
                return None
            return zone

        @staticmethod
        def new_frm_fp_l(file, origin, ttl, rr_class, raiseException=True):
            """Create a new zone from a file, keep track of the line numbering
               
               :param file: a file object
               :param origin: (ldns_rdf) the zones' origin
               :param ttl: default ttl to use
               :param rr_class: efault class to use (IN)
               :param raiseException: if True, an exception occurs in case a zone instance can't be created
               :returns: 
                   * zone - zone instance or None. If an instance can't be created and raiseException is True, an exception occurs.

                   * line - used for error msg, to get to the line number
            """
            status, zone = _ldns.ldns_zone_new_frm_fp_l(file, line)
            if status != LDNS_STATUS_OK:
                if (raiseException): raise Exception("Can't create zone, error: %d" % status)
                return None
            return zone
        #_LDNS_ZONE_CONSTRUCTORS#

        def sign(self,key_list):
            """Signs the zone, and returns a newly allocated signed zone.
               
               :param key_list:
                   list of keys to sign with
               :returns: (ldns_zone \*) signed zone
            """
            return _ldns.ldns_zone_sign(self,key_list)
            #parameters: const ldns_zone *,ldns_key_list *,
            #retvals: ldns_zone *

        def sign_nsec3(self,key_list,algorithm,flags,iterations,salt_length,salt):
            """Signs the zone with NSEC3, and returns a newly allocated signed zone.
               
               :param key_list:
                   list of keys to sign with
               :param algorithm:
                   the NSEC3 hashing algorithm to use
               :param flags:
                   NSEC3 flags
               :param iterations:
                   the number of NSEC3 hash iterations to use
               :param salt_length:
                   the length (in octets) of the NSEC3 salt
               :param salt:
                   the NSEC3 salt data
               :returns: (ldns_zone \*) signed zone
            """
            return _ldns.ldns_zone_sign_nsec3(self,key_list,algorithm,flags,iterations,salt_length,salt)
            #parameters: ldns_zone *,ldns_key_list *,uint8_t,uint8_t,uint16_t,uint8_t,uint8_t *,
            #retvals: ldns_zone *

        #LDNS_ZONE_METHODS_#
        def glue_rr_list(self):
            """Retrieve all resource records from the zone that are glue records.
               
               The resulting list does are pointer references to the zone's data.
               
               Due to the current zone implementation (as a list of rr's), this function is extremely slow. Another (probably better) way to do this is to use an ldns_dnssec_zone structure and the mark_glue function
               
               :returns: (ldns_rr_list \*) the rr_list with the glue
            """
            return _ldns.ldns_zone_glue_rr_list(self)
            #parameters: const ldns_zone *,
            #retvals: ldns_rr_list *

        def push_rr(self,rr):
            """push an single rr to a zone structure.
               
               This function use pointer copying, so the rr_list structure inside z is modified!
               
               :param rr:
                   the rr to add
               :returns: (bool) a true on succes otherwise falsed
            """
            return _ldns.ldns_zone_push_rr(self,rr)
            #parameters: ldns_zone *,ldns_rr *,
            #retvals: bool

        def push_rr_list(self,list):
            """push an rrlist to a zone structure.
               
               This function use pointer copying, so the rr_list structure inside z is modified!
               
               :param list:
                   the list to add
               :returns: (bool) a true on succes otherwise falsed
            """
            return _ldns.ldns_zone_push_rr_list(self,list)
            #parameters: ldns_zone *,ldns_rr_list *,
            #retvals: bool

        def rr_count(self):
            """Returns the number of resource records in the zone, NOT counting the SOA record.
               
               :returns: (size_t) the number of rr's in the zone
            """
            return _ldns.ldns_zone_rr_count(self)
            #parameters: const ldns_zone *,
            #retvals: size_t

        def rrs(self):
            """Get a list of a zone's content.
               
               Note that the SOA isn't included in this list. You need to get the with ldns_zone_soa.
               
               :returns: (ldns_rr_list \*) the rrs from this zone
            """
            return _ldns.ldns_zone_rrs(self)
            #parameters: const ldns_zone *,
            #retvals: ldns_rr_list *

        def set_rrs(self,rrlist):
            """Set the zone's contents.
               
               :param rrlist:
                   the rrlist to use
            """
            _ldns.ldns_zone_set_rrs(self,rrlist)
            #parameters: ldns_zone *,ldns_rr_list *,
            #retvals: 

        def set_soa(self,soa):
            """Set the zone's soa record.
               
               :param soa:
                   the soa to set
            """
            _ldns.ldns_zone_set_soa(self,soa)
            #parameters: ldns_zone *,ldns_rr *,
            #retvals: 

        def soa(self):
            """Return the soa record of a zone.
               
               :returns: (ldns_rr \*) the soa record in the zone
            """
            return _ldns.ldns_zone_soa(self)
            #parameters: const ldns_zone *,
            #retvals: ldns_rr *

        def sort(self):
            """Sort the rrs in a zone, with the current impl.
               
               this is slow
            """
            _ldns.ldns_zone_sort(self)
            #parameters: ldns_zone *,
            #retvals: 

            #_LDNS_ZONE_METHODS#
 %}
}