1.6.14
+ * Various improvements and fixes of pyldns from Katel Slany
* bugfix: Make ldns_resolver_pop_nameserver clear the array when
there was only one.
* bugfix #459: Export only symbols defined in ldns_symbols
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
+
+.PHONY: help clean testenv test doc te bw bw3 sw sw3
+
help:
@echo "Please use \`make <target>' where <target> is one of"
@echo " testenv to make test environment and run bash "
_ldns.so: ../../Makefile
$(MAKE) -C ../..
-../../.libs/ldns.so.1: ../../Makefile
+../../.libs/libldns.so.1: ../../Makefile
$(MAKE) -C ../..
clean:
cd examples && LD_LIBRARY_PATH=ldns bash
rm -rf examples/ldns
-doc: ../../.libs/ldns.so.1 _ldns.so
+test: ../../.libs/libldns.so.1 _ldns.so examples/test_buffer.py examples/test_rdf.py examples/test_dname.py
+ @rm -rf examples/ldns
+ @cd examples && mkdir ldns && ln -s ../../ldns.py ldns/__init__.py && ln -s ../../../../.libs/_ldns.so ldns/_ldns.so && ln -s ../../../../.libs/libldns.so.1 ldns/libldns.so.1
+ @cd examples && LD_LIBRARY_PATH=ldns ./test_buffer.py 2>/dev/null
+ @cd examples && LD_LIBRARY_PATH=ldns ./test_rdf.py 2>/dev/null
+ @cd examples && LD_LIBRARY_PATH=ldns ./test_dname.py 2>/dev/null
+ @rm -rf examples/ldns
+
+doc: ../../.libs/libldns.so.1 _ldns.so
+ echo @VERSION_MAJOR@
+ rm -f _ldns.so
+ ln -s ../../.libs/_ldns.so
$(MAKE) -C docs html
+ rm -f _ldns.so
+
+# For development only:
+
+# Test environment, does not build the wrapper from dependencies.
+te:
+ rm -rf examples/ldns
+ cd examples && mkdir ldns && ln -s ../../ldns.py ldns/__init__.py && ln -s ../../../../.libs/_ldns.so ldns/_ldns.so && ln -s ../../../../.libs/libldns.so.1 ldns/libldns.so.1 && ls -la
+ @echo "Run a script by typing ./script_name.py"
+ cd examples && LD_LIBRARY_PATH=ldns bash
+ rm -rf examples/ldns
+
+# Builds Python 2 wrapper from present wrapper C code.
+bw:
+ gcc -c ldns_wrapper.c -O9 -fPIC -I../.. -I../../ldns -I/usr/include/python2.7 -I. -o ldns_wrapper.o
+ mkdir -p ../../.libs
+ ld -shared ldns_wrapper.o -L../../.libs -lldns -o ../../.libs/_ldns.so
+
+# Builds Python 3 wrapper from present wrapper C code.
+bw3:
+ gcc -c ldns_wrapper.c -O9 -fPIC -I../.. -I../../ldns -I/usr/include/python3.2 -I. -o ldns_wrapper.o
+ mkdir -p ../../.libs
+ ld -shared ldns_wrapper.o -L../../.libs -ldns -o ../../.libs/_ldns.so
+
+# Builds Python 2 wrapper from interface file.
+sw: ldns.i
+ swig -python -o ldns_wrapper.c -I../.. ldns.i
+ $(MAKE) bw
-#for development only
-swig: ldns.i
- swig -python -py3 -o ldns_wrapper.c -I../.. ldns.i
- gcc -c ldns_wrapper.c -O9 -fPIC -I../.. -I../../ldns -I/usr/include/python3.1 -I. -o ldns_wrapper.o
- ld -shared ldns_wrapper.o -L../../.libs -lldns -o _ldns.so
+# Builds Python 3 wrapper from interface file.
+sw3: ldns.i
+ swig -python -py3 -DPY3 -o ldns_wrapper.c -I../.. ldns.i
+ $(MAKE) bw3
# other places throughout the built documents.
#
# The short X.Y version.
-version = '1.0'
+version = '1.6'
# The full version, including alpha/beta/rc tags.
-release = '1.0.0'
+release = '1.6.14'
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
**Prerequisites**
-Python 2.4 or higher, SWIG 1.3 or higher, GNU make
+SWIG 1.3 and GNU make are required to build modules for Python 2.4 and higher
+(but lower than 3). In order to build modules for Python 3.2 or higher,
+SWIG in version 2.0.4 or higher is required.
+
+Note that Python 3.0 and 3.1 are not supported.
+
+In order to build this documentation the Sphinx Python documentation generator
+is required.
**Download**
-You can download the source codes `here`_.
-The latest release is 1.4.1, Jan 15, 2009.
+The lates source codes can be downloaded from `here`_.
-.. _here: ldns-1.4.1-py.tar.gz
+.. _here: http://nlnetlabs.nl/projects/ldns/
**Compiling**
-After downloading, you can compile the library by doing::
+After downloading the source code archive (this example uses
+ldns-1.6.13.tar.gz), pyLDNS can be enabled and compiled by typing::
- > tar -xzf ldns-1.4.1-py.tar.gz
- > cd ldns-1.4.1
+ > tar -xzf ldns-1.6.13.tar.gz
+ > cd ldns-1.6.13
> ./configure --with-pyldns
> make
-You need GNU make to compile pyLDNS; SWIG and Python development libraries to compile extension module.
+You need GNU make to compile pyLDNS; SWIG and Python development libraries to
+compile the extension module.
+
+**Selecting Target Python Interpreter**
+
+By default, the pyLDNS module builds for the default Python interpreter (i.e.,
+the Python interpreter which can be accessed by just typing ``python`` in
+the command line). If you desire to build the pyLDNS module for a different
+Python version then you must specify the desired Python version by setting
+the ``PYTHON_VERSION`` variable during the configure phase::
+ > PYTHON_VERSION=3.2 ./configure --with-pyldns
+ > make
+
+By default the pyLDNS compiles from sources for a single Python interpreter.
+Remember to execute scripts requiring pyLDNS in those Python interpreters which
+have pyLDNS installed.
**Testing**
-If the compilation is successfull, you can test the python LDNS extension module by::
+If the compilation is successful, you can test the python LDNS extension module
+by executing the commands::
> cd contrib/python
> make testenv
> ./ldns-mx.py
-This will start a new shell, during which the symbolic links will be working.
-When you exit the shell, then symbolic links will be deleted.
+Again, remember to use the Python interpreter version which the pyLDNS module
+has been compiled with.
-In ``contrib/examples`` you can find many simple applications in python which demostrates the capabilities of LDNS library.
+The commands will start a new shell, in which several symbolic links will be
+set-up. When you exit the shell, then symbolic links will be deleted.
+
+In ``contrib/python/examples`` several simple Python scripts utilising pyLDNS
+can be found. These scripts demonstrate the capabilities of the LDNS library.
**Installation**
-To install libraries and extension type::
+To install the libraries and it's extensions type::
- > cd ldns-1.4.1
+ > cd ldns-1.6.13
> make install
-
--- /dev/null
+#!/usr/bin/env python
+
+#
+# ldns_buffer testing script.
+#
+# Do not use constructs that differ between Python 2 and 3.
+# Use write on stdout or stderr.
+#
+
+
+import ldns
+import sys
+import inspect
+
+
+class_name = "ldns_buffer"
+method_name = None
+error_detected = False
+
+
+def set_error():
+ """
+ Writes an error message and sets error flag.
+ """
+ global class_name
+ global method_name
+ global error_detected
+ error_detected = True
+ sys.stderr.write("(line %d): malfunctioning method %s.\n" % \
+ (inspect.currentframe().f_back.f_lineno, method_name))
+
+
+# Buffer creation.
+capacity = 1024
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.__init__()"
+ try:
+ buf = ldns.ldns_buffer(1024)
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.__str__()"
+ buf.printf("abcedf")
+ try:
+ string = buf.__str__()
+ except:
+ set_error()
+ if not isinstance(string, str):
+ # Should be string.
+ set_error()
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.at()"
+ try:
+ ret = buf.at(512)
+ except:
+ set_error()
+ try:
+ # Must raise TypeError.
+ ret = buf.at("")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.available()"
+ try:
+ ret = buf.available(capacity)
+ except:
+ set_error()
+ if not isinstance(ret, bool):
+ # Should be bool.
+ set_error()
+ if not buf.available(capacity):
+ # Should return True.
+ set_error()
+ if buf.available(capacity + 1):
+ # Should return False.
+ set_error()
+ try:
+ # Must raise TypeError.
+ ret = buf.available("")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+# try:
+# # Must raise ValueError.
+# ret = buf.available("")
+# set_error()
+# except ValueError:
+# pass
+# except:
+# set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.available_at()"
+ try:
+ ret = buf.available_at(512, capacity - 512)
+ except:
+ set_error()
+ if not isinstance(ret, bool):
+ # Should be bool.
+ set_error()
+ if not buf.available_at(512, capacity - 512):
+ # Should return True.
+ set_error()
+ if buf.available_at(512, capacity - 512 + 1):
+ # Should return False.
+ set_error()
+ try:
+ # Must raise TypeError.
+ ret = buf.available_at("", 1)
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+ try:
+ # Must raise TypeError.
+ ret = buf.available_at(1, "")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+# try:
+# # Must raise ValueError.
+# ret = buf.available_at(-1, 512)
+# set_error()
+# except ValueError:
+# pass
+# except:
+# set_error()
+# try:
+# # Must raise ValueError.
+# ret = buf.available_at(512, -1)
+# set_error()
+# except ValueError:
+# pass
+# except:
+# set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.begin()"
+ try:
+ ret = buf.begin()
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.capacity()"
+ try:
+ ret = buf.capacity()
+ except:
+ set_error()
+ if not isinstance(ret, int):
+ # Should be int.
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.clear()"
+ try:
+ buf.clear()
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.copy()"
+ sys.stderr.write("%s not tested.\n" % (method_name))
+# buf2 = ldns.ldns_buffer(10)
+# buf2.printf("abcdef")
+# try:
+# buf.copy(buf2)
+# print buf.capacity()
+# print buf2.capacity()
+# except:
+# set_error()
+# buf.printf("2")
+# print buf
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.current()"
+ try:
+ ret = buf.current()
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.end()"
+ try:
+ ret = buf.end()
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.export()"
+ sys.stderr.write("%s not tested.\n" % (method_name))
+
+
+#if not error_detected:
+if True:
+ mehod_name = "ldns_buffer.flip()"
+ buf.printf("abcdef")
+ try:
+ buf.flip()
+ except:
+ set_error()
+# if buf.remaining() != capacity:
+# # Should be at beginning.
+# set_error()
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.getc()"
+ buf.printf("a")
+ buf.rewind()
+ try:
+ ret = buf.getc()
+ except:
+ set_error()
+ if ret != ord("a"):
+ set_error()
+# Test return value for -1
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.invariant()"
+ try:
+ buf.invariant()
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.limit()"
+ try:
+ ret = buf.limit()
+ except:
+ set_error()
+ if ret != capacity:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.position()"
+ try:
+ ret = buf.position()
+ except:
+ set_error()
+ if not isinstance(ret, int):
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.printf()"
+ try:
+ ret = buf.printf("abcdef")
+ except:
+ set_error()
+ if not isinstance(ret, int):
+ set_error()
+ try:
+ ret = buf.printf(10)
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.read()"
+ sys.stderr.write("%s not tested.\n" % (method_name))
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.read_at()"
+ sys.stderr.write("%s not tested.\n" % (method_name))
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.read_u16()"
+ buf.printf("aac")
+ buf.rewind()
+ try:
+ ret = buf.read_u16()
+ except:
+ set_error()
+ if not isinstance(ret, int):
+ set_error()
+ if ret != (ord("a") * 0x0101):
+ set_error()
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.read_u16_at()"
+ buf.printf("abbc")
+ try:
+ ret = buf.read_u16_at(1)
+ except:
+ set_error()
+ if not isinstance(ret, int):
+ set_error()
+ if ret != (ord("b") * 0x0101):
+ set_error()
+ try:
+ ret = buf.read_u16_at("")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+# try:
+# ret = buf.read_u16_at(-1)
+# set_error()
+# except ValueError:
+# pass
+# except:
+# set_error()
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.read_u32()"
+ buf.printf("aaaac")
+ buf.rewind()
+ try:
+ ret = buf.read_u32()
+ except:
+ set_error()
+ if not isinstance(ret, int):
+ set_error()
+ if ret != (ord("a") * 0x01010101):
+ set_error()
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.read_u32_at()"
+ buf.printf("abbbbc")
+ try:
+ ret = buf.read_u32_at(1)
+ except:
+ set_error()
+ if not isinstance(ret, int):
+ set_error()
+ if ret != (ord("b") * 0x01010101):
+ set_error()
+ try:
+ ret = buf.read_u32_at("")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+# try:
+# ret = buf.read_u32_at(-1)
+# set_error()
+# except ValueError:
+# pass
+# except:
+# set_error()
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.read_u8()"
+ buf.printf("ac")
+ buf.rewind()
+ try:
+ ret = buf.read_u8()
+ except:
+ set_error()
+ if not isinstance(ret, int):
+ set_error()
+ if ret != ord("a"):
+ set_error()
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.read_u8_at()"
+ buf.printf("abc")
+ try:
+ ret = buf.read_u8_at(1)
+ except:
+ set_error()
+ if not isinstance(ret, int):
+ set_error()
+ if ret != ord("b"):
+ set_error()
+ try:
+ ret = buf.read_u8_at("")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+# try:
+# ret = buf.read_u8_at(-1)
+# set_error()
+# except ValueError:
+# pass
+# except:
+# set_error()
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.remaining()"
+ buf.printf("abcdef")
+ try:
+ ret = buf.remaining()
+ except:
+ set_error()
+ if not isinstance(ret, int):
+ set_error()
+ if ret != (capacity - 6):
+ set_error()
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.remaining_at()"
+ buf.printf("abcdef")
+ try:
+ ret = buf.remaining_at(1)
+ except:
+ set_error()
+ if not isinstance(ret, int):
+ set_error()
+ if ret != (capacity - 1):
+ set_error()
+ try:
+ ret = buf.remaining_at("")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+# try:
+# ret = buf.remaining_at(-1)
+# set_error()
+# except ValueError:
+# pass
+# except:
+# set_error()
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.reserve()"
+ buf2 = ldns.ldns_buffer(512)
+ try:
+ ret = buf2.reserve(1024)
+ except:
+ set_error()
+ if not isinstance(ret, bool):
+ set_error()
+ try:
+ ret = buf2.reserve("")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+# try:
+# ret = buf2.reserve(-1)
+# set_error()
+# except ValueError:
+# pass
+# except:
+# set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.rewind()"
+ buf.printf("abcdef")
+ try:
+ buf.rewind()
+ except:
+ set_error()
+ if buf.position() != 0:
+ set_error()
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.set_capacity()"
+ try:
+ ret = buf.set_capacity(capacity)
+ except:
+ set_error()
+ if not isinstance(ret, bool):
+ set_error()
+ try:
+ ret = buf.set_capacity("")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+# try:
+# ret = buf.set_capacity(-1)
+# set_error()
+# except ValueError:
+# pass
+# except:
+# set_error()
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.set_limit()"
+ try:
+ buf.set_limit(0)
+ except:
+ set_error()
+ try:
+ buf.set_limit("")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+# try:
+# buf.set_limit(-1)
+# set_error()
+# except ValueError:
+# pass
+# except:
+# set_error()
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.set_position()"
+ try:
+ buf.set_position(0)
+ except:
+ set_error()
+ try:
+ buf.set_position("")
+ except TypeError:
+ pass
+ except:
+ set_error()
+# try:
+# buf.set_position(-1)
+# except ValueError:
+# pass
+# except:
+# set_error()
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.skip()"
+ try:
+ buf.skip(10)
+ except:
+ set_error()
+ try:
+ buf.skip(-1)
+ except:
+ set_error()
+ try:
+ buf.skip("")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.status()"
+ try:
+ ret = buf.status()
+ except:
+ set_error()
+ # Returned status is an integer.
+ if not isinstance(ret, int):
+ set_error()
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.status_ok()"
+ try:
+ ret = buf.status_ok()
+ except:
+ set_error()
+ if not isinstance(ret, bool):
+ set_error()
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.write()"
+ sys.stderr.write("%s not tested.\n" % (method_name))
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.write_at()"
+ sys.stderr.write("%s not tested.\n" % (method_name))
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.write_string()"
+ try:
+ buf.write_string("abcdef")
+ except:
+ set_error()
+# try:
+# buf.write_sring(-1)
+# set_error()
+# except TypeError:
+# pass
+# except:
+# set_error()
+ sys.stderr.write("%s not tested for parameter correctness.\n" % \
+ (method_name))
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.write_string_at()"
+ sys.stderr.write("%s not tested.\n" % (method_name))
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.write_u16()"
+ try:
+ buf.write_u16(ord("b") * 0x0101)
+ except:
+ set_error()
+ try:
+ buf.write_u16("")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.write_u16_at()"
+ buf.printf("a")
+ try:
+ buf.write_u16_at(1, ord("b") * 0x0101)
+ except:
+ set_error()
+ try:
+ buf.write_u16_at("", ord("b") * 0x0101)
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+# try:
+# buf.write_u16_at(-1, ord("b") * 0x0101)
+# set_error()
+# except ValueError:
+# pass
+# except:
+# set_error()
+ try:
+ buf.write_u16_at(1, "")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.write_u32()"
+ try:
+ buf.write_u32(ord("b") * 0x01010101)
+ except:
+ set_error()
+ try:
+ buf.write_u32("")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.write_u32_at()"
+ buf.printf("a")
+ try:
+ buf.write_u32_at(1, ord("b") * 0x01010101)
+ except:
+ set_error()
+ try:
+ buf.write_u32_at("", ord("b") * 0x01010101)
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+# try:
+# buf.write_u32_at(-1, ord("b") * 0x01010101)
+# set_error()
+# except ValueError:
+# pass
+# except:
+# set_error()
+ try:
+ buf.write_u32_at(1, "")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.write_u8()"
+ try:
+ buf.write_u8(ord("b"))
+ except:
+ set_error()
+ try:
+ buf.write_u8("")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+ buf.clear()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_buffer.write_u8_at()"
+ buf.printf("a")
+ try:
+ buf.write_u8_at(1, ord("b"))
+ except:
+ set_error()
+ try:
+ buf.write_u8_at("", ord("b"))
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+# try:
+# buf.write_u8_at(-1, ord("b"))
+# set_error()
+# except ValueError:
+# pass
+# except:
+# set_error()
+ try:
+ buf.write_u8_at(1, "")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+
+
+if not error_detected:
+ sys.stdout.write("%s: passed.\n" % (class_name))
+else:
+ sys.stdout.write("%s: errors detected.\n" % (class_name))
+ sys.exit(1)
--- /dev/null
+#!/usr/bin/env python
+
+#
+# ldns_dname testing script.
+#
+# Do not use constructs that differ between Python 2 and 3.
+# Use write on stdout or stderr.
+#
+
+
+import ldns
+import sys
+import os
+import inspect
+
+
+class_name = "ldns_dname"
+method_name = None
+error_detected = False
+temp_fname = "tmp_dname.txt"
+
+
+def set_error():
+ """
+ Writes an error message and sets error flag.
+ """
+ global class_name
+ global method_name
+ global error_detected
+ error_detected = True
+ sys.stderr.write("(line %d): malfunctioning method %s.\n" % \
+ (inspect.currentframe().f_back.f_lineno, method_name))
+
+
+#if not error_detected:
+if True:
+ method_name = class_name + ".__init__()"
+ rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "test.nic.cz.")
+ rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "217.31.205.50")
+ try:
+ dname = ldns.ldns_dname("www.nic.cz.")
+ if not isinstance(dname, ldns.ldns_dname):
+ set_error()
+ except:
+ set_error()
+ #
+ # Error when printing a dname wich was created fron an empty string.
+ # Must find out why.
+ #
+ try:
+ dname = ldns.ldns_dname(rdf1)
+ if not isinstance(dname, ldns.ldns_dname):
+ set_error()
+ except:
+ set_error()
+ # Test whether rdf1 and dname independent.
+ dname.cat(dname)
+ if dname.__str__() == rdf1.__str__():
+ set_error()
+ # Test whether rdf1 and dname are dependent.
+ dname = ldns.ldns_dname(rdf1, clone=False)
+ dname.cat(dname)
+ if dname.__str__() != rdf1.__str__():
+ set_error()
+ # Test whether constructs from non-dname rdfs.
+ try:
+ dname = ldns.ldns_dname(rdf2)
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+ try:
+ dname = ldns.ldns_dname(1)
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = class_name + ".absolute()"
+ dname = ldns.ldns_dname("www.nic.cz.")
+ try:
+ ret = dname.absolute()
+ if not isinstance(ret, bool):
+ set_error()
+ if ret != True:
+ set_error()
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = class_name + ".cat()"
+ rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "test.nic.cz.")
+ rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "217.31.205.50")
+ dname = ldns.ldns_dname("www.nic.cz.")
+ try:
+ ret = dname.cat(dname)
+ if ret != ldns.LDNS_STATUS_OK:
+ set_error()
+ if dname.__str__() != "www.nic.cz.www.nic.cz.":
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = dname.cat(rdf1)
+ if ret != ldns.LDNS_STATUS_OK:
+ set_error()
+ if dname.__str__() != "www.nic.cz.www.nic.cz.test.nic.cz.":
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = dname.cat(rdf2)
+ if ret == ldns.LDNS_STATUS_OK:
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = dname.cat("")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = class_name + ".cat_clone()"
+ rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "test.nic.cz.")
+ rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "217.31.205.50")
+ dname = ldns.ldns_dname("www.nic.cz.")
+ try:
+ ret = dname.cat_clone(dname)
+ if not isinstance(ret, ldns.ldns_dname):
+ set_error()
+ if ret.__str__() != "www.nic.cz.www.nic.cz.":
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = dname.cat_clone(rdf1)
+ if not isinstance(ret, ldns.ldns_dname):
+ set_error()
+ if ret.__str__() != "www.nic.cz.test.nic.cz.":
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = dname.cat_clone(rdf2)
+ if ret != None:
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = dname.cat_clone("")
+ except TypeError:
+ pass
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = class_name + ".interval()"
+ dn1 = ldns.ldns_dname("a.ns.nic.cz.")
+ dn2 = ldns.ldns_dname("b.ns.nic.cz.")
+ dn3 = ldns.ldns_dname("c.ns.nic.cz.")
+ try:
+ ret = dn1.interval(dn2, dn3)
+ if ret != -1:
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = dn2.interval(dn1, dn3)
+ if ret != 1:
+ set_error()
+ except:
+ set_error()
+ rdf4 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "d.ns.nic.cz.")
+ rdf5 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "194.0.12.1")
+ try:
+ ret = dn1.interval(dn2, rdf4)
+ if ret != -1:
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = dn2.interval(dn1, rdf4)
+ if ret != 1:
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = dn1.interval(dn2, rdf5)
+ set_error()
+ except Exception:
+ pass
+ except:
+ set_error()
+ try:
+ ret = dn1.interval(dn2, "")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = class_name + ".is_subdomain()"
+ dn1 = ldns.ldns_dname("nic.cz.")
+ dn2 = ldns.ldns_dname("www.nic.cz.")
+ rdf3 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
+ try:
+ ret = dn1.is_subdomain(dn2)
+ if not isinstance(ret, bool):
+ set_error()
+ if ret == True:
+ set_error()
+ ret = dn2.is_subdomain(dn1)
+ if ret != True:
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = dn1.is_subdomain(rdf3)
+ if not isinstance(ret, bool):
+ set_error()
+ if ret == True:
+ set_error()
+ except:
+ set_error()
+ rdf4 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "194.0.12.1")
+ try:
+ ret = dn1.is_subdomain(rdf4)
+ if ret != False:
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = dn1.is_subdomain("")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = class_name + ".label()"
+ dn = ldns.ldns_dname("nic.cz.")
+ try:
+ ret = dn.label(0)
+ if not isinstance(ret, ldns.ldns_dname):
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = dn.label(10)
+ if ret != None:
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = dn.label("")
+ except TypeError:
+ pass
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = class_name + ".label_count()"
+ dn = ldns.ldns_dname("www.nic.cz.")
+ try:
+ ret = dn.label_count()
+ if not isinstance(ret, int):
+ set_error()
+ if ret != 3:
+ set_error()
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = class_name + ".left_chop()"
+ dn = ldns.ldns_dname("www.nic.cz.")
+ try:
+ ret = dn.left_chop()
+ if not isinstance(ret, ldns.ldns_dname):
+ set_error()
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = class_name + ".make_canonical()"
+ dn = ldns.ldns_dname("WWW.NIC.CZ.")
+ try:
+ dn.make_canonical()
+ if dn.__str__() != "www.nic.cz.":
+ set_error()
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = class_name + ".new_frm_rdf()"
+ # Tested via constructor call.
+
+
+#if not error_detected:
+if True:
+ method_name = class_name + ".new_frm_str()"
+ # Tested via constructor call.
+
+
+#if not error_detected:
+if True:
+ method_name = class_name + ".reverse()"
+ dn = ldns.ldns_dname("www.nic.cz.")
+ try:
+ ret = dn.reverse()
+ if not isinstance(ret, ldns.ldns_dname):
+ set_error()
+ if ret.__str__() != "cz.nic.www.":
+ set_error()
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = class_name + ".write_to_buffer()"
+ dn = ldns.ldns_dname("www.nic.cz.")
+ buf = ldns.ldns_buffer(1024)
+ try:
+ ret = dn.write_to_buffer(buf)
+ if ret != ldns.LDNS_STATUS_OK:
+ set_error()
+ if buf.position() != 12:
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = dn.write_to_buffer("")
+ except TypeError:
+ pass
+ except:
+ set_error()
+
+
+if not error_detected:
+ sys.stdout.write("%s: passed.\n" % (class_name))
+else:
+ sys.stdout.write("%s: errors detected.\n" % (class_name))
+ sys.exit(1)
--- /dev/null
+#!/usr/bin/env python
+
+#
+# ldns_rdf testing script.
+#
+# Do not use constructs that differ between Python 2 and 3.
+# Use write on stdout or stderr.
+#
+
+
+import ldns
+import sys
+import os
+import inspect
+
+
+class_name = "ldns_rdf"
+method_name = None
+error_detected = False
+temp_fname = "tmp_rdf.txt"
+
+
+def set_error():
+ """
+ Writes an error message and sets error flag.
+ """
+ global class_name
+ global method_name
+ global error_detected
+ error_detected = True
+ sys.stderr.write("(line %d): malfunctioning method %s.\n" % \
+ (inspect.currentframe().f_back.f_lineno, method_name))
+
+
+#if not error_detected:
+if True:
+ method_name = class_name + ".__init__()"
+ try:
+ # Should raise an Exception
+ rdf = ldns.ldns_rdf()
+ set_error()
+ except Exception as e:
+ pass
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf_new()"
+ sys.stderr.write("%s not tested.\n" % (method_name))
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf_new_frm_data()"
+ sys.stderr.write("%s not tested.\n" % (method_name))
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf_new_frm_str()"
+ try:
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz")
+ except:
+ set_error()
+ try:
+ rdf = ldns.ldns_rdf_new_frm_str("", "www.nic.cz")
+ et_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+ try:
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, 1)
+ except TypeError:
+ pass
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf_new_frm_fp()"
+ f = open(temp_fname, "w")
+ f.write("217.31.205.50")
+ f.close()
+ f = open(temp_fname, "r")
+ try:
+ status, rdf = ldns.ldns_rdf_new_frm_fp(ldns.LDNS_RDF_TYPE_A, f)
+ if status != ldns.LDNS_STATUS_OK:
+ set_error()
+ if rdf == None:
+ set_error()
+ except:
+ set_error()
+ try:
+ # Reading past file end.
+ status, rdf = ldns.ldns_rdf_new_frm_fp(ldns.LDNS_RDF_TYPE_AAAA, f)
+ if status == ldns.LDNS_STATUS_OK:
+ set_error()
+ if rdf != None:
+ set_error()
+ except:
+ set_error()
+ f.close()
+ f = open(temp_fname, "r")
+ try:
+ status, rdf = ldns.ldns_rdf_new_frm_fp(ldns.LDNS_RDF_TYPE_AAAA, f)
+ if status != ldns.LDNS_STATUS_OK:
+ set_error()
+ if rdf != None:
+ set_error()
+ except:
+ set_error()
+ f.close()
+ os.remove(temp_fname)
+ try:
+ status, rdf = ldns.ldns_rdf_new_frm_fp("", f)
+ except TypeError:
+ pass
+ except:
+ set_error()
+ try:
+ status, rdf = ldns.ldns_rdf_new_frm_fp(ldns.LDNS_RDF_TYPE_AAAA, "")
+ except TypeError:
+ pass
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf_new_frm_fp_l()"
+ f = open(temp_fname, "w")
+ f.write("217.31.205.50\n194.0.12.1")
+ f.close()
+ f = open(temp_fname, "r")
+ try:
+ status, rdf, line = ldns.ldns_rdf_new_frm_fp_l(ldns.LDNS_RDF_TYPE_A, f)
+ if status != ldns.LDNS_STATUS_OK:
+ set_error()
+ if rdf == None:
+ set_error()
+ except:
+ set_error()
+ try:
+ status, rdf, line = ldns.ldns_rdf_new_frm_fp_l(ldns.LDNS_RDF_TYPE_A, f)
+ if status != ldns.LDNS_STATUS_OK:
+ set_error()
+ if rdf == None:
+ set_error()
+ except:
+ set_error()
+ try:
+ # Reading past file end.
+ status, rdf, line = ldns.ldns_rdf_new_frm_fp_l(ldns.LDNS_RDF_TYPE_A, f)
+ if status == ldns.LDNS_STATUS_OK:
+ set_error()
+ if rdf != None:
+ set_error()
+ except:
+ set_error()
+ f.close()
+ os.remove(temp_fname)
+ try:
+ status, rdf = ldns.ldns_rdf_new_frm_fp_l("", f)
+ except TypeError:
+ pass
+ except:
+ set_error()
+ try:
+ status, rdf = ldns.ldns_rdf_new_frm_fp_l(ldns.LDNS_RDF_TYPE_AAAA, "")
+ except TypeError:
+ pass
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_drf.absolute()"
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
+ try:
+ ret = rdf.absolute()
+ if not isinstance(ret, bool):
+ set_error()
+ if not ret:
+ set_error()
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf.address_reverse()"
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "194.0.12.1")
+ try:
+ ret = rdf.address_reverse()
+ if ret == None:
+ set_error()
+ except:
+ set_error()
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_AAAA, "::1")
+ try:
+ ret = rdf.address_reverse()
+ if ret == None:
+ set_error()
+ except:
+ set_error()
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
+ try:
+ ret = rdf.address_reverse()
+ if ret != None:
+ set_error()
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf.cat()"
+ rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic")
+ rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "cz.")
+ try:
+ ret = rdf1.cat(rdf2)
+ if ret != ldns.LDNS_STATUS_OK:
+ set_error()
+ except:
+ set_error()
+ rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.")
+ rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
+ try:
+ ret = rdf1.cat(rdf2)
+ if ret == ldns.LDNS_STATUS_OK:
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = rdf2.cat(rdf1)
+ if ret == ldns.LDNS_STATUS_OK:
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = rdf2.cat("")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf.cat_clone()"
+ rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic")
+ rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "cz.")
+ try:
+ ret = rdf1.cat_clone(rdf2)
+ if ret == None:
+ set_error()
+ except:
+ set_error()
+ rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.")
+ rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
+ try:
+ ret = rdf1.cat_clone(rdf2)
+ if ret != None:
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = rdf2.cat_clone(rdf1)
+ if ret != None:
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = rdf2.cat_clone("")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf.clone()"
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
+ try:
+ ret = rdf.clone()
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf.data()"
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
+ try:
+ ret = rdf.data()
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf.dname_compare()"
+ rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
+ rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "nic.cz.")
+ try:
+ ret = rdf1.dname_compare(rdf2)
+ if ret != 1:
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = rdf2.dname_compare(rdf1)
+ if ret != -1:
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = rdf1.dname_compare(rdf1)
+ if ret != 0:
+ set_error()
+ except:
+ set_error()
+ rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
+ rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
+ try:
+ ret = rdf1.dname_compare(rdf2)
+ set_error()
+ except Exception:
+ pass
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf.dname_new_frm_str()"
+ try:
+ rdf = ldns.ldns_rdf.dname_new_frm_str("www.nic.cz.")
+ if rdf == None:
+ set_error()
+ except:
+ set_error()
+ try:
+ rdf = ldns.ldns_rdf.dname_new_frm_str("")
+ if rdf != None:
+ set_error()
+ except:
+ set_error()
+ try:
+ rdf = ldns.ldns_rdf.dname_new_frm_str(1)
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf.get_type()"
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
+ try:
+ ret = rdf.get_type()
+ if not isinstance(ret, int):
+ set_error()
+ if ret != ldns.LDNS_RDF_TYPE_DNAME:
+ set_error()
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf.get_type_str()"
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
+ try:
+ ret = rdf.get_type_str()
+ if not isinstance(ret, str):
+ set_error()
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf.interval()"
+ rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "a.ns.nic.cz.")
+ rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "b.ns.nic.cz.")
+ rdf3 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "c.ns.nic.cz.")
+ try:
+ ret = rdf1.interval(rdf2, rdf3)
+ if ret != -1:
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = rdf2.interval(rdf1, rdf3)
+ if ret != 1:
+ set_error()
+ except:
+ set_error()
+ rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "194.0.12.1")
+ rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "b.ns.nic.cz.")
+ rdf3 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "c.ns.nic.cz.")
+ try:
+ ret = rdf1.interval(rdf2, rdf3)
+ set_error()
+ except Exception:
+ pass
+ except:
+ set_error()
+ try:
+ ret = rdf2.interval("", rdf3)
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf.is_subdomain()"
+ rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "nic.cz.")
+ rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
+ try:
+ ret = rdf1.is_subdomain(rdf2)
+ if not isinstance(ret, bool):
+ set_error()
+ if ret == True:
+ set_error()
+ ret = rdf2.is_subdomain(rdf1)
+ if ret != True:
+ set_error()
+ except:
+ set_error()
+ rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "194.0.12.1")
+ rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
+ try:
+ ret = rdf1.is_subdomain(rdf2)
+ if ret != False:
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = rdf2.is_subdomain(rdf1)
+ if ret != False:
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = rdf2.is_subdomain("")
+ set_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf.label()"
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
+ try:
+ ret = rdf.label(0)
+ if not isinstance(ret, ldns.ldns_rdf):
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = rdf.label(10)
+ if ret != None:
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = rdf.label("")
+ except TypeError:
+ pass
+ except:
+ set_error()
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
+ try:
+ ret = rdf.label(0)
+ if ret != None:
+ set_error()
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf.label_count()"
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
+ try:
+ ret = rdf.label_count()
+ if not isinstance(ret, int):
+ set_error()
+ if ret != 3:
+ set_error()
+ except:
+ set_error()
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
+ try:
+ ret = rdf.label_count()
+ if not isinstance(ret, int):
+ set_error()
+ if ret != 0:
+ set_error()
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf.left_chop()"
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
+ try:
+ ret = rdf.left_chop()
+ if not isinstance(ret, ldns.ldns_rdf):
+ set_error()
+ except:
+ set_error()
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
+ try:
+ ret = rdf.left_chop()
+ if ret != None:
+ set_error()
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf.make_canonical()"
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "WWW.NIC.CZ.")
+ try:
+ rdf.make_canonical()
+ if rdf.__str__() != "www.nic.cz.":
+ set_error()
+ except:
+ set_error()
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
+ try:
+ rdf.make_canonical()
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf.new_frm_str()"
+ try:
+ rdf = ldns.ldns_rdf.new_frm_str("www.nic.cz.", ldns.LDNS_RDF_TYPE_DNAME)
+ except:
+ set_error()
+ try:
+ rdf = ldns.ldns_rdf.new_frm_str("www.nic.cz.", ldns.LDNS_RDF_TYPE_AAAA)
+ set_error()
+ except Exception:
+ pass
+ except:
+ set_error()
+ try:
+ rdf = ldns.ldns_rdf.new_frm_str("www.nic.cz.", ldns.LDNS_RDF_TYPE_AAAA, raiseException = False)
+ if rdf != None:
+ set_error()
+ except:
+ set_error()
+ try:
+ rdf = ldns.ldns_rdf.new_frm_str("", "www.nic.cz")
+ et_error()
+ except TypeError:
+ pass
+ except:
+ set_error()
+ try:
+ rdf = ldns.ldns_rdf.new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, 1)
+ except TypeError:
+ pass
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
+ f = open(temp_fname, "w")
+ try:
+ rdf.print_to_file(f)
+ except:
+ set_error()
+ f.close()
+ f = open(temp_fname, "r")
+ if f.read() != "127.0.0.1":
+ set_error()
+ f.close()
+ os.remove(temp_fname)
+
+
+#if not error_detected:
+if True:
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
+ try:
+ ret = rdf.reverse()
+ if not isinstance(ret, ldns.ldns_rdf):
+ set_error()
+ if ret.__str__() != "cz.nic.www.":
+ set_error()
+ except:
+ set_error()
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
+ try:
+ ret = rdf.reverse()
+ if not isinstance(ret, ldns.ldns_rdf):
+ set_error()
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf.set_data()"
+ sys.stderr.write("%s not tested.\n" % (method_name))
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf.set_size()"
+ sys.stderr.write("%s not tested.\n" % (method_name))
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf.set_type()"
+ sys.stderr.write("%s not tested.\n" % (method_name))
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf.size()"
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
+ try:
+ ret = rdf.size()
+ if ret != 12:
+ set_error()
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf.write_to_buffer()"
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
+ buf = ldns.ldns_buffer(1024)
+ try:
+ ret = rdf.write_to_buffer(buf)
+ if ret != ldns.LDNS_STATUS_OK:
+ set_error()
+ if buf.position() != 12:
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = rdf.write_to_buffer("")
+ except TypeError:
+ pass
+ except:
+ set_error()
+
+
+#if not error_detected:
+if True:
+ method_name = "ldns_rdf.write_to_buffer_canonical()"
+ rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "WWW.NIC.CZ.")
+ buf = ldns.ldns_buffer(1024)
+ try:
+ ret = rdf.write_to_buffer_canonical(buf)
+ if ret != ldns.LDNS_STATUS_OK:
+ set_error()
+ if buf.position() != 12:
+ set_error()
+ except:
+ set_error()
+ try:
+ ret = rdf.write_to_buffer_canonical("")
+ except TypeError:
+ pass
+ except:
+ set_error()
+
+
+if not error_detected:
+ sys.stdout.write("%s: passed.\n" % (class_name))
+else:
+ sys.stdout.write("%s: errors detected.\n" % (class_name))
+ sys.exit(1)
%typemap(check, noblock = 1) FILE* {
if ($1 == NULL) {
- SWIG_exception_fail(SWIG_ValueError, "in method '" "$symname" "', argument "
+ /* The generated wrapper function raises TypeError on mismatching types. */
+ SWIG_exception_fail(SWIG_TypeError, "in method '" "$symname" "', argument "
"$argnum"" of type '" "$type""'");
}
}
#endif
%include "typemaps.i"
+
+/* ========================================================================= */
+/* Preliminary Python code. */
+/* ========================================================================= */
+
+%pythoncode
+%{
+ #
+ # Use and don't ignore DeprecationWarning and
+ # PendingDeprecationWarning.
+ #
+ import warnings
+ warnings.filterwarnings("module", category=DeprecationWarning)
+ warnings.filterwarnings("module", category=PendingDeprecationWarning)
+%}
+
+
+/* Tell SWIG how to handle ssize_t as input parameter. */
+%typemap(in, noblock=1) (ssize_t)
+{
+ int $1_res = 0;
+ $1_res = SWIG_AsVal_long($input, &$1);
+ if (!SWIG_IsOK($1_res)) {
+ SWIG_exception_fail(SWIG_ArgError($1_res), "in method '"
+ "$symname" "', argument " "$argnum" " of type '"
+ "$type""'");
+ }
+}
+
+
%inline %{
struct timeval* ldns_make_timeval(uint32_t sec, uint32_t usec)
{
%immutable ldns_error_str;
%immutable ldns_signing_algorithms;
-//new_frm_fp_l
-%apply int *OUTPUT { int *line_nr};
+//*_new_frm_fp_l
+%apply int *OUTPUT { (int *line_nr) };
+
%apply uint32_t *OUTPUT { uint32_t *default_ttl};
// wire2pkt
* 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.
+ * 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
* 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_buffer **)
+
+/* ========================================================================= */
+/* SWIG setting and definitions. */
+/* ========================================================================= */
+
+/* Creates a temporary instance of (ldns_buffer *). */
+%typemap(in, numinputs=0, noblock=1) (ldns_buffer **)
{
- ldns_buffer *$1_buf;
- $1 = &$1_buf;
+ ldns_buffer *$1_buf;
+ $1 = &$1_buf;
}
-/* result generation */
-%typemap(argout,noblock=1) (ldns_buffer **)
+/* Result generation, appends (ldns_buffer *) after the result. */
+%typemap(argout, noblock=1) (ldns_buffer **)
{
- $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(SWIG_as_voidptr($1_buf), SWIGTYPE_p_ldns_struct_buffer, SWIG_POINTER_OWN | 0 ));
+ $result = SWIG_Python_AppendOutput($result,
+ SWIG_NewPointerObj(SWIG_as_voidptr($1_buf),
+ SWIGTYPE_p_ldns_struct_buffer, SWIG_POINTER_OWN | 0));
}
-%nodefaultctor ldns_struct_buffer; //no default constructor & destructor
-%nodefaultdtor ldns_struct_buffer;
+/*
+ * Limit the number of arguments to 2 and deal with variable
+ * number of arguments in the Python way.
+ */
+%varargs(2, char *arg = NULL) ldns_buffer_printf;
+
+%nodefaultctor ldns_struct_buffer; /* No default constructor. */
+%nodefaultdtor ldns_struct_buffer; /* No default destructor. */
-%delobject ldns_buffer_free;
%newobject ldns_buffer_new;
-%newobject ldns_dname_new;
%newobject ldns_dname_new_frm_data;
-%newobject ldns_dname_label;
-# limit the number of arguments to 2 and
-# deal with variable number of arguments the Python way
-%varargs(2, char *arg = NULL) ldns_buffer_printf;
+%delobject ldns_buffer_free;
%rename(ldns_buffer) ldns_struct_buffer;
-#ifdef LDNS_DEBUG
-%rename(__ldns_buffer_free) ldns_buffer_free;
-%inline %{
-void _ldns_buffer_free (ldns_buffer* b) {
- printf("******** LDNS_BUFFER free 0x%lX ************\n", (long unsigned int)b);
- ldns_buffer_free(b);
-}
-%}
-#else
-%rename(_ldns_buffer_free) ldns_buffer_free;
-#endif
-
%ignore ldns_struct_buffer::_position;
%ignore ldns_struct_buffer::_limit;
%ignore ldns_struct_buffer::_capacity;
%ignore ldns_struct_buffer::_fixed;
%ignore ldns_struct_buffer::_status;
+%ignore ldns_buffer_new_frm_data;
+
+
+/* ========================================================================= */
+/* Debugging related code. */
+/* ========================================================================= */
+
+#ifdef LDNS_DEBUG
+%rename(__ldns_buffer_free) ldns_buffer_free;
+%inline
+%{
+ /*!
+ * @brief Frees the buffer and print a message.
+ */
+ void _ldns_buffer_free (ldns_buffer* b)
+ {
+ printf("******** LDNS_BUFFER free 0x%lX ************\n",
+ (long unsigned int) b);
+ ldns_buffer_free(b);
+ }
+%}
+#else /* !LDNS_DEBUG */
+%rename(_ldns_buffer_free) ldns_buffer_free;
+#endif /* LDNS_DEBUG */
+
+
+/* ========================================================================= */
+/* Added C code. */
+/* ========================================================================= */
+
+/* None. */
+
+
+/* ========================================================================= */
+/* Encapsulating Python code. */
+/* ========================================================================= */
+
+%feature("docstring") "LDNS buffer."
+
%extend ldns_struct_buffer {
- %pythoncode %{
+ %pythoncode
+ %{
def __init__(self, capacity):
- """Creates a new buffer with the specified capacity.
+ """
+ Creates a new buffer with the specified capacity.
- :param capacity: the size (in bytes) to allocate for the buffer
+ :param capacity: Number of bytes to allocate for the buffer.
+ :type capacity: integer
+ :throws TypeError: When `capacity` of non-integer type.
+ :return: (:class:`ldns_buffer`)
"""
self.this = _ldns.ldns_buffer_new(capacity)
__swig_destroy__ = _ldns._ldns_buffer_free
def __str__(self):
- """Returns the data in the buffer as a string. Buffer data must be char * type."""
+ """
+ Returns the data in the buffer as a string.
+ Buffer data must be char * type.
+
+ :return: string
+ """
return _ldns.ldns_buffer2str(self)
def getc(self):
- """returns the next character from a buffer.
+ """
+ Returns the next character from a buffer.
- Advances the position pointer with 1. When end of buffer is reached returns EOF. This is the buffer's equivalent for getc().
+ Advances the position pointer with 1. When end of buffer
+ is reached returns EOF. This is the buffer's equivalent
+ for getc().
- :returns: (int) EOF on failure otherwise return the character
+ :return: (integer) EOF on failure otherwise return
+ the character.
"""
return _ldns.ldns_bgetc(self)
- #LDNS_BUFFER_METHODS_#
- def at(self,at):
- """returns a pointer to the data at the indicated position.
+ #
+ # LDNS_BUFFER_METHODS_
+ #
+
+ def at(self, at):
+ """
+ Returns a pointer to the data at the indicated position.
- :param at:
- position
- :returns: (uint8_t \*) the pointer to the data
+ :param at: position
+ :type at: positive integer
+ :throws TypeError: When `at` of non-integer type.
+ :return: (uint8_t \*) The pointer to the data.
"""
- return _ldns.ldns_buffer_at(self,at)
- #parameters: const ldns_buffer *,size_t,
+ return _ldns.ldns_buffer_at(self, at)
+ #parameters: const ldns_buffer *, size_t,
#retvals: uint8_t *
- def available(self,count):
- """checks if the buffer has count bytes available at the current position
+ def available(self, count):
+ """
+ Checks whether the buffer has count bytes available at
+ the current position.
- :param count:
- how much is available
- :returns: (int) true or false
+ :param count: How much is available.
+ :type count: integer
+ :throws TypeError: When `count` of non-integer type.
+ :return: (bool) True or False.
"""
- return _ldns.ldns_buffer_available(self,count)
- #parameters: ldns_buffer *,size_t,
+ return _ldns.ldns_buffer_available(self, count) != 0
+ #parameters: ldns_buffer *, size_t,
#retvals: int
- def available_at(self,at,count):
- """checks if the buffer has at least COUNT more bytes available.
+ def available_at(self, at, count):
+ """
+ Checks if the buffer has at least `count` more bytes available.
- Before reading or writing the caller needs to ensure enough space is available!
+ Before reading or writing the caller needs to ensure that
+ enough space is available!
- :param at:
- indicated position
- :param count:
- how much is available
- :returns: (int) true or false
+ :param at: Indicated position.
+ :type at: positive integer
+ :param count: How much is available.
+ :type count: positive integer
+ :throws TypeError: When `at` or `count` of non-integer type.
+ :return: (bool) True or False.
"""
- return _ldns.ldns_buffer_available_at(self,at,count)
+ return _ldns.ldns_buffer_available_at(self, at, count) != 0
#parameters: ldns_buffer *,size_t,size_t,
#retvals: int
def begin(self):
- """returns a pointer to the beginning of the buffer (the data at position 0).
+ """
+ Returns a pointer to the beginning of the buffer
+ (the data at position 0).
- :returns: (uint8_t \*) the pointer
+ :return: (uint8_t \*) Pointer.
"""
return _ldns.ldns_buffer_begin(self)
#parameters: const ldns_buffer *,
#retvals: uint8_t *
def capacity(self):
- """returns the number of bytes the buffer can hold.
+ """
+ Returns the number of bytes the buffer can hold.
- :returns: (size_t) the number of bytes
+ :return: (size_t) The number of bytes.
"""
return _ldns.ldns_buffer_capacity(self)
#parameters: ldns_buffer *,
#retvals: size_t
def clear(self):
- """clears the buffer and make it ready for writing.
+ """
+ Clears the buffer and make it ready for writing.
- The buffer's limit is set to the capacity and the position is set to 0.
+ The buffer's limit is set to the capacity and the position
+ is set to 0.
"""
_ldns.ldns_buffer_clear(self)
#parameters: ldns_buffer *,
#retvals:
- def copy(self,bfrom):
- """Copy contents of the other buffer to this buffer.
+ def copy(self, bfrom):
+ """
+ Copy contents of the other buffer to this buffer.
Silently truncated if this buffer is too small.
- :param bfrom: other buffer
+ :param bfrom: Source buffer.
+ :type bfrom: :class:`ldns_buffer`
+ :throws TypeError: When `bfrom` of non-:class:`ldns_buffer`
+ type.
"""
- _ldns.ldns_buffer_copy(self,bfrom)
- #parameters: ldns_buffer *,ldns_buffer *,
+ _ldns.ldns_buffer_copy(self, bfrom)
+ #parameters: ldns_buffer *, ldns_buffer *,
#retvals:
def current(self):
- """returns a pointer to the data at the buffer's current position.
+ """
+ Returns a pointer to the data at the buffer's current position.
- :returns: (uint8_t \*) the pointer
+ :return: (uint8_t \*) A pointer.
"""
return _ldns.ldns_buffer_current(self)
#parameters: ldns_buffer *,
#retvals: uint8_t *
def end(self):
- """returns a pointer to the end of the buffer (the data at the buffer's limit).
+ """
+ Returns a pointer to the end of the buffer (the data
+ at the buffer's limit).
- :returns: (uint8_t \*) the pointer
+ :return: (uint8_t \*) Pointer.
"""
return _ldns.ldns_buffer_end(self)
#parameters: ldns_buffer *,
#retvals: uint8_t *
def export(self):
- """Makes the buffer fixed and returns a pointer to the data.
+ """
+ Makes the buffer fixed and returns a pointer to the data.
- The caller is responsible for free'ing the result.
+ The caller is responsible for freeing the result.
- :returns: (void \*) void
+ :return: (void \*) Void pointer.
"""
return _ldns.ldns_buffer_export(self)
#parameters: ldns_buffer *,
#retvals: void *
def flip(self):
- """makes the buffer ready for reading the data that has been written to the buffer.
+ """
+ Makes the buffer ready for reading the data that has been
+ written to the buffer.
- The buffer's limit is set to the current position and the position is set to 0.
+ The buffer's limit is set to the current position and
+ the position is set to 0.
"""
_ldns.ldns_buffer_flip(self)
#parameters: ldns_buffer *,
def invariant(self):
+ """
+ Performs no action.
+
+ In debugging mode this method performs a buffer settings
+ check. It asserts if something is wrong.
+ """
_ldns.ldns_buffer_invariant(self)
#parameters: ldns_buffer *,
def limit(self):
- """returns the maximum size of the buffer
+ """
+ Returns the maximum size of the buffer.
- :returns: (size_t) the size
+ :return: (size_t) The size.
"""
return _ldns.ldns_buffer_limit(self)
#parameters: ldns_buffer *,
#retvals: size_t
def position(self):
- """returns the current position in the buffer (as a number of bytes)
+ """
+ Returns the current position in the buffer
+ (as a number of bytes).
- :returns: (size_t) the current position
+ :return: (size_t) The current position.
"""
return _ldns.ldns_buffer_position(self)
#parameters: ldns_buffer *,
#retvals: size_t
- def printf(self, str, *args):
- """Prints to the buffer, increasing the capacity if required using buffer_reserve().
+ def printf(self, string, *args):
+ """
+ Prints to the buffer, increasing the capacity
+ if required using buffer_reserve().
- The buffer's position is set to the terminating '\0'. Returns the number of characters written (not including the terminating '\0') or -1 on failure.
- :param str: a string
- :returns: (int)
+ The buffer's position is set to the terminating '\0'.
+ Returns the number of characters written (not including
+ the terminating '\0') or -1 on failure.
+
+ :param string: A string to be written.
+ :type string: string
+ :throws: TypeError when `string` not a string.
+ :return: (int) Number of written characters or -1 on failure.
"""
- data = str % args
- return _ldns.ldns_buffer_printf(self,data)
- #parameters: ldns_buffer *,const char *,...
+ data = string % args
+ return _ldns.ldns_buffer_printf(self, data)
+ #parameters: ldns_buffer *, const char *, ...
#retvals: int
- def read(self,data,count):
- """copies count bytes of data at the current position to the given data-array
+ def read(self, data, count):
+ """
+ Copies count bytes of data at the current position to the given
+ `data`-array
- :param data:
- buffer to copy to
- :param count:
- the length of the data to copy
+ :param data: Target buffer to copy to.
+ :type data: void \*
+ :param count: The length of the data to copy.
+ :type count: size_t
"""
_ldns.ldns_buffer_read(self,data,count)
- #parameters: ldns_buffer *,void *,size_t,
+ #parameters: ldns_buffer *, void *, size_t,
#retvals:
- def read_at(self,at,data,count):
- """copies count bytes of data at the given position to the given data-array
+ def read_at(self, at, data, count):
+ """
+ Copies count bytes of data at the given position to the
+ given `data`-array.
- :param at:
- the position in the buffer to start
- :param data:
- buffer to copy to
- :param count:
- the length of the data to copy
+ :param at: The position in the buffer to start reading.
+ :type at: size_t
+ :param data: Target buffer to copy to.
+ :type data: void \*
+ :param count: The length of the data to copy.
+ :type count: size_t
"""
_ldns.ldns_buffer_read_at(self,at,data,count)
- #parameters: ldns_buffer *,size_t,void *,size_t,
+ #parameters: ldns_buffer *, size_t, void *, size_t,
#retvals:
def read_u16(self):
- """returns the 2-byte integer value at the current position in the buffer
+ """
+ Returns the 2-byte integer value at the current position
+ from the buffer.
- :returns: (uint16_t) 2 byte integer
+ :return: (uint16_t) Word.
"""
return _ldns.ldns_buffer_read_u16(self)
#parameters: ldns_buffer *,
#retvals: uint16_t
- def read_u16_at(self,at):
- """returns the 2-byte integer value at the given position in the buffer
+ def read_u16_at(self, at):
+ """
+ Returns the 2-byte integer value at the given position
+ from the buffer.
- :param at:
- position in the buffer
- :returns: (uint16_t) 2 byte integer
+ :param at: Position in the buffer.
+ :type at: positive integer
+ :throws TypeError: When `at` of non-integer type.
+ :return: (uint16_t) Word.
"""
- return _ldns.ldns_buffer_read_u16_at(self,at)
- #parameters: ldns_buffer *,size_t,
+ return _ldns.ldns_buffer_read_u16_at(self, at)
+ #parameters: ldns_buffer *, size_t,
#retvals: uint16_t
def read_u32(self):
- """returns the 4-byte integer value at the current position in the buffer
+ """
+ Returns the 4-byte integer value at the current position
+ from the buffer.
- :returns: (uint32_t) 4 byte integer
+ :return: (uint32_t) Double-word.
"""
return _ldns.ldns_buffer_read_u32(self)
#parameters: ldns_buffer *,
#retvals: uint32_t
- def read_u32_at(self,at):
- """returns the 4-byte integer value at the given position in the buffer
+ def read_u32_at(self, at):
+ """
+ Returns the 4-byte integer value at the given position
+ from the buffer.
- :param at:
- position in the buffer
- :returns: (uint32_t) 4 byte integer
+ :param at: Position in the buffer.
+ :type at: positive integer
+ :throws TypeError: When `at` of non-integer type.
+ :return: (uint32_t) Double-word.
"""
- return _ldns.ldns_buffer_read_u32_at(self,at)
- #parameters: ldns_buffer *,size_t,
+ return _ldns.ldns_buffer_read_u32_at(self, at)
+ #parameters: ldns_buffer *, size_t,
#retvals: uint32_t
def read_u8(self):
- """returns the byte value at the current position in the buffer
+ """
+ Returns the byte value at the current position from the buffer.
- :returns: (uint8_t) 1 byte integer
+ :return: (uint8_t) A byte (not a character).
"""
return _ldns.ldns_buffer_read_u8(self)
#parameters: ldns_buffer *,
#retvals: uint8_t
- def read_u8_at(self,at):
- """returns the byte value at the given position in the buffer
+ def read_u8_at(self, at):
+ """
+ Returns the byte value at the given position from the buffer.
- :param at:
- the position in the buffer
- :returns: (uint8_t) 1 byte integer
+ :param at: The position in the buffer.
+ :type at: positive integer
+ :throws TypeError: When `at` of non-integer type.
+ :return: (uint8_t) Byte value.
"""
- return _ldns.ldns_buffer_read_u8_at(self,at)
- #parameters: ldns_buffer *,size_t,
+ return _ldns.ldns_buffer_read_u8_at(self, at)
+ #parameters: ldns_buffer *, size_t,
#retvals: uint8_t
def remaining(self):
- """returns the number of bytes remaining between the buffer's position and limit.
+ """
+ Returns the number of bytes remaining between the buffer's
+ position and limit.
- :returns: (size_t) the number of bytes
+ :return: (size_t) The number of bytes.
"""
return _ldns.ldns_buffer_remaining(self)
#parameters: ldns_buffer *,
#retvals: size_t
- def remaining_at(self,at):
- """returns the number of bytes remaining between the indicated position and the limit.
+ def remaining_at(self, at):
+ """
+ Returns the number of bytes remaining between the indicated
+ position and the limit.
- :param at:
- indicated position
- :returns: (size_t) number of bytes
+ :param at: Indicated position.
+ :type at: positive integer
+ :throws TypeError: When `at` of non-integer type.
+ :return: (size_t) number of bytes
"""
- return _ldns.ldns_buffer_remaining_at(self,at)
+ return _ldns.ldns_buffer_remaining_at(self, at)
#parameters: ldns_buffer *,size_t,
#retvals: size_t
- def reserve(self,amount):
- """ensures BUFFER can contain at least AMOUNT more bytes.
+ def reserve(self, amount):
+ """
+ Ensures that the buffer can contain at least `amount` more
+ bytes.
- The buffer's capacity is increased if necessary using buffer_set_capacity().
+ The buffer's capacity is increased if necessary using
+ buffer_set_capacity().
- The buffer's limit is always set to the (possibly increased) capacity.
+ The buffer's limit is always set to the (possibly increased)
+ capacity.
- :param amount:
- amount to use
- :returns: (bool) whether this failed or succeeded
+ :param amount: Amount to use.
+ :type amount: positive integer
+ :throws TypeError: When `amount` of non-integer type.
+ :return: (bool) hether this failed or succeeded.
"""
- return _ldns.ldns_buffer_reserve(self,amount)
- #parameters: ldns_buffer *,size_t,
+ return _ldns.ldns_buffer_reserve(self, amount)
+ #parameters: ldns_buffer *, size_t,
#retvals: bool
def rewind(self):
- """make the buffer ready for re-reading the data.
+ """
+ Make the buffer ready for re-reading the data.
The buffer's position is reset to 0.
"""
#parameters: ldns_buffer *,
#retvals:
- def set_capacity(self,capacity):
- """changes the buffer's capacity.
+ def set_capacity(self, capacity):
+ """
+ Changes the buffer's capacity.
- The data is reallocated so any pointers to the data may become invalid. The buffer's limit is set to the buffer's new capacity.
+ The data is reallocated so any pointers to the data may become
+ invalid. The buffer's limit is set to the buffer's new capacity.
- :param capacity:
- the capacity to use
- :returns: (bool) whether this failed or succeeded
+ :param capacity: The capacity to use.
+ :type capacity: positive integer
+ :throws TypeError: When `capacity` of non-integer type.
+ :return: (bool) whether this failed or succeeded
"""
- return _ldns.ldns_buffer_set_capacity(self,capacity)
- #parameters: ldns_buffer *,size_t,
+ return _ldns.ldns_buffer_set_capacity(self, capacity)
+ #parameters: ldns_buffer *, size_t,
#retvals: bool
- def set_limit(self,limit):
- """changes the buffer's limit.
+ def set_limit(self, limit):
+ """
+ Changes the buffer's limit.
- If the buffer's position is greater than the new limit the position is set to the limit.
+ If the buffer's position is greater than the new limit
+ then the position is set to the limit.
- :param limit:
- the new limit
+ :param limit: The new limit.
+ :type limit: positive integer
+ :throws TypeError: When `limit` of non-integer type.
"""
- _ldns.ldns_buffer_set_limit(self,limit)
- #parameters: ldns_buffer *,size_t,
+ _ldns.ldns_buffer_set_limit(self, limit)
+ #parameters: ldns_buffer *, size_t,
#retvals:
def set_position(self,mark):
- """sets the buffer's position to MARK.
+ """
+ Sets the buffer's position to `mark`.
The position must be less than or equal to the buffer's limit.
- :param mark:
- the mark to use
+ :param mark: The mark to use.
+ :type mark: positive integer
+ :throws TypeError: When `mark` of non-integer type.
"""
_ldns.ldns_buffer_set_position(self,mark)
#parameters: ldns_buffer *,size_t,
#retvals:
- def skip(self,count):
- """changes the buffer's position by COUNT bytes.
+ def skip(self, count):
+ """
+ Changes the buffer's position by `count` bytes.
- The position must not be moved behind the buffer's limit or before the beginning of the buffer.
+ The position must not be moved behind the buffer's limit or
+ before the beginning of the buffer.
- :param count:
- the count to use
+ :param count: The count to use.
+ :type count: integer
+ :throws TypeError: When `count` of non-integer type.
"""
- _ldns.ldns_buffer_skip(self,count)
- #parameters: ldns_buffer *,ssize_t,
+ _ldns.ldns_buffer_skip(self, count)
+ #parameters: ldns_buffer *, ssize_t,
#retvals:
def status(self):
- """returns the status of the buffer
+ """
+ Returns the status of the buffer.
- :returns: (ldns_status) the status
+ :return: (ldns_status) The status.
"""
return _ldns.ldns_buffer_status(self)
#parameters: ldns_buffer *,
#retvals: ldns_status
def status_ok(self):
- """returns true if the status of the buffer is LDNS_STATUS_OK, false otherwise
+ """
+ Returns True if the status of the buffer is LDNS_STATUS_OK,
+ False otherwise.
- :returns: (bool) true or false
+ :return: (bool) True or False.
"""
return _ldns.ldns_buffer_status_ok(self)
#parameters: ldns_buffer *,
#retvals: bool
- def write(self,data,count):
- """writes count bytes of data to the current position of the buffer
+ def write(self, data, count):
+ """
+ Writes count bytes of data to the current position of
+ the buffer.
- :param data:
- the data to write
- :param count:
- the lenght of the data to write
+ :param data: The data to write.
+ :type data: void \*
+ :param count: The length of the data to write.
+ :type count: size_t
"""
- _ldns.ldns_buffer_write(self,data,count)
- #parameters: ldns_buffer *,const void *,size_t,
+ _ldns.ldns_buffer_write(self, data, count)
+ #parameters: ldns_buffer *, const void *, size_t,
#retvals:
- def write_at(self,at,data,count):
- """writes the given data to the buffer at the specified position
+ def write_at(self, at, data, count):
+ """
+ Writes the given data to the buffer at the specified position
+ by `at`.
- :param at:
- the position (in number of bytes) to write the data at
- :param data:
- pointer to the data to write to the buffer
- :param count:
- the number of bytes of data to write
+ :param at: The position (in number of bytes) to write the
+ data at.
+ :param data: Pointer to the data to write to the buffer.
+ :param count: The number of bytes of data to write.
"""
- _ldns.ldns_buffer_write_at(self,at,data,count)
- #parameters: ldns_buffer *,size_t,const void *,size_t,
+ _ldns.ldns_buffer_write_at(self, at, data, count)
+ #parameters: ldns_buffer *, size_t, const void *, size_t,
#retvals:
- def write_string(self,str):
- """copies the given (null-delimited) string to the current position at the buffer
+ def write_string(self, string):
+ """
+ Copies the given (null-delimited) string to the current
+ position into the buffer.
- :param str:
- the string to write
+ :param string: The string to write.
+ :type string: string
+ :throws TypeError: When `string` not a string.
"""
- _ldns.ldns_buffer_write_string(self,str)
+ _ldns.ldns_buffer_write_string(self,string)
#parameters: ldns_buffer *,const char *,
#retvals:
- def write_string_at(self,at,str):
- """copies the given (null-delimited) string to the specified position at the buffer
+ def write_string_at(self, at, string):
+ """
+ Copies the given (null-delimited) string to the specified
+ position `at` into the buffer.
- :param at:
- the position in the buffer
- :param str:
- the string to write
+ :param at: The position in the buffer.
+ :type at: positive integer
+ :param string: The string to write.
+ :type string: string
+ :throws TypeError: When types mismatch.
"""
- _ldns.ldns_buffer_write_string_at(self,at,str)
- #parameters: ldns_buffer *,size_t,const char *,
+ _ldns.ldns_buffer_write_string_at(self, at, string)
+ #parameters: ldns_buffer *, size_t, const char *,
#retvals:
- def write_u16(self,data):
- """writes the given 2 byte integer at the current position in the buffer
+ def write_u16(self, data):
+ """Writes the given 2 byte integer at the current
+ position in the buffer.
- :param data:
- the 16 bits to write
+ :param data: The word to write.
+ :type data: uint16_t
+ :throws TypeError: When `data` of non-integer type.
"""
- _ldns.ldns_buffer_write_u16(self,data)
- #parameters: ldns_buffer *,uint16_t,
+ _ldns.ldns_buffer_write_u16(self, data)
+ #parameters: ldns_buffer *, uint16_t,
#retvals:
- def write_u16_at(self,at,data):
- """writes the given 2 byte integer at the given position in the buffer
+ def write_u16_at(self, at, data):
+ """
+ Writes the given 2 byte integer at the given position
+ in the buffer.
- :param at:
- the position in the buffer
- :param data:
- the 16 bits to write
+ :param at: The position in the buffer.
+ :type at: positive integer
+ :param data: The word to write.
+ :type data: uint16_t
+ :throws TypeError: When `at` or `data` of non-integer type.
"""
_ldns.ldns_buffer_write_u16_at(self,at,data)
#parameters: ldns_buffer *,size_t,uint16_t,
#retvals:
- def write_u32(self,data):
- """writes the given 4 byte integer at the current position in the buffer
+ def write_u32(self, data):
+ """
+ Writes the given 4 byte integer at the current position
+ in the buffer.
- :param data:
- the 32 bits to write
+ :param data: The double-word to write.
+ :type data: uint32_t
+ :throws TypeError: When `data` of non-integer type.
"""
- _ldns.ldns_buffer_write_u32(self,data)
- #parameters: ldns_buffer *,uint32_t,
+ _ldns.ldns_buffer_write_u32(self, data)
+ #parameters: ldns_buffer *, uint32_t,
#retvals:
- def write_u32_at(self,at,data):
- """writes the given 4 byte integer at the given position in the buffer
+ def write_u32_at(self, at, data):
+ """
+ Writes the given 4 byte integer at the given position
+ in the buffer.
- :param at:
- the position in the buffer
- :param data:
- the 32 bits to write
+ :param at: The position in the buffer.
+ :type at: positive integer
+ :param data: The double-word to write.
+ :type data: uint32_t
+ :throws TypeError: When `at` or `data` of non-integer type.
"""
- _ldns.ldns_buffer_write_u32_at(self,at,data)
+ _ldns.ldns_buffer_write_u32_at(self, at, data)
#parameters: ldns_buffer *,size_t,uint32_t,
#retvals:
- def write_u8(self,data):
- """writes the given byte of data at the current position in the buffer
+ def write_u8(self, data):
+ """
+ Writes the given byte of data at the current position
+ in the buffer.
- :param data:
- the 8 bits to write
+ :param data: The byte to write.
+ :type data: uint8_t
+ :throws TypeError: When `data` of non-integer type.
"""
- _ldns.ldns_buffer_write_u8(self,data)
- #parameters: ldns_buffer *,uint8_t,
+ _ldns.ldns_buffer_write_u8(self, data)
+ #parameters: ldns_buffer *, uint8_t,
#retvals:
def write_u8_at(self,at,data):
- """writes the given byte of data at the given position in the buffer
+ """
+ Writes the given byte of data at the given position
+ in the buffer.
- :param at:
- the position in the buffer
- :param data:
- the 8 bits to write
+ :param at: The position in the buffer.
+ :type at: positive integer
+ :param data: The byte to write.
+ :type data: uint8_t
+ :throws TypeError: When `at` or `data` of non-integer type.
"""
_ldns.ldns_buffer_write_u8_at(self,at,data)
#parameters: ldns_buffer *,size_t,uint8_t,
#retvals:
- #_LDNS_BUFFER_METHODS#
- %}
+ #
+ # _LDNS_BUFFER_METHODS
+ #
+ %}
}
-
* 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.
+ * 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
* 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.
- ******************************************************************************/
-%pythoncode %{
+ *****************************************************************************/
+
+
+/* ========================================================================= */
+/* SWIG setting and definitions. */
+/* ========================================================================= */
+
+/*
+ * Not here (with the exception of functions defined in this C code sction),
+ * must be set in ldns_rdf.i.
+ */
+
+
+/* ========================================================================= */
+/* Debugging related code. */
+/* ========================================================================= */
+
+/*
+ * Not here (with the exception of functions defined in this C code sction),
+ * must be set in ldns_rdf.i.
+ */
+
+
+/* ========================================================================= */
+/* Added C code. */
+/* ========================================================================= */
+
+/* None */
+
+
+/* ========================================================================= */
+/* Encapsulating Python code. */
+/* ========================================================================= */
+
+%pythoncode
+%{
class ldns_dname(ldns_rdf):
- """Domain name
+ """
+ Domain name.
- This class contains methods to read and manipulate domain names.
- Domain names are stored in ldns_rdf structures, with the type LDNS_RDF_TYPE_DNAME
+ This class contains methods to read and manipulate domain name drfs.
+ Domain names are stored in :class:`ldns_rdf` structures,
+ with the type LDNS_RDF_TYPE_DNAME. This class encapsulates such
+ rdfs.
**Usage**
- >>> import ldns
- >>> resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
- >>> dn1 = ldns.ldns_dname("test.nic.cz")
- >>> print dn1
- test.nic.cz.
- >>> dn2 = ldns.ldns_dname("nic.cz")
- >>> if dn2.is_subdomain(dn1): print dn2,"is subdomain of",dn1
- >>> if dn1.is_subdomain(dn2): print dn1,"is subdomain of",dn2
- test.nic.cz. is subdomain of nic.cz.
+ >>> import ldns
+ >>> dn1 = ldns.ldns_dname("test.nic.cz")
+ >>> print dn1
+ test.nic.cz.
+ >>> dn2 = ldns.ldns_dname("nic.cz")
+ >>> if dn2.is_subdomain(dn1): print dn2, "is sub-domain of", dn1
+ >>> if dn1.is_subdomain(dn2): print dn1, "is sub-domain of", dn2
+ test.nic.cz. is sub-domain of nic.cz.
+
+ The following two examples show the creation of :class:`ldns_dname`
+ from :class:`ldns_rdf`. The first shows the creation of
+ :class:`ldns_dname` instance which is independent of the original
+ `rdf`.
+
+
+ >>> import ldns
+ >>> rdf = ldns.ldns_rdf.new_frm_str("a.ns.nic.cz", ldns.LDNS_RDF_TYPE_DNAME)
+ >>> dn = ldns.ldns_dname(rdf)
+ >>> print dn
+ a.ns.nic.cz.
+
+ The latter shows the wrapping of a :class:`ldns_rdf` onto
+ a :class:`ldns_dname` without the creation of a copy.
+
+ >>> import ldns
+ >>> dn = ldns.ldns_dname(ldns.ldns_rdf.new_frm_str("a.ns.nic.cz", ldns.LDNS_RDF_TYPE_DNAME), clone=False)
+ >>> print dn
+ a.ns.nic.cz.
"""
- def __init__(self, str):
- """Creates a new dname rdf from a string.
+ def __init__(self, initialiser, clone=True):
+ """
+ Creates a new dname rdf from a string or :class:`ldns_rdf`.
- :parameter str: str string to use
+ :param initialiser: string or :class:`ldns_rdf`
+ :type initialiser: string or :class:`ldns_rdf` containing
+ a dname
+ :param clone: Whether to clone or directly grab the parameter.
+ :type clone: bool
+ :throws TypeError: When `initialiser` of invalid type.
"""
- self.this = _ldns.ldns_dname_new_frm_str(str)
+ if isinstance(initialiser, ldns_rdf) and \
+ (initialiser.get_type() == _ldns.LDNS_RDF_TYPE_DNAME):
+ if clone == True:
+ self.this = _ldns.ldns_rdf_clone(initialiser)
+ else:
+ self.this = initialiser
+ else:
+ self.this = _ldns.ldns_dname_new_frm_str(initialiser)
+
+ #
+ # LDNS_DNAME_CONSTRUCTORS_
+ #
@staticmethod
- def new_frm_str(str):
- """Creates a new dname rdf instance from a string.
+ def new_frm_str(string):
+ """
+ Creates a new dname rdf instance from a string.
- This static method is equivalent to using of default class constructor.
+ This static method is equivalent to using default
+ :class:`ldns_dname` constructor.
- :parameter str: str string to use
+ :param string: String to use.
+ :type string: string
+ :throws TypeError: When `string` not a string.
+ :return: (:class:`ldns_dname`) dname rdf.
"""
- return ldns_dname(str)
+ return ldns_dname(string)
+
+ @staticmethod
+ def new_frm_rdf(rdf, clone=True):
+ """
+ Creates a new dname rdf instance from a dname :class:`ldns_rdf`.
+
+ This static method is equivalent to using the default
+ :class:`ldns_dname` constructor.
+
+ :param rdf: A dname :class:`ldns_rdf`.
+ :type rdf: :class:`ldns_rdf`
+ :throws TypeError: When `rdf` of inappropriate type.
+ :param clone: Whether to create a clone or to wrap present
+ instance.
+ :type clone: bool
+ :return: (:class:`ldns_dname`) dname rdf.
+ """
+ return ldns_dname(rdf, clone=clone)
+
+ #
+ # _LDNS_DNAME_CONSTRUCTORS
+ #
+
+ def write_to_buffer(self, buffer):
+ """
+ Copies the dname data to the buffer in wire format.
+
+ :param buffer: Buffer to append the result to.
+ :type param: :class:`ldns_buffer`
+ :throws TypeError: When `buffer` of non-:class:`ldns_buffer`
+ type.
+ :return: (ldns_status) ldns_status
+ """
+ return _ldns.ldns_dname2buffer_wire(buffer, self)
+ #parameters: ldns_buffer *, const ldns_rdf *,
+ #retvals: ldns_status
- def absolute(self):
- """Checks whether the given dname string is absolute (i.e. ends with a '.')
- :returns: (bool) True or False
+ #
+ # LDNS_DNAME_METHODS_
+ #
+
+ def absolute(self):
"""
- return self.endswith(".")
+ Checks whether the given dname string is absolute (i.e.,
+ ends with a '.').
+ :return: (bool) True or False
+ """
+ string = self.__str__()
+ return _ldns.ldns_dname_str_absolute(string) != 0
def make_canonical(self):
- """Put a dname into canonical fmt - ie. lowercase it
+ """
+ Put a dname into canonical format (i.e., convert to lower case).
"""
_ldns.ldns_dname2canonical(self)
- def __cmp__(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.
+ def __cmp__(self, other):
"""
- return _ldns.ldns_dname_compare(self,other)
-
- def write_to_buffer(self,buffer):
- """Copies the dname data to the buffer in wire format.
+ Compares the two dname rdf's according to the algorithm for
+ ordering in RFC4034 Section 6.
- :param buffer: buffer to append the result to
- :returns: (ldns_status) ldns_status
- """
- return _ldns.ldns_dname2buffer_wire(buffer,self)
- #parameters: ldns_buffer *,const ldns_rdf *,
- #retvals: ldns_status
+ :param other: The second dname rdf to compare.
+ :type other: :class:`ldns_dname`
+ :throws TypeError: When `other` of invalid type.
+ :return: (int) -1, 0 or 1 if self comes before other,
+ self is equal or self comes after other respectively.
- #LDNS_DNAME_METHODS_#
+ .. note::
+ The type checking of parameter `other` is benevolent.
+ It allows also to pass a dname :class:`ldns_rdf` object.
+ This will probably change in future.
+ """
+ #
+ # The wrapped function generates asserts instead of setting
+ # error status. They cannot be caught from Python so a check
+ # is necessary.
+ #
+ if (not isinstance(other, ldns_dname)) and \
+ isinstance(other, ldns_rdf) and \
+ other.get_type() == _ldns.LDNS_RDF_TYPE_DNAME:
+ warnings.warn("The ldns_dname.__cmp__() method will" +
+ " drop the possibility to compare ldns_rdf." +
+ " Convert arguments to ldns_dname.",
+ PendingDeprecationWarning, stacklevel=2)
+ if not isinstance(other, ldns_rdf):
+ raise TypeError("Parameter must be derived from ldns_rdf.")
+ if (other.get_type() != _ldns.LDNS_RDF_TYPE_DNAME):
+ raise Exception("Operands must be ldns_dname.")
+ return _ldns.ldns_dname_compare(self, other)
- def cat(self,rd2):
- """concatenates rd2 after this dname (rd2 is copied, this dname is modified)
+ 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
+ :param rd2: The right-hand side.
+ :type rd2: :class:`ldns_dname`
+ :throws TypeError: When `rd2` of invalid type.
+ :return: (ldns_status) LDNS_STATUS_OK on success
+
+ .. note::
+ The type checking of parameter `rd2` is benevolent.
+ It allows also to pass a dname :class:`ldns_rdf` object.
+ This will probably change in future.
"""
- return _ldns.ldns_dname_cat(self,rd2)
- #parameters: ldns_rdf *,ldns_rdf *,
+ if (not isinstance(rd2, ldns_dname)) and \
+ isinstance(rd2, ldns_rdf) and \
+ rd2.get_type() == _ldns.LDNS_RDF_TYPE_DNAME:
+ warnings.warn("The ldns_dname.cat() method will" +
+ " drop the support of ldns_rdf." +
+ " Convert arguments to ldns_dname.",
+ PendingDeprecationWarning, stacklevel=2)
+ return _ldns.ldns_dname_cat(self, rd2)
+ #parameters: ldns_rdf *, ldns_rdf *,
#retvals: ldns_status
- def cat_clone(self,rd2):
- """concatenates two dnames together
+ def cat_clone(self, rd2):
+ """
+ Concatenates two dnames together.
- :param rd2:
- the rightside
- :returns: (ldns_rdf \*) a new rdf with leftside/rightside
+ :param rd2: The right-hand side.
+ :type rd2: :class:`ldns_dname`
+ :throws TypeError: When `rd2` of invalid type.
+ :return: (:class:`ldns_dname`) A new rdf with
+ left-hand side + right-hand side content None when
+ error.
+
+ .. note::
+ The type checking of parameter `rd2` is benevolent.
+ It allows also to pass a dname :class:`ldns_rdf` object.
+ This will probably change in future.
"""
- return _ldns.ldns_dname_cat_clone(self,rd2)
- #parameters: const ldns_rdf *,const ldns_rdf *,
+ if (not isinstance(rd2, ldns_dname)) and \
+ isinstance(rd2, ldns_rdf) and \
+ rd2.get_type() == _ldns.LDNS_RDF_TYPE_DNAME:
+ warnings.warn("The ldns_dname.cat_clone() method will" +
+ " drop the support of ldns_rdf." +
+ " Convert arguments to ldns_dname.",
+ PendingDeprecationWarning, stacklevel=2)
+ ret = _ldns.ldns_dname_cat_clone(self, rd2)
+ if ret != None:
+ ret = ldns_dname(ret, clone=False)
+ return ret
+ #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.
+ def interval(self, middle, next):
+ """
+ Check whether `middle` lays in the interval defined by
+ `this` and `next` (`this` <= `middle` < `next`).
- This is usefull for nsec checking
+ This method is useful 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 *,
+ :param middle: The dname to check.
+ :type middle: :class:`ldns_dname`
+ :param next: The boundary.
+ :type next: :class:`ldns_dname`
+ :throws TypeError: When `middle` or `next` of
+ non-:class:`ldns_rdf` type.
+ :throws Exception: When non-dname rdfs compared.
+ :return: (int) 0 on error or unknown,
+ -1 when middle is in the interval, 1 when not.
+
+ .. note::
+ The type checking of parameters is benevolent.
+ It allows also to pass a dname :class:`ldns_rdf` object.
+ This will probably change in future.
+ """
+ #
+ # The wrapped function generates asserts instead of setting
+ # error status. They cannot be caught from Python so a check
+ # is necessary.
+ #
+ if (not isinstance(middle, ldns_rdf)) or \
+ (not isinstance(next, ldns_rdf)):
+ raise TypeError("Parameters must be derived from ldns_dname.")
+ if (self.get_type() != _ldns.LDNS_RDF_TYPE_DNAME) or \
+ (middle.get_type() != _ldns.LDNS_RDF_TYPE_DNAME) or \
+ (next.get_type() != _ldns.LDNS_RDF_TYPE_DNAME):
+ raise Exception("All operands must be dname rdfs.")
+ if (not isinstance(middle, ldns_dname)) or \
+ (not isinstance(next, ldns_dname)):
+ warnings.warn("The ldns_dname.interval() method will" +
+ " drop the possibility to compare ldns_rdf." +
+ " Convert arguments to ldns_dname.",
+ PendingDeprecationWarning, stacklevel=2)
+ 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).
+ def is_subdomain(self, parent):
+ """
+ Tests whether the name of the instance falls under
+ `parent` (i.e., is a sub-domain 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
+ :param parent: The parent's name.
+ :type parent: :class:`ldns_dname`
+ :throws TypeError: When `parent` of non-:class:`ldns_rdf`
+ or derived type.
+ :return: (bool) True if `this` falls under `parent`, otherwise
+ False.
+
+ .. note::
+ The type checking of parameters is benevolent.
+ It allows also to pass a dname :class:`ldns_rdf` object.
+ This will probably change in future.
"""
- return _ldns.ldns_dname_is_subdomain(self,parent)
- #parameters: const ldns_rdf *,const ldns_rdf *,
+ if (not isinstance(parent, ldns_dname)) and \
+ isinstance(parent, ldns_rdf) and \
+ parent.get_type() == _ldns.LDNS_RDF_TYPE_DNAME:
+ warnings.warn("The ldns_dname.is_subdomain() method will" +
+ " drop the support of ldns_rdf." +
+ " Convert arguments to ldns_dname.",
+ PendingDeprecationWarning, stacklevel=2)
+ 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.
+ def label(self, labelpos):
+ """
+ Look inside the rdf 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
+
+ :param labelpos: Index of the label. (Labels are numbered
+ 0, which is the left most.)
+ :type labelpos: integer
+ :throws TypeError: When `labelpos` of non-integer type.
+ :return: (:class:`ldns_dname`) A new rdf with the label
+ as name or None on error.
"""
- return _ldns.ldns_dname_label(self,labelpos)
- #parameters: const ldns_rdf *,uint8_t,
+ ret = _ldns.ldns_dname_label(self, labelpos)
+ if ret != None:
+ ret = ldns_dname(ret, clone=False)
+ return ret
+ #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.
+ """
+ Counts the number of labels.
- :returns: (uint8_t) the number of labels
+ :return: (uint8_t) the number of labels. Will return 0
+ if not a dname.
"""
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.
+ """
+ Chop one label off the left side of a dname.
- so wwww.nlnetlabs.nl, becomes nlnetlabs.nl
+ (e.g., wwww.nlnetlabs.nl, becomes nlnetlabs.nl)
- :returns: (ldns_rdf \*) the remaining dname
+ :return: (:class:`ldns_dname`) The remaining dname or None
+ when error.
"""
- return _ldns.ldns_dname_left_chop(self)
+ return ldns_dname(_ldns.ldns_dname_left_chop(self), clone=False)
#parameters: const ldns_rdf *,
#retvals: ldns_rdf *
def reverse(self):
- """Returns a clone of the given dname with the labels reversed.
+ """
+ Returns a clone of the given dname with the labels reversed.
- :returns: (ldns_rdf \*) clone of the dname with the labels reversed.
+ :return: (:class:`ldns_dname`) A clone of the dname with
+ the labels reversed.
"""
- return _ldns.ldns_dname_reverse(self)
+ return ldns_dname(_ldns.ldns_dname_reverse(self), clone=False)
#parameters: const ldns_rdf *,
#retvals: ldns_rdf *
- #_LDNS_DNAME_METHODS#
+ #
+ # _LDNS_DNAME_METHODS
+ #
%}
-
/******************************************************************************
- * ldns_rdata.i: LDNS record data
+ * ldns_rdf.i: LDNS record data
*
* Copyright (c) 2009, Zdenek Vasicek (vasicek AT fit.vutbr.cz)
* Karel Slany (slany AT fit.vutbr.cz)
* 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.
+ * 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
* 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 (Python_str_Check($input)) {
-#ifdef SWIG_Python_str_AsChar
- tmp = ldns_dname_new_frm_str(SWIG_Python_str_AsChar($input));
-#else
- tmp = ldns_dname_new_frm_str(PyString_AsString($input));
-#endif
- 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 **)
+/* ========================================================================= */
+/* SWIG setting and definitions. */
+/* ========================================================================= */
+
+/* Creates a temporary instance of (ldns_rdf *). */
+%typemap(in, numinputs=0, noblock=1) (ldns_rdf **)
{
- ldns_rdf *$1_rdf;
- $1 = &$1_rdf;
+ ldns_rdf *$1_rdf = NULL;
+ $1 = &$1_rdf;
}
-// result generation
-%typemap(argout,noblock=1) (ldns_rdf **)
+/* Result generation, appends (ldns_rdf *) after the result. */
+%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 ));
+ $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;
+/*
+ * Automatic conversion of const (ldns_rdf *) parameter from string.
+ * Argument default value.
+ */
+%typemap(arginit, noblock=1) const ldns_rdf *
+{
+ char *$1_str = NULL;
+}
+
+/*
+ * Automatic conversion of const (ldns_rdf *) parameter from string.
+ * Preparation of arguments.
+ */
+%typemap(in, noblock=1) const ldns_rdf * (void* argp, $1_ltype tmp = 0, int res)
+{
+ if (Python_str_Check($input)) {
+ $1_str = SWIG_Python_str_AsChar($input);
+ if ($1_str == NULL) {
+ %argument_fail(SWIG_TypeError, "char *", $symname, $argnum);
+ }
+ tmp = ldns_dname_new_frm_str($1_str);
+ 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;
+ }
+}
+
+/*
+ * Automatic conversion of const (ldns_rdf *) parameter from string.
+ * Freeing of allocated memory (in Python 3 when daling with strings).
+ */
+%typemap(freearg, noblock=1) const ldns_rdf *
+{
+ if ($1_str != NULL) {
+ /* Is not NULL only when a conversion form string occurred. */
+ SWIG_Python_str_DelForPy3($1_str); /* Is a empty macro for Python < 3. */
+ }
+}
+
+%nodefaultctor ldns_struct_rdf; /* No default constructor. */
+%nodefaultdtor ldns_struct_rdf; /* No default destructor. */
+
+
+/*
+ * This file must contain all %newobject and %delobject tags also for
+ * ldns_dname. This is because the ldns_dname us a derived class from ldns_rdf.
+ */
-%newobject ldns_dname_new;
-%newobject ldns_dname_new_frm_str;
-%newobject ldns_dname_new_frm_data;
%newobject ldns_rdf_new;
%newobject ldns_rdf_new_frm_str;
%newobject ldns_rdf_new_frm_data;
+%newobject ldns_rdf_address_reverse;
+%newobject ldns_rdf_clone;
+%newobject ldns_rdf2str;
+
+%newobject ldns_dname_new;
+%newobject ldns_dname_new_frm_str;
+%newobject ldns_dname_new_frm_data;
+
+%newobject ldns_dname_cat_clone;
+%newobject ldns_dname_label;
+%newobject ldns_dname_left_chop;
+%newobject ldns_dname_reverse;
+
%delobject ldns_rdf_deep_free;
%delobject ldns_rdf_free;
+
+/*
+ * Should the ldns_rdf_new() should also be marked as deleting its data
+ * parameter?
+ */
+%delobject ldns_rdf_set_data; /* Because data are directly coupled into rdf. */
+
%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;
-}
-%}
+/* ========================================================================= */
+/* Debugging related code. */
+/* ========================================================================= */
#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);
-}
+%inline
+%{
+ /*!
+ * @brief Prints information about deallocated rdf and deallocates.
+ */
+ void _ldns_rdf_deep_free (ldns_rdf *r)
+ {
+ printf("******** LDNS_RDF deep free 0x%lX ************\n",
+ (long unsigned int) r);
+ ldns_rdf_deep_free(r);
+ }
+
+ /*!
+ * @brief Prints information about deallocated rdf and deallocates.
+ */
+ void _ldns_rdf_free (ldns_rdf* r)
+ {
+ printf("******** LDNS_RDF free 0x%lX ************\n",
+ (long unsigned int) r);
+ ldns_rdf_free(r);
+ }
%}
-#else
+#else /* !LDNS_DEBUG */
%rename(_ldns_rdf_deep_free) ldns_rdf_deep_free;
%rename(_ldns_rdf_free) ldns_rdf_free;
-#endif
+#endif /* LDNS_DEBUG */
%newobject ldns_rdf2str;
+/* ========================================================================= */
+/* Added C code. */
+/* ========================================================================= */
+
+
+%inline
+%{
+ /*!
+ * @brief returns a human readable string containing rdf type.
+ */
+ 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_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_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_PERIOD: return "PERIOD";
+ case LDNS_RDF_TYPE_TSIGTIME: return "TSIGTIME";
+ case LDNS_RDF_TYPE_TSIG: return "TSIG";
+ case LDNS_RDF_TYPE_INT16_DATA: return "INT16_DATA";
+ case LDNS_RDF_TYPE_SERVICE: return "SERVICE";
+ case LDNS_RDF_TYPE_LOC: return "LOC";
+ case LDNS_RDF_TYPE_WKS: return "WKS";
+ 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_NSEC3_SALT: return "NSEC3_SALT";
+ case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER:
+ return "NSEC3_NEXT_OWNER";
+ }
+ }
+ return 0;
+ }
+%}
+
+
+/* ========================================================================= */
+/* Encapsulating Python code. */
+/* ========================================================================= */
+
%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."
+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 %{
+ %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")
+ """
+ Cannot be created directly from Python.
+ """
+ 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_deep_free
- #LDNS_RDF_CONSTRUCTORS_#
+ #
+ # LDNS_RDF_CONSTRUCTORS_
+ #
+
@staticmethod
- def new_frm_str(str, rr_type, raiseException = True):
- """Creates a new rdf from a string of a given type.
+ def new_frm_str(string, 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.
+ :param string: string to use
+ :type string: string
+ :param rr_type: The type of the rdf. See predefined `RDF_TYPE_`
+ constants.
+ :type rr_type: integer
+ :param raiseException: If True, an exception occurs in case
+ a RDF object can't be created.
+ :type raiseException: bool
+ :throws TypeError: When parameters of mismatching types.
+ :throws Exception: When raiseException set and rdf couldn't
+ be created.
+ :return: :class:`ldns_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)
+
+ >>> 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, string)
+ if (not rr) and raiseException:
+ raise Exception("Can't create query packet, " +
+ "error: %d" % status)
return rr
- #_LDNS_RDF_CONSTRUCTORS#
+
+ #
+ # _LDNS_RDF_CONSTRUCTORS
+ #
def __str__(self):
- """Converts the rdata field to presentation format"""
+ """
+ Converts the rdata field to presentation format.
+ """
return _ldns.ldns_rdf2str(self)
- def __cmp__(self,other):
- """compares two rdf's on their wire formats.
+ def __cmp__(self, other):
+ """
+ Compares two rdf's on their wire formats.
- (To order dnames according to rfc4034, use ldns_dname_compare)
+ (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
+ :param other: The second one RDF.
+ :type other: :class:`ldns_rdf`
+ :throws TypeError: When other of non-:class:`ldns_rdf` type.
+ :return: (int) -1, 0 or 1 if self comes before other,
+ is equal or self comes after other respectively.
"""
- return _ldns.ldns_rdf_compare(self,other)
+ 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 print_to_file(self, output):
+ """
+ Prints the data in the rdata field to the given `output` file
+ stream (in presentation format).
+ """
+ _ldns.ldns_rdf_print(output, self)
def get_type_str(self):
- """Converts type to string"""
+ """
+ Returns the type of the rdf as a human readable string.
+
+ :return: String containing rdf type.
+ """
return ldns_rdf_type2str(self)
def write_to_buffer(self, buffer):
- """Copies the rdata data to the buffer in wire format.
+ """
+ Copies the rdata data to the buffer in wire format.
- :param buffer: buffer to append the result to
- :returns: (ldns_status) ldns_status
+ :param buffer: Buffer to append the rdf to.
+ :type param: :class:`ldns_buffer`
+ :throws TypeError: When `buffer` of non-:class:`ldns_buffer`
+ type.
+ :return: (ldns_status) ldns_status
"""
return _ldns.ldns_rdf2buffer_wire(buffer, self)
- #parameters: ldns_buffer *,const ldns_rdf *,
+ #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.
+ """
+ Copies the rdata data to the buffer in wire format.
+ If the rdata is a dname, the letters will be converted
+ to lower case during the conversion.
- :param buffer: LDNS buffer
- :returns: (ldns_status) ldns_status
+ :param buffer: LDNS buffer.
+ :type buffer: :class:`ldns_buffer`
+ :throws TypeError: When `buffer` of non-:class:`ldns_buffer`
+ type.
+ :return: (ldns_status) ldns_status
"""
return _ldns.ldns_rdf2buffer_wire_canonical(buffer, self)
- #parameters: ldns_buffer *,const ldns_rdf *,
+ #parameters: ldns_buffer *, const ldns_rdf *,
#retvals: ldns_status
- #LDNS_RDF_METHODS_#
+ #
+ # LDNS_RDF_METHODS_
+ #
+
def address_reverse(self):
- """reverses an rdf, only actually useful for AAAA and A records.
+ """
+ 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: (:class:`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.
+ """
+ Clones a rdf structure.
- The data is copied.
+ The data are copied.
- :returns: (ldns_rdf \*) a new rdf structure
+ :return: (:class:`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 the data of the rdf.
- :returns: (uint8_t \*) uint8_t* pointer to the rdf's data
+ :return: (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.
+ """
+ Returns the type of the rdf.
- We need to insert _get_ here to prevent conflict the the rdf_type TYPE.
+ We need to prepend the prefix get_ here to prevent conflict
+ with the rdf_type TYPE.
- :returns: (ldns_rdf_type) ldns_rdf_type with the type
+ :return: (ldns_rdf_type) Identifier of 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.
+ def set_data(self, data):
+ """
+ Sets the data portion of the rdf.
+
+ The data are not copied, but are assigned to the rdf,
+ `data` are decoupled from the Python engine.
- :param data:
+ :param data: Data to be set.
+ :type data: void \*
"""
- _ldns.ldns_rdf_set_data(self,data)
- #parameters: ldns_rdf *,void *,
+ _ldns.ldns_rdf_set_data(self, data)
+ #parameters: ldns_rdf *, void *,
#retvals:
- def set_size(self,size):
- """sets the size of the rdf.
+ def set_size(self, size):
+ """
+ Sets the size of the rdf.
- :param size:
- the new size
+ :param size: The new size.
+ :type size: integer
+ :throws TypeError: When size of non-integer type.
"""
_ldns.ldns_rdf_set_size(self,size)
#parameters: ldns_rdf *,size_t,
#retvals:
- def set_type(self,atype):
- """sets the size of the rdf.
+ def set_type(self, atype):
+ """
+ Sets the type of the rdf.
- :param atype:
+ :param atype: rdf type
+ :type atype: integer
+ :throws TypeError: When atype of non-integer type.
"""
- _ldns.ldns_rdf_set_type(self,atype)
- #parameters: ldns_rdf *,ldns_rdf_type,
+ _ldns.ldns_rdf_set_type(self, atype)
+ #parameters: ldns_rdf *, ldns_rdf_type,
#retvals:
def size(self):
- """returns the size of the rdf.
+ """
+ Returns the size of the rdf.
- :returns: (size_t) uint16_t with the size
+ :return: (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.
+ def dname_new_frm_str(string):
+ """
+ Creates a new dname rdf instance from a given string.
- This static method is equivalent to using of default class constructor.
+ This static method is equivalent to using of default
+ :class:`ldns_rdf` constructor.
- :parameter str: str string to use
+ :parameter string: String to use.
+ :type string: string
+ :throws TypeError: When not a string used.
+ :return: :class:`ldns_rdf` or None if error.
+
+ .. warning::
+
+ It is scheduled to be deprecated and removed. Use
+ :class:`ldns_dname` constructor instead.
"""
- return _ldns.ldns_dname_new_frm_str(str)
+ warnings.warn("The ldns_rdf.dname_new_frm_str() method is" +
+ " scheduled to be deprecated in future releases." +
+ " Use ldsn_dname constructor instead.",
+ PendingDeprecationWarning, stacklevel=2)
+ return _ldns.ldns_dname_new_frm_str(string)
def absolute(self):
- """Checks whether the given dname string is absolute (i.e. ends with a '.')
+ """
+ Checks whether the given dname string is absolute
+ (i.e., ends with a '.').
+
+ :return: (bool) True or False
+
+ .. note::
- :returns: (bool) True or False
+ This method was malfunctioning in ldns-1.3.16 and also
+ possibly earlier.
+
+ .. warning::
+
+ It is scheduled to be deprecated and removed. Convert
+ :class:`ldns_rdf` to :class:`ldns_dname` to use the method.
"""
- return self.endswith(".")
+ warnings.warn("The ldns_rdf.absolute() method is scheduled" +
+ " to be deprecated in future releases." +
+ " Convert the ldns_rdf to ldsn_dname and the use its" +
+ " methods.", PendingDeprecationWarning, stacklevel=2)
+ if self.get_type() == _ldns.LDNS_RDF_TYPE_DNAME:
+ string = self.__str__()
+ return _ldns.ldns_dname_str_absolute(string) != 0
+ else:
+ return False
def make_canonical(self):
- """Put a dname into canonical fmt - ie. lowercase it
"""
+ Put a dname into canonical format (i.e., convert to lower case).
+
+ Performs no action if not a dname.
+
+ .. warning::
+
+ This method is scheduled to be deprecated and removed.
+ Convert :class:`ldns_rdf` to :class:`ldns_dname` to use
+ the method.
+ """
+ warnings.warn("The ldns_rdf.make_canonical() method is scheduled" +
+ " to be deprecated in future releases." +
+ " Convert the ldns_rdf to ldsn_dname and the use its" +
+ " methods.", PendingDeprecationWarning, stacklevel=2)
_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.
+ def dname_compare(self, other):
"""
- return _ldns.ldns_dname_compare(self,other)
+ Compares the two dname rdf's according to the algorithm
+ for ordering in RFC4034 Section 6.
- def cat(self,rd2):
- """concatenates rd2 after this dname (rd2 is copied, this dname is modified)
+ :param other: The second dname rdf to compare.
+ :type other: :class:`ldns_rdf`
+ :throws TypeError: When not a :class:`ldns_rdf` used.
+ :throws Exception: When not dnames compared.
+ :return: (int) -1, 0 or 1 if self comes before other,
+ self is equal or self comes after other respectively.
+
+ .. warning::
+
+ It is scheduled to be deprecated and removed. Convert
+ :class:`ldns_rdf` to :class:`ldns_dname`.
+ """
+ warnings.warn("The ldns_rdf.dname_compare() method is" +
+ " scheduled to be deprecated in future releases." +
+ " Convert the ldns_rdf to ldsn_dname and the use its" +
+ " methods.", PendingDeprecationWarning, stacklevel=2)
+ #
+ # The wrapped function generates asserts instead of setting
+ # error status. They cannot be caught from Python so a check
+ # is necessary.
+ #
+ if not isinstance(other, ldns_rdf):
+ raise TypeError("Parameter must be derived from ldns_rdf.")
+ if (self.get_type() != _ldns.LDNS_RDF_TYPE_DNAME) or \
+ (other.get_type() != _ldns.LDNS_RDF_TYPE_DNAME):
+ raise Exception("Both operands must be dname rdfs.")
+ 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
+ :param rd2: The right-hand side.
+ :type rd2: :class:`ldns_rdf`
+ :throws TypeError: When `rd2` of non-:class:`ldns_rdf` or
+ non-:class:`ldns_dname` type.
+ :return: (ldns_status) LDNS_STATUS_OK on success.
+
+ .. warning::
+
+ It is scheduled to be deprecated and removed. Convert
+ :class:`ldns_rdf` to :class:`ldns_dname`.
"""
- return _ldns.ldns_dname_cat(self,rd2)
- #parameters: ldns_rdf *,ldns_rdf *,
+ warnings.warn("The ldns_rdf.cat() method is scheduled" +
+ " to be deprecated in future releases." +
+ " Convert the ldns_rdf to ldsn_dname and the use its" +
+ " methods.", PendingDeprecationWarning, stacklevel=2)
+ 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
+ def cat_clone(self, rd2):
"""
- return _ldns.ldns_dname_cat_clone(self,rd2)
- #parameters: const ldns_rdf *,const ldns_rdf *,
+ Concatenates two dnames together.
+
+ :param rd2: The right-hand side.
+ :type rd2: :class:`ldns_rdf`
+ :throws TypeError: When `rd2` of non-:class:`ldns_rdf` or
+ non-:class:`ldns_dname` type.
+ :return: (:class:`ldns_rdf`) A new rdf with
+ left-hand side + right-hand side content None when
+ error.
+
+ .. warning::
+
+ It is scheduled to be deprecated and removed. Convert
+ :class:`ldns_rdf` to :class:`ldns_dname`.
+ """
+ warnings.warn("The ldns_rdf.cat_clone() method is scheduled" +
+ " to be deprecated in future releases." +
+ " Convert the ldns_rdf to ldsn_dname and the use its" +
+ " methods.", PendingDeprecationWarning, stacklevel=2)
+ 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 *,
+ def interval(self, middle, next):
+ """
+ Check whether the `middle` lays in the interval defined by
+ `this` and `next` (`this` <= `middle` < `next`).
+
+ This method is useful for nsec checking
+
+ :param middle: The dname to check.
+ :type middle: :class:`ldns_rdf`
+ :param next: The boundary.
+ :type next: :class:`ldns_rdf`
+ :throws TypeError: When `middle` or `next` of
+ non-:class:`ldns_rdf` type.
+ :throws Exception: When non-dname rdfs compared.
+ :return: (int) 0 on error or unknown,
+ -1 when middle is in the interval, 1 when not.
+
+ .. warning::
+
+ It is scheduled to be deprecated and removed. Convert
+ :class:`ldns_rdf` to :class:`ldns_dname`.
+ """
+ warnings.warn("The ldns_rdf.interval() method is scheduled" +
+ " to be deprecated in future releases." +
+ " Convert the ldns_rdf to ldsn_dname and the use its" +
+ " methods.", PendingDeprecationWarning, stacklevel=2)
+ #
+ # The wrapped function generates asserts instead of setting
+ # error status. They cannot be caught from Python so a check
+ # is necessary.
+ #
+ if (not isinstance(middle, ldns_rdf)) or \
+ (not isinstance(next, ldns_rdf)):
+ raise TypeError("Parameters must be derived from ldns_rdf.")
+ if (self.get_type() != _ldns.LDNS_RDF_TYPE_DNAME) or \
+ (middle.get_type() != _ldns.LDNS_RDF_TYPE_DNAME) or \
+ (next.get_type() != _ldns.LDNS_RDF_TYPE_DNAME):
+ raise Exception("All operands must be dname rdfs.")
+ 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).
+ def is_subdomain(self, parent):
+ """
+ Tests whether the name of the given instance falls under
+ `parent` (i.e., is a sub-domain of `parent`).
- This function will return false if the given dnames are equal.
+ 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
+ :param parent: The parent's name.
+ :type parent: :class:`ldns_rdf`
+ :throws TypeError: When `parent` of non-:class:`ldns_rdf` type.
+ :return: (bool) True if `this` falls under `parent`, otherwise
+ False.
+
+ .. warning::
+
+ It is scheduled to be deprecated and removed. Convert
+ :class:`ldns_rdf` to :class:`ldns_dname`.
"""
- return _ldns.ldns_dname_is_subdomain(self,parent)
- #parameters: const ldns_rdf *,const ldns_rdf *,
+ warnings.warn("The ldns_rdf.is_subdomain() method is scheduled" +
+ " to be deprecated in future releases." +
+ " Convert the ldns_rdf to ldsn_dname and the use its" +
+ " methods.", PendingDeprecationWarning, stacklevel=2)
+ 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.
+ 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
+ :param labelpos: Index of the label. (Labels are numbered
+ 0, which is the left most.)
+ :type labelpos: integer
+ :throws TypeError: When `labelpos` of non-integer type.
+ :return: (:class:`ldns_rdf`) A new rdf with the label
+ as name or None on error.
+
+ .. warning::
+
+ It is scheduled to be deprecated and removed. Convert
+ :class:`ldns_rdf` to :class:`ldns_dname`.
"""
- return _ldns.ldns_dname_label(self,labelpos)
- #parameters: const ldns_rdf *,uint8_t,
+ warnings.warn("The ldns_rdf.label() method is scheduled" +
+ " to be deprecated in future releases." +
+ " Convert the ldns_rdf to ldsn_dname and the use its" +
+ " methods.", PendingDeprecationWarning, stacklevel=2)
+ 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.
+ """
+ Count the number of labels inside a LDNS_RDF_DNAME type rdf.
- :returns: (uint8_t) the number of labels
+ :return: (uint8_t) The number of labels. Will return 0 if
+ not a dname.
+
+ .. warning::
+
+ It is scheduled to be deprecated and removed. Convert
+ :class:`ldns_rdf` to :class:`ldns_dname`.
"""
+ warnings.warn("The ldns_rdf.label_count() method is scheduled" +
+ " to be deprecated in future releases." +
+ " Convert the ldns_rdf to ldsn_dname and the use its" +
+ " methods.", PendingDeprecationWarning, stacklevel=2)
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.
+ """
+ Chop one label off the left side of a dname.
- so wwww.nlnetlabs.nl, becomes nlnetlabs.nl
+ (e.g., wwww.nlnetlabs.nl, becomes nlnetlabs.nl)
- :returns: (ldns_rdf \*) the remaining dname
+ :return: (:class:`ldns_rdf`) The remaining dname or None when
+ error.
+
+ .. warning::
+
+ It is scheduled to be deprecated and removed. Convert
+ :class:`ldns_rdf` to :class:`ldns_dname`.
"""
+ warnings.warn("The ldns_rdf.left_chop() method is scheduled" +
+ " to be deprecated in future releases." +
+ " Convert the ldns_rdf to ldsn_dname and the use its" +
+ " methods.", PendingDeprecationWarning, stacklevel=2)
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 a clone of the given dname with the labels reversed.
+
+ When reversing non-dnames a "." (root name) dname is returned.
- :returns: (ldns_rdf \*) clone of the dname with the labels reversed.
+ :return: (:class:`ldns_rdf`) Clone of the dname with the labels
+ reversed or ".".
+
+ .. warning::
+
+ It is scheduled to be deprecated and removed. Convert
+ :class:`ldns_rdf` to :class:`ldns_dname`.
"""
+ warnings.warn("The ldns_rdf.reverse() method is scheduled" +
+ " to be deprecated in future releases." +
+ " Convert the ldns_rdf to ldsn_dname and the use its" +
+ " methods.", PendingDeprecationWarning, stacklevel=2)
return _ldns.ldns_dname_reverse(self)
#parameters: const ldns_rdf *,
#retvals: ldns_rdf *
- #_LDNS_RDF_METHODS#
- %}
+ #
+ # _LDNS_RDF_METHODS
+ #
+ %}
}
%rename(__ldns_rr_list_deep_free) ldns_rr_list_deep_free;
%rename(__ldns_rr_list_free) ldns_rr_list_free;
%inline %{
-void _ldns_rr_list_free(ldns_rr_list* r) {
+void _ldns_rr_list_deep_free(ldns_rr_list* r) {
printf("******** LDNS_RR_LIST deep free 0x%lX ************\n", (long unsigned int)r);
ldns_rr_list_deep_free(r);
}
+
+void _ldns_rr_list_free(ldns_rr_list* r) {
+ printf("******** LDNS_RR_LIST deep free 0x%lX ************\n", (long unsigned int)r);
+ ldns_rr_list_free(r);
+}
%}
#else
%rename(_ldns_rr_list_deep_free) ldns_rr_list_deep_free;
projects / thirdparty / ldns.git / commitdiff
