Update var.py

When multiple filter expressions are defined:
GAM_CSV_ROW_FILTER - should match only if all expressions match
GAM_CSV_ROW_DROP_FILTER - should match if any expression matches

Currently, the opposite is true

.github/ISSUE_TEMPLATE.txt

@@ -5,7 +5,7 @@ Please confirm the following:
 * I am typing the command as described in the GAM Wiki at https://github.com/jay0lee/gam/wiki
 
 Full steps to reproduce the issue:
-1. 
+1.
 2.
 3.
 

.github/ISSUE_TEMPLATE/aa-question.md

@@ -0,0 +1,14 @@
+---
+name: Question about using GAM
+about: Help with using GAM or running it for the first time
+title: Please use the GAM discussion group
+labels: invalid
+assignees: ''
+
+---
+
+If you need help with GAM, please do not file an issue here, it will be closed and ignored.
+
+Please post your question to the GAM discussion group where other admins are ready and willing to help:
+
+https://groups.google.com/g/google-apps-manager

.github/ISSUE_TEMPLATE/za-bug-report.md

@@ -0,0 +1,23 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: jay0lee
+
+---
+
+The issue tracker is for reporting product deficiencies. "How do I?" questions should be posted to the discussion forum at https://groups.google.com/group/google-apps-manager. When in doubt, start at the discussion forum and return here only when instructed to do so.
+
+Please confirm the following:
+* I have upgraded to the latest GAM release from https://git.io/gamreleases and I still have this issue.
+* I am typing the command as described in the GAM Wiki at https://github.com/jay0lee/gam/wiki
+
+Full steps to reproduce the issue:
+1.
+2.
+3.
+
+Expected outcome (what are you trying to do?):
+
+Actual outcome (what errors or bad behavior do you see instead?):

.github/ISSUE_TEMPLATE/zz-feature-request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for GAM
+title: ''
+labels: enhancement
+assignees: jay0lee
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/actions/decrypt.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+
+gpgfile="$1"
+echo "source file is ${gpgfile}"
+credsfile="$2"
+echo "target file is ${credsfile}"
+if [ -z ${PASSCODE+x} ]; then
+  echo "PASSCODE is unset";
+else
+  echo "PASSCODE is set";
+fi
+
+gpg --quiet --batch --yes --decrypt --passphrase="${PASSCODE}" \
+    --output "${credsfile}" "${gpgfile}"
+
+tar xvvf "${credsfile}" --directory "${gampath}"
+ls -l "${gampath}"

.github/actions/linux-before-install.sh

@@ -0,0 +1,113 @@
+echo "RUNNING: apt update..."
+sudo apt-get -qq --yes update > /dev/null
+sudo apt-get -qq --yes install swig libpcsclite-dev
+if [[ "$TRAVIS_JOB_NAME" == *"Testing" ]]; then
+  export python="python"
+  export pip="pip"
+  echo "Travis setup Python $TRAVIS_PYTHON_VERSION"
+  echo "running tests with this version"
+else
+  export whereibelong=$(pwd)
+  echo "We are running on $ImageOS $ImageVersion"
+  export LD_LIBRARY_PATH=~/ssl/lib:~/python/lib
+  cpucount=$(nproc --all)
+  echo "This device has $cpucount CPUs for compiling..."
+  SSLVER=$(~/ssl/bin/openssl version)
+  SSLRESULT=$?
+  PYVER=$(~/python/bin/python3 -V)
+  PYRESULT=$?
+  if [ $SSLRESULT -ne 0 ] || [[ "$SSLVER" != "OpenSSL $BUILD_OPENSSL_VERSION "* ]] || [ $PYRESULT -ne 0 ] || [[ "$PYVER" != "Python $BUILD_PYTHON_VERSION"* ]]; then
+    echo "SSL Result: $SSLRESULT - SSL Ver: $SSLVER - Py Result: $PYRESULT - Py Ver: $PYVER"
+    if [ $SSLRESULT -ne 0 ]; then
+      echo "sslresult -ne 0"
+    fi
+    if [[ "$SSLVER" != "OpenSSL $BUILD_OPENSSL_VERSION "* ]]; then
+      echo "sslver not equal to..."
+    fi
+    if [ $PYRESULT -ne 0 ]; then
+      echo "pyresult -ne 0"
+    fi
+    if [[ "$PYVER" != "Python $BUILD_PYTHON_VERSION" ]]; then
+      echo "pyver not equal to..."
+    fi
+    cd ~
+    rm -rf ssl
+    rm -rf python
+    mkdir ssl
+    mkdir python
+    echo "RUNNING: apt upgrade..."
+    sudo apt-mark hold openssh-server
+    sudo apt-get --yes upgrade
+    sudo apt-get --yes --with-new-pkgs upgrade
+    echo "Installing build tools..."
+    sudo apt-get -qq --yes install build-essential
+    echo "Installing deps for python3"
+    sudo cp -v /etc/apt/sources.list /tmp
+    sudo chmod a+rwx /tmp/sources.list
+    echo "deb-src http://archive.ubuntu.com/ubuntu/ $TRAVIS_DIST main" >> /tmp/sources.list
+    sudo cp -v /tmp/sources.list /etc/apt
+    sudo apt-get -qq --yes update > /dev/null
+    sudo apt-get -qq --yes build-dep python3 > /dev/null
+
+    # Compile latest OpenSSL
+    wget --quiet https://www.openssl.org/source/openssl-$BUILD_OPENSSL_VERSION.tar.gz
+    echo "Extracting OpenSSL..."
+    tar xf openssl-$BUILD_OPENSSL_VERSION.tar.gz
+    cd openssl-$BUILD_OPENSSL_VERSION
+    echo "Compiling OpenSSL $BUILD_OPENSSL_VERSION..."
+    ./config shared --prefix=$HOME/ssl
+    echo "Running make for OpenSSL..."
+    make -j$cpucount -s
+    echo "Running make install for OpenSSL..."
+    make install > /dev/null
+    cd ~
+
+    # Compile latest Python
+    echo "Downloading Python $BUILD_PYTHON_VERSION..."
+    curl -O https://www.python.org/ftp/python/$BUILD_PYTHON_VERSION/Python-$BUILD_PYTHON_VERSION.tar.xz
+    echo "Extracting Python..."
+    tar xf Python-$BUILD_PYTHON_VERSION.tar.xz
+    cd Python-$BUILD_PYTHON_VERSION
+    echo "Compiling Python $BUILD_PYTHON_VERSION..."
+    safe_flags="--with-openssl=$HOME/ssl --enable-shared --prefix=$HOME/python --with-ensurepip=upgrade"
+    unsafe_flags="--enable-optimizations --with-lto"
+    if [ ! -e Makefile ]; then
+      echo "running configure with safe and unsafe"
+      ./configure $safe_flags $unsafe_flags > /dev/null
+    fi
+    #make -j$cpucount PROFILE_TASK="-m test.regrtest --pgo -j$(( $cpucount * 2 ))" -s
+    make -j$cpucount -s
+    RESULT=$?
+    echo "First make exited with $RESULT"
+    if [ $RESULT != 0 ]; then
+      echo "Trying Python compile again without unsafe flags..."
+      make clean
+      ./configure $safe_flags > /dev/null
+      make -j$cpucount -s
+      echo "Sticking with safe Python for now..."
+    fi
+    echo "Installing Python..."
+    make install > /dev/null
+    cd ~
+  fi
+
+  python=~/python/bin/python3
+  pip=~/python/bin/pip3
+
+  if ([ "${ImageOS}" == "ubuntu20" ]) && [ "${HOSTTYPE}" == "x86_64" ]; then
+    echo "Installing deps for StaticX..."
+    if [ ! -d patchelf-$PATCHELF_VERSION ]; then
+      echo "Downloading PatchELF $PATCHELF_VERSION"
+      wget https://github.com/NixOS/patchelf/archive/$PATCHELF_VERSION.tar.gz 
+      tar xf $PATCHELF_VERSION.tar.gz
+      cd patchelf-$PATCHELF_VERSION/
+      ./bootstrap.sh
+      ./configure
+      make
+      sudo make install
+    fi
+    $pip install staticx
+  fi
+
+  cd $whereibelong
+fi

.github/actions/linux-install.sh

@@ -0,0 +1,34 @@
+export distpath="dist/"
+export gampath="${distpath}gam"
+rm -rf $gampath
+#mkdir -p $gampath
+#export gampath=$(readlink -e $gampath)
+$pip install wheel
+$python -OO -m PyInstaller --clean --noupx --strip --distpath $gampath gam.spec
+export gam="${gampath}/gam"
+export GAMVERSION=`$gam version simple`
+cp LICENSE $gampath
+cp GamCommands.txt $gampath
+this_glibc_ver=$(ldd --version | awk '/ldd/{print $NF}')
+GAM_ARCHIVE="gam-${GAMVERSION}-${GAMOS}-${PLATFORM}-glibc${this_glibc_ver}.tar.xz"
+rm $gampath/lastupdatecheck.txt
+# tar will cd to dist and tar up gam/
+tar -C ${distpath} --create --file $GAM_ARCHIVE --xz gam
+echo "PyInstaller GAM info:"
+du -h $gam
+time $gam version extended
+if ([ "${ImageOS}" == "ubuntu20" ]) && [ "${HOSTTYPE}" == "x86_64" ]; then
+  GAM_LEGACY_ARCHIVE=gam-${GAMVERSION}-${GAMOS}-${PLATFORM}-legacy.tar.xz
+  $python -OO -m staticx $gam $gam-staticx
+  #strip $gam-staticx
+  rm $gampath/gam
+  mv $gam-staticx $gam
+  chmod 755 $gam
+  rm $gampath/lastupdatecheck.txt
+  tar -C dist/ --create --file $GAM_LEGACY_ARCHIVE --xz gam
+  echo "Legacy StaticX GAM info:"
+  du -h $gam
+  time $gam version extended
+fi
+echo "GAM packages:"
+ls -l gam-*.tar.xz

.github/actions/macos-before-install.sh

@@ -0,0 +1,132 @@
+mypath=$HOME
+whereibelong=$(pwd)
+cpucount=$(sysctl -n hw.ncpu)
+echo "This device has $cpucount CPUs for compiling..."
+
+#echo "Brew installing xz..."
+#brew install xz > /dev/null
+
+#brew upgrade
+
+brew install coreutils
+brew install bash
+
+# prefer standard GNU tools like date over MacOS defaults
+export PATH="/usr/local/opt/coreutils/libexec/gnubin:$(brew --prefix)/opt/gnu-tar/libexec/gnubin:$PATH"
+
+date --version
+gdate --version
+bash --version
+
+cd ~
+
+# Use official Python.org version of Python which is backwards compatible
+# with older MacOS versions
+export pyfile=python-$BUILD_PYTHON_VERSION-macos11.pkg
+
+wget https://www.python.org/ftp/python/$BUILD_PYTHON_VERSION/$pyfile
+echo "installing Python $BUILD_PYTHON_VERSION..."
+sudo installer -pkg ./$pyfile -target /
+
+# This fixes https://github.com/pyinstaller/pyinstaller/issues/5062
+codesign --remove-signature /Library/Frameworks/Python.framework/Versions/3.9/Python
+
+#if [ ! -f python-$MIN_PYTHON_VERSION-macosx10.9.pkg ]; then
+#  wget --quiet https://www.python.org/ftp/python/$MIN_PYTHON_VERSION/python-$MIN_PYTHON_VERSION-macosx10.9.pkg
+#fi
+#sudo installer -pkg python-$MIN_PYTHON_VERSION-macosx10.9.pkg -target /
+
+#brew install openssl@1.1
+#brew upgrade python
+
+#export python=python3
+#export pip=pip3
+
+#echo "Python location:"
+#which $python
+
+cd ~
+
+#export LD_LIBRARY_PATH=~/ssl/lib:~/python/lib
+#export openssl=~/ssl/bin/openssl
+#export python=~/python/bin/python3
+#export pip=~/python/bin/pip3
+
+export python=/usr/local/bin/python3
+export pip=/usr/local/bin/pip3
+SSLVER=$($openssl version)
+SSLRESULT=$?
+PYVER=$($python -V)
+PYRESULT=$?
+
+brew install swig
+$pip install pyscard
+
+#wget --quiet https://www.python.org/ftp/python/$BUILD_PYTHON_VERSION/python-$BUILD_PYTHON_VERSION-macosx10.9.pkg
+
+#if [ $SSLRESULT -ne 0 ] || [[ "$SSLVER" != "OpenSSL $BUILD_OPENSSL_VERSION "* ]] || [ $PYRESULT -ne 0 ] || [[ "$PYVER" != "Python $BUILD_PYTHON_VERSION"* ]]; then
+#  echo "SSL Result: $SSLRESULT - SSL Ver: $SSLVER - Py Result: $PYRESULT - Py Ver: $PYVER"
+#  if [ $SSLRESULT -ne 0 ]; then
+#    echo "sslresult -ne 0"
+#  fi
+#  if [[ "$SSLVER" != "OpenSSL $BUILD_OPENSSL_VERSION "* ]]; then
+#    echo "sslver not equal to..."
+#  fi
+#  if [ $PYRESULT -ne 0 ]; then
+#    echo "pyresult -ne 0"
+#  fi
+#  if [[ "$PYVER" != "Python $BUILD_PYTHON_VERSION" ]]; then
+#    echo "pyver not equal to..."
+#  fi
+
+  # Start clean
+ # rm -rf python
+ # rm -rf ssl
+ # mkdir python
+ # mkdir ssl
+
+  # Compile latest OpenSSL
+#  wget --quiet https://www.openssl.org/source/openssl-$BUILD_OPENSSL_VERSION.tar.gz
+#  echo "Extracting OpenSSL..."
+#  tar xf openssl-$BUILD_OPENSSL_VERSION.tar.gz
+#  cd openssl-$BUILD_OPENSSL_VERSION
+#  echo "Compiling OpenSSL $BUILD_OPENSSL_VERSION..."
+#  ./config shared --prefix=$HOME/ssl
+#  echo "Running make for OpenSSL..."
+#  make -j$cpucount -s
+#  echo "Running make install for OpenSSL..."
+#  make install > /dev/null
+#  cd ~
+
+  # Compile latest Python
+#  echo "Downloading Python $BUILD_PYTHON_VERSION..."
+#  curl -O https://www.python.org/ftp/python/$BUILD_PYTHON_VERSION/Python-$BUILD_PYTHON_VERSION.tar.xz
+#  echo "Extracting Python..."
+#  tar xf Python-$BUILD_PYTHON_VERSION.tar.xz
+#  cd Python-$BUILD_PYTHON_VERSION
+#  echo "Compiling Python $BUILD_PYTHON_VERSION..."
+#  safe_flags="--with-openssl=$HOME/ssl --enable-shared --prefix=$HOME/python --with-ensurepip=upgrade"
+#  unsafe_flags="--enable-optimizations --with-lto"
+#  if [ ! -e Makefile ]; then
+#    echo "running configure with safe and unsafe"
+#    ./configure $safe_flags $unsafe_flags > /dev/null
+#  fi
+#  make -j$cpucount PROFILE_TASK="-m test.regrtest --pgo -j$(( $cpucount * 2 ))" -s
+#  RESULT=$?
+#  echo "First make exited with $RESULT"
+#  if [ $RESULT != 0 ]; then
+#    echo "Trying Python compile again without unsafe flags..."
+#    make clean
+#    ./configure $safe_flags > /dev/null
+#    make -j$cpucount -s
+#    echo "Sticking with safe Python for now..."
+#  fi
+#  echo "Installing Python..."
+#  make install > /dev/null
+#  cd ~
+#fi
+
+$python -V
+
+cd $whereibelong
+

.github/actions/macos-install.sh

@@ -0,0 +1,19 @@
+echo "MacOS Version Info According to Python:"
+macver=$(python -c "import platform; print(platform.mac_ver()[0])")
+echo $macver
+echo "Xcode version:"
+xcodebuild -version
+export distpath="dist/"
+export gampath="${distpath}gam"
+rm -rf $gampath
+export specfile="gam.spec"
+$python -OO -m PyInstaller --clean --noupx --strip --distpath "${gampath}" --target-architecture $PLATFORM "${specfile}"
+export gam="${gampath}/gam"
+$gam version extended
+export GAMVERSION=`$gam version simple`
+cp LICENSE "${gampath}"
+cp GamCommands.txt "${gampath}"
+GAM_ARCHIVE="gam-${GAMVERSION}-${GAMOS}-${PLATFORM}.tar.xz"
+rm "${gampath}/lastupdatecheck.txt"
+# tar will cd to dist/ and tar up gam/
+tar -C dist/ --create --file $GAM_ARCHIVE --xz gam

.github/actions/windows-before-install.sh

@@ -0,0 +1,57 @@
+if [[ "$PLATFORM" == "x86_64" ]]; then
+  export BITS="64"
+  export PYTHONFILE_BITS="-amd64"
+  export OPENSSL_BITS="-x64"
+elif [[ "$PLATFORM" == "x86" ]]; then
+  export BITS="32"
+  export PYTHONFILE_BITS=""
+  export OPENSSL_BITS=""
+  export CHOCOPTIONS="--forcex86"
+fi
+echo "This is a ${BITS}-bit build for ${PLATFORM}"
+
+export mypath=$(pwd)
+cd ~
+
+export python="c:\python\python.exe"
+export pip="c:\python\scripts\pip.exe"
+
+# pyscard needs swig, keep these two together
+choco install $CHOCOPTIONS swig
+$pip install pyscard
+
+# Python
+#echo "Installing Python..."
+#export python_file=python-${BUILD_PYTHON_VERSION}${PYTHONFILE_BITS}.exe
+#if [ ! -e $python_file ]; then
+#  echo "Downloading $python_file..."
+#  curl -O https://www.python.org/ftp/python/$BUILD_PYTHON_VERSION/$python_file
+#fi
+#until ./${python_file} /quiet InstallAllUsers=1 TargetDir=c:\\python; do echo "trying python again..."; done
+#export python=/c/python/python.exe
+#export pip=/c/python/scripts/pip.exe
+#until [ -f $python ]; do sleep 1; done
+#export PATH=$PATH:/c/python/scripts
+
+# OpenSSL
+#echo "Installing OpenSSL..."
+#export exefile=Win${BITS}OpenSSL_Light-${BUILD_OPENSSL_VERSION//./_}.exe
+#if [ ! -e $exefile ]; then
+#  echo "Downloading $exefile..."
+#  curl -O https://slproweb.com/download/$exefile
+#fi
+#until ./${exefile} /silent /sp- /suppressmsgboxes /DIR=C:\\ssl; do echo "trying openssl again..."; done
+#until cp -v /c/ssl/libcrypto-1_1${OPENSSL_BITS}.dll /c/python/DLLs/; do echo "trying libcrypto copy again..."; sleep 3; done
+#until cp -v /c/ssl/libssl-1_1${OPENSSL_BITS}.dll /c/python/DLLs/; do echo "trying libssl copy again..."; done
+#if [[ "$PLATFORM" == "x86_64" ]]; then
+#  cp -v /c/python/DLLs/libssl-1_1-x64.dll /c/python/DLLs/libssl-1_1.dll
+#  cp -v /c/python/DLLs/libcrypto-1_1-x64.dll /c/python/DLLs/libcrypto-1_1.dll
+#fi
+
+cd $mypath
+
+echo "PATH: $PATH"
+cd ..
+$python setup.py install
+echo "cd to $mypath"
+cd $mypath

.github/actions/windows-install.sh

@@ -0,0 +1,31 @@
+if [[ "$PLATFORM" == "x86_64" ]]; then
+  export WIX_BITS="x64"
+elif [[ "$PLATFORM" == "x86" ]]; then
+  export WIX_BITS="x86"
+fi
+echo "compiling GAM with pyinstaller..."
+export distpath="dist/"
+export gampath="${distpath}gam"
+rm -rf $gampath
+/c/python/scripts/pyinstaller --clean --noupx --distpath $gampath gam.spec
+export gam="${gampath}/gam"
+echo "running compiled GAM..."
+$gam version
+export GAMVERSION=$($gam version simple)
+rm $gampath/lastupdatecheck.txt
+cp LICENSE $gampath
+cp GamCommands.txt $gampath
+cp gam-setup.bat $gampath
+GAM_ARCHIVE=gam-$GAMVERSION-$GAMOS-$PLATFORM.zip
+cwd=$(pwd)
+cd "${distpath}"
+/c/Program\ Files/7-Zip/7z.exe a -tzip $GAM_ARCHIVE gam -xr!.svn
+mv "${GAM_ARCHIVE}" "${cwd}"
+cd "${cwd}"
+echo "Running WIX candle $WIX_BITS..."
+/c/Program\ Files\ \(x86\)/WiX\ Toolset\ v3.11/bin/candle.exe -arch $WIX_BITS gam.wxs
+echo "Done with WIX candle..."
+echo "Running WIX light..."
+/c/Program\ Files\ \(x86\)/WiX\ Toolset\ v3.11/bin/light.exe -ext /c/Program\ Files\ \(x86\)/WiX\ Toolset\ v3.11/bin/WixUIExtension.dll gam.wixobj -o gam-$GAMVERSION-$GAMOS-$PLATFORM.msi || true;
+echo "Done with WIX light..."
+rm *.wixpdb

.github/stale.yml

@@ -0,0 +1,61 @@
+# Configuration for probot-stale - https://github.com/probot/stale
+
+# Number of days of inactivity before an Issue or Pull Request becomes stale
+daysUntilStale: 90
+
+# Number of days of inactivity before an Issue or Pull Request with the stale label is closed.
+# Set to false to disable. If disabled, issues still need to be closed manually, but will remain marked as stale.
+daysUntilClose: 7
+
+# Only issues or pull requests with all of these labels are check if stale. Defaults to `[]` (disabled)
+onlyLabels: []
+
+# Issues or Pull Requests with these labels will never be considered stale. Set to `[]` to disable
+exemptLabels:
+  - pinned
+  - enhancement
+  - help wanted
+  - security
+
+# Set to true to ignore issues in a project (defaults to false)
+exemptProjects: false
+
+# Set to true to ignore issues in a milestone (defaults to false)
+exemptMilestones: false
+
+# Set to true to ignore issues with an assignee (defaults to false)
+exemptAssignees: false
+
+# Label to use when marking as stale
+staleLabel: wontfix
+
+# Comment to post when marking as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs.
+
+# Comment to post when removing the stale label.
+# unmarkComment: >
+#   Your comment here.
+
+# Comment to post when closing a stale Issue or Pull Request.
+# closeComment: >
+#   Your comment here.
+
+# Limit the number of actions per hour, from 1-30. Default is 30
+limitPerRun: 30
+
+# Limit to only `issues` or `pulls`
+# only: issues
+
+# Optionally, specify configuration settings that are specific to just 'issues' or 'pulls':
+# pulls:
+#   daysUntilStale: 30
+#   markComment: >
+#     This pull request has been automatically marked as stale because it has not had
+#     recent activity. It will be closed if no further activity occurs. Thank you
+#     for your contributions.
+
+# issues:
+#   exemptLabels:
+#     - confirmed

.github/workflows/build.yml

@@ -0,0 +1,373 @@
+name: Build and test GAM
+
+on:
+  push:
+  pull_request:
+  schedule:
+    - cron: '37 22 * * *'
+
+defaults:
+  run:
+    shell: bash
+    working-directory: src
+
+env:
+  BUILD_PYTHON_VERSION: "3.10.0"
+  MIN_PYTHON_VERSION: "3.10.0"
+  BUILD_OPENSSL_VERSION: "1.1.1l"
+  MIN_OPENSSL_VERSION: "1.1.1l"
+  PATCHELF_VERSION: "0.13"
+  # PYINSTALLER_VERSION can be full commit hash or version like v4.20
+  PYINSTALLER_VERSION: "1e6a8d53f150cf24b574c32085f3745cbd2afaa6"
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-18.04
+            jid: 1
+            goal: "build"
+            gamos: "linux"
+            platform: "x86_64"
+          - os: ubuntu-20.04
+            jid: 2
+            goal: "build"
+            gamos: "linux"
+            platform: "x86_64"
+          - os: macos-11.0
+            jid: 3
+            goal: "build"
+            gamos: "macos"
+            platform: "universal2"
+          - os: windows-2019
+            jid: 4
+            goal: "build"
+            gamos: "windows"
+            pyarch: "x64" 
+            platform: "x86_64"
+          - os: windows-2019
+            jid: 5
+            goal: "build"
+            gamos: "windows"
+            platform: "x86"
+            pyarch: "x86"
+          - os: ubuntu-20.04
+            goal: "test"
+            python: "3.6"
+            jid: 6
+            gamos: "linux"
+            platform: "x86_64"
+          - os: ubuntu-20.04
+            goal: "test"
+            python: "3.7"
+            jid: 7
+            gamos: "linux"
+            platform: "x86_64"
+          - os: ubuntu-20.04
+            goal: "test"
+            python: "3.8"
+            jid: 8
+            gamos: "linux"
+            platform: "x86_64"
+          - os: ubuntu-20.04
+            goal: test
+            python: "3.10.0"
+            jid: 9
+            gamos: linux
+            platform: x86_64
+
+    steps:
+
+      - uses: actions/checkout@master
+        with:
+          persist-credentials: false
+          fetch-depth: 0
+
+      - name: Cache multiple paths
+        uses: actions/cache@v2
+        if: matrix.goal != 'test'
+        with:
+          path: |
+            ~/python
+            ~/ssl
+          key: ${{ matrix.os }}-${{ matrix.jid }}-20211014
+
+      - name: Set env variables
+        env:
+          GAMOS: ${{ matrix.gamos }}
+          GOAL: ${{ matrix.goal }}
+          JID: ${{ matrix.jid }}
+          PLATFORM: ${{ matrix.platform }}
+        run: |
+          echo "GAMOS=${GAMOS}" >> $GITHUB_ENV
+          echo "GOAL=${GOAL}" >> $GITHUB_ENV
+          echo "JID=${JID}" >> $GITHUB_ENV
+          echo "PLATFORM=${PLATFORM}" >> $GITHUB_ENV
+          uname -a
+
+      - name: Use pre-compiled Python for testing
+        if: matrix.python != ''
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python }}
+          architecture: ${{ matrix.pyarch }}
+
+      - name: Install Python on Windows
+        if: matrix.os == 'windows-2019'
+        run: |
+          if ( ${Env:PLATFORM} -eq "x86_64" )
+          {
+            Set-Variable -name py_arch -value "-amd64"
+          }
+          else
+          {
+            Set-Variable -name py_arch -value ""
+          }
+          Write-Output "py_arch: $py_arch"
+          Set-Variable -name python_file -value "python-${Env:BUILD_PYTHON_VERSION}${py_arch}.exe"
+          Write-Output "python_file: $python_file"
+          Set-Variable -name python_url -value "https://www.python.org/ftp/python/${Env:BUILD_PYTHON_VERSION}/${python_file}"
+          Write-Output "python_url: $python_url"
+          Invoke-WebRequest -Uri $python_url -OutFile $python_file
+          Start-Process -wait -FilePath $python_file -ArgumentList "/quiet","InstallAllUsers=0","TargetDir=c:\\python","AssociateFiles=1","PrependPath=1"
+        shell: pwsh
+  
+      - name: Set env variables for pre-compiled Python
+        if: matrix.goal == 'test'
+        run: |
+             export python=$(which python3)
+             export pip=$(which pip3)
+             export gam="${python} -m gam"
+             export gampath="$(readlink -e .)"
+             echo -e "python: $python\npip: $pip\ngam: $gam\ngampath: $gampath"
+             echo "python=${python}" >> $GITHUB_ENV
+             echo "pip=${pip}" >> $GITHUB_ENV
+             echo "gam=${gam}" >> $GITHUB_ENV
+             echo "gampath=${gampath}" >> $GITHUB_ENV
+             echo "RUNNING: apt update..."
+             sudo apt-get -qq --yes update > /dev/null
+             sudo apt-get -qq --yes install swig libpcsclite-dev
+             $pip install --upgrade pip
+
+      - name: Build and install Python, OpenSSL and PyInstaller
+        if: matrix.goal != 'test' && steps.cache-primes.outputs.cache-hit != 'true'
+        run: |
+             set +e
+             source ../.github/actions/${GAMOS}-before-install.sh
+             echo "PATH=$PATH" >> $GITHUB_ENV # keep gnutools for MacOS
+             echo "python=$python" >> $GITHUB_ENV
+             echo "pip=$pip" >> $GITHUB_ENV
+             echo "LD_LIBRARY_PATH=$LD_LIBRARY_PATH" >> $GITHUB_ENV
+             echo -e "Python: $python\nPip: $pip\nLD_LIB...: $LD_LIBRARY_PATH"
+             $pip install --upgrade pip
+             $pip install wheel
+             export url="https://codeload.github.com/pyinstaller/pyinstaller/tar.gz/${PYINSTALLER_VERSION}"
+             echo "Downloading ${url}"
+             curl -o pyinstaller.tar.gz --compressed "${url}"
+             tar xf pyinstaller.tar.gz
+             cd "pyinstaller-${PYINSTALLER_VERSION}/"
+             if [ $GAMOS == "windows" ]; then
+               # remove pre-compiled bootloaders so we fail if bootloader compile fails
+               rm -rf PyInstaller/bootloader/*bit
+               cd bootloader
+               if [ "${PLATFORM}" == "x86" ]; then
+                 TARGETARCH="--target-arch=32bit"
+               else
+                 TARGETARCH=""
+               fi
+               $python ./waf all $TARGETARCH
+               cd ..
+             fi
+             $pip install .
+             #$python setup.py install
+             #$pip install pyinstaller
+
+      - name: Install pip requirements
+        if: matrix.os != 'self-hosted'
+        run: |
+             set +e
+             $pip list --outdated --format=freeze | grep -v '^\-e' | cut -d = -f 1  | xargs -n1 $pip install -U --force-reinstall
+
+             $pip install --upgrade -r requirements.txt
+
+      - name: Build GAM with PyInstaller
+        if: matrix.goal != 'test'
+        run: |
+             set +e
+             source ../.github/actions/${GAMOS}-install.sh
+             ls -alRF $gampath
+             echo "gampath=$gampath" >> $GITHUB_ENV
+             echo "gam=$gam" >> $GITHUB_ENV
+             echo -e "GAM: ${gam}\nGAMPATH: ${gampath}\nGAMVERSION: ${GAMVERSION}"
+
+      - name: Basic Tests all jobs
+        run: |
+             echo -e "python: $python\npip: $pip\ngam: $gam\ngampath: $gampath\n"
+             $python -m unittest discover --start-directory ./ --pattern "*_test.py" --buffer
+             touch "${gampath}/nobrowser.txt"
+             $gam version extended
+             export GAMVERSION=$($gam version simple)
+             echo "GAM Version ${GAMVERSION}"
+             echo "GAMVERSION=${GAMVERSION}" >> $GITHUB_ENV
+
+      - name: Basic Tests build jobs only
+        if: matrix.goal != 'test'
+        run: |
+             $pip install packaging
+             export vline=$($gam version | grep "Python ")
+             export python_line=($vline)
+             export this_python=${python_line[1]}
+             $python tools/a_atleast_b.py "${this_python}" "${MIN_PYTHON_VERSION}"
+             export vline=$($gam version extended | grep "OpenSSL ")
+             export openssl_line=($vline)
+             export this_openssl="${openssl_line[1]}"
+             $python tools/a_atleast_b.py "${this_openssl}" "${MIN_OPENSSL_VERSION}"
+
+
+      - name: Live API tests push only
+        if: github.event_name == 'push' || github.event_name == 'schedule'
+        env: # Or as an environment variable
+          PASSCODE: ${{ secrets.PASSCODE }}
+        run: |
+             source ../.github/actions/decrypt.sh ../.github/actions/creds.tar.gpg creds.tar
+             export OAUTHFILE="oauth2.txt-gam-gha-${JID}"
+             echo "OAUTHFILE=${OAUTHFILE}" >> $GITHUB_ENV
+             export gam_user="gam-gha-${JID}@pdl.jaylee.us"
+             echo "gam_user=${gam_user}" >> $GITHUB_ENV
+             $gam oauth info
+             $gam info domain
+             $gam oauth refresh
+             $gam info user
+             #$gam info user $gam_user grouptree
+             export tstamp=$(date +%s%3N)
+             export newbase=gha-test-$JID-$tstamp
+             export newuser=$newbase@pdl.jaylee.us
+             export newgroup=$newbase-group@pdl.jaylee.us
+             export newalias=$newbase-alias@pdl.jaylee.us
+             export newbuilding=$newbase-building
+             export newresource=$newbase-resource
+             export GAM_THREADS=5
+             echo email > sample.csv;
+             for i in {01..10}; do
+               echo "${newbase}-bulkuser-$i" >> sample.csv;
+             done
+             $gam create user $newuser firstname GHA lastname $JID password random recoveryphone 12125121110 recoveryemail jay0lee@gmail.com gha.jid $JID
+             $gam user $gam_user sendemail recipient $newuser subject "test message $newbase" message "GHA test message"
+             $gam user $gam_user sendemail recipient exchange@pdl.jaylee.us subject "test ${tstamp}" message "test message"
+             $gam create group $newgroup name "GHA $JID group" description "This is a description" isarchived true
+             $gam update cigroup $newgroup memberrestriction 'member.type == 1 || member.customer_id == groupCustomerId()'
+             $gam info cigroup $newgroup
+             $gam user $newuser add license gsuitebusiness
+             $gam update group $newgroup add owner $gam_user
+             $gam update group $newgroup add member $newuser
+             $gam csv sample.csv gam create user ~~email~~ firstname "GHA Bulk" lastname ~~email~~ gha.jid $JID
+             $gam csv sample.csv gam update user ~~email~~ recoveryphone 12125121110 recoveryemail jay0lee@gmail.com password random
+             $gam csv sample.csv gam update user ~~email~~ recoveryphone "" recoveryemail ""
+             $gam csv sample.csv gam user ~email add license gsuitebusiness
+             $gam csv sample.csv gam user $gam_user sendemail recipient ~~email~~@pdl.jaylee.us subject "test message $newbase" message "GHA test message"
+             $gam csv sample.csv gam update group $newgroup add member ~email
+             $gam info group $newgroup
+             $gam info cigroup $newgroup membertree
+             $gam user $gam_user check serviceaccount
+             # confirm mailbox is provisoned before continuing
+             $gam user $newuser waitformailbox
+             $gam user $newuser imap on
+             $gam user $newuser show imap
+             $gam user $newuser show delegates
+             #$gam user $newuser add contactdelegate "${newbase}-bulkuser-01"
+             #$gam user $newuser print contactdelegates
+             export biohazard=$(echo -e '\xe2\x98\xa3')
+             $gam user $newuser label "$biohazard unicode biohazard $biohazard"
+             $gam user $newuser show labels
+             $gam user $newuser show labels > labels.txt
+             $gam user $gam_user importemail subject "GHA import $newbase" message "This is a test import" labels IMPORTANT,UNREAD,INBOX,STARRED
+             $gam user $gam_user insertemail subject "GHA insert $newbase" file gam.py labels INBOX,UNREAD # yep body is gam code
+             $gam user $gam_user sendemail subject "GHA send $gam_user $newbase" file gam.py recipient admin@pdl.jaylee.us
+             $gam user $gam_user draftemail subject "GHA draft $newbase" message "Draft message test"
+             $gam csvfile sample.csv:email waitformailbox
+             $gam user $newuser delegate to "${newbase}-bulkuser-01"
+             $gam users "$gam_user $newbase-bulkuser-01 $newbase-bulkuser-02 $newbase-bulkuser-03" delete messages query in:anywhere maxtodelete 99999 doit
+             $gam users "$newbase-bulkuser-04 $newbase-bulkuser-05 $newbase-bulkuser-06" trash messages query in:anywhere maxtotrash 99999 doit
+             $gam users "$newbase-bulkuser-07 $newbase-bulkuser-08 $newbase-bulkuser-09" modify messages query in:anywhere maxtomodify 99999 addlabel IMPORTANT addlabel STARRED doit
+             $gam user $newuser delete label --ALL_LABELS--
+             $gam create feature name Whiteboard-$newbase
+             $gam create feature name VC-$newbase
+             $gam create building "My Building - $newbase" id $newbuilding floors 1,2,3,4,5,6,7,8,9,10,11,12,14,15 description "No 13th floor here..."
+             $gam create resource $newresource "Resource Calendar $tstamp" capacity 25 features Whiteboard-$newbase,VC-$newbase building $newbuilding floor 15 type Room
+             $gam info resource $newresource
+             $gam user $newuser show filelist
+             $gam calendar $gam_user printacl | $gam csv - gam calendar $gam_user delete id ~id # clear ACLs
+             $gam calendar $gam_user update read domain
+             $gam calendar $gam_user update freebusy default
+             $gam calendar $gam_user add editor $newuser
+             $gam calendar $gam_user showacl
+             $gam calendar $gam_user printacl | $gam csv - gam calendar $gam_user delete id ~id
+             $gam calendar $gam_user addevent summary "GHA test event" start $(date '+%FT%T.%N%:z' -d "now + 1 hour") end $(date '+%FT%T.%N%:z' -d "now + 2 hours") attendee $newgroup hangoutsmeet guestscanmodify true sendupdates all
+             $gam calendar $gam_user printevents after -0d
+             matterid=uid:$($gam create vaultmatter name "GHA matter $newbase" description "test matter" collaborators $newuser | head -1 | cut -d ' ' -f 3)
+             $gam create vaulthold matter $matterid name "GHA hold $newbase" corpus mail accounts $newuser
+             $gam print vaultmatters matterstate open
+             $gam print vaultholds matter $matterid
+             $gam print vaultcount matter $matterid corpus mail everyone todrive
+             $gam create vaultexport matter $matterid name "GHA export $newbase" corpus mail accounts $newuser
+             $gam print exports matter $matterid | $gam csv - gam info export $matterid id:~~id~~
+             $gam csv sample.csv gam user ~email add calendar id:$newresource
+             $gam delete resource $newresource
+             $gam delete feature Whiteboard-$newbase
+             $gam delete feature VC-$newbase
+             $gam delete building $newbuilding
+             $gam delete group $newgroup
+             $gam create alias $newalias user $newuser
+             $gam whatis $newuser
+             $gam user $gam_user show tokens
+             $gam print exports matter $matterid | $gam csv - gam download export $matterid id:~~id~~
+             $gam delete hold "GHA hold $newbase" matter $matterid
+             $gam update matter $matterid action close
+             $gam update matter $matterid action delete
+             $gam delete user $newuser
+             $gam print users query "gha.jid=$JID" | $gam csv - gam delete user ~primaryEmail
+             $gam print mobile
+             $gam print devices
+             $gam print browsers
+             export sn="$JID$JID$JID$JID-$(openssl rand -base64 32 | sed 's/[^a-zA-Z0-9]//g')"
+             $gam create device serialnumber $sn devicetype android
+             $gam print cros allfields nolists
+             $gam report usageparameters customer
+             $gam report usage customer parameters gmail:num_emails_sent,accounts:num_1day_logins
+             $gam report customer todrive
+             $gam report users fields accounts:is_less_secure_apps_access_allowed,gmail:last_imap_time,gmail:last_pop_time filters "accounts:last_login_time>2019-01-01T00:00:00.000Z" todrive
+             $gam report admin start -3d todrive
+             $gam print devices nopersonaldevices nodeviceusers filter "serial:$JID$JID$JID$JID-" | $gam csv - gam delete device id ~name
+             $gam print userinvitations
+             $gam print userinvitations | $gam csv - gam send userinvitation ~name
+             export CUSTOMER_ID="C01wfv983"
+             export GA_DOMAIN="pdl.jaylee.us"
+             touch $gampath/enabledasa.txt
+             echo "printer model count:"
+             $gam print printermodels | wc -l
+             #$gam print printers
+             #$gam create printer displayname "${newbase}" uri ipp://localhost:631 driverless description "made by $(date)"
+             rm $gampath/enabledasa.txt
+
+      - name: Upload to Google Drive, build only.
+        if: github.event_name == 'push' && matrix.goal != 'test'
+        run: |
+             ls gam-$GAMVERSION-*
+             for gamfile in gam-$GAMVERSION-*; do
+               echo "Uploading file ${gamfile} to Google Drive..."
+               fileid=$($gam user $gam_user add drivefile localfile $gamfile drivefilename $GAMVERSION-${GITHUB_SHA:0:7}-$gamfile parentid 1N2zbO33qzUQFsGM49-m9AQC1ijzd_ru1 returnidonly)
+               echo "file uploaded as ${fileid}, setting ACL..."
+               $gam user $gam_user add drivefileacl $fileid anyone role reader withlink
+             done
+
+      - name: Archive production artifacts
+        uses: actions/upload-artifact@v2
+        if: github.event_name == 'push' && matrix.goal != 'test'
+        with:
+          name: gam-binaries
+          path: |
+            src/*.tar.xz
+            src/*.zip
+            src/*.msi

.pre-commit-config.yaml

@@ -0,0 +1,29 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+default_language_version:
+    python: python3.7
+
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v2.5.0
+    hooks:
+    -   id: trailing-whitespace
+    -   id: end-of-file-fixer
+    -   id: double-quote-string-fixer
+    -   id: check-yaml
+    -   id: check-docstring-first
+    -   id: name-tests-test
+    -   id: requirements-txt-fixer
+    -   id: check-merge-conflict
+
+-   repo: https://github.com/pre-commit/mirrors-yapf
+    rev: v0.30.0
+    hooks:
+    -   id: yapf
+        args: [--style=google, --in-place]
+
+-   repo: https://github.com/PyCQA/pylint
+    rev: pylint-2.5.0
+    hooks:
+    -   id: pylint
+        args: [--output-format=colorized]

.travis.yml

@@ -1,91 +0,0 @@
-if: tag IS blank
-
-matrix:
-  include:
-    - os: linux
-      language: python
-      dist: precise
-      python:
-        - "2.7.15"
-      env:
-        - GAMOS=linux
-        - PLATFORM=x86_64
-#    - os: linux
-#      language: python
-#      dist: precise
-#      python:
-#        - "2.7.15"
-#      env:
-#        - GAMOS=linux
-#        - PLATFORM=i686
-    - os: osx
-      language: generic
-      osx_image: xcode10.1
-      env:
-        - GAMOS=macos
-        - PLATFORM=x64
-      addons:
-        homebrew:
-          packages:
-            python@2
-    - os: windows
-      language: shell
-      env:
-        - GAMOS=windows
-          PLATFORM=x64
-          CINST_ARGS=""
-    - os: windows
-      language: shell
-      env:
-        - GAMOS=windows
-        - CINST_ARGS=--forcex86
-        - PLATFORM=x86
-
-before_install:
-- if [[ "$TRAVIS_OS_NAME" == "windows" ]]; then
-    powershell Install-WindowsFeature Net-Framework-Core;
-    cinst -y $CINST_ARGS python2;
-    export PATH=$PATH:/c/Python27/scripts;
-    cinst -y wixtoolset;
-  fi
-- pip install pyinstaller
-
-install:
-- cd src
-- pyinstaller --clean -F --distpath=gam $GAMOS-gam.spec
-- gam/gam version
-- export GAMVERSION=`gam/gam version simple`
-- cp LICENSE gam
-- cp whatsnew.txt gam
-- cp GamCommands.txt gam
-- if [[ "$TRAVIS_OS_NAME" == "windows" ]]; then
-    cp gam-setup.bat gam;
-    GAM_ARCHIVE=gam-$GAMVERSION-$GAMOS-$PLATFORM.zip;
-    /c/Program\ Files/7-Zip/7z.exe a -tzip $GAM_ARCHIVE gam -xr!.svn;
-    mkdir gam-64;
-    cp -rf gam/* gam-64/;
-    /c/Program\ Files\ \(x86\)/WiX\ Toolset\ v3.11/bin/candle.exe -arch $PLATFORM gam.wxs;
-    /c/Program\ Files\ \(x86\)/Wix\ Toolset\ v3.11/bin/light.exe -ext /c/Program\ Files\ \(x86\)/WiX\ Toolset\ v3.11/bin/WixUIExtension.dll gam.wixobj -o gam-$GAMVERSION-$GAMOS-$PLATFORM.msi || true;
-    rm *.wixpdb;
-  else
-    GAM_ARCHIVE=gam-$GAMVERSION-$GAMOS-$PLATFORM.tar.xz;
-    tar cfJ $GAM_ARCHIVE gam/;
-  fi
-
-script:
-- gam/gam version
-
-before_deploy:
-- export TRAVIS_TAG="preview"
-
-deploy:
-  provider: releases
-  api_key:
-    secure: bzambMcQwyv/o5c5GrKGCsZHgE5R85tg8sNFvPfpISz3+uosCjnBXas7wvCKzT75XUFi2ztfbYak6HdKf4sGnNHk0saEicB3slH+ghPyZbYzp76yvvduhFO2nWW3/F01tL+Yfqqt4/q8wFaWGjrC5km+6GLVyB4lWA/Uyu49qKnz02uSwyhBD/VFbO7DOQ65a1iWk9HngyMsu0Oi7HIbSjSLtxTHedNfOf3waW0NivTTxYXiYGX/MCu3GWhgIGj47a+H3A6FcQ/9QWvnKgnoixdgPBUz7kDb7ktsWwQsILPGStgH7iMuG49ZlXdEFmqwifBri2wvzmFEevBGZjHcupy1IGrNFRG+IUGKMotio+OkLHlLjuv7ZJtqCz/Vf5SNFgNyMSanx6jKEUJuYvndVg99IRXmYVwHFwPu5BAcJACpU6C0AfyGmmSqqwxCd46uXL62ynxNFpHuRfOqlDnmCTfZgjOciJSlDDpf+Xz9fF7+oCoeCi3mrcZVFjhd3tT6Oxw5HrsDtm0ZNld1cdLidaq8H6vOFgHMd0A9yNYZzTzXTvpmxzkXT4Zc7s+PYKN6z5fRZ+pJeckUjRXblvVEfs5HFSymavcOc5AkRwxpvOsTQMNmlnaJCBo5UNs0K/rVmRi5cFmaiwTcBCY0kTllOBJ4zWsfq8seiokWwNUNK2g=
-  file_glob: true
-  overwrite: true
-  file: gam-$GAMVERSION-*
-  skip_cleanup: true
-  draft: true
-  on:
-    repo: jay0lee/GAM

README.md

@@ -1,21 +1,46 @@
-GAM is a command line tool for Google G Suite Administrators to manage domain and user settings quickly and easily.
+GAM is a command line tool for Google Workspace (fka G Suite) Administrators to manage domain and user settings quickly and easily.
+
+![Build Status](https://github.com/jay0lee/GAM/workflows/Build%20and%20test%20GAM/badge.svg)
+
 # Quick Start
+
 ## Linux / MacOS
+
 Open a terminal and run:
-```
+
+```sh
 bash <(curl -s -S -L https://git.io/install-gam)
 ```
+
 this will download GAM, install it and start setup.
+
+To install with `pip`, run
+
+```sh
+pip install git+https://github.com/jay0lee/GAM.git#subdirectory=src
+```
+
+This will only download and install GAM. To start setup, simply invoke the `gam` CLI.
+
 ## Windows
+
 Download the MSI Installer from the [GitHub Releases] page. Install the MSI and you'll be prompted to setup GAM.
+
 # Documentation
+
 The GAM documentation is hosted in the [GitHub Wiki]
+
 # Mailing List / Discussion group
+
 The GAM mailing list / discussion group is hosted on [Google Groups].  You can join the list and interact via email, or just post from the web itself.
-# IM Room
-[![Join the chat at https://gitter.im/jay0lee-GAM/community](https://badges.gitter.im/jay0lee-GAM/community.svg)](https://gitter.im/jay0lee-GAM/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+# Chat Room
+
+There is a public chat room hosted in Google Chat. [Instructions to join](https://git.io/gam-chat).
+
 # Author
-GAM is maintained by <a href="mailto:jay0lee@gmail.com">Jay Lee</a>. Please direct "how do I?" questions to [Google Groups].
+
+GAM is maintained by [Jay Lee](mailto:jay0lee@gmail.com). Please direct "how do I?" questions to [Google Groups].
 
 [GAM release]: https://git.io/gamreleases
 [GitHub Releases]: https://github.com/jay0lee/GAM/releases

src/.gitignore

@@ -64,7 +64,7 @@ nobrowser.txt
 nocache.txt
 noverifyssl.txt
 gamcache/
-gam/
+dist/
 gam-64/
 *.zip
 *.msi

src/LICENSE

@@ -202,12 +202,12 @@
 
 
 
-APACHE HTTP SERVER SUBCOMPONENTS: 
+APACHE HTTP SERVER SUBCOMPONENTS:
 
 The Apache HTTP Server includes a number of subcomponents with
 separate copyright notices and license terms. Your use of the source
 code for the these subcomponents is subject to the terms and
-conditions of the following licenses. 
+conditions of the following licenses.
 
 For the mod_mime_magic component:
 
@@ -273,7 +273,7 @@ For the  server\util_md5.c component:
  *  Original Code Copyright (C) 1994, Jeff Hostetler, Spyglass, Inc.
  *  Portions of Content-MD5 code Copyright (C) 1993, 1994 by Carnegie Mellon
  *     University (see Copyright below).
- *  Portions of Content-MD5 code Copyright (C) 1991 Bell Communications 
+ *  Portions of Content-MD5 code Copyright (C) 1991 Bell Communications
  *     Research, Inc. (Bellcore) (see Copyright below).
  *  Portions extracted from mpack, John G. Myers - jgm+@cmu.edu
  *  Content-MD5 Code contributed by Martin Hamilton (martin@net.lut.ac.uk)
@@ -319,10 +319,10 @@ For the  server\util_md5.c component:
  * of an authorized representative of Bellcore.  BELLCORE
  * MAKES NO REPRESENTATIONS ABOUT THE ACCURACY OR SUITABILITY
  * OF THIS MATERIAL FOR ANY PURPOSE.  IT IS PROVIDED "AS IS",
- * WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES.  
+ * WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES.
  */
 
-For the  srclib\apr\include\apr_md5.h component: 
+For the  srclib\apr\include\apr_md5.h component:
 /*
  * This is work is derived from material Copyright RSA Data Security, Inc.
  *
@@ -501,21 +501,21 @@ This program is Copyright (C) Zeus Technology Limited 1996.
 This program may be used and copied freely providing this copyright notice
 is not removed.
 
-This software is provided "as is" and any express or implied waranties, 
+This software is provided "as is" and any express or implied waranties,
 including but not limited to, the implied warranties of merchantability and
-fitness for a particular purpose are disclaimed.  In no event shall 
-Zeus Technology Ltd. be liable for any direct, indirect, incidental, special, 
-exemplary, or consequential damaged (including, but not limited to, 
+fitness for a particular purpose are disclaimed.  In no event shall
+Zeus Technology Ltd. be liable for any direct, indirect, incidental, special,
+exemplary, or consequential damaged (including, but not limited to,
 procurement of substitute good or services; loss of use, data, or profits;
 or business interruption) however caused and on theory of liability.  Whether
-in contract, strict liability or tort (including negligence or otherwise) 
+in contract, strict liability or tort (including negligence or otherwise)
 arising in any way out of the use of this software, even if advised of the
 possibility of such damage.
 
      Written by Adam Twiss (adam@zeus.co.uk).  March 1996
 
 Thanks to the following people for their input:
-  Mike Belshe (mbelshe@netscape.com) 
+  Mike Belshe (mbelshe@netscape.com)
   Michael Campanella (campanella@stevms.enet.dec.com)
 
 */
@@ -532,10 +532,10 @@ without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
-	
+
 The above copyright notice and this permission notice shall be included
 in all copies or substantial portions of the Software.
-	
+
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

src/cachetools/__init__.py

@@ -1,112 +0,0 @@
-"""Extensible memoizing collections and decorators."""
-
-from __future__ import absolute_import
-
-import functools
-
-from . import keys
-from .cache import Cache
-from .lfu import LFUCache
-from .lru import LRUCache
-from .rr import RRCache
-from .ttl import TTLCache
-
-__all__ = (
-    'Cache', 'LFUCache', 'LRUCache', 'RRCache', 'TTLCache',
-    'cached', 'cachedmethod'
-)
-
-__version__ = '3.1.0'
-
-if hasattr(functools.update_wrapper(lambda f: f(), lambda: 42), '__wrapped__'):
-    _update_wrapper = functools.update_wrapper
-else:
-    def _update_wrapper(wrapper, wrapped):
-        functools.update_wrapper(wrapper, wrapped)
-        wrapper.__wrapped__ = wrapped
-        return wrapper
-
-
-def cached(cache, key=keys.hashkey, lock=None):
-    """Decorator to wrap a function with a memoizing callable that saves
-    results in a cache.
-
-    """
-    def decorator(func):
-        if cache is None:
-            def wrapper(*args, **kwargs):
-                return func(*args, **kwargs)
-        elif lock is None:
-            def wrapper(*args, **kwargs):
-                k = key(*args, **kwargs)
-                try:
-                    return cache[k]
-                except KeyError:
-                    pass  # key not found
-                v = func(*args, **kwargs)
-                try:
-                    cache[k] = v
-                except ValueError:
-                    pass  # value too large
-                return v
-        else:
-            def wrapper(*args, **kwargs):
-                k = key(*args, **kwargs)
-                try:
-                    with lock:
-                        return cache[k]
-                except KeyError:
-                    pass  # key not found
-                v = func(*args, **kwargs)
-                try:
-                    with lock:
-                        cache[k] = v
-                except ValueError:
-                    pass  # value too large
-                return v
-        return _update_wrapper(wrapper, func)
-    return decorator
-
-
-def cachedmethod(cache, key=keys.hashkey, lock=None):
-    """Decorator to wrap a class or instance method with a memoizing
-    callable that saves results in a cache.
-
-    """
-    def decorator(method):
-        if lock is None:
-            def wrapper(self, *args, **kwargs):
-                c = cache(self)
-                if c is None:
-                    return method(self, *args, **kwargs)
-                k = key(*args, **kwargs)
-                try:
-                    return c[k]
-                except KeyError:
-                    pass  # key not found
-                v = method(self, *args, **kwargs)
-                try:
-                    c[k] = v
-                except ValueError:
-                    pass  # value too large
-                return v
-        else:
-            def wrapper(self, *args, **kwargs):
-                c = cache(self)
-                if c is None:
-                    return method(self, *args, **kwargs)
-                k = key(*args, **kwargs)
-                try:
-                    with lock(self):
-                        return c[k]
-                except KeyError:
-                    pass  # key not found
-                v = method(self, *args, **kwargs)
-                try:
-                    with lock(self):
-                        c[k] = v
-                except ValueError:
-                    pass  # value too large
-                return v
-        return _update_wrapper(wrapper, method)
-    return decorator

src/cachetools/abc.py

@@ -1,52 +0,0 @@
-from __future__ import absolute_import
-
-from abc import abstractmethod
-
-try:
-    from collections.abc import MutableMapping
-except ImportError:
-    from collections import MutableMapping
-
-
-class DefaultMapping(MutableMapping):
-
-    __slots__ = ()
-
-    @abstractmethod
-    def __contains__(self, key):  # pragma: nocover
-        return False
-
-    @abstractmethod
-    def __getitem__(self, key):  # pragma: nocover
-        if hasattr(self.__class__, '__missing__'):
-            return self.__class__.__missing__(self, key)
-        else:
-            raise KeyError(key)
-
-    def get(self, key, default=None):
-        if key in self:
-            return self[key]
-        else:
-            return default
-
-    __marker = object()
-
-    def pop(self, key, default=__marker):
-        if key in self:
-            value = self[key]
-            del self[key]
-        elif default is self.__marker:
-            raise KeyError(key)
-        else:
-            value = default
-        return value
-
-    def setdefault(self, key, default=None):
-        if key in self:
-            value = self[key]
-        else:
-            self[key] = value = default
-        return value
-
-
-DefaultMapping.register(dict)

src/cachetools/cache.py

@@ -1,91 +0,0 @@
-from __future__ import absolute_import
-
-from .abc import DefaultMapping
-
-
-class _DefaultSize(object):
-    def __getitem__(self, _):
-        return 1
-
-    def __setitem__(self, _, value):
-        assert value == 1
-
-    def pop(self, _):
-        return 1
-
-
-class Cache(DefaultMapping):
-    """Mutable mapping to serve as a simple cache or cache base class."""
-
-    __size = _DefaultSize()
-
-    def __init__(self, maxsize, getsizeof=None):
-        if getsizeof:
-            self.getsizeof = getsizeof
-        if self.getsizeof is not Cache.getsizeof:
-            self.__size = dict()
-        self.__data = dict()
-        self.__currsize = 0
-        self.__maxsize = maxsize
-
-    def __repr__(self):
-        return '%s(%r, maxsize=%r, currsize=%r)' % (
-            self.__class__.__name__,
-            list(self.__data.items()),
-            self.__maxsize,
-            self.__currsize,
-        )
-
-    def __getitem__(self, key):
-        try:
-            return self.__data[key]
-        except KeyError:
-            return self.__missing__(key)
-
-    def __setitem__(self, key, value):
-        maxsize = self.__maxsize
-        size = self.getsizeof(value)
-        if size > maxsize:
-            raise ValueError('value too large')
-        if key not in self.__data or self.__size[key] < size:
-            while self.__currsize + size > maxsize:
-                self.popitem()
-        if key in self.__data:
-            diffsize = size - self.__size[key]
-        else:
-            diffsize = size
-        self.__data[key] = value
-        self.__size[key] = size
-        self.__currsize += diffsize
-
-    def __delitem__(self, key):
-        size = self.__size.pop(key)
-        del self.__data[key]
-        self.__currsize -= size
-
-    def __contains__(self, key):
-        return key in self.__data
-
-    def __missing__(self, key):
-        raise KeyError(key)
-
-    def __iter__(self):
-        return iter(self.__data)
-
-    def __len__(self):
-        return len(self.__data)
-
-    @property
-    def maxsize(self):
-        """The maximum size of the cache."""
-        return self.__maxsize
-
-    @property
-    def currsize(self):
-        """The current size of the cache."""
-        return self.__currsize
-
-    @staticmethod
-    def getsizeof(value):
-        """Return the size of a cache element's value."""
-        return 1

src/cachetools/func.py

@@ -1,140 +0,0 @@
-"""`functools.lru_cache` compatible memoizing function decorators."""
-
-from __future__ import absolute_import
-
-import collections
-import functools
-import random
-
-try:
-    from time import monotonic as default_timer
-except ImportError:
-    from time import time as default_timer
-
-try:
-    from threading import RLock
-except ImportError:  # pragma: no cover
-    from dummy_threading import RLock
-
-from . import keys
-from .lfu import LFUCache
-from .lru import LRUCache
-from .rr import RRCache
-from .ttl import TTLCache
-
-__all__ = ('lfu_cache', 'lru_cache', 'rr_cache', 'ttl_cache')
-
-
-_CacheInfo = collections.namedtuple('CacheInfo', [
-    'hits', 'misses', 'maxsize', 'currsize'
-])
-
-
-class _UnboundCache(dict):
-
-    maxsize = None
-
-    @property
-    def currsize(self):
-        return len(self)
-
-
-class _UnboundTTLCache(TTLCache):
-    def __init__(self, ttl, timer):
-        TTLCache.__init__(self, float('inf'), ttl, timer)
-
-    @property
-    def maxsize(self):
-        return None
-
-
-def _cache(cache, typed=False):
-    def decorator(func):
-        key = keys.typedkey if typed else keys.hashkey
-        lock = RLock()
-        stats = [0, 0]
-
-        def cache_info():
-            with lock:
-                hits, misses = stats
-                maxsize = cache.maxsize
-                currsize = cache.currsize
-            return _CacheInfo(hits, misses, maxsize, currsize)
-
-        def cache_clear():
-            with lock:
-                try:
-                    cache.clear()
-                finally:
-                    stats[:] = [0, 0]
-
-        def wrapper(*args, **kwargs):
-            k = key(*args, **kwargs)
-            with lock:
-                try:
-                    v = cache[k]
-                    stats[0] += 1
-                    return v
-                except KeyError:
-                    stats[1] += 1
-            v = func(*args, **kwargs)
-            try:
-                with lock:
-                    cache[k] = v
-            except ValueError:
-                pass  # value too large
-            return v
-        functools.update_wrapper(wrapper, func)
-        if not hasattr(wrapper, '__wrapped__'):
-            wrapper.__wrapped__ = func  # Python 2.7
-        wrapper.cache_info = cache_info
-        wrapper.cache_clear = cache_clear
-        return wrapper
-    return decorator
-
-
-def lfu_cache(maxsize=128, typed=False):
-    """Decorator to wrap a function with a memoizing callable that saves
-    up to `maxsize` results based on a Least Frequently Used (LFU)
-    algorithm.
-
-    """
-    if maxsize is None:
-        return _cache(_UnboundCache(), typed)
-    else:
-        return _cache(LFUCache(maxsize), typed)
-
-
-def lru_cache(maxsize=128, typed=False):
-    """Decorator to wrap a function with a memoizing callable that saves
-    up to `maxsize` results based on a Least Recently Used (LRU)
-    algorithm.
-
-    """
-    if maxsize is None:
-        return _cache(_UnboundCache(), typed)
-    else:
-        return _cache(LRUCache(maxsize), typed)
-
-
-def rr_cache(maxsize=128, choice=random.choice, typed=False):
-    """Decorator to wrap a function with a memoizing callable that saves
-    up to `maxsize` results based on a Random Replacement (RR)
-    algorithm.
-
-    """
-    if maxsize is None:
-        return _cache(_UnboundCache(), typed)
-    else:
-        return _cache(RRCache(maxsize, choice), typed)
-
-
-def ttl_cache(maxsize=128, ttl=600, timer=default_timer, typed=False):
-    """Decorator to wrap a function with a memoizing callable that saves
-    up to `maxsize` results based on a Least Recently Used (LRU)
-    algorithm with a per-item time-to-live (TTL) value.
-    """
-    if maxsize is None:
-        return _cache(_UnboundTTLCache(ttl, timer), typed)
-    else:
-        return _cache(TTLCache(maxsize, ttl, timer), typed)

src/cachetools/keys.py

@@ -1,43 +0,0 @@
-"""Key functions for memoizing decorators."""
-
-from __future__ import absolute_import
-
-__all__ = ('hashkey', 'typedkey')
-
-
-class _HashedTuple(tuple):
-
-    __hashvalue = None
-
-    def __hash__(self, hash=tuple.__hash__):
-        hashvalue = self.__hashvalue
-        if hashvalue is None:
-            self.__hashvalue = hashvalue = hash(self)
-        return hashvalue
-
-    def __add__(self, other, add=tuple.__add__):
-        return _HashedTuple(add(self, other))
-
-    def __radd__(self, other, add=tuple.__add__):
-        return _HashedTuple(add(other, self))
-
-
-_kwmark = (object(),)
-
-
-def hashkey(*args, **kwargs):
-    """Return a cache key for the specified hashable arguments."""
-
-    if kwargs:
-        return _HashedTuple(args + sum(sorted(kwargs.items()), _kwmark))
-    else:
-        return _HashedTuple(args)
-
-
-def typedkey(*args, **kwargs):
-    """Return a typed cache key for the specified hashable arguments."""
-
-    key = hashkey(*args, **kwargs)
-    key += tuple(type(v) for v in args)
-    key += tuple(type(v) for _, v in sorted(kwargs.items()))
-    return key

src/cachetools/lfu.py

@@ -1,35 +0,0 @@
-from __future__ import absolute_import
-
-import collections
-
-from .cache import Cache
-
-
-class LFUCache(Cache):
-    """Least Frequently Used (LFU) cache implementation."""
-
-    def __init__(self, maxsize, getsizeof=None):
-        Cache.__init__(self, maxsize, getsizeof)
-        self.__counter = collections.Counter()
-
-    def __getitem__(self, key, cache_getitem=Cache.__getitem__):
-        value = cache_getitem(self, key)
-        self.__counter[key] -= 1
-        return value
-
-    def __setitem__(self, key, value, cache_setitem=Cache.__setitem__):
-        cache_setitem(self, key, value)
-        self.__counter[key] -= 1
-
-    def __delitem__(self, key, cache_delitem=Cache.__delitem__):
-        cache_delitem(self, key)
-        del self.__counter[key]
-
-    def popitem(self):
-        """Remove and return the `(key, value)` pair least frequently used."""
-        try:
-            (key, _), = self.__counter.most_common(1)
-        except ValueError:
-            raise KeyError('%s is empty' % self.__class__.__name__)
-        else:
-            return (key, self.pop(key))

src/cachetools/lru.py

@@ -1,48 +0,0 @@
-from __future__ import absolute_import
-
-import collections
-
-from .cache import Cache
-
-
-class LRUCache(Cache):
-    """Least Recently Used (LRU) cache implementation."""
-
-    def __init__(self, maxsize, getsizeof=None):
-        Cache.__init__(self, maxsize, getsizeof)
-        self.__order = collections.OrderedDict()
-
-    def __getitem__(self, key, cache_getitem=Cache.__getitem__):
-        value = cache_getitem(self, key)
-        self.__update(key)
-        return value
-
-    def __setitem__(self, key, value, cache_setitem=Cache.__setitem__):
-        cache_setitem(self, key, value)
-        self.__update(key)
-
-    def __delitem__(self, key, cache_delitem=Cache.__delitem__):
-        cache_delitem(self, key)
-        del self.__order[key]
-
-    def popitem(self):
-        """Remove and return the `(key, value)` pair least recently used."""
-        try:
-            key = next(iter(self.__order))
-        except StopIteration:
-            raise KeyError('%s is empty' % self.__class__.__name__)
-        else:
-            return (key, self.pop(key))
-
-    if hasattr(collections.OrderedDict, 'move_to_end'):
-        def __update(self, key):
-            try:
-                self.__order.move_to_end(key)
-            except KeyError:
-                self.__order[key] = None
-    else:
-        def __update(self, key):
-            try:
-                self.__order[key] = self.__order.pop(key)
-            except KeyError:
-                self.__order[key] = None

src/cachetools/rr.py

@@ -1,36 +0,0 @@
-from __future__ import absolute_import
-
-import random
-
-from .cache import Cache
-
-
-# random.choice cannot be pickled in Python 2.7
-def _choice(seq):
-    return random.choice(seq)
-
-
-class RRCache(Cache):
-    """Random Replacement (RR) cache implementation."""
-
-    def __init__(self, maxsize, choice=random.choice, getsizeof=None):
-        Cache.__init__(self, maxsize, getsizeof)
-        # TODO: use None as default, assing to self.choice directly?
-        if choice is random.choice:
-            self.__choice = _choice
-        else:
-            self.__choice = choice
-
-    @property
-    def choice(self):
-        """The `choice` function used by the cache."""
-        return self.__choice
-
-    def popitem(self):
-        """Remove and return a random `(key, value)` pair."""
-        try:
-            key = self.__choice(list(self))
-        except IndexError:
-            raise KeyError('%s is empty' % self.__class__.__name__)
-        else:
-            return (key, self.pop(key))

src/cachetools/ttl.py

@@ -1,220 +0,0 @@
-from __future__ import absolute_import
-
-import collections
-
-try:
-    from time import monotonic as default_timer
-except ImportError:
-    from time import time as default_timer
-
-from .cache import Cache
-
-
-class _Link(object):
-
-    __slots__ = ('key', 'expire', 'next', 'prev')
-
-    def __init__(self, key=None, expire=None):
-        self.key = key
-        self.expire = expire
-
-    def __reduce__(self):
-        return _Link, (self.key, self.expire)
-
-    def unlink(self):
-        next = self.next
-        prev = self.prev
-        prev.next = next
-        next.prev = prev
-
-
-class _Timer(object):
-
-    def __init__(self, timer):
-        self.__timer = timer
-        self.__nesting = 0
-
-    def __call__(self):
-        if self.__nesting == 0:
-            return self.__timer()
-        else:
-            return self.__time
-
-    def __enter__(self):
-        if self.__nesting == 0:
-            self.__time = time = self.__timer()
-        else:
-            time = self.__time
-        self.__nesting += 1
-        return time
-
-    def __exit__(self, *exc):
-        self.__nesting -= 1
-
-    def __reduce__(self):
-        return _Timer, (self.__timer,)
-
-    def __getattr__(self, name):
-        return getattr(self.__timer, name)
-
-
-class TTLCache(Cache):
-    """LRU Cache implementation with per-item time-to-live (TTL) value."""
-
-    def __init__(self, maxsize, ttl, timer=default_timer, getsizeof=None):
-        Cache.__init__(self, maxsize, getsizeof)
-        self.__root = root = _Link()
-        root.prev = root.next = root
-        self.__links = collections.OrderedDict()
-        self.__timer = _Timer(timer)
-        self.__ttl = ttl
-
-    def __contains__(self, key):
-        try:
-            link = self.__links[key]  # no reordering
-        except KeyError:
-            return False
-        else:
-            return not (link.expire < self.__timer())
-
-    def __getitem__(self, key, cache_getitem=Cache.__getitem__):
-        try:
-            link = self.__getlink(key)
-        except KeyError:
-            expired = False
-        else:
-            expired = link.expire < self.__timer()
-        if expired:
-            return self.__missing__(key)
-        else:
-            return cache_getitem(self, key)
-
-    def __setitem__(self, key, value, cache_setitem=Cache.__setitem__):
-        with self.__timer as time:
-            self.expire(time)
-            cache_setitem(self, key, value)
-        try:
-            link = self.__getlink(key)
-        except KeyError:
-            self.__links[key] = link = _Link(key)
-        else:
-            link.unlink()
-        link.expire = time + self.__ttl
-        link.next = root = self.__root
-        link.prev = prev = root.prev
-        prev.next = root.prev = link
-
-    def __delitem__(self, key, cache_delitem=Cache.__delitem__):
-        cache_delitem(self, key)
-        link = self.__links.pop(key)
-        link.unlink()
-        if link.expire < self.__timer():
-            raise KeyError(key)
-
-    def __iter__(self):
-        root = self.__root
-        curr = root.next
-        while curr is not root:
-            # "freeze" time for iterator access
-            with self.__timer as time:
-                if not (curr.expire < time):
-                    yield curr.key
-            curr = curr.next
-
-    def __len__(self):
-        root = self.__root
-        curr = root.next
-        time = self.__timer()
-        count = len(self.__links)
-        while curr is not root and curr.expire < time:
-            count -= 1
-            curr = curr.next
-        return count
-
-    def __setstate__(self, state):
-        self.__dict__.update(state)
-        root = self.__root
-        root.prev = root.next = root
-        for link in sorted(self.__links.values(), key=lambda obj: obj.expire):
-            link.next = root
-            link.prev = prev = root.prev
-            prev.next = root.prev = link
-        self.expire(self.__timer())
-
-    def __repr__(self, cache_repr=Cache.__repr__):
-        with self.__timer as time:
-            self.expire(time)
-            return cache_repr(self)
-
-    @property
-    def currsize(self):
-        with self.__timer as time:
-            self.expire(time)
-            return super(TTLCache, self).currsize
-
-    @property
-    def timer(self):
-        """The timer function used by the cache."""
-        return self.__timer
-
-    @property
-    def ttl(self):
-        """The time-to-live value of the cache's items."""
-        return self.__ttl
-
-    def expire(self, time=None):
-        """Remove expired items from the cache."""
-        if time is None:
-            time = self.__timer()
-        root = self.__root
-        curr = root.next
-        links = self.__links
-        cache_delitem = Cache.__delitem__
-        while curr is not root and curr.expire < time:
-            cache_delitem(self, curr.key)
-            del links[curr.key]
-            next = curr.next
-            curr.unlink()
-            curr = next
-
-    def clear(self):
-        with self.__timer as time:
-            self.expire(time)
-            Cache.clear(self)
-
-    def get(self, *args, **kwargs):
-        with self.__timer:
-            return Cache.get(self, *args, **kwargs)
-
-    def pop(self, *args, **kwargs):
-        with self.__timer:
-            return Cache.pop(self, *args, **kwargs)
-
-    def setdefault(self, *args, **kwargs):
-        with self.__timer:
-            return Cache.setdefault(self, *args, **kwargs)
-
-    def popitem(self):
-        """Remove and return the `(key, value)` pair least recently used that
-        has not already expired.
-
-        """
-        with self.__timer as time:
-            self.expire(time)
-            try:
-                key = next(iter(self.__links))
-            except StopIteration:
-                raise KeyError('%s is empty' % self.__class__.__name__)
-            else:
-                return (key, self.pop(key))
-
-    if hasattr(collections.OrderedDict, 'move_to_end'):
-        def __getlink(self, key):
-            value = self.__links[key]
-            self.__links.move_to_end(key)
-            return value
-    else:
-        def __getlink(self, key):
-            value = self.__links.pop(key)
-            self.__links[key] = value
-            return value

src/cbcm-v1.1beta1.json

@@ -0,0 +1,594 @@
+{
+  "auth": {
+    "oauth2": {
+      "scopes": {
+        "https://www.googleapis.com/auth/admin.directory.device.chromebrowsers": {
+          "description": "View and manage your Chrome browsers registered with Cloud Management"
+        },
+        "https://www.googleapis.com/auth/admin.directory.device.chromebrowsers.readonly": {
+          "description": "View your Chrome browsers registered with Cloud Management"
+        }
+      }
+    }
+  },
+  "basePath": "",
+  "baseUrl": "https://www.googleapis.com/admin/directory/v1.1beta1/customer/",
+  "batchPath": "batch",
+  "canonicalName": "cbcm",
+  "discoveryVersion": "v1",
+  "documentationLink": "https://support.google.com/chrome/a/answer/9681204",
+  "fullyEncodeReservedExpansion": true,
+  "icons": {
+    "x16": "http://www.google.com/images/icons/product/search-16.gif",
+    "x32": "http://www.google.com/images/icons/product/search-32.gif"
+  },
+  "id": "cbcm:v1.1beta1",
+  "kind": "discovery#restDescription",
+  "mtlsRootUrl": "https://admin.mtls.googleapis.com/",
+  "name": "cbcm",
+  "ownerDomain": "google.com",
+  "ownerName": "Jay Lee",
+  "packagePath": "cbcm",
+  "parameters": {
+    "$.xgafv": {
+      "description": "V1 error format.",
+      "enum": [
+        "1",
+        "2"
+      ],
+      "enumDescriptions": [
+        "v1 error format",
+        "v2 error format"
+      ],
+      "location": "query",
+      "type": "string"
+    },
+    "access_token": {
+      "description": "OAuth access token.",
+      "location": "query",
+      "type": "string"
+    },
+    "alt": {
+      "default": "json",
+      "description": "Data format for response.",
+      "enum": [
+        "json",
+        "media",
+        "proto"
+      ],
+      "enumDescriptions": [
+        "Responses with Content-Type of application/json",
+        "Media download with context-dependent Content-Type",
+        "Responses with Content-Type of application/x-protobuf"
+      ],
+      "location": "query",
+      "type": "string"
+    },
+    "callback": {
+      "description": "JSONP",
+      "location": "query",
+      "type": "string"
+    },
+    "fields": {
+      "description": "Selector specifying which fields to include in a partial response.",
+      "location": "query",
+      "type": "string"
+    },
+    "key": {
+      "description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.",
+      "location": "query",
+      "type": "string"
+    },
+    "oauth_token": {
+      "description": "OAuth 2.0 token for the current user.",
+      "location": "query",
+      "type": "string"
+    },
+    "prettyPrint": {
+      "default": "true",
+      "description": "Returns response with indentations and line breaks.",
+      "location": "query",
+      "type": "boolean"
+    },
+    "quotaUser": {
+      "description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.",
+      "location": "query",
+      "type": "string"
+    },
+    "uploadType": {
+      "description": "Legacy upload protocol for media (e.g. \"media\", \"multipart\").",
+      "location": "query",
+      "type": "string"
+    },
+    "upload_protocol": {
+      "description": "Upload protocol for media (e.g. \"raw\", \"multipart\").",
+      "location": "query",
+      "type": "string"
+    }
+  },
+  "protocol": "rest",
+  "resources": {
+    "chromebrowsers": {
+      "methods": {
+        "delete": {
+          "description": "Deletes a browser.",
+          "flatPath": "{customer}/devices/chromebrowsers/{deviceId}",
+          "httpMethod": "DELETE",
+          "id": "cbcm.chromebrowsers.delete",
+          "parameterOrder": [
+            "customer",
+            "deviceId"
+          ],
+          "parameters": {
+            "customer": {
+              "description": "Immutable ID of the G Suite account.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "deviceId": {
+              "description": "Immutable ID of the browser.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "{customer}/devices/chromebrowsers/{deviceId}",
+          "scopes": [
+            "https://www.googleapis.com/auth/admin.directory.device.chromebrowsers"
+          ]
+        },
+        "get": {
+          "description": "Retrieves a browser.",
+          "flatPath": "{customer}/devices/chromebrowsers/{deviceId}",
+          "httpMethod": "GET",
+          "id": "cbcm.chromebrowsers.get",
+          "parameterOrder": [
+            "customer",
+            "deviceId"
+          ],
+          "parameters": {
+            "customer": {
+              "description": "Immutable ID of the G Suite account.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "deviceId": {
+              "description": "Immutable ID of the browser.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "projection": {
+              "description": "Restrict information returned to a set of selected fields. FULL or BASIC.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "{customer}/devices/chromebrowsers/{deviceId}",
+          "response": {
+            "$ref": "ChromeBrowser"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/admin.directory.device.chromebrowsers",
+            "https://www.googleapis.com/auth/admin.directory.device.chromebrowsers.readonly"
+          ]
+        },
+        "list": {
+          "description": "Retrieves a paginated list of all the browsers in a domain.",
+          "flatPath": "{customer}/devices/chromebrowsers",
+          "httpMethod": "GET",
+          "id": "cbcm.chromebrowsers.list",
+          "parameterOrder": [
+            "customer"
+          ],
+          "parameters": {
+            "customer": {
+              "description": "Immutable ID of the G Suite account.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "maxResults": {
+              "description": "Maximum number of results to return.",
+              "format": "int32",
+              "location": "query",
+              "maximum": "100",
+              "minimum": "1",
+              "type": "integer"
+            },
+            "orderBy": {
+              "description": "property to use for sorting results.",
+              "location": "query",
+              "type": "string"
+            },
+            "orgUnitPath": {
+              "description": "The full path of the organizational unit or its unique ID.",
+              "location": "query",
+              "type": "string"
+            },
+            "pageToken": {
+              "description": "Token to specify the next page in the list.",
+              "location": "query",
+              "type": "string"
+            },
+            "projection": {
+              "description": "Restrict information returned to a set of selected fields. FULL or BASIC.",
+              "location": "query",
+              "type": "string"
+            },
+            "query": {
+              "description": "Search string using the list page query language.",
+              "location": "query",
+              "type": "string"
+            },
+            "sortOrder": {
+              "description": "Whether to return results in ascending or descending order. Must be used with the orderBy parameter.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "{customer}/devices/chromebrowsers",
+          "response": {
+            "$ref": "ChromeBrowsers"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/admin.directory.device.chromebrowsers",
+            "https://www.googleapis.com/auth/admin.directory.device.chromebrowsers.readonly"
+          ]
+        },
+        "moveChromeBrowsersToOu": {
+          "description": "Move Chrome Browsers Device between Organization Units",
+          "flatPath": "{customer}/devices/chromebrowsers/moveChromeBrowsersToOu",
+          "httpMethod": "POST",
+          "id": "cbcm.chromebrowsers.moveChromeBrowsersToOu",
+          "parameterOrder": [
+            "customer"
+          ],
+          "parameters": {
+            "customer": {
+              "description": "Immutable ID of the G Suite account.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "{customer}/devices/chromebrowsers/moveChromeBrowsersToOu",
+          "request": {
+            "$ref": "MoveChromeBrowsersRequest"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/admin.directory.device.chromebrowsers"
+          ]
+        },
+        "update": {
+          "description": "Updates a browser.",
+          "flatPath": "{customer}/devices/chromebrowsers/{deviceId}",
+          "httpMethod": "PUT",
+          "id": "cbcm.chromebrowsers.update",
+          "parameterOrder": [
+            "customer",
+            "deviceId"
+          ],
+          "parameters": {
+            "customer": {
+              "description": "Immutable ID of the G Suite account.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "deviceId": {
+              "description": "Immutable ID of the browser.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "projection": {
+              "description": "BASIC or FULL",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "{customer}/devices/chromebrowsers/{deviceId}",
+          "request": {
+            "$ref": "ChromeBrowser"
+          },
+          "response": {
+            "$ref": "ChromeBrowser"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/admin.directory.device.chromebrowsers"
+          ]
+        }
+      }
+    },
+    "enrollmentTokens": {
+      "methods": {
+        "list": {
+          "description": "Retrieves a paginated list of all the browser entollment tokens in a domain.",
+          "flatPath": "{customer}/chrome/enrollmentTokens",
+          "httpMethod": "GET",
+          "id": "cbcm.enrollmentTokens.list",
+          "parameterOrder": [
+            "customer"
+          ],
+          "parameters": {
+            "customer": {
+              "description": "Immutable ID of the G Suite account.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "pageSize": {
+              "description": "Maximum number of results to return.",
+              "format": "int32",
+              "location": "query",
+              "maximum": "100",
+              "minimum": "1",
+              "type": "integer"
+            },
+            "orgUnitPath": {
+              "description": "The full path of the organizational unit or its unique ID.",
+              "location": "query",
+              "type": "string"
+            },
+            "pageToken": {
+              "description": "Token to specify the next page in the list.",
+              "location": "query",
+              "type": "string"
+            },
+            "query": {
+              "description": "Search string using the list page query language.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "{customer}/chrome/enrollmentTokens",
+          "response": {
+            "$ref": "EnrollmentTokens"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/admin.directory.device.chromebrowsers",
+            "https://www.googleapis.com/auth/admin.directory.device.chromebrowsers.readonly"
+          ]
+        },
+        "create": {
+          "description": "Creates a browser enrollment token in a domain.",
+          "flatPath": "{customer}/chrome/enrollmentTokens",
+          "httpMethod": "POST",
+          "id": "cbcm.enrollmentTokens.create",
+          "parameterOrder": [
+            "customer"
+          ],
+          "parameters": {
+            "customer": {
+              "description": "Immutable ID of the G Suite account.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "{customer}/chrome/enrollmentTokens",
+          "request": {
+            "$ref": "CreateEnrollmentTokenRequest"
+          },
+          "response": {
+            "$ref": "EnrollmentToken"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/admin.directory.device.chromebrowsers"
+          ]
+        },
+        "revoke": {
+          "description": "Revokes a browser enrollment token in a domain.",
+          "flatPath": "{customer}/chrome/enrollmentTokens/{tokenPermanentId}:revoke",
+          "httpMethod": "POST",
+          "id": "cbcm.enrollmentTokens.revoke",
+          "parameterOrder": [
+            "customer",
+            "tokenPermanentId"
+          ],
+          "parameters": {
+            "customer": {
+              "description": "Immutable ID of the G Suite account.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "tokenPermanentId": {
+              "description": "Unique identifier for an enrollment token.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "{customer}/chrome/enrollmentTokens/{tokenPermanentId}:revoke",
+          "scopes": [
+            "https://www.googleapis.com/auth/admin.directory.device.chromebrowsers"
+          ]
+        }
+      }
+    }
+  },
+  "revision": "20201203",
+  "rootUrl": "https://www.googleapis.com/admin/directory/v1.1beta1/customer/",
+  "schemas": {
+    "ChromeBrowser": {
+      "id": "ChromeBrowser",
+      "properties": {
+        "annotatedAssetId": {
+          "description": "Asset identifier as annotated by the administrator or specified during enrollment.",
+          "type": "string"
+        },
+        "annotatedLocation": {
+          "description": "Address or location of the device as annotated by the administrator.",
+          "type": "string"
+        },
+        "annotatedNotes": {
+          "description": "Notes about this device as annotated by the administrator",
+          "type": "string"
+        },
+        "annotatedUser": {
+          "description": "User of the device as annotated by the administrator.",
+          "type": "string"
+        },
+        "deviceId": {
+          "annotations": {
+            "required": [
+              "cbcm.chromebrowsers.update"
+            ]
+          },
+          "description": "The unique ID of the device.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "ChromeBrowsers": {
+      "id": "ChromeBrowsers",
+      "properties": {
+        "browsers": {
+          "description": "List of Chrome browser objects.",
+          "items": {
+            "$ref": "ChromeBrowser"
+          },
+          "type": "array"
+        },
+        "etag": {
+          "description": "ETag of the resource.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "admin#directory#chromeosdevices",
+          "description": "Kind of resource this is.",
+          "type": "string"
+        },
+        "nextPageToken": {
+          "description": "Token used to access the next page of this result. To access the next page, use this token's value in the `pageToken` query string of this request.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "EnrollmentToken": {
+      "id": "EnrollmentToken",
+      "properties": {
+        "kind": {
+          "default": "admin#directory#chromeEnrollmentToken",
+          "description": "Kind of resource this is.",
+          "type": "string"
+        },
+        "tokenId": {
+          "description": "Enrollment Token ID.",
+          "type": "string"
+        },
+        "tokenPermanentId": {
+          "description": "Enrollment Token Permanent ID.",
+          "type": "string"
+        },
+        "customerId": {
+          "description": "Immutable ID of the G Suite account.",
+          "type": "string"
+        },
+        "orgUnitPath": {
+          "description": "The full path of the organizational unit or its unique ID.",
+          "type": "string"
+        },
+        "creatorId": {
+          "description": "Creator ID.",
+          "type": "string"
+        },
+        "createTime": {
+          "description": "Creation Time.",
+          "type": "string"
+        },
+        "revokerId": {
+          "description": "Revoker ID.",
+          "type": "string"
+        },
+        "revokeTime": {
+          "description": "Revoke Time",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "EnrollmentTokens": {
+      "id": "EnrollmentTokens",
+      "properties": {
+        "chrome_enrollment_tokens": {
+          "description": "List of Chrome browser enrollment token objects.",
+          "items": {
+            "$ref": "EnrollmentToken"
+          },
+          "type": "array"
+        },
+        "kind": {
+          "default": "admin#directory#chromeEnrollmentTokens",
+          "description": "Kind of resource this is.",
+          "type": "string"
+        },
+        "nextPageToken": {
+          "description": "Token used to access the next page of this result. To access the next page, use this token's value in the `pageToken` query string of this request.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "CreateEnrollmentTokenRequest": {
+      "id": "CreateEnrollmentTokenRequest",
+      "type": "object",
+      "properties": {
+        "org_unit_path": {
+          "description": "The full path of the organizational unit or its unique ID.",
+          "type": "string"
+        },
+        "expire_time": {
+          "description": "Expiration Time.",
+          "type": "string"
+        },
+        "token_type": {
+          "id": "token_type",
+          "annotations": {
+            "required": [
+              "cbcm.enrollmentTokens.create"
+            ]
+          },
+          "description": "CHROME_BROWSER.",
+          "type": "string"
+        }
+      }
+    },
+    "MoveChromeBrowsersRequest": {
+      "id": "MoveChromeBrowsersRequest",
+      "type": "object",
+      "properties": {
+        "org_unit_path": {
+          "annotations": {
+            "required": [
+              "cbcm.chromebrowsers.moveChromeBrowsersToOu"
+            ]
+          },
+          "description": "Destination organization unit to move devices to. Full path of the organizational unit or its ID prefixed with id:",
+          "type": "string"
+        },
+        "resource_ids": {
+          "annotations": {
+            "required": [
+              "cbcm.chromebrowsers.moveChromeBrowsersToOu"
+            ]
+          },
+          "description": "List of unique device IDs of Chrome Browser Devices to move. A maximum of 600 browsers may be moved per request.",
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    }
+  },
+  "servicePath": "",
+  "title": "Admin SDK API",
+  "version": "cbcm_v1.1beta1"
+}

src/cloudprint-v2.json

@@ -1,486 +0,0 @@
-{
- "kind": "discovery#restDescription",
- "discoveryVersion": "v1",
- "id": "cloudprint:v2",
- "name": "cloudprint",
- "version": "v2",
- "revision": "20150605",
- "title": "Cloud Print API",
- "description": "Lets you access Cloud Print Printers",
- "ownerDomain": "google.com",
- "ownerName": "Google",
- "icons": {
-  "x16": "http://www.google.com/images/icons/product/search-16.gif",
-  "x32": "http://www.google.com/images/icons/product/search-32.gif"
- },
- "documentationLink": "https://developers.google.com/cloud-print",
- "protocol": "rest",
- "baseUrl": "https://www.google.com/",
- "basePath": "/cloudprint/",
- "rootUrl": "https://www.google.com/",
- "servicePath": "/cloudprint/",
- "parameters": {
-  "prettyPrint": {
-   "type": "boolean",
-   "description": "Returns response with indentations and line breaks.",
-   "default": "true",
-   "location": "query"
-  }
- },
- "auth": {
-  "oauth2": {
-   "scopes": {
-    "https://www.googleapis.com/auth/cloudprint": {
-     "description": "Manage Cloud Print"
-    }
-   }
-  }
- },
- "schemas": {
-  "Job": {
-   "id": "Job",
-   "type": "object",
-   "description": "Job Object",
-   "properties": {
-    "title": {
-     "type": "string",
-     "description": "Job Title"
-    },
-    "id": {
-     "type": "string",
-     "description": "Unique ID"
-    }
-   }
-  },
-  "Jobs": {
-   "id": "Jobs",
-   "type": "object",
-   "description": "List of Jobs.",
-   "properties": {
-    "jobs": {
-     "type": "array",
-     "description": "List of job objects.",
-     "items": {
-      "$ref": "Job"
-     }
-    }
-   }
-  },
-  "Printer": {
-   "id": "Printer",
-   "type": "object",
-   "description": "Printer Object",
-   "properties": {
-    "displayName": {
-     "type": "string",
-     "description": "Display Name"
-    },
-    "id": {
-     "type": "string",
-     "description": "Unique ID"
-    }
-   }
-  },
-  "Printers": {
-   "id": "Printers",
-   "type": "object",
-   "description": "List of Printers.",
-   "properties": {
-    "printers": {
-     "type": "array",
-     "description": "List of printer objects.",
-     "items": {
-      "$ref": "Printer"
-     }
-    }
-   }
-  }
- },
- "resources": {
-  "jobs": {
-   "methods": {
-    "delete": {
-     "id": "cloudprint.jobs.delete",
-     "path": "deletejob",
-     "httpMethod": "GET",
-     "parameters": {
-      "jobid": {
-       "type": "string",
-       "location": "query",
-       "required": "true"
-      }
-     }
-    },
-    "fetch": {
-     "id": "cloudprint.jobs.fetch",
-     "path": "fetch",
-     "httpMethod": "GET",
-     "parameters": {
-      "printerid": {
-       "type": "string",
-       "required": "true",
-       "location": "query"
-      }
-     },
-     "response": {
-      "$ref": "Jobs"
-     }
-    },
-    "getticket": {
-     "id": "cloudprint.jobs.getticket",
-     "path": "ticket",
-     "httpMethod": "GET",
-     "parameters": {
-      "jobid": {
-       "type": "string",
-       "required": "true",
-       "location": "query"
-      },
-      "use_cjt": {
-       "type": "boolean",
-       "required": "true",
-       "location": "query"
-      }
-     }
-    }, 
-    "list": {
-     "id": "cloudprint.jobs.list",
-     "path": "jobs",
-     "httpMethod": "GET",
-     "parameters": {
-      "printerid": {
-       "type": "string",
-       "location": "query"
-      },
-      "owner": {
-       "type": "string",
-       "location": "query"
-      },
-      "status": {
-       "type": "string",
-       "location": "query"
-      },
-      "q": {
-       "type": "string",
-       "location": "query"
-      },
-      "offset": {
-       "type": "string",
-       "location": "query"
-      },
-      "limit": {
-       "type": "string",
-       "location": "query"
-      },
-      "sortorder": {
-       "type": "string",
-       "location": "query"
-      }
-     },
-     "response": {
-      "$ref": "Jobs"
-     }
-    },
-    "update": {
-     "id": "cloudprint.jobs.update",
-     "path": "control",
-     "httpMethod": "GET",
-     "parameters": {
-      "jobid": {
-       "type": "string",
-       "required": "true",
-       "location": "query"
-      },
-      "semantic_state_diff": {
-       "type": "string",
-       "required": "true",
-       "location": "query"
-      }
-     },
-     "response": {
-      "$ref": "Jobs"
-     }
-    },
-    "resubmit": {
-     "id": "cloudprint.jobs.resubmit",
-     "path": "resubmit",
-     "httpMethod": "POST",
-     "description": "resubmit a job to new printer.",
-     "parameters": {
-      "printerid": {
-       "type": "string",
-       "required": "true",
-       "location": "query"
-      },
-      "jobid": {
-       "type": "string",
-       "required": "true",
-       "location": "query"
-      },
-      "ticket": {
-       "type": "string",
-       "location": "query"
-      }
-     },
-     "response": {
-      "$ref": "Job"
-     }
-    },
-    "submit": {
-     "id": "cloudprint.jobs.submit",
-     "path": "submit",
-     "httpMethod": "POST",
-     "description": "Send a print job to cloud print.",
-     "request": {
-      "printerid": {
-       "type": "string",
-       "required": "true",
-       "location": "query"
-      },
-      "title": {
-       "type": "string",
-       "location": "query"
-      },
-      "ticket": {
-       "type": "string",
-       "location": "query"
-      },
-      "content": {
-       "type": "string",
-       "location": "query"
-      },
-      "contentType": {
-       "type": "string",
-       "location": "query"
-      },
-      "tag": {
-       "type": "string",
-       "location": "query"
-      }
-     },
-     "response": {
-      "$ref": "Job"
-     }
-    }
-   }
-  },
-  "printers": {
-   "methods": {
-    "get": {
-     "id": "cloudprint.printers.get",
-     "path": "printer",
-     "httpMethod": "GET",
-     "parameters": {
-      "printerid": {
-       "type": "string",
-       "required": "true",
-       "location": "query"
-      },
-      "extra_fields": {
-       "type": "string",
-       "location": "query"
-      }
-     },
-     "response": {
-      "$ref": "Printer"
-     }
-    },
-    "list": {
-     "id": "cloudprint.printers.list",
-     "path": "search",
-     "httpMethod": "GET",
-     "description": "List all printers",
-     "parameters": {
-      "q": {
-       "type": "string",
-       "description": "Query list of printers",
-       "location": "query"
-      },
-      "type": {
-       "type": "string",
-       "description": "limit results to printers of type",
-       "location": "query"
-       },
-      "connection_status": {
-       "type": "string",
-       "description": "limit results to printers with this status",
-       "location": "query"
-      },
-      "extra_fields": {
-       "type": "string",
-       "description": "include extra fields",
-       "location": "query"
-      }
-     },
-     "response": {
-      "$ref": "Printers"
-     }
-    },
-    "share": {
-     "id": "cloudprint.printers.share",
-     "path": "share",
-     "httpMethod": "GET",
-     "description": "Share printer with user, group or domain",
-     "parameters": {
-      "printerid": {
-       "type": "string",
-       "required": "true",
-       "location": "query"
-      },
-      "scope": {
-       "type": "string",
-       "location": "query"
-      },
-      "role": {
-       "type": "string",
-       "location": "query"
-      },
-      "type": {
-        "type": "string",
-        "location": "query"
-      },
-      "skip_notification": {
-       "type": "boolean",
-       "location": "query"
-      },
-      "public": {
-       "type": "boolean",
-       "location": "query"
-      }
-     } 
-    },
-    "unshare": {
-     "id": "cloudprint.printers.unshare",
-     "path": "unshare",
-     "httpMethod": "GET",
-     "description": "unshare printer with user, group or domain",
-     "parameters": {
-      "printerid": {
-       "type": "string",
-       "required": "true",
-       "location": "query"
-      },
-      "scope": {
-       "type": "string",
-       "location": "query"
-      },
-      "public": {
-       "type": "string",
-       "location": "query"
-      }
-     }
-    },
-    "delete": {
-     "id": "cloudprint.printers.delete",
-     "path": "delete",
-     "httpMethod": "GET",
-     "description": "delete a printer",
-     "parameters": {
-      "printerid": {
-       "type": "string",
-       "required": "true",
-       "location": "query"
-      }
-     }
-    },
-    "update": {
-     "id": "cloudprint.printers.update",
-     "path": "update",
-     "httpMethod": "GET",
-     "description": "update a printer",
-     "parameters": {
-      "isTosAccepted": {
-       "type": "boolean",
-       "location": "query"
-      },
-      "gcpVersion": {
-       "type": "string",
-       "location": "query"
-      },
-      "setupUrl": {
-       "type": "string",
-       "location": "query"
-      },
-      "supportUrl": {
-       "type": "string",
-       "location": "query"
-      },
-      "firmware": {
-       "type": "string",
-       "location": "query"
-      },
-      "currentQuota": {
-       "type": "string",
-       "location": "query"
-      },
-      "type": {
-       "type": "string",
-       "location": "query"
-      },
-      "public": {
-       "type": "boolean",
-       "location": "query"
-      },
-      "status": {
-       "type": "string",
-       "location": "query"
-      },
-      "proxy": {
-       "type": "string",
-       "location": "query"
-      },
-      "manufacturer": {
-       "type": "string",
-       "location": "query"
-      },
-      "defaultDisplayName": {
-       "type": "string",
-       "location": "query"
-      },
-      "displayName": {
-       "type": "string",
-       "location": "query"
-      },
-      "name": {
-       "type": "string",
-       "location": "query"
-      },
-      "uuid": {
-       "type": "string",
-       "location": "query"
-      },
-      "updateUrl": {
-       "type": "string",
-       "location": "query"
-      },
-      "ownerId": {
-       "type": "string",
-       "location": "query"
-      },
-      "model": {
-       "type": "string",
-       "location": "query"
-      },
-      "description": {
-       "type": "string",
-       "location": "query"
-      },
-      "printerid": {
-       "type": "string",
-       "required": "true",
-       "location": "query"
-      },
-      "quotaEnabled": {
-       "type": "boolean",
-       "location": "query"
-      },
-      "dailyQuota": {
-       "type": "string",
-       "location": "query"
-      }
-     }
-    } 
-   }
-  }
- }
-}

src/contactdelegation-v1.json

@@ -0,0 +1,249 @@
+{
+  "auth": {
+    "oauth2": {
+      "scopes": {
+        "https://www.googleapis.com/auth/admin.contact.delegation": {
+          "description": "View and manage your Contact Delegation"
+        }, 
+        "https://www.googleapis.com/auth/admin.contact.delegation.readonly": {
+          "description": "View your Contact Delegation"
+        }
+      }
+    }
+  }, 
+  "basePath": "",
+  "baseUrl": "https://admin.googleapis.com/admin/contacts/v1/",
+  "batchPath": "batch",
+  "canonicalName": "contactdelegation",
+  "description": "The Contact Delegation API allows Admins to delegate access of one user's, called the delegator, contacts to another user, called the delegate.",
+  "discoveryVersion": "v1",
+  "documentationLink": "https://developers.google.com/admin-sdk/contact-delegation",
+  "fullyEncodeReservedExpansion": true,
+  "icons": {
+    "x16": "http://www.google.com/images/icons/product/search-16.gif",
+    "x32": "http://www.google.com/images/icons/product/search-32.gif"
+  },
+  "id": "contactdelegation:v1",
+  "kind": "discovery#restDescription",
+  "name": "contactdelegation",
+  "ownerDomain": "google.com",
+  "ownerName": "Google",
+  "packagePath": "admin",
+  "parameters": {
+    "$.xgafv": {
+      "description": "V1 error format.",
+      "enum": [
+        "1",
+        "2"
+      ],
+      "enumDescriptions": [
+        "v1 error format",
+        "v2 error format"
+      ],
+      "location": "query",
+      "type": "string"
+    },
+    "access_token": {
+      "description": "OAuth access token.",
+      "location": "query",
+      "type": "string"
+    },
+    "alt": {
+      "default": "json",
+      "description": "Data format for response.",
+      "enum": [
+        "json",
+        "media",
+        "proto"
+      ],
+      "enumDescriptions": [
+        "Responses with Content-Type of application/json",
+        "Media download with context-dependent Content-Type",
+        "Responses with Content-Type of application/x-protobuf"
+      ],
+      "location": "query",
+      "type": "string"
+    },
+    "callback": {
+      "description": "JSONP",
+      "location": "query",
+      "type": "string"
+    },
+    "fields": {
+      "description": "Selector specifying which fields to include in a partial response.",
+      "location": "query",
+      "type": "string"
+    },
+    "key": {
+      "description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.",
+      "location": "query",
+      "type": "string"
+    },
+    "oauth_token": {
+      "description": "OAuth 2.0 token for the current user.",
+      "location": "query",
+      "type": "string"
+    },
+    "prettyPrint": {
+      "default": "true",
+      "description": "Returns response with indentations and line breaks.",
+      "location": "query",
+      "type": "boolean"
+    },
+    "quotaUser": {
+      "description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.",
+      "location": "query",
+      "type": "string"
+    },
+    "uploadType": {
+      "description": "Legacy upload protocol for media (e.g. \"media\", \"multipart\").",
+      "location": "query",
+      "type": "string"
+    },
+    "upload_protocol": {
+      "description": "Upload protocol for media (e.g. \"raw\", \"multipart\").",
+      "location": "query",
+      "type": "string"
+    }
+  },
+  "protocol": "rest",
+  "resources": {
+    "delegates": {
+      "methods": {
+        "create": {
+          "description": "Creates a contact delegations",
+          "flatPath": "users/{user}/delegates",
+          "httpMethod": "POST",
+          "id": "contactdelegations.delegates.create",
+          "parameterOrder": [
+            "user"
+          ],
+          "parameters": {
+            "user": {
+              "description": "Email address of the delegator.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "users/{user}/delegates/{delegate}",
+          "request": {
+            "$ref": "Delegate"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/admin.contact.delegation"
+          ]
+        },
+        "delete": {
+          "description": "Deletes a contact delegation.",
+          "flatPath": "users/{user}/delegates/{delegate}",
+          "httpMethod": "DELETE",
+          "id": "contactdelegations.delegates.delete",
+          "parameterOrder": [
+            "user",
+            "delegate"
+          ],
+          "parameters": {
+            "delegate": {
+              "description": "Email address of the delegate",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "user": {
+              "description": "Email address of the delegator.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "users/{user}/delegates/{delegate}",
+          "scopes": [
+            "https://www.googleapis.com/auth/admin.contact.delegation"
+          ]
+        },
+        "list": {
+          "description": "Lists contact delegates for a user",
+          "flatPath": "users/{user}/delegates",
+          "httpMethod": "GET",
+          "id": "contactdelegations.delegates.list",
+          "parameterOrder": [
+            "user"
+          ],
+          "parameters": {
+            "pageSize": {
+              "description": "Determines how many delegates are returned in each response. ",
+              "format": "int32",
+              "location": "query",
+              "minimum": "1",
+              "type": "integer"
+            },
+            "pageToken": {
+              "description": "Token to specify the next page in the list.",
+              "location": "query",
+              "type": "string"
+            },
+            "user": {
+              "description": "Email address of the delegator.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "users/{user}/delegates",
+          "response": {
+            "$ref": "Delegates"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/admin.contact.delegation",
+            "https://www.googleapis.com/auth/admin.contact.delegation.readonly"
+          ]
+        }
+      }
+    }
+  },
+  "rootUrl": "https://admin.googleapis.com/admin/contacts/v1/",
+  "schemas": {
+    "Delegate": {
+      "description": "JSON template for a delegate.",
+      "id": "Delegate",
+      "properties": {
+        "email": {
+          "description": "Email of the delegate.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "Delegates": {
+      "id": "Delegates",
+      "properties": {
+        "delegates": {
+          "description": "List of delegates.",
+          "items": {
+            "$ref": "Delegate"
+          },
+          "type": "array"
+        },
+        "etag": {
+          "description": "ETag of the resource.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "",
+          "description": "Kind of resource this is.",
+          "type": "string"
+        },
+        "nextPageToken": {
+          "description": "Token used to access the next page of this result. To access the next page, use this token's value in the `pageToken` query string of this request.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    }
+  },
+  "servicePath": "",
+  "title": "Contact Delegation API",
+  "version": "v1",
+  "version_module": true
+}

src/dns/__init__.py

@@ -1,56 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2007, 2009, 2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""dnspython DNS toolkit"""
-
-__all__ = [
-    'dnssec',
-    'e164',
-    'edns',
-    'entropy',
-    'exception',
-    'flags',
-    'hash',
-    'inet',
-    'ipv4',
-    'ipv6',
-    'message',
-    'name',
-    'namedict',
-    'node',
-    'opcode',
-    'query',
-    'rcode',
-    'rdata',
-    'rdataclass',
-    'rdataset',
-    'rdatatype',
-    'renderer',
-    'resolver',
-    'reversename',
-    'rrset',
-    'set',
-    'tokenizer',
-    'tsig',
-    'tsigkeyring',
-    'ttl',
-    'rdtypes',
-    'update',
-    'version',
-    'wiredata',
-    'zone',
-]

src/dns/_compat.py

@@ -1,59 +0,0 @@
-import sys
-import decimal
-from decimal import Context
-
-PY3 = sys.version_info[0] == 3
-PY2 = sys.version_info[0] == 2
-
-
-if PY3:
-    long = int
-    xrange = range
-else:
-    long = long  # pylint: disable=long-builtin
-    xrange = xrange  # pylint: disable=xrange-builtin
-
-# unicode / binary types
-if PY3:
-    text_type = str
-    binary_type = bytes
-    string_types = (str,)
-    unichr = chr
-    def maybe_decode(x):
-        return x.decode()
-    def maybe_encode(x):
-        return x.encode()
-    def maybe_chr(x):
-        return x
-    def maybe_ord(x):
-        return x
-else:
-    text_type = unicode  # pylint: disable=unicode-builtin, undefined-variable
-    binary_type = str
-    string_types = (
-        basestring,  # pylint: disable=basestring-builtin, undefined-variable
-    )
-    unichr = unichr  # pylint: disable=unichr-builtin
-    def maybe_decode(x):
-        return x
-    def maybe_encode(x):
-        return x
-    def maybe_chr(x):
-        return chr(x)
-    def maybe_ord(x):
-        return ord(x)
-
-
-def round_py2_compat(what):
-    """
-    Python 2 and Python 3 use different rounding strategies in round(). This
-    function ensures that results are python2/3 compatible and backward
-    compatible with previous py2 releases
-    :param what: float
-    :return: rounded long
-    """
-    d = Context(
-        prec=len(str(long(what))),  # round to integer with max precision
-        rounding=decimal.ROUND_HALF_UP
-    ).create_decimal(str(what))  # str(): python 2.6 compat
-    return long(d)

src/dns/dnssec.py

@@ -1,519 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2017 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""Common DNSSEC-related functions and constants."""
-
-from io import BytesIO
-import struct
-import time
-
-import dns.exception
-import dns.name
-import dns.node
-import dns.rdataset
-import dns.rdata
-import dns.rdatatype
-import dns.rdataclass
-from ._compat import string_types
-
-
-class UnsupportedAlgorithm(dns.exception.DNSException):
-    """The DNSSEC algorithm is not supported."""
-
-
-class ValidationFailure(dns.exception.DNSException):
-    """The DNSSEC signature is invalid."""
-
-
-#: RSAMD5
-RSAMD5 = 1
-#: DH
-DH = 2
-#: DSA
-DSA = 3
-#: ECC
-ECC = 4
-#: RSASHA1
-RSASHA1 = 5
-#: DSANSEC3SHA1
-DSANSEC3SHA1 = 6
-#: RSASHA1NSEC3SHA1
-RSASHA1NSEC3SHA1 = 7
-#: RSASHA256
-RSASHA256 = 8
-#: RSASHA512
-RSASHA512 = 10
-#: ECDSAP256SHA256
-ECDSAP256SHA256 = 13
-#: ECDSAP384SHA384
-ECDSAP384SHA384 = 14
-#: INDIRECT
-INDIRECT = 252
-#: PRIVATEDNS
-PRIVATEDNS = 253
-#: PRIVATEOID
-PRIVATEOID = 254
-
-_algorithm_by_text = {
-    'RSAMD5': RSAMD5,
-    'DH': DH,
-    'DSA': DSA,
-    'ECC': ECC,
-    'RSASHA1': RSASHA1,
-    'DSANSEC3SHA1': DSANSEC3SHA1,
-    'RSASHA1NSEC3SHA1': RSASHA1NSEC3SHA1,
-    'RSASHA256': RSASHA256,
-    'RSASHA512': RSASHA512,
-    'INDIRECT': INDIRECT,
-    'ECDSAP256SHA256': ECDSAP256SHA256,
-    'ECDSAP384SHA384': ECDSAP384SHA384,
-    'PRIVATEDNS': PRIVATEDNS,
-    'PRIVATEOID': PRIVATEOID,
-}
-
-# We construct the inverse mapping programmatically to ensure that we
-# cannot make any mistakes (e.g. omissions, cut-and-paste errors) that
-# would cause the mapping not to be true inverse.
-
-_algorithm_by_value = {y: x for x, y in _algorithm_by_text.items()}
-
-
-def algorithm_from_text(text):
-    """Convert text into a DNSSEC algorithm value.
-
-    Returns an ``int``.
-    """
-
-    value = _algorithm_by_text.get(text.upper())
-    if value is None:
-        value = int(text)
-    return value
-
-
-def algorithm_to_text(value):
-    """Convert a DNSSEC algorithm value to text
-
-    Returns a ``str``.
-    """
-
-    text = _algorithm_by_value.get(value)
-    if text is None:
-        text = str(value)
-    return text
-
-
-def _to_rdata(record, origin):
-    s = BytesIO()
-    record.to_wire(s, origin=origin)
-    return s.getvalue()
-
-
-def key_id(key, origin=None):
-    """Return the key id (a 16-bit number) for the specified key.
-
-    Note the *origin* parameter of this function is historical and
-    is not needed.
-
-    Returns an ``int`` between 0 and 65535.
-    """
-
-    rdata = _to_rdata(key, origin)
-    rdata = bytearray(rdata)
-    if key.algorithm == RSAMD5:
-        return (rdata[-3] << 8) + rdata[-2]
-    else:
-        total = 0
-        for i in range(len(rdata) // 2):
-            total += (rdata[2 * i] << 8) + \
-                rdata[2 * i + 1]
-        if len(rdata) % 2 != 0:
-            total += rdata[len(rdata) - 1] << 8
-        total += ((total >> 16) & 0xffff)
-        return total & 0xffff
-
-
-def make_ds(name, key, algorithm, origin=None):
-    """Create a DS record for a DNSSEC key.
-
-    *name* is the owner name of the DS record.
-
-    *key* is a ``dns.rdtypes.ANY.DNSKEY``.
-
-    *algorithm* is a string describing which hash algorithm to use.  The
-    currently supported hashes are "SHA1" and "SHA256".  Case does not
-    matter for these strings.
-
-    *origin* is a ``dns.name.Name`` and will be used as the origin
-    if *key* is a relative name.
-
-    Returns a ``dns.rdtypes.ANY.DS``.
-    """
-
-    if algorithm.upper() == 'SHA1':
-        dsalg = 1
-        hash = SHA1.new()
-    elif algorithm.upper() == 'SHA256':
-        dsalg = 2
-        hash = SHA256.new()
-    else:
-        raise UnsupportedAlgorithm('unsupported algorithm "%s"' % algorithm)
-
-    if isinstance(name, string_types):
-        name = dns.name.from_text(name, origin)
-    hash.update(name.canonicalize().to_wire())
-    hash.update(_to_rdata(key, origin))
-    digest = hash.digest()
-
-    dsrdata = struct.pack("!HBB", key_id(key), key.algorithm, dsalg) + digest
-    return dns.rdata.from_wire(dns.rdataclass.IN, dns.rdatatype.DS, dsrdata, 0,
-                               len(dsrdata))
-
-
-def _find_candidate_keys(keys, rrsig):
-    candidate_keys = []
-    value = keys.get(rrsig.signer)
-    if value is None:
-        return None
-    if isinstance(value, dns.node.Node):
-        try:
-            rdataset = value.find_rdataset(dns.rdataclass.IN,
-                                           dns.rdatatype.DNSKEY)
-        except KeyError:
-            return None
-    else:
-        rdataset = value
-    for rdata in rdataset:
-        if rdata.algorithm == rrsig.algorithm and \
-                key_id(rdata) == rrsig.key_tag:
-            candidate_keys.append(rdata)
-    return candidate_keys
-
-
-def _is_rsa(algorithm):
-    return algorithm in (RSAMD5, RSASHA1,
-                         RSASHA1NSEC3SHA1, RSASHA256,
-                         RSASHA512)
-
-
-def _is_dsa(algorithm):
-    return algorithm in (DSA, DSANSEC3SHA1)
-
-
-def _is_ecdsa(algorithm):
-    return _have_ecdsa and (algorithm in (ECDSAP256SHA256, ECDSAP384SHA384))
-
-
-def _is_md5(algorithm):
-    return algorithm == RSAMD5
-
-
-def _is_sha1(algorithm):
-    return algorithm in (DSA, RSASHA1,
-                         DSANSEC3SHA1, RSASHA1NSEC3SHA1)
-
-
-def _is_sha256(algorithm):
-    return algorithm in (RSASHA256, ECDSAP256SHA256)
-
-
-def _is_sha384(algorithm):
-    return algorithm == ECDSAP384SHA384
-
-
-def _is_sha512(algorithm):
-    return algorithm == RSASHA512
-
-
-def _make_hash(algorithm):
-    if _is_md5(algorithm):
-        return MD5.new()
-    if _is_sha1(algorithm):
-        return SHA1.new()
-    if _is_sha256(algorithm):
-        return SHA256.new()
-    if _is_sha384(algorithm):
-        return SHA384.new()
-    if _is_sha512(algorithm):
-        return SHA512.new()
-    raise ValidationFailure('unknown hash for algorithm %u' % algorithm)
-
-
-def _make_algorithm_id(algorithm):
-    if _is_md5(algorithm):
-        oid = [0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x02, 0x05]
-    elif _is_sha1(algorithm):
-        oid = [0x2b, 0x0e, 0x03, 0x02, 0x1a]
-    elif _is_sha256(algorithm):
-        oid = [0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01]
-    elif _is_sha512(algorithm):
-        oid = [0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03]
-    else:
-        raise ValidationFailure('unknown algorithm %u' % algorithm)
-    olen = len(oid)
-    dlen = _make_hash(algorithm).digest_size
-    idbytes = [0x30] + [8 + olen + dlen] + \
-              [0x30, olen + 4] + [0x06, olen] + oid + \
-              [0x05, 0x00] + [0x04, dlen]
-    return struct.pack('!%dB' % len(idbytes), *idbytes)
-
-
-def _validate_rrsig(rrset, rrsig, keys, origin=None, now=None):
-    """Validate an RRset against a single signature rdata
-
-    The owner name of *rrsig* is assumed to be the same as the owner name
-    of *rrset*.
-
-    *rrset* is the RRset to validate.  It can be a ``dns.rrset.RRset`` or
-    a ``(dns.name.Name, dns.rdataset.Rdataset)`` tuple.
-
-    *rrsig* is a ``dns.rdata.Rdata``, the signature to validate.
-
-    *keys* is the key dictionary, used to find the DNSKEY associated with
-    a given name.  The dictionary is keyed by a ``dns.name.Name``, and has
-    ``dns.node.Node`` or ``dns.rdataset.Rdataset`` values.
-
-    *origin* is a ``dns.name.Name``, the origin to use for relative names.
-
-    *now* is an ``int``, the time to use when validating the signatures,
-    in seconds since the UNIX epoch.  The default is the current time.
-    """
-
-    if isinstance(origin, string_types):
-        origin = dns.name.from_text(origin, dns.name.root)
-
-    candidate_keys = _find_candidate_keys(keys, rrsig)
-    if candidate_keys is None:
-        raise ValidationFailure('unknown key')
-
-    for candidate_key in candidate_keys:
-        # For convenience, allow the rrset to be specified as a (name,
-        # rdataset) tuple as well as a proper rrset
-        if isinstance(rrset, tuple):
-            rrname = rrset[0]
-            rdataset = rrset[1]
-        else:
-            rrname = rrset.name
-            rdataset = rrset
-
-        if now is None:
-            now = time.time()
-        if rrsig.expiration < now:
-            raise ValidationFailure('expired')
-        if rrsig.inception > now:
-            raise ValidationFailure('not yet valid')
-
-        hash = _make_hash(rrsig.algorithm)
-
-        if _is_rsa(rrsig.algorithm):
-            keyptr = candidate_key.key
-            (bytes_,) = struct.unpack('!B', keyptr[0:1])
-            keyptr = keyptr[1:]
-            if bytes_ == 0:
-                (bytes_,) = struct.unpack('!H', keyptr[0:2])
-                keyptr = keyptr[2:]
-            rsa_e = keyptr[0:bytes_]
-            rsa_n = keyptr[bytes_:]
-            try:
-                pubkey = CryptoRSA.construct(
-                    (number.bytes_to_long(rsa_n),
-                     number.bytes_to_long(rsa_e)))
-            except ValueError:
-                raise ValidationFailure('invalid public key')
-            sig = rrsig.signature
-        elif _is_dsa(rrsig.algorithm):
-            keyptr = candidate_key.key
-            (t,) = struct.unpack('!B', keyptr[0:1])
-            keyptr = keyptr[1:]
-            octets = 64 + t * 8
-            dsa_q = keyptr[0:20]
-            keyptr = keyptr[20:]
-            dsa_p = keyptr[0:octets]
-            keyptr = keyptr[octets:]
-            dsa_g = keyptr[0:octets]
-            keyptr = keyptr[octets:]
-            dsa_y = keyptr[0:octets]
-            pubkey = CryptoDSA.construct(
-                (number.bytes_to_long(dsa_y),
-                 number.bytes_to_long(dsa_g),
-                 number.bytes_to_long(dsa_p),
-                 number.bytes_to_long(dsa_q)))
-            sig = rrsig.signature[1:]
-        elif _is_ecdsa(rrsig.algorithm):
-            # use ecdsa for NIST-384p -- not currently supported by pycryptodome
-
-            keyptr = candidate_key.key
-
-            if rrsig.algorithm == ECDSAP256SHA256:
-                curve = ecdsa.curves.NIST256p
-                key_len = 32
-            elif rrsig.algorithm == ECDSAP384SHA384:
-                curve = ecdsa.curves.NIST384p
-                key_len = 48
-
-            x = number.bytes_to_long(keyptr[0:key_len])
-            y = number.bytes_to_long(keyptr[key_len:key_len * 2])
-            if not ecdsa.ecdsa.point_is_valid(curve.generator, x, y):
-                raise ValidationFailure('invalid ECDSA key')
-            point = ecdsa.ellipticcurve.Point(curve.curve, x, y, curve.order)
-            verifying_key = ecdsa.keys.VerifyingKey.from_public_point(point,
-                                                                      curve)
-            pubkey = ECKeyWrapper(verifying_key, key_len)
-            r = rrsig.signature[:key_len]
-            s = rrsig.signature[key_len:]
-            sig = ecdsa.ecdsa.Signature(number.bytes_to_long(r),
-                                        number.bytes_to_long(s))
-
-        else:
-            raise ValidationFailure('unknown algorithm %u' % rrsig.algorithm)
-
-        hash.update(_to_rdata(rrsig, origin)[:18])
-        hash.update(rrsig.signer.to_digestable(origin))
-
-        if rrsig.labels < len(rrname) - 1:
-            suffix = rrname.split(rrsig.labels + 1)[1]
-            rrname = dns.name.from_text('*', suffix)
-        rrnamebuf = rrname.to_digestable(origin)
-        rrfixed = struct.pack('!HHI', rdataset.rdtype, rdataset.rdclass,
-                              rrsig.original_ttl)
-        rrlist = sorted(rdataset)
-        for rr in rrlist:
-            hash.update(rrnamebuf)
-            hash.update(rrfixed)
-            rrdata = rr.to_digestable(origin)
-            rrlen = struct.pack('!H', len(rrdata))
-            hash.update(rrlen)
-            hash.update(rrdata)
-
-        try:
-            if _is_rsa(rrsig.algorithm):
-                verifier = pkcs1_15.new(pubkey)
-                # will raise ValueError if verify fails:
-                verifier.verify(hash, sig)
-            elif _is_dsa(rrsig.algorithm):
-                verifier = DSS.new(pubkey, 'fips-186-3')
-                verifier.verify(hash, sig)
-            elif _is_ecdsa(rrsig.algorithm):
-                digest = hash.digest()
-                if not pubkey.verify(digest, sig):
-                    raise ValueError
-            else:
-                # Raise here for code clarity; this won't actually ever happen
-                # since if the algorithm is really unknown we'd already have
-                # raised an exception above
-                raise ValidationFailure('unknown algorithm %u' % rrsig.algorithm)
-            # If we got here, we successfully verified so we can return without error
-            return
-        except ValueError:
-            # this happens on an individual validation failure
-            continue
-    # nothing verified -- raise failure:
-    raise ValidationFailure('verify failure')
-
-
-def _validate(rrset, rrsigset, keys, origin=None, now=None):
-    """Validate an RRset.
-
-    *rrset* is the RRset to validate.  It can be a ``dns.rrset.RRset`` or
-    a ``(dns.name.Name, dns.rdataset.Rdataset)`` tuple.
-
-    *rrsigset* is the signature RRset to be validated.  It can be a
-    ``dns.rrset.RRset`` or a ``(dns.name.Name, dns.rdataset.Rdataset)`` tuple.
-
-    *keys* is the key dictionary, used to find the DNSKEY associated with
-    a given name.  The dictionary is keyed by a ``dns.name.Name``, and has
-    ``dns.node.Node`` or ``dns.rdataset.Rdataset`` values.
-
-    *origin* is a ``dns.name.Name``, the origin to use for relative names.
-
-    *now* is an ``int``, the time to use when validating the signatures,
-    in seconds since the UNIX epoch.  The default is the current time.
-    """
-
-    if isinstance(origin, string_types):
-        origin = dns.name.from_text(origin, dns.name.root)
-
-    if isinstance(rrset, tuple):
-        rrname = rrset[0]
-    else:
-        rrname = rrset.name
-
-    if isinstance(rrsigset, tuple):
-        rrsigname = rrsigset[0]
-        rrsigrdataset = rrsigset[1]
-    else:
-        rrsigname = rrsigset.name
-        rrsigrdataset = rrsigset
-
-    rrname = rrname.choose_relativity(origin)
-    rrsigname = rrsigname.choose_relativity(origin)
-    if rrname != rrsigname:
-        raise ValidationFailure("owner names do not match")
-
-    for rrsig in rrsigrdataset:
-        try:
-            _validate_rrsig(rrset, rrsig, keys, origin, now)
-            return
-        except ValidationFailure:
-            pass
-    raise ValidationFailure("no RRSIGs validated")
-
-
-def _need_pycrypto(*args, **kwargs):
-    raise NotImplementedError("DNSSEC validation requires pycryptodome/pycryptodomex")
-
-
-try:
-    try:
-        # test we're using pycryptodome, not pycrypto (which misses SHA1 for example)
-        from Crypto.Hash import MD5, SHA1, SHA256, SHA384, SHA512
-        from Crypto.PublicKey import RSA as CryptoRSA, DSA as CryptoDSA
-        from Crypto.Signature import pkcs1_15, DSS
-        from Crypto.Util import number
-    except ImportError:
-        from Cryptodome.Hash import MD5, SHA1, SHA256, SHA384, SHA512
-        from Cryptodome.PublicKey import RSA as CryptoRSA, DSA as CryptoDSA
-        from Cryptodome.Signature import pkcs1_15, DSS
-        from Cryptodome.Util import number
-except ImportError:
-    validate = _need_pycrypto
-    validate_rrsig = _need_pycrypto
-    _have_pycrypto = False
-    _have_ecdsa = False
-else:
-    validate = _validate
-    validate_rrsig = _validate_rrsig
-    _have_pycrypto = True
-
-    try:
-        import ecdsa
-        import ecdsa.ecdsa
-        import ecdsa.ellipticcurve
-        import ecdsa.keys
-    except ImportError:
-        _have_ecdsa = False
-    else:
-        _have_ecdsa = True
-
-        class ECKeyWrapper(object):
-
-            def __init__(self, key, key_len):
-                self.key = key
-                self.key_len = key_len
-
-            def verify(self, digest, sig):
-                diglong = number.bytes_to_long(digest)
-                return self.key.pubkey.verifies(diglong, sig)

src/dns/dnssec.pyi

@@ -1,19 +0,0 @@
-from typing import Union, Dict, Tuple, Optional
-from . import rdataset, rrset, exception, name, rdtypes, rdata, node
-import dns.rdtypes.ANY.DS as DS
-import dns.rdtypes.ANY.DNSKEY as DNSKEY
-
-_have_ecdsa : bool
-_have_pycrypto : bool
-
-def validate_rrsig(rrset : Union[Tuple[name.Name, rdataset.Rdataset], rrset.RRset], rrsig : rdata.Rdata, keys : Dict[name.Name, Union[node.Node, rdataset.Rdataset]], origin : Optional[name.Name] = None, now : Optional[int] = None) -> None:
-    ...
-
-def validate(rrset: Union[Tuple[name.Name, rdataset.Rdataset], rrset.RRset], rrsigset : Union[Tuple[name.Name, rdataset.Rdataset], rrset.RRset], keys : Dict[name.Name, Union[node.Node, rdataset.Rdataset]], origin=None, now=None) -> None:
-    ...
-
-class ValidationFailure(exception.DNSException):
-    ...
-
-def make_ds(name : name.Name, key : DNSKEY.DNSKEY, algorithm : str, origin : Optional[name.Name] = None) -> DS.DS:
-    ...

src/dns/e164.py

@@ -1,105 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2006-2017 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""DNS E.164 helpers."""
-
-import dns.exception
-import dns.name
-import dns.resolver
-from ._compat import string_types, maybe_decode
-
-#: The public E.164 domain.
-public_enum_domain = dns.name.from_text('e164.arpa.')
-
-
-def from_e164(text, origin=public_enum_domain):
-    """Convert an E.164 number in textual form into a Name object whose
-    value is the ENUM domain name for that number.
-
-    Non-digits in the text are ignored, i.e. "16505551212",
-    "+1.650.555.1212" and "1 (650) 555-1212" are all the same.
-
-    *text*, a ``text``, is an E.164 number in textual form.
-
-    *origin*, a ``dns.name.Name``, the domain in which the number
-    should be constructed.  The default is ``e164.arpa.``.
-
-    Returns a ``dns.name.Name``.
-    """
-
-    parts = [d for d in text if d.isdigit()]
-    parts.reverse()
-    return dns.name.from_text('.'.join(parts), origin=origin)
-
-
-def to_e164(name, origin=public_enum_domain, want_plus_prefix=True):
-    """Convert an ENUM domain name into an E.164 number.
-
-    Note that dnspython does not have any information about preferred
-    number formats within national numbering plans, so all numbers are
-    emitted as a simple string of digits, prefixed by a '+' (unless
-    *want_plus_prefix* is ``False``).
-
-    *name* is a ``dns.name.Name``, the ENUM domain name.
-
-    *origin* is a ``dns.name.Name``, a domain containing the ENUM
-    domain name.  The name is relativized to this domain before being
-    converted to text.  If ``None``, no relativization is done.
-
-    *want_plus_prefix* is a ``bool``.  If True, add a '+' to the beginning of
-    the returned number.
-
-    Returns a ``text``.
-
-    """
-    if origin is not None:
-        name = name.relativize(origin)
-    dlabels = [d for d in name.labels if d.isdigit() and len(d) == 1]
-    if len(dlabels) != len(name.labels):
-        raise dns.exception.SyntaxError('non-digit labels in ENUM domain name')
-    dlabels.reverse()
-    text = b''.join(dlabels)
-    if want_plus_prefix:
-        text = b'+' + text
-    return maybe_decode(text)
-
-
-def query(number, domains, resolver=None):
-    """Look for NAPTR RRs for the specified number in the specified domains.
-
-    e.g. lookup('16505551212', ['e164.dnspython.org.', 'e164.arpa.'])
-
-    *number*, a ``text`` is the number to look for.
-
-    *domains* is an iterable containing ``dns.name.Name`` values.
-
-    *resolver*, a ``dns.resolver.Resolver``, is the resolver to use.  If
-    ``None``, the default resolver is used.
-    """
-
-    if resolver is None:
-        resolver = dns.resolver.get_default_resolver()
-    e_nx = dns.resolver.NXDOMAIN()
-    for domain in domains:
-        if isinstance(domain, string_types):
-            domain = dns.name.from_text(domain)
-        qname = dns.e164.from_e164(number, domain)
-        try:
-            return resolver.query(qname, 'NAPTR')
-        except dns.resolver.NXDOMAIN as e:
-            e_nx += e
-    raise e_nx

src/dns/e164.pyi

@@ -1,10 +0,0 @@
-from typing import Optional, Iterable
-from . import name, resolver
-def from_e164(text : str, origin=name.Name(".")) -> name.Name:
-    ...
-
-def to_e164(name : name.Name, origin : Optional[name.Name] = None, want_plus_prefix=True) -> str:
-    ...
-
-def query(number : str, domains : Iterable[str], resolver : Optional[resolver.Resolver] = None) -> resolver.Answer:
-    ...

src/dns/edns.py

@@ -1,269 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2009-2017 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""EDNS Options"""
-
-from __future__ import absolute_import
-
-import math
-import struct
-
-import dns.inet
-
-#: NSID
-NSID = 3
-#: DAU
-DAU = 5
-#: DHU
-DHU = 6
-#: N3U
-N3U = 7
-#: ECS (client-subnet)
-ECS = 8
-#: EXPIRE
-EXPIRE = 9
-#: COOKIE
-COOKIE = 10
-#: KEEPALIVE
-KEEPALIVE = 11
-#: PADDING
-PADDING = 12
-#: CHAIN
-CHAIN = 13
-
-class Option(object):
-
-    """Base class for all EDNS option types."""
-
-    def __init__(self, otype):
-        """Initialize an option.
-
-        *otype*, an ``int``, is the option type.
-        """
-        self.otype = otype
-
-    def to_wire(self, file):
-        """Convert an option to wire format.
-        """
-        raise NotImplementedError
-
-    @classmethod
-    def from_wire(cls, otype, wire, current, olen):
-        """Build an EDNS option object from wire format.
-
-        *otype*, an ``int``, is the option type.
-
-        *wire*, a ``binary``, is the wire-format message.
-
-        *current*, an ``int``, is the offset in *wire* of the beginning
-        of the rdata.
-
-        *olen*, an ``int``, is the length of the wire-format option data
-
-        Returns a ``dns.edns.Option``.
-        """
-
-        raise NotImplementedError
-
-    def _cmp(self, other):
-        """Compare an EDNS option with another option of the same type.
-
-        Returns < 0 if < *other*, 0 if == *other*, and > 0 if > *other*.
-        """
-        raise NotImplementedError
-
-    def __eq__(self, other):
-        if not isinstance(other, Option):
-            return False
-        if self.otype != other.otype:
-            return False
-        return self._cmp(other) == 0
-
-    def __ne__(self, other):
-        if not isinstance(other, Option):
-            return False
-        if self.otype != other.otype:
-            return False
-        return self._cmp(other) != 0
-
-    def __lt__(self, other):
-        if not isinstance(other, Option) or \
-                self.otype != other.otype:
-            return NotImplemented
-        return self._cmp(other) < 0
-
-    def __le__(self, other):
-        if not isinstance(other, Option) or \
-                self.otype != other.otype:
-            return NotImplemented
-        return self._cmp(other) <= 0
-
-    def __ge__(self, other):
-        if not isinstance(other, Option) or \
-                self.otype != other.otype:
-            return NotImplemented
-        return self._cmp(other) >= 0
-
-    def __gt__(self, other):
-        if not isinstance(other, Option) or \
-                self.otype != other.otype:
-            return NotImplemented
-        return self._cmp(other) > 0
-
-
-class GenericOption(Option):
-
-    """Generic Option Class
-
-    This class is used for EDNS option types for which we have no better
-    implementation.
-    """
-
-    def __init__(self, otype, data):
-        super(GenericOption, self).__init__(otype)
-        self.data = data
-
-    def to_wire(self, file):
-        file.write(self.data)
-
-    def to_text(self):
-        return "Generic %d" % self.otype
-
-    @classmethod
-    def from_wire(cls, otype, wire, current, olen):
-        return cls(otype, wire[current: current + olen])
-
-    def _cmp(self, other):
-        if self.data == other.data:
-            return 0
-        if self.data > other.data:
-            return 1
-        return -1
-
-
-class ECSOption(Option):
-    """EDNS Client Subnet (ECS, RFC7871)"""
-
-    def __init__(self, address, srclen=None, scopelen=0):
-        """*address*, a ``text``, is the client address information.
-
-        *srclen*, an ``int``, the source prefix length, which is the
-        leftmost number of bits of the address to be used for the
-        lookup.  The default is 24 for IPv4 and 56 for IPv6.
-
-        *scopelen*, an ``int``, the scope prefix length.  This value
-        must be 0 in queries, and should be set in responses.
-        """
-
-        super(ECSOption, self).__init__(ECS)
-        af = dns.inet.af_for_address(address)
-
-        if af == dns.inet.AF_INET6:
-            self.family = 2
-            if srclen is None:
-                srclen = 56
-        elif af == dns.inet.AF_INET:
-            self.family = 1
-            if srclen is None:
-                srclen = 24
-        else:
-            raise ValueError('Bad ip family')
-
-        self.address = address
-        self.srclen = srclen
-        self.scopelen = scopelen
-
-        addrdata = dns.inet.inet_pton(af, address)
-        nbytes = int(math.ceil(srclen/8.0))
-
-        # Truncate to srclen and pad to the end of the last octet needed
-        # See RFC section 6
-        self.addrdata = addrdata[:nbytes]
-        nbits = srclen % 8
-        if nbits != 0:
-            last = struct.pack('B', ord(self.addrdata[-1:]) & (0xff << nbits))
-            self.addrdata = self.addrdata[:-1] + last
-
-    def to_text(self):
-        return "ECS {}/{} scope/{}".format(self.address, self.srclen,
-                                           self.scopelen)
-
-    def to_wire(self, file):
-        file.write(struct.pack('!H', self.family))
-        file.write(struct.pack('!BB', self.srclen, self.scopelen))
-        file.write(self.addrdata)
-
-    @classmethod
-    def from_wire(cls, otype, wire, cur, olen):
-        family, src, scope = struct.unpack('!HBB', wire[cur:cur+4])
-        cur += 4
-
-        addrlen = int(math.ceil(src/8.0))
-
-        if family == 1:
-            af = dns.inet.AF_INET
-            pad = 4 - addrlen
-        elif family == 2:
-            af = dns.inet.AF_INET6
-            pad = 16 - addrlen
-        else:
-            raise ValueError('unsupported family')
-
-        addr = dns.inet.inet_ntop(af, wire[cur:cur+addrlen] + b'\x00' * pad)
-        return cls(addr, src, scope)
-
-    def _cmp(self, other):
-        if self.addrdata == other.addrdata:
-            return 0
-        if self.addrdata > other.addrdata:
-            return 1
-        return -1
-
-_type_to_class = {
-        ECS: ECSOption
-}
-
-def get_option_class(otype):
-    """Return the class for the specified option type.
-
-    The GenericOption class is used if a more specific class is not
-    known.
-    """
-
-    cls = _type_to_class.get(otype)
-    if cls is None:
-        cls = GenericOption
-    return cls
-
-
-def option_from_wire(otype, wire, current, olen):
-    """Build an EDNS option object from wire format.
-
-    *otype*, an ``int``, is the option type.
-
-    *wire*, a ``binary``, is the wire-format message.
-
-    *current*, an ``int``, is the offset in *wire* of the beginning
-    of the rdata.
-
-    *olen*, an ``int``, is the length of the wire-format option data
-
-    Returns an instance of a subclass of ``dns.edns.Option``.
-    """
-
-    cls = get_option_class(otype)
-    return cls.from_wire(otype, wire, current, olen)

src/dns/entropy.py

@@ -1,148 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2009-2017 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import os
-import random
-import time
-from ._compat import long, binary_type
-try:
-    import threading as _threading
-except ImportError:
-    import dummy_threading as _threading
-
-
-class EntropyPool(object):
-
-    # This is an entropy pool for Python implementations that do not
-    # have a working SystemRandom.  I'm not sure there are any, but
-    # leaving this code doesn't hurt anything as the library code
-    # is used if present.
-
-    def __init__(self, seed=None):
-        self.pool_index = 0
-        self.digest = None
-        self.next_byte = 0
-        self.lock = _threading.Lock()
-        try:
-            import hashlib
-            self.hash = hashlib.sha1()
-            self.hash_len = 20
-        except ImportError:
-            try:
-                import sha
-                self.hash = sha.new()
-                self.hash_len = 20
-            except ImportError:
-                import md5  # pylint: disable=import-error
-                self.hash = md5.new()
-                self.hash_len = 16
-        self.pool = bytearray(b'\0' * self.hash_len)
-        if seed is not None:
-            self.stir(bytearray(seed))
-            self.seeded = True
-            self.seed_pid = os.getpid()
-        else:
-            self.seeded = False
-            self.seed_pid = 0
-
-    def stir(self, entropy, already_locked=False):
-        if not already_locked:
-            self.lock.acquire()
-        try:
-            for c in entropy:
-                if self.pool_index == self.hash_len:
-                    self.pool_index = 0
-                b = c & 0xff
-                self.pool[self.pool_index] ^= b
-                self.pool_index += 1
-        finally:
-            if not already_locked:
-                self.lock.release()
-
-    def _maybe_seed(self):
-        if not self.seeded or self.seed_pid != os.getpid():
-            try:
-                seed = os.urandom(16)
-            except Exception:
-                try:
-                    r = open('/dev/urandom', 'rb', 0)
-                    try:
-                        seed = r.read(16)
-                    finally:
-                        r.close()
-                except Exception:
-                    seed = str(time.time())
-            self.seeded = True
-            self.seed_pid = os.getpid()
-            self.digest = None
-            seed = bytearray(seed)
-            self.stir(seed, True)
-
-    def random_8(self):
-        self.lock.acquire()
-        try:
-            self._maybe_seed()
-            if self.digest is None or self.next_byte == self.hash_len:
-                self.hash.update(binary_type(self.pool))
-                self.digest = bytearray(self.hash.digest())
-                self.stir(self.digest, True)
-                self.next_byte = 0
-            value = self.digest[self.next_byte]
-            self.next_byte += 1
-        finally:
-            self.lock.release()
-        return value
-
-    def random_16(self):
-        return self.random_8() * 256 + self.random_8()
-
-    def random_32(self):
-        return self.random_16() * 65536 + self.random_16()
-
-    def random_between(self, first, last):
-        size = last - first + 1
-        if size > long(4294967296):
-            raise ValueError('too big')
-        if size > 65536:
-            rand = self.random_32
-            max = long(4294967295)
-        elif size > 256:
-            rand = self.random_16
-            max = 65535
-        else:
-            rand = self.random_8
-            max = 255
-        return first + size * rand() // (max + 1)
-
-pool = EntropyPool()
-
-try:
-    system_random = random.SystemRandom()
-except Exception:
-    system_random = None
-
-def random_16():
-    if system_random is not None:
-        return system_random.randrange(0, 65536)
-    else:
-        return pool.random_16()
-
-def between(first, last):
-    if system_random is not None:
-        return system_random.randrange(first, last + 1)
-    else:
-        return pool.random_between(first, last)

src/dns/entropy.pyi

@@ -1,10 +0,0 @@
-from typing import Optional
-from random import SystemRandom
-
-system_random : Optional[SystemRandom]
-
-def random_16() -> int:
-   pass
-
-def between(first: int, last: int) -> int:
-    pass

src/dns/exception.py

@@ -1,128 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2017 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""Common DNS Exceptions.
-
-Dnspython modules may also define their own exceptions, which will
-always be subclasses of ``DNSException``.
-"""
-
-class DNSException(Exception):
-    """Abstract base class shared by all dnspython exceptions.
-
-    It supports two basic modes of operation:
-
-    a) Old/compatible mode is used if ``__init__`` was called with
-    empty *kwargs*.  In compatible mode all *args* are passed
-    to the standard Python Exception class as before and all *args* are
-    printed by the standard ``__str__`` implementation.  Class variable
-    ``msg`` (or doc string if ``msg`` is ``None``) is returned from ``str()``
-    if *args* is empty.
-
-    b) New/parametrized mode is used if ``__init__`` was called with
-    non-empty *kwargs*.
-    In the new mode *args* must be empty and all kwargs must match
-    those set in class variable ``supp_kwargs``. All kwargs are stored inside
-    ``self.kwargs`` and used in a new ``__str__`` implementation to construct
-    a formatted message based on the ``fmt`` class variable, a ``string``.
-
-    In the simplest case it is enough to override the ``supp_kwargs``
-    and ``fmt`` class variables to get nice parametrized messages.
-    """
-
-    msg = None  # non-parametrized message
-    supp_kwargs = set()  # accepted parameters for _fmt_kwargs (sanity check)
-    fmt = None  # message parametrized with results from _fmt_kwargs
-
-    def __init__(self, *args, **kwargs):
-        self._check_params(*args, **kwargs)
-        if kwargs:
-            self.kwargs = self._check_kwargs(**kwargs)
-            self.msg = str(self)
-        else:
-            self.kwargs = dict()  # defined but empty for old mode exceptions
-        if self.msg is None:
-            # doc string is better implicit message than empty string
-            self.msg = self.__doc__
-        if args:
-            super(DNSException, self).__init__(*args)
-        else:
-            super(DNSException, self).__init__(self.msg)
-
-    def _check_params(self, *args, **kwargs):
-        """Old exceptions supported only args and not kwargs.
-
-        For sanity we do not allow to mix old and new behavior."""
-        if args or kwargs:
-            assert bool(args) != bool(kwargs), \
-                'keyword arguments are mutually exclusive with positional args'
-
-    def _check_kwargs(self, **kwargs):
-        if kwargs:
-            assert set(kwargs.keys()) == self.supp_kwargs, \
-                'following set of keyword args is required: %s' % (
-                    self.supp_kwargs)
-        return kwargs
-
-    def _fmt_kwargs(self, **kwargs):
-        """Format kwargs before printing them.
-
-        Resulting dictionary has to have keys necessary for str.format call
-        on fmt class variable.
-        """
-        fmtargs = {}
-        for kw, data in kwargs.items():
-            if isinstance(data, (list, set)):
-                # convert list of <someobj> to list of str(<someobj>)
-                fmtargs[kw] = list(map(str, data))
-                if len(fmtargs[kw]) == 1:
-                    # remove list brackets [] from single-item lists
-                    fmtargs[kw] = fmtargs[kw].pop()
-            else:
-                fmtargs[kw] = data
-        return fmtargs
-
-    def __str__(self):
-        if self.kwargs and self.fmt:
-            # provide custom message constructed from keyword arguments
-            fmtargs = self._fmt_kwargs(**self.kwargs)
-            return self.fmt.format(**fmtargs)
-        else:
-            # print *args directly in the same way as old DNSException
-            return super(DNSException, self).__str__()
-
-
-class FormError(DNSException):
-    """DNS message is malformed."""
-
-
-class SyntaxError(DNSException):
-    """Text input is malformed."""
-
-
-class UnexpectedEnd(SyntaxError):
-    """Text input ended unexpectedly."""
-
-
-class TooBig(DNSException):
-    """The DNS message is too big."""
-
-
-class Timeout(DNSException):
-    """The DNS operation timed out."""
-    supp_kwargs = {'timeout'}
-    fmt = "The DNS operation timed out after {timeout} seconds"

src/dns/exception.pyi

@@ -1,9 +0,0 @@
-from typing import Set, Optional, Dict
-
-class DNSException(Exception):
-    supp_kwargs : Set[str]
-    kwargs : Optional[Dict]
-
-class SyntaxError(DNSException): ...
-class FormError(DNSException): ...
-class Timeout(DNSException): ...

src/dns/flags.py

@@ -1,130 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2001-2017 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""DNS Message Flags."""
-
-# Standard DNS flags
-
-#: Query Response
-QR = 0x8000
-#: Authoritative Answer
-AA = 0x0400
-#: Truncated Response
-TC = 0x0200
-#: Recursion Desired
-RD = 0x0100
-#: Recursion Available
-RA = 0x0080
-#: Authentic Data
-AD = 0x0020
-#: Checking Disabled
-CD = 0x0010
-
-# EDNS flags
-
-#: DNSSEC answer OK
-DO = 0x8000
-
-_by_text = {
-    'QR': QR,
-    'AA': AA,
-    'TC': TC,
-    'RD': RD,
-    'RA': RA,
-    'AD': AD,
-    'CD': CD
-}
-
-_edns_by_text = {
-    'DO': DO
-}
-
-
-# We construct the inverse mappings programmatically to ensure that we
-# cannot make any mistakes (e.g. omissions, cut-and-paste errors) that
-# would cause the mappings not to be true inverses.
-
-_by_value = {y: x for x, y in _by_text.items()}
-
-_edns_by_value = {y: x for x, y in _edns_by_text.items()}
-
-
-def _order_flags(table):
-    order = list(table.items())
-    order.sort()
-    order.reverse()
-    return order
-
-_flags_order = _order_flags(_by_value)
-
-_edns_flags_order = _order_flags(_edns_by_value)
-
-
-def _from_text(text, table):
-    flags = 0
-    tokens = text.split()
-    for t in tokens:
-        flags = flags | table[t.upper()]
-    return flags
-
-
-def _to_text(flags, table, order):
-    text_flags = []
-    for k, v in order:
-        if flags & k != 0:
-            text_flags.append(v)
-    return ' '.join(text_flags)
-
-
-def from_text(text):
-    """Convert a space-separated list of flag text values into a flags
-    value.
-
-    Returns an ``int``
-    """
-
-    return _from_text(text, _by_text)
-
-
-def to_text(flags):
-    """Convert a flags value into a space-separated list of flag text
-    values.
-
-    Returns a ``text``.
-    """
-
-    return _to_text(flags, _by_value, _flags_order)
-
-
-def edns_from_text(text):
-    """Convert a space-separated list of EDNS flag text values into a EDNS
-    flags value.
-
-    Returns an ``int``
-    """
-
-    return _from_text(text, _edns_by_text)
-
-
-def edns_to_text(flags):
-    """Convert an EDNS flags value into a space-separated list of EDNS flag
-    text values.
-
-    Returns a ``text``.
-    """
-
-    return _to_text(flags, _edns_by_value, _edns_flags_order)

src/dns/grange.py

@@ -1,69 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2012-2017 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""DNS GENERATE range conversion."""
-
-import dns
-
-def from_text(text):
-    """Convert the text form of a range in a ``$GENERATE`` statement to an
-    integer.
-
-    *text*, a ``str``, the textual range in ``$GENERATE`` form.
-
-    Returns a tuple of three ``int`` values ``(start, stop, step)``.
-    """
-
-    # TODO, figure out the bounds on start, stop and step.
-    step = 1
-    cur = ''
-    state = 0
-    # state   0 1 2 3 4
-    #         x - y / z
-
-    if text and text[0] == '-':
-        raise dns.exception.SyntaxError("Start cannot be a negative number")
-
-    for c in text:
-        if c == '-' and state == 0:
-            start = int(cur)
-            cur = ''
-            state = 2
-        elif c == '/':
-            stop = int(cur)
-            cur = ''
-            state = 4
-        elif c.isdigit():
-            cur += c
-        else:
-            raise dns.exception.SyntaxError("Could not parse %s" % (c))
-
-    if state in (1, 3):
-        raise dns.exception.SyntaxError()
-
-    if state == 2:
-        stop = int(cur)
-
-    if state == 4:
-        step = int(cur)
-
-    assert step >= 1
-    assert start >= 0
-    assert start <= stop
-    # TODO, can start == stop?
-
-    return (start, stop, step)

src/dns/hash.py

@@ -1,37 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""Hashing backwards compatibility wrapper"""
-
-import hashlib
-import warnings
-
-warnings.warn(
-    "dns.hash module will be removed in future versions. Please use hashlib instead.",
-    DeprecationWarning)
-
-hashes = {}
-hashes['MD5'] = hashlib.md5
-hashes['SHA1'] = hashlib.sha1
-hashes['SHA224'] = hashlib.sha224
-hashes['SHA256'] = hashlib.sha256
-hashes['SHA384'] = hashlib.sha384
-hashes['SHA512'] = hashlib.sha512
-
-
-def get(algorithm):
-    return hashes[algorithm.upper()]

src/dns/inet.py

@@ -1,124 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2017 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""Generic Internet address helper functions."""
-
-import socket
-
-import dns.ipv4
-import dns.ipv6
-
-from ._compat import maybe_ord
-
-# We assume that AF_INET is always defined.
-
-AF_INET = socket.AF_INET
-
-# AF_INET6 might not be defined in the socket module, but we need it.
-# We'll try to use the socket module's value, and if it doesn't work,
-# we'll use our own value.
-
-try:
-    AF_INET6 = socket.AF_INET6
-except AttributeError:
-    AF_INET6 = 9999
-
-
-def inet_pton(family, text):
-    """Convert the textual form of a network address into its binary form.
-
-    *family* is an ``int``, the address family.
-
-    *text* is a ``text``, the textual address.
-
-    Raises ``NotImplementedError`` if the address family specified is not
-    implemented.
-
-    Returns a ``binary``.
-    """
-
-    if family == AF_INET:
-        return dns.ipv4.inet_aton(text)
-    elif family == AF_INET6:
-        return dns.ipv6.inet_aton(text)
-    else:
-        raise NotImplementedError
-
-
-def inet_ntop(family, address):
-    """Convert the binary form of a network address into its textual form.
-
-    *family* is an ``int``, the address family.
-
-    *address* is a ``binary``, the network address in binary form.
-
-    Raises ``NotImplementedError`` if the address family specified is not
-    implemented.
-
-    Returns a ``text``.
-    """
-
-    if family == AF_INET:
-        return dns.ipv4.inet_ntoa(address)
-    elif family == AF_INET6:
-        return dns.ipv6.inet_ntoa(address)
-    else:
-        raise NotImplementedError
-
-
-def af_for_address(text):
-    """Determine the address family of a textual-form network address.
-
-    *text*, a ``text``, the textual address.
-
-    Raises ``ValueError`` if the address family cannot be determined
-    from the input.
-
-    Returns an ``int``.
-    """
-
-    try:
-        dns.ipv4.inet_aton(text)
-        return AF_INET
-    except Exception:
-        try:
-            dns.ipv6.inet_aton(text)
-            return AF_INET6
-        except:
-            raise ValueError
-
-
-def is_multicast(text):
-    """Is the textual-form network address a multicast address?
-
-    *text*, a ``text``, the textual address.
-
-    Raises ``ValueError`` if the address family cannot be determined
-    from the input.
-
-    Returns a ``bool``.
-    """
-
-    try:
-        first = maybe_ord(dns.ipv4.inet_aton(text)[0])
-        return first >= 224 and first <= 239
-    except Exception:
-        try:
-            first = maybe_ord(dns.ipv6.inet_aton(text)[0])
-            return first == 255
-        except Exception:
-            raise ValueError

src/dns/inet.pyi

@@ -1,4 +0,0 @@
-from typing import Union
-from socket import AddressFamily
-
-AF_INET6 : Union[int, AddressFamily]

src/dns/ipv4.py

@@ -1,63 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2017 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""IPv4 helper functions."""
-
-import struct
-
-import dns.exception
-from ._compat import binary_type
-
-def inet_ntoa(address):
-    """Convert an IPv4 address in binary form to text form.
-
-    *address*, a ``binary``, the IPv4 address in binary form.
-
-    Returns a ``text``.
-    """
-
-    if len(address) != 4:
-        raise dns.exception.SyntaxError
-    if not isinstance(address, bytearray):
-        address = bytearray(address)
-    return ('%u.%u.%u.%u' % (address[0], address[1],
-                             address[2], address[3]))
-
-def inet_aton(text):
-    """Convert an IPv4 address in text form to binary form.
-
-    *text*, a ``text``, the IPv4 address in textual form.
-
-    Returns a ``binary``.
-    """
-
-    if not isinstance(text, binary_type):
-        text = text.encode()
-    parts = text.split(b'.')
-    if len(parts) != 4:
-        raise dns.exception.SyntaxError
-    for part in parts:
-        if not part.isdigit():
-            raise dns.exception.SyntaxError
-        if len(part) > 1 and part[0] == '0':
-            # No leading zeros
-            raise dns.exception.SyntaxError
-    try:
-        bytes = [int(part) for part in parts]
-        return struct.pack('BBBB', *bytes)
-    except:
-        raise dns.exception.SyntaxError

src/dns/ipv6.py

@@ -1,181 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2017 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""IPv6 helper functions."""
-
-import re
-import binascii
-
-import dns.exception
-import dns.ipv4
-from ._compat import xrange, binary_type, maybe_decode
-
-_leading_zero = re.compile(r'0+([0-9a-f]+)')
-
-def inet_ntoa(address):
-    """Convert an IPv6 address in binary form to text form.
-
-    *address*, a ``binary``, the IPv6 address in binary form.
-
-    Raises ``ValueError`` if the address isn't 16 bytes long.
-    Returns a ``text``.
-    """
-
-    if len(address) != 16:
-        raise ValueError("IPv6 addresses are 16 bytes long")
-    hex = binascii.hexlify(address)
-    chunks = []
-    i = 0
-    l = len(hex)
-    while i < l:
-        chunk = maybe_decode(hex[i : i + 4])
-        # strip leading zeros.  we do this with an re instead of
-        # with lstrip() because lstrip() didn't support chars until
-        # python 2.2.2
-        m = _leading_zero.match(chunk)
-        if not m is None:
-            chunk = m.group(1)
-        chunks.append(chunk)
-        i += 4
-    #
-    # Compress the longest subsequence of 0-value chunks to ::
-    #
-    best_start = 0
-    best_len = 0
-    start = -1
-    last_was_zero = False
-    for i in xrange(8):
-        if chunks[i] != '0':
-            if last_was_zero:
-                end = i
-                current_len = end - start
-                if current_len > best_len:
-                    best_start = start
-                    best_len = current_len
-                last_was_zero = False
-        elif not last_was_zero:
-            start = i
-            last_was_zero = True
-    if last_was_zero:
-        end = 8
-        current_len = end - start
-        if current_len > best_len:
-            best_start = start
-            best_len = current_len
-    if best_len > 1:
-        if best_start == 0 and \
-           (best_len == 6 or
-            best_len == 5 and chunks[5] == 'ffff'):
-            # We have an embedded IPv4 address
-            if best_len == 6:
-                prefix = '::'
-            else:
-                prefix = '::ffff:'
-            hex = prefix + dns.ipv4.inet_ntoa(address[12:])
-        else:
-            hex = ':'.join(chunks[:best_start]) + '::' + \
-                  ':'.join(chunks[best_start + best_len:])
-    else:
-        hex = ':'.join(chunks)
-    return hex
-
-_v4_ending = re.compile(br'(.*):(\d+\.\d+\.\d+\.\d+)$')
-_colon_colon_start = re.compile(br'::.*')
-_colon_colon_end = re.compile(br'.*::$')
-
-def inet_aton(text):
-    """Convert an IPv6 address in text form to binary form.
-
-    *text*, a ``text``, the IPv6 address in textual form.
-
-    Returns a ``binary``.
-    """
-
-    #
-    # Our aim here is not something fast; we just want something that works.
-    #
-    if not isinstance(text, binary_type):
-        text = text.encode()
-
-    if text == b'::':
-        text = b'0::'
-    #
-    # Get rid of the icky dot-quad syntax if we have it.
-    #
-    m = _v4_ending.match(text)
-    if not m is None:
-        b = bytearray(dns.ipv4.inet_aton(m.group(2)))
-        text = (u"{}:{:02x}{:02x}:{:02x}{:02x}".format(m.group(1).decode(),
-                                                       b[0], b[1], b[2],
-                                                       b[3])).encode()
-    #
-    # Try to turn '::<whatever>' into ':<whatever>'; if no match try to
-    # turn '<whatever>::' into '<whatever>:'
-    #
-    m = _colon_colon_start.match(text)
-    if not m is None:
-        text = text[1:]
-    else:
-        m = _colon_colon_end.match(text)
-        if not m is None:
-            text = text[:-1]
-    #
-    # Now canonicalize into 8 chunks of 4 hex digits each
-    #
-    chunks = text.split(b':')
-    l = len(chunks)
-    if l > 8:
-        raise dns.exception.SyntaxError
-    seen_empty = False
-    canonical = []
-    for c in chunks:
-        if c == b'':
-            if seen_empty:
-                raise dns.exception.SyntaxError
-            seen_empty = True
-            for i in xrange(0, 8 - l + 1):
-                canonical.append(b'0000')
-        else:
-            lc = len(c)
-            if lc > 4:
-                raise dns.exception.SyntaxError
-            if lc != 4:
-                c = (b'0' * (4 - lc)) + c
-            canonical.append(c)
-    if l < 8 and not seen_empty:
-        raise dns.exception.SyntaxError
-    text = b''.join(canonical)
-
-    #
-    # Finally we can go to binary.
-    #
-    try:
-        return binascii.unhexlify(text)
-    except (binascii.Error, TypeError):
-        raise dns.exception.SyntaxError
-
-_mapped_prefix = b'\x00' * 10 + b'\xff\xff'
-
-def is_mapped(address):
-    """Is the specified address a mapped IPv4 address?
-
-    *address*, a ``binary`` is an IPv6 address in binary form.
-
-    Returns a ``bool``.
-    """
-
-    return address.startswith(_mapped_prefix)

src/dns/message.pyi

@@ -1,55 +0,0 @@
-from typing import Optional, Dict, List, Tuple, Union
-from . import name, rrset, tsig, rdatatype, entropy, edns, rdataclass
-import hmac
-
-class Message:
-    def to_wire(self, origin : Optional[name.Name]=None, max_size=0, **kw) -> bytes:
-        ...
-    def find_rrset(self, section : List[rrset.RRset], name : name.Name, rdclass : int, rdtype : int,
-                   covers=rdatatype.NONE, deleting : Optional[int]=None, create=False,
-                   force_unique=False) -> rrset.RRset:
-        ...
-    def __init__(self, id : Optional[int] =None) -> None:
-        self.id : int
-        self.flags = 0
-        self.question : List[rrset.RRset] = []
-        self.answer : List[rrset.RRset] = []
-        self.authority : List[rrset.RRset] = []
-        self.additional : List[rrset.RRset] = []
-        self.edns = -1
-        self.ednsflags = 0
-        self.payload = 0
-        self.options : List[edns.Option] = []
-        self.request_payload = 0
-        self.keyring = None
-        self.keyname = None
-        self.keyalgorithm = tsig.default_algorithm
-        self.request_mac = b''
-        self.other_data = b''
-        self.tsig_error = 0
-        self.fudge = 300
-        self.original_id = self.id
-        self.mac = b''
-        self.xfr = False
-        self.origin = None
-        self.tsig_ctx = None
-        self.had_tsig = False
-        self.multi = False
-        self.first = True
-        self.index : Dict[Tuple[rrset.RRset, name.Name, int, int, Union[int,str], int], rrset.RRset] = {}
-def from_text(a : str) -> Message:
-    ...
-
-def from_wire(wire, keyring : Optional[Dict[name.Name,bytes]] = None, request_mac = b'', xfr=False, origin=None,
-              tsig_ctx : Optional[hmac.HMAC] = None, multi=False, first=True,
-              question_only=False, one_rr_per_rrset=False,
-              ignore_trailing=False) -> Message:
-    ...
-def make_response(query : Message, recursion_available=False, our_payload=8192,
-                  fudge=300) -> Message:
-    ...
-
-def make_query(qname : Union[name.Name,str], rdtype : Union[str,int], rdclass : Union[int,str] =rdataclass.IN, use_edns : Optional[bool] = None,
-               want_dnssec=False, ednsflags : Optional[int] = None, payload : Optional[int] = None,
-               request_payload : Optional[int] = None, options : Optional[List[edns.Option]] = None) -> Message:
-    ...

src/dns/name.py

@@ -1,994 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2001-2017 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""DNS Names.
-"""
-
-from io import BytesIO
-import struct
-import sys
-import copy
-import encodings.idna
-try:
-    import idna
-    have_idna_2008 = True
-except ImportError:
-    have_idna_2008 = False
-
-import dns.exception
-import dns.wiredata
-
-from ._compat import long, binary_type, text_type, unichr, maybe_decode
-
-try:
-    maxint = sys.maxint  # pylint: disable=sys-max-int
-except AttributeError:
-    maxint = (1 << (8 * struct.calcsize("P"))) // 2 - 1
-
-
-# fullcompare() result values
-
-#: The compared names have no relationship to each other.
-NAMERELN_NONE = 0
-#: the first name is a superdomain of the second.
-NAMERELN_SUPERDOMAIN = 1
-#: The first name is a subdomain of the second.
-NAMERELN_SUBDOMAIN = 2
-#: The compared names are equal.
-NAMERELN_EQUAL = 3
-#: The compared names have a common ancestor.
-NAMERELN_COMMONANCESTOR = 4
-
-
-class EmptyLabel(dns.exception.SyntaxError):
-    """A DNS label is empty."""
-
-
-class BadEscape(dns.exception.SyntaxError):
-    """An escaped code in a text format of DNS name is invalid."""
-
-
-class BadPointer(dns.exception.FormError):
-    """A DNS compression pointer points forward instead of backward."""
-
-
-class BadLabelType(dns.exception.FormError):
-    """The label type in DNS name wire format is unknown."""
-
-
-class NeedAbsoluteNameOrOrigin(dns.exception.DNSException):
-    """An attempt was made to convert a non-absolute name to
-    wire when there was also a non-absolute (or missing) origin."""
-
-
-class NameTooLong(dns.exception.FormError):
-    """A DNS name is > 255 octets long."""
-
-
-class LabelTooLong(dns.exception.SyntaxError):
-    """A DNS label is > 63 octets long."""
-
-
-class AbsoluteConcatenation(dns.exception.DNSException):
-    """An attempt was made to append anything other than the
-    empty name to an absolute DNS name."""
-
-
-class NoParent(dns.exception.DNSException):
-    """An attempt was made to get the parent of the root name
-    or the empty name."""
-
-class NoIDNA2008(dns.exception.DNSException):
-    """IDNA 2008 processing was requested but the idna module is not
-    available."""
-
-
-class IDNAException(dns.exception.DNSException):
-    """IDNA processing raised an exception."""
-
-    supp_kwargs = {'idna_exception'}
-    fmt = "IDNA processing exception: {idna_exception}"
-
-
-class IDNACodec(object):
-    """Abstract base class for IDNA encoder/decoders."""
-
-    def __init__(self):
-        pass
-
-    def encode(self, label):
-        raise NotImplementedError
-
-    def decode(self, label):
-        # We do not apply any IDNA policy on decode; we just
-        downcased = label.lower()
-        if downcased.startswith(b'xn--'):
-            try:
-                label = downcased[4:].decode('punycode')
-            except Exception as e:
-                raise IDNAException(idna_exception=e)
-        else:
-            label = maybe_decode(label)
-        return _escapify(label, True)
-
-
-class IDNA2003Codec(IDNACodec):
-    """IDNA 2003 encoder/decoder."""
-
-    def __init__(self, strict_decode=False):
-        """Initialize the IDNA 2003 encoder/decoder.
-
-        *strict_decode* is a ``bool``. If `True`, then IDNA2003 checking
-        is done when decoding.  This can cause failures if the name
-        was encoded with IDNA2008.  The default is `False`.
-        """
-
-        super(IDNA2003Codec, self).__init__()
-        self.strict_decode = strict_decode
-
-    def encode(self, label):
-        """Encode *label*."""
-
-        if label == '':
-            return b''
-        try:
-            return encodings.idna.ToASCII(label)
-        except UnicodeError:
-            raise LabelTooLong
-
-    def decode(self, label):
-        """Decode *label*."""
-        if not self.strict_decode:
-            return super(IDNA2003Codec, self).decode(label)
-        if label == b'':
-            return u''
-        try:
-            return _escapify(encodings.idna.ToUnicode(label), True)
-        except Exception as e:
-            raise IDNAException(idna_exception=e)
-
-
-class IDNA2008Codec(IDNACodec):
-    """IDNA 2008 encoder/decoder.
-
-        *uts_46* is a ``bool``.  If True, apply Unicode IDNA
-        compatibility processing as described in Unicode Technical
-        Standard #46 (http://unicode.org/reports/tr46/).
-        If False, do not apply the mapping.  The default is False.
-
-        *transitional* is a ``bool``: If True, use the
-        "transitional" mode described in Unicode Technical Standard
-        #46.  The default is False.
-
-        *allow_pure_ascii* is a ``bool``.  If True, then a label which
-        consists of only ASCII characters is allowed.  This is less
-        strict than regular IDNA 2008, but is also necessary for mixed
-        names, e.g. a name with starting with "_sip._tcp." and ending
-        in an IDN suffix which would otherwise be disallowed.  The
-        default is False.
-
-        *strict_decode* is a ``bool``: If True, then IDNA2008 checking
-        is done when decoding.  This can cause failures if the name
-        was encoded with IDNA2003.  The default is False.
-        """
-
-    def __init__(self, uts_46=False, transitional=False,
-                 allow_pure_ascii=False, strict_decode=False):
-        """Initialize the IDNA 2008 encoder/decoder."""
-        super(IDNA2008Codec, self).__init__()
-        self.uts_46 = uts_46
-        self.transitional = transitional
-        self.allow_pure_ascii = allow_pure_ascii
-        self.strict_decode = strict_decode
-
-    def is_all_ascii(self, label):
-        for c in label:
-            if ord(c) > 0x7f:
-                return False
-        return True
-
-    def encode(self, label):
-        if label == '':
-            return b''
-        if self.allow_pure_ascii and self.is_all_ascii(label):
-            return label.encode('ascii')
-        if not have_idna_2008:
-            raise NoIDNA2008
-        try:
-            if self.uts_46:
-                label = idna.uts46_remap(label, False, self.transitional)
-            return idna.alabel(label)
-        except idna.IDNAError as e:
-            raise IDNAException(idna_exception=e)
-
-    def decode(self, label):
-        if not self.strict_decode:
-            return super(IDNA2008Codec, self).decode(label)
-        if label == b'':
-            return u''
-        if not have_idna_2008:
-            raise NoIDNA2008
-        try:
-            if self.uts_46:
-                label = idna.uts46_remap(label, False, False)
-            return _escapify(idna.ulabel(label), True)
-        except idna.IDNAError as e:
-            raise IDNAException(idna_exception=e)
-
-_escaped = bytearray(b'"().;\\@$')
-
-IDNA_2003_Practical = IDNA2003Codec(False)
-IDNA_2003_Strict = IDNA2003Codec(True)
-IDNA_2003 = IDNA_2003_Practical
-IDNA_2008_Practical = IDNA2008Codec(True, False, True, False)
-IDNA_2008_UTS_46 = IDNA2008Codec(True, False, False, False)
-IDNA_2008_Strict = IDNA2008Codec(False, False, False, True)
-IDNA_2008_Transitional = IDNA2008Codec(True, True, False, False)
-IDNA_2008 = IDNA_2008_Practical
-
-def _escapify(label, unicode_mode=False):
-    """Escape the characters in label which need it.
-    @param unicode_mode: escapify only special and whitespace (<= 0x20)
-    characters
-    @returns: the escaped string
-    @rtype: string"""
-    if not unicode_mode:
-        text = ''
-        if isinstance(label, text_type):
-            label = label.encode()
-        for c in bytearray(label):
-            if c in _escaped:
-                text += '\\' + chr(c)
-            elif c > 0x20 and c < 0x7F:
-                text += chr(c)
-            else:
-                text += '\\%03d' % c
-        return text.encode()
-
-    text = u''
-    if isinstance(label, binary_type):
-        label = label.decode()
-    for c in label:
-        if c > u'\x20' and c < u'\x7f':
-            text += c
-        else:
-            if c >= u'\x7f':
-                text += c
-            else:
-                text += u'\\%03d' % ord(c)
-    return text
-
-def _validate_labels(labels):
-    """Check for empty labels in the middle of a label sequence,
-    labels that are too long, and for too many labels.
-
-    Raises ``dns.name.NameTooLong`` if the name as a whole is too long.
-
-    Raises ``dns.name.EmptyLabel`` if a label is empty (i.e. the root
-    label) and appears in a position other than the end of the label
-    sequence
-
-    """
-
-    l = len(labels)
-    total = 0
-    i = -1
-    j = 0
-    for label in labels:
-        ll = len(label)
-        total += ll + 1
-        if ll > 63:
-            raise LabelTooLong
-        if i < 0 and label == b'':
-            i = j
-        j += 1
-    if total > 255:
-        raise NameTooLong
-    if i >= 0 and i != l - 1:
-        raise EmptyLabel
-
-
-def _maybe_convert_to_binary(label):
-    """If label is ``text``, convert it to ``binary``.  If it is already
-    ``binary`` just return it.
-
-    """
-
-    if isinstance(label, binary_type):
-        return label
-    if isinstance(label, text_type):
-        return label.encode()
-    raise ValueError
-
-
-class Name(object):
-
-    """A DNS name.
-
-    The dns.name.Name class represents a DNS name as a tuple of
-    labels.  Each label is a `binary` in DNS wire format.  Instances
-    of the class are immutable.
-    """
-
-    __slots__ = ['labels']
-
-    def __init__(self, labels):
-        """*labels* is any iterable whose values are ``text`` or ``binary``.
-        """
-
-        labels = [_maybe_convert_to_binary(x) for x in labels]
-        super(Name, self).__setattr__('labels', tuple(labels))
-        _validate_labels(self.labels)
-
-    def __setattr__(self, name, value):
-        # Names are immutable
-        raise TypeError("object doesn't support attribute assignment")
-
-    def __copy__(self):
-        return Name(self.labels)
-
-    def __deepcopy__(self, memo):
-        return Name(copy.deepcopy(self.labels, memo))
-
-    def __getstate__(self):
-        # Names can be pickled
-        return {'labels': self.labels}
-
-    def __setstate__(self, state):
-        super(Name, self).__setattr__('labels', state['labels'])
-        _validate_labels(self.labels)
-
-    def is_absolute(self):
-        """Is the most significant label of this name the root label?
-
-        Returns a ``bool``.
-        """
-
-        return len(self.labels) > 0 and self.labels[-1] == b''
-
-    def is_wild(self):
-        """Is this name wild?  (I.e. Is the least significant label '*'?)
-
-        Returns a ``bool``.
-        """
-
-        return len(self.labels) > 0 and self.labels[0] == b'*'
-
-    def __hash__(self):
-        """Return a case-insensitive hash of the name.
-
-        Returns an ``int``.
-        """
-
-        h = long(0)
-        for label in self.labels:
-            for c in bytearray(label.lower()):
-                h += (h << 3) + c
-        return int(h % maxint)
-
-    def fullcompare(self, other):
-        """Compare two names, returning a 3-tuple
-        ``(relation, order, nlabels)``.
-
-        *relation* describes the relation ship between the names,
-        and is one of: ``dns.name.NAMERELN_NONE``,
-        ``dns.name.NAMERELN_SUPERDOMAIN``, ``dns.name.NAMERELN_SUBDOMAIN``,
-        ``dns.name.NAMERELN_EQUAL``, or ``dns.name.NAMERELN_COMMONANCESTOR``.
-
-        *order* is < 0 if *self* < *other*, > 0 if *self* > *other*, and ==
-        0 if *self* == *other*.  A relative name is always less than an
-        absolute name.  If both names have the same relativity, then
-        the DNSSEC order relation is used to order them.
-
-        *nlabels* is the number of significant labels that the two names
-        have in common.
-
-        Here are some examples.  Names ending in "." are absolute names,
-        those not ending in "." are relative names.
-
-        =============  =============  ===========  =====  =======
-        self           other          relation     order  nlabels
-        =============  =============  ===========  =====  =======
-        www.example.   www.example.   equal        0      3
-        www.example.   example.       subdomain    > 0    2
-        example.       www.example.   superdomain  < 0    2
-        example1.com.  example2.com.  common anc.  < 0    2
-        example1       example2.      none         < 0    0
-        example1.      example2       none         > 0    0
-        =============  =============  ===========  =====  =======
-        """
-
-        sabs = self.is_absolute()
-        oabs = other.is_absolute()
-        if sabs != oabs:
-            if sabs:
-                return (NAMERELN_NONE, 1, 0)
-            else:
-                return (NAMERELN_NONE, -1, 0)
-        l1 = len(self.labels)
-        l2 = len(other.labels)
-        ldiff = l1 - l2
-        if ldiff < 0:
-            l = l1
-        else:
-            l = l2
-
-        order = 0
-        nlabels = 0
-        namereln = NAMERELN_NONE
-        while l > 0:
-            l -= 1
-            l1 -= 1
-            l2 -= 1
-            label1 = self.labels[l1].lower()
-            label2 = other.labels[l2].lower()
-            if label1 < label2:
-                order = -1
-                if nlabels > 0:
-                    namereln = NAMERELN_COMMONANCESTOR
-                return (namereln, order, nlabels)
-            elif label1 > label2:
-                order = 1
-                if nlabels > 0:
-                    namereln = NAMERELN_COMMONANCESTOR
-                return (namereln, order, nlabels)
-            nlabels += 1
-        order = ldiff
-        if ldiff < 0:
-            namereln = NAMERELN_SUPERDOMAIN
-        elif ldiff > 0:
-            namereln = NAMERELN_SUBDOMAIN
-        else:
-            namereln = NAMERELN_EQUAL
-        return (namereln, order, nlabels)
-
-    def is_subdomain(self, other):
-        """Is self a subdomain of other?
-
-        Note that the notion of subdomain includes equality, e.g.
-        "dnpython.org" is a subdomain of itself.
-
-        Returns a ``bool``.
-        """
-
-        (nr, o, nl) = self.fullcompare(other)
-        if nr == NAMERELN_SUBDOMAIN or nr == NAMERELN_EQUAL:
-            return True
-        return False
-
-    def is_superdomain(self, other):
-        """Is self a superdomain of other?
-
-        Note that the notion of superdomain includes equality, e.g.
-        "dnpython.org" is a superdomain of itself.
-
-        Returns a ``bool``.
-        """
-
-        (nr, o, nl) = self.fullcompare(other)
-        if nr == NAMERELN_SUPERDOMAIN or nr == NAMERELN_EQUAL:
-            return True
-        return False
-
-    def canonicalize(self):
-        """Return a name which is equal to the current name, but is in
-        DNSSEC canonical form.
-        """
-
-        return Name([x.lower() for x in self.labels])
-
-    def __eq__(self, other):
-        if isinstance(other, Name):
-            return self.fullcompare(other)[1] == 0
-        else:
-            return False
-
-    def __ne__(self, other):
-        if isinstance(other, Name):
-            return self.fullcompare(other)[1] != 0
-        else:
-            return True
-
-    def __lt__(self, other):
-        if isinstance(other, Name):
-            return self.fullcompare(other)[1] < 0
-        else:
-            return NotImplemented
-
-    def __le__(self, other):
-        if isinstance(other, Name):
-            return self.fullcompare(other)[1] <= 0
-        else:
-            return NotImplemented
-
-    def __ge__(self, other):
-        if isinstance(other, Name):
-            return self.fullcompare(other)[1] >= 0
-        else:
-            return NotImplemented
-
-    def __gt__(self, other):
-        if isinstance(other, Name):
-            return self.fullcompare(other)[1] > 0
-        else:
-            return NotImplemented
-
-    def __repr__(self):
-        return '<DNS name ' + self.__str__() + '>'
-
-    def __str__(self):
-        return self.to_text(False)
-
-    def to_text(self, omit_final_dot=False):
-        """Convert name to DNS text format.
-
-        *omit_final_dot* is a ``bool``.  If True, don't emit the final
-        dot (denoting the root label) for absolute names.  The default
-        is False.
-
-        Returns a ``text``.
-        """
-
-        if len(self.labels) == 0:
-            return maybe_decode(b'@')
-        if len(self.labels) == 1 and self.labels[0] == b'':
-            return maybe_decode(b'.')
-        if omit_final_dot and self.is_absolute():
-            l = self.labels[:-1]
-        else:
-            l = self.labels
-        s = b'.'.join(map(_escapify, l))
-        return maybe_decode(s)
-
-    def to_unicode(self, omit_final_dot=False, idna_codec=None):
-        """Convert name to Unicode text format.
-
-        IDN ACE labels are converted to Unicode.
-
-        *omit_final_dot* is a ``bool``.  If True, don't emit the final
-        dot (denoting the root label) for absolute names.  The default
-        is False.
-        *idna_codec* specifies the IDNA encoder/decoder.  If None, the
-        dns.name.IDNA_2003_Practical encoder/decoder is used.
-        The IDNA_2003_Practical decoder does
-        not impose any policy, it just decodes punycode, so if you
-        don't want checking for compliance, you can use this decoder
-        for IDNA2008 as well.
-
-        Returns a ``text``.
-        """
-
-        if len(self.labels) == 0:
-            return u'@'
-        if len(self.labels) == 1 and self.labels[0] == b'':
-            return u'.'
-        if omit_final_dot and self.is_absolute():
-            l = self.labels[:-1]
-        else:
-            l = self.labels
-        if idna_codec is None:
-            idna_codec = IDNA_2003_Practical
-        return u'.'.join([idna_codec.decode(x) for x in l])
-
-    def to_digestable(self, origin=None):
-        """Convert name to a format suitable for digesting in hashes.
-
-        The name is canonicalized and converted to uncompressed wire
-        format.  All names in wire format are absolute.  If the name
-        is a relative name, then an origin must be supplied.
-
-        *origin* is a ``dns.name.Name`` or ``None``.  If the name is
-        relative and origin is not ``None``, then origin will be appended
-        to the name.
-
-        Raises ``dns.name.NeedAbsoluteNameOrOrigin`` if the name is
-        relative and no origin was provided.
-
-        Returns a ``binary``.
-        """
-
-        if not self.is_absolute():
-            if origin is None or not origin.is_absolute():
-                raise NeedAbsoluteNameOrOrigin
-            labels = list(self.labels)
-            labels.extend(list(origin.labels))
-        else:
-            labels = self.labels
-        dlabels = [struct.pack('!B%ds' % len(x), len(x), x.lower())
-                   for x in labels]
-        return b''.join(dlabels)
-
-    def to_wire(self, file=None, compress=None, origin=None):
-        """Convert name to wire format, possibly compressing it.
-
-        *file* is the file where the name is emitted (typically a
-        BytesIO file).  If ``None`` (the default), a ``binary``
-        containing the wire name will be returned.
-
-        *compress*, a ``dict``, is the compression table to use.  If
-        ``None`` (the default), names will not be compressed.
-
-        *origin* is a ``dns.name.Name`` or ``None``.  If the name is
-        relative and origin is not ``None``, then *origin* will be appended
-        to it.
-
-        Raises ``dns.name.NeedAbsoluteNameOrOrigin`` if the name is
-        relative and no origin was provided.
-
-        Returns a ``binary`` or ``None``.
-        """
-
-        if file is None:
-            file = BytesIO()
-            want_return = True
-        else:
-            want_return = False
-
-        if not self.is_absolute():
-            if origin is None or not origin.is_absolute():
-                raise NeedAbsoluteNameOrOrigin
-            labels = list(self.labels)
-            labels.extend(list(origin.labels))
-        else:
-            labels = self.labels
-        i = 0
-        for label in labels:
-            n = Name(labels[i:])
-            i += 1
-            if compress is not None:
-                pos = compress.get(n)
-            else:
-                pos = None
-            if pos is not None:
-                value = 0xc000 + pos
-                s = struct.pack('!H', value)
-                file.write(s)
-                break
-            else:
-                if compress is not None and len(n) > 1:
-                    pos = file.tell()
-                    if pos <= 0x3fff:
-                        compress[n] = pos
-                l = len(label)
-                file.write(struct.pack('!B', l))
-                if l > 0:
-                    file.write(label)
-        if want_return:
-            return file.getvalue()
-
-    def __len__(self):
-        """The length of the name (in labels).
-
-        Returns an ``int``.
-        """
-
-        return len(self.labels)
-
-    def __getitem__(self, index):
-        return self.labels[index]
-
-    def __add__(self, other):
-        return self.concatenate(other)
-
-    def __sub__(self, other):
-        return self.relativize(other)
-
-    def split(self, depth):
-        """Split a name into a prefix and suffix names at the specified depth.
-
-        *depth* is an ``int`` specifying the number of labels in the suffix
-
-        Raises ``ValueError`` if *depth* was not >= 0 and <= the length of the
-        name.
-
-        Returns the tuple ``(prefix, suffix)``.
-        """
-
-        l = len(self.labels)
-        if depth == 0:
-            return (self, dns.name.empty)
-        elif depth == l:
-            return (dns.name.empty, self)
-        elif depth < 0 or depth > l:
-            raise ValueError(
-                'depth must be >= 0 and <= the length of the name')
-        return (Name(self[: -depth]), Name(self[-depth:]))
-
-    def concatenate(self, other):
-        """Return a new name which is the concatenation of self and other.
-
-        Raises ``dns.name.AbsoluteConcatenation`` if the name is
-        absolute and *other* is not the empty name.
-
-        Returns a ``dns.name.Name``.
-        """
-
-        if self.is_absolute() and len(other) > 0:
-            raise AbsoluteConcatenation
-        labels = list(self.labels)
-        labels.extend(list(other.labels))
-        return Name(labels)
-
-    def relativize(self, origin):
-        """If the name is a subdomain of *origin*, return a new name which is
-        the name relative to origin.  Otherwise return the name.
-
-        For example, relativizing ``www.dnspython.org.`` to origin
-        ``dnspython.org.`` returns the name ``www``.  Relativizing ``example.``
-        to origin ``dnspython.org.`` returns ``example.``.
-
-        Returns a ``dns.name.Name``.
-        """
-
-        if origin is not None and self.is_subdomain(origin):
-            return Name(self[: -len(origin)])
-        else:
-            return self
-
-    def derelativize(self, origin):
-        """If the name is a relative name, return a new name which is the
-        concatenation of the name and origin.  Otherwise return the name.
-
-        For example, derelativizing ``www`` to origin ``dnspython.org.``
-        returns the name ``www.dnspython.org.``.  Derelativizing ``example.``
-        to origin ``dnspython.org.`` returns ``example.``.
-
-        Returns a ``dns.name.Name``.
-        """
-
-        if not self.is_absolute():
-            return self.concatenate(origin)
-        else:
-            return self
-
-    def choose_relativity(self, origin=None, relativize=True):
-        """Return a name with the relativity desired by the caller.
-
-        If *origin* is ``None``, then the name is returned.
-        Otherwise, if *relativize* is ``True`` the name is
-        relativized, and if *relativize* is ``False`` the name is
-        derelativized.
-
-        Returns a ``dns.name.Name``.
-        """
-
-        if origin:
-            if relativize:
-                return self.relativize(origin)
-            else:
-                return self.derelativize(origin)
-        else:
-            return self
-
-    def parent(self):
-        """Return the parent of the name.
-
-        For example, the parent of ``www.dnspython.org.`` is ``dnspython.org``.
-
-        Raises ``dns.name.NoParent`` if the name is either the root name or the
-        empty name, and thus has no parent.
-
-        Returns a ``dns.name.Name``.
-        """
-
-        if self == root or self == empty:
-            raise NoParent
-        return Name(self.labels[1:])
-
-#: The root name, '.'
-root = Name([b''])
-
-#: The empty name.
-empty = Name([])
-
-def from_unicode(text, origin=root, idna_codec=None):
-    """Convert unicode text into a Name object.
-
-    Labels are encoded in IDN ACE form according to rules specified by
-    the IDNA codec.
-
-    *text*, a ``text``, is the text to convert into a name.
-
-    *origin*, a ``dns.name.Name``, specifies the origin to
-    append to non-absolute names.  The default is the root name.
-
-    *idna_codec*, a ``dns.name.IDNACodec``, specifies the IDNA
-    encoder/decoder.  If ``None``, the default IDNA 2003 encoder/decoder
-    is used.
-
-    Returns a ``dns.name.Name``.
-    """
-
-    if not isinstance(text, text_type):
-        raise ValueError("input to from_unicode() must be a unicode string")
-    if not (origin is None or isinstance(origin, Name)):
-        raise ValueError("origin must be a Name or None")
-    labels = []
-    label = u''
-    escaping = False
-    edigits = 0
-    total = 0
-    if idna_codec is None:
-        idna_codec = IDNA_2003
-    if text == u'@':
-        text = u''
-    if text:
-        if text == u'.':
-            return Name([b''])        # no Unicode "u" on this constant!
-        for c in text:
-            if escaping:
-                if edigits == 0:
-                    if c.isdigit():
-                        total = int(c)
-                        edigits += 1
-                    else:
-                        label += c
-                        escaping = False
-                else:
-                    if not c.isdigit():
-                        raise BadEscape
-                    total *= 10
-                    total += int(c)
-                    edigits += 1
-                    if edigits == 3:
-                        escaping = False
-                        label += unichr(total)
-            elif c in [u'.', u'\u3002', u'\uff0e', u'\uff61']:
-                if len(label) == 0:
-                    raise EmptyLabel
-                labels.append(idna_codec.encode(label))
-                label = u''
-            elif c == u'\\':
-                escaping = True
-                edigits = 0
-                total = 0
-            else:
-                label += c
-        if escaping:
-            raise BadEscape
-        if len(label) > 0:
-            labels.append(idna_codec.encode(label))
-        else:
-            labels.append(b'')
-
-    if (len(labels) == 0 or labels[-1] != b'') and origin is not None:
-        labels.extend(list(origin.labels))
-    return Name(labels)
-
-
-def from_text(text, origin=root, idna_codec=None):
-    """Convert text into a Name object.
-
-    *text*, a ``text``, is the text to convert into a name.
-
-    *origin*, a ``dns.name.Name``, specifies the origin to
-    append to non-absolute names.  The default is the root name.
-
-    *idna_codec*, a ``dns.name.IDNACodec``, specifies the IDNA
-    encoder/decoder.  If ``None``, the default IDNA 2003 encoder/decoder
-    is used.
-
-    Returns a ``dns.name.Name``.
-    """
-
-    if isinstance(text, text_type):
-        return from_unicode(text, origin, idna_codec)
-    if not isinstance(text, binary_type):
-        raise ValueError("input to from_text() must be a string")
-    if not (origin is None or isinstance(origin, Name)):
-        raise ValueError("origin must be a Name or None")
-    labels = []
-    label = b''
-    escaping = False
-    edigits = 0
-    total = 0
-    if text == b'@':
-        text = b''
-    if text:
-        if text == b'.':
-            return Name([b''])
-        for c in bytearray(text):
-            byte_ = struct.pack('!B', c)
-            if escaping:
-                if edigits == 0:
-                    if byte_.isdigit():
-                        total = int(byte_)
-                        edigits += 1
-                    else:
-                        label += byte_
-                        escaping = False
-                else:
-                    if not byte_.isdigit():
-                        raise BadEscape
-                    total *= 10
-                    total += int(byte_)
-                    edigits += 1
-                    if edigits == 3:
-                        escaping = False
-                        label += struct.pack('!B', total)
-            elif byte_ == b'.':
-                if len(label) == 0:
-                    raise EmptyLabel
-                labels.append(label)
-                label = b''
-            elif byte_ == b'\\':
-                escaping = True
-                edigits = 0
-                total = 0
-            else:
-                label += byte_
-        if escaping:
-            raise BadEscape
-        if len(label) > 0:
-            labels.append(label)
-        else:
-            labels.append(b'')
-    if (len(labels) == 0 or labels[-1] != b'') and origin is not None:
-        labels.extend(list(origin.labels))
-    return Name(labels)
-
-
-def from_wire(message, current):
-    """Convert possibly compressed wire format into a Name.
-
-    *message* is a ``binary`` containing an entire DNS message in DNS
-    wire form.
-
-    *current*, an ``int``, is the offset of the beginning of the name
-    from the start of the message
-
-    Raises ``dns.name.BadPointer`` if a compression pointer did not
-    point backwards in the message.
-
-    Raises ``dns.name.BadLabelType`` if an invalid label type was encountered.
-
-    Returns a ``(dns.name.Name, int)`` tuple consisting of the name
-    that was read and the number of bytes of the wire format message
-    which were consumed reading it.
-    """
-
-    if not isinstance(message, binary_type):
-        raise ValueError("input to from_wire() must be a byte string")
-    message = dns.wiredata.maybe_wrap(message)
-    labels = []
-    biggest_pointer = current
-    hops = 0
-    count = message[current]
-    current += 1
-    cused = 1
-    while count != 0:
-        if count < 64:
-            labels.append(message[current: current + count].unwrap())
-            current += count
-            if hops == 0:
-                cused += count
-        elif count >= 192:
-            current = (count & 0x3f) * 256 + message[current]
-            if hops == 0:
-                cused += 1
-            if current >= biggest_pointer:
-                raise BadPointer
-            biggest_pointer = current
-            hops += 1
-        else:
-            raise BadLabelType
-        count = message[current]
-        current += 1
-        if hops == 0:
-            cused += 1
-    labels.append('')
-    return (Name(labels), cused)

src/dns/name.pyi

@@ -1,35 +0,0 @@
-from typing import Optional, Union, Tuple, Iterable, List
-
-class Name:
-    def is_subdomain(self, o : Name) -> bool: ...
-    def is_superdomain(self, o : Name) -> bool: ...
-    def __init__(self, labels : Iterable[Union[bytes,str]]) -> None:
-        self.labels : List[bytes]
-    def is_absolute(self) -> bool: ...
-    def is_wild(self) -> bool: ...
-    def fullcompare(self, other) -> Tuple[int,int,int]: ...
-    def canonicalize(self) -> Name: ...
-    def __lt__(self, other : Name): ...
-    def __le__(self, other : Name): ...
-    def __ge__(self, other : Name): ...
-    def __gt__(self, other : Name): ...
-    def to_text(self, omit_final_dot=False) -> str: ...
-    def to_unicode(self, omit_final_dot=False, idna_codec=None) -> str: ...
-    def to_digestable(self, origin=None) -> bytes: ...
-    def to_wire(self, file=None, compress=None, origin=None) -> Optional[bytes]: ...
-    def __add__(self, other : Name): ...
-    def __sub__(self, other : Name): ...
-    def split(self, depth) -> List[Tuple[str,str]]: ...
-    def concatenate(self, other : Name) -> Name: ...
-    def relativize(self, origin): ...
-    def derelativize(self, origin): ...
-    def choose_relativity(self, origin : Optional[Name] = None, relativize=True): ...
-    def parent(self) -> Name: ...
-
-class IDNACodec:
-    pass
-
-def from_text(text, origin : Optional[Name] = Name('.'), idna_codec : Optional[IDNACodec] = None) -> Name:
-    ...
-
-empty : Name

src/dns/namedict.py

@@ -1,108 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2017 Nominum, Inc.
-# Copyright (C) 2016 Coresec Systems AB
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND CORESEC SYSTEMS AB DISCLAIMS ALL
-# WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
-# WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL CORESEC
-# SYSTEMS AB BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
-# CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
-# OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
-# NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
-# WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""DNS name dictionary"""
-
-import collections
-import dns.name
-from ._compat import xrange
-
-
-class NameDict(collections.MutableMapping):
-    """A dictionary whose keys are dns.name.Name objects.
-
-    In addition to being like a regular Python dictionary, this
-    dictionary can also get the deepest match for a given key.
-    """
-
-    __slots__ = ["max_depth", "max_depth_items", "__store"]
-
-    def __init__(self, *args, **kwargs):
-        super(NameDict, self).__init__()
-        self.__store = dict()
-        #: the maximum depth of the keys that have ever been added
-        self.max_depth = 0
-        #: the number of items of maximum depth
-        self.max_depth_items = 0
-        self.update(dict(*args, **kwargs))
-
-    def __update_max_depth(self, key):
-        if len(key) == self.max_depth:
-            self.max_depth_items = self.max_depth_items + 1
-        elif len(key) > self.max_depth:
-            self.max_depth = len(key)
-            self.max_depth_items = 1
-
-    def __getitem__(self, key):
-        return self.__store[key]
-
-    def __setitem__(self, key, value):
-        if not isinstance(key, dns.name.Name):
-            raise ValueError('NameDict key must be a name')
-        self.__store[key] = value
-        self.__update_max_depth(key)
-
-    def __delitem__(self, key):
-        value = self.__store.pop(key)
-        if len(value) == self.max_depth:
-            self.max_depth_items = self.max_depth_items - 1
-        if self.max_depth_items == 0:
-            self.max_depth = 0
-            for k in self.__store:
-                self.__update_max_depth(k)
-
-    def __iter__(self):
-        return iter(self.__store)
-
-    def __len__(self):
-        return len(self.__store)
-
-    def has_key(self, key):
-        return key in self.__store
-
-    def get_deepest_match(self, name):
-        """Find the deepest match to *fname* in the dictionary.
-
-        The deepest match is the longest name in the dictionary which is
-        a superdomain of *name*.  Note that *superdomain* includes matching
-        *name* itself.
-
-        *name*, a ``dns.name.Name``, the name to find.
-
-        Returns a ``(key, value)`` where *key* is the deepest
-        ``dns.name.Name``, and *value* is the value associated with *key*.
-        """
-
-        depth = len(name)
-        if depth > self.max_depth:
-            depth = self.max_depth
-        for i in xrange(-depth, 0):
-            n = dns.name.Name(name[i:])
-            if n in self:
-                return (n, self[n])
-        v = self[dns.name.empty]
-        return (dns.name.empty, v)

src/dns/node.py

@@ -1,182 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2001-2017 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""DNS nodes.  A node is a set of rdatasets."""
-
-from io import StringIO
-
-import dns.rdataset
-import dns.rdatatype
-import dns.renderer
-
-
-class Node(object):
-
-    """A Node is a set of rdatasets."""
-
-    __slots__ = ['rdatasets']
-
-    def __init__(self):
-        #: the set of rdatsets, represented as a list.
-        self.rdatasets = []
-
-    def to_text(self, name, **kw):
-        """Convert a node to text format.
-
-        Each rdataset at the node is printed.  Any keyword arguments
-        to this method are passed on to the rdataset's to_text() method.
-
-        *name*, a ``dns.name.Name`` or ``text``, the owner name of the rdatasets.
-
-        Returns a ``text``.
-        """
-
-        s = StringIO()
-        for rds in self.rdatasets:
-            if len(rds) > 0:
-                s.write(rds.to_text(name, **kw))
-                s.write(u'\n')
-        return s.getvalue()[:-1]
-
-    def __repr__(self):
-        return '<DNS node ' + str(id(self)) + '>'
-
-    def __eq__(self, other):
-        #
-        # This is inefficient.  Good thing we don't need to do it much.
-        #
-        for rd in self.rdatasets:
-            if rd not in other.rdatasets:
-                return False
-        for rd in other.rdatasets:
-            if rd not in self.rdatasets:
-                return False
-        return True
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def __len__(self):
-        return len(self.rdatasets)
-
-    def __iter__(self):
-        return iter(self.rdatasets)
-
-    def find_rdataset(self, rdclass, rdtype, covers=dns.rdatatype.NONE,
-                      create=False):
-        """Find an rdataset matching the specified properties in the
-        current node.
-
-        *rdclass*, an ``int``, the class of the rdataset.
-
-        *rdtype*, an ``int``, the type of the rdataset.
-
-        *covers*, an ``int``, the covered type.  Usually this value is
-        dns.rdatatype.NONE, but if the rdtype is dns.rdatatype.SIG or
-        dns.rdatatype.RRSIG, then the covers value will be the rdata
-        type the SIG/RRSIG covers.  The library treats the SIG and RRSIG
-        types as if they were a family of
-        types, e.g. RRSIG(A), RRSIG(NS), RRSIG(SOA).  This makes RRSIGs much
-        easier to work with than if RRSIGs covering different rdata
-        types were aggregated into a single RRSIG rdataset.
-
-        *create*, a ``bool``.  If True, create the rdataset if it is not found.
-
-        Raises ``KeyError`` if an rdataset of the desired type and class does
-        not exist and *create* is not ``True``.
-
-        Returns a ``dns.rdataset.Rdataset``.
-        """
-
-        for rds in self.rdatasets:
-            if rds.match(rdclass, rdtype, covers):
-                return rds
-        if not create:
-            raise KeyError
-        rds = dns.rdataset.Rdataset(rdclass, rdtype)
-        self.rdatasets.append(rds)
-        return rds
-
-    def get_rdataset(self, rdclass, rdtype, covers=dns.rdatatype.NONE,
-                     create=False):
-        """Get an rdataset matching the specified properties in the
-        current node.
-
-        None is returned if an rdataset of the specified type and
-        class does not exist and *create* is not ``True``.
-
-        *rdclass*, an ``int``, the class of the rdataset.
-
-        *rdtype*, an ``int``, the type of the rdataset.
-
-        *covers*, an ``int``, the covered type.  Usually this value is
-        dns.rdatatype.NONE, but if the rdtype is dns.rdatatype.SIG or
-        dns.rdatatype.RRSIG, then the covers value will be the rdata
-        type the SIG/RRSIG covers.  The library treats the SIG and RRSIG
-        types as if they were a family of
-        types, e.g. RRSIG(A), RRSIG(NS), RRSIG(SOA).  This makes RRSIGs much
-        easier to work with than if RRSIGs covering different rdata
-        types were aggregated into a single RRSIG rdataset.
-
-        *create*, a ``bool``.  If True, create the rdataset if it is not found.
-
-        Returns a ``dns.rdataset.Rdataset`` or ``None``.
-        """
-
-        try:
-            rds = self.find_rdataset(rdclass, rdtype, covers, create)
-        except KeyError:
-            rds = None
-        return rds
-
-    def delete_rdataset(self, rdclass, rdtype, covers=dns.rdatatype.NONE):
-        """Delete the rdataset matching the specified properties in the
-        current node.
-
-        If a matching rdataset does not exist, it is not an error.
-
-        *rdclass*, an ``int``, the class of the rdataset.
-
-        *rdtype*, an ``int``, the type of the rdataset.
-
-        *covers*, an ``int``, the covered type.
-        """
-
-        rds = self.get_rdataset(rdclass, rdtype, covers)
-        if rds is not None:
-            self.rdatasets.remove(rds)
-
-    def replace_rdataset(self, replacement):
-        """Replace an rdataset.
-
-        It is not an error if there is no rdataset matching *replacement*.
-
-        Ownership of the *replacement* object is transferred to the node;
-        in other words, this method does not store a copy of *replacement*
-        at the node, it stores *replacement* itself.
-
-        *replacement*, a ``dns.rdataset.Rdataset``.
-
-        Raises ``ValueError`` if *replacement* is not a
-        ``dns.rdataset.Rdataset``.
-        """
-
-        if not isinstance(replacement, dns.rdataset.Rdataset):
-            raise ValueError('replacement is not an rdataset')
-        self.delete_rdataset(replacement.rdclass, replacement.rdtype,
-                             replacement.covers)
-        self.rdatasets.append(replacement)

src/dns/node.pyi

@@ -1,17 +0,0 @@
-from typing import List, Optional, Union
-from . import rdataset, rdatatype, name
-class Node:
-    def __init__(self):
-        self.rdatasets : List[rdataset.Rdataset]
-    def to_text(self, name : Union[str,name.Name], **kw) -> str:
-        ...
-    def find_rdataset(self, rdclass : int, rdtype : int, covers=rdatatype.NONE,
-                      create=False) -> rdataset.Rdataset:
-        ...
-    def get_rdataset(self, rdclass : int, rdtype : int, covers=rdatatype.NONE,
-                     create=False) -> Optional[rdataset.Rdataset]:
-        ...
-    def delete_rdataset(self, rdclass : int, rdtype : int, covers=rdatatype.NONE):
-        ...
-    def replace_rdataset(self, replacement : rdataset.Rdataset) -> None:
-        ...

src/dns/opcode.py

@@ -1,119 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2001-2017 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""DNS Opcodes."""
-
-import dns.exception
-
-#: Query
-QUERY = 0
-#: Inverse Query (historical)
-IQUERY = 1
-#: Server Status (unspecified and unimplemented anywhere)
-STATUS = 2
-#: Notify
-NOTIFY = 4
-#: Dynamic Update
-UPDATE = 5
-
-_by_text = {
-    'QUERY': QUERY,
-    'IQUERY': IQUERY,
-    'STATUS': STATUS,
-    'NOTIFY': NOTIFY,
-    'UPDATE': UPDATE
-}
-
-# We construct the inverse mapping programmatically to ensure that we
-# cannot make any mistakes (e.g. omissions, cut-and-paste errors) that
-# would cause the mapping not to be true inverse.
-
-_by_value = {y: x for x, y in _by_text.items()}
-
-
-class UnknownOpcode(dns.exception.DNSException):
-    """An DNS opcode is unknown."""
-
-
-def from_text(text):
-    """Convert text into an opcode.
-
-    *text*, a ``text``, the textual opcode
-
-    Raises ``dns.opcode.UnknownOpcode`` if the opcode is unknown.
-
-    Returns an ``int``.
-    """
-
-    if text.isdigit():
-        value = int(text)
-        if value >= 0 and value <= 15:
-            return value
-    value = _by_text.get(text.upper())
-    if value is None:
-        raise UnknownOpcode
-    return value
-
-
-def from_flags(flags):
-    """Extract an opcode from DNS message flags.
-
-    *flags*, an ``int``, the DNS flags.
-
-    Returns an ``int``.
-    """
-
-    return (flags & 0x7800) >> 11
-
-
-def to_flags(value):
-    """Convert an opcode to a value suitable for ORing into DNS message
-    flags.
-
-    *value*, an ``int``, the DNS opcode value.
-
-    Returns an ``int``.
-    """
-
-    return (value << 11) & 0x7800
-
-
-def to_text(value):
-    """Convert an opcode to text.
-
-    *value*, an ``int`` the opcode value,
-
-    Raises ``dns.opcode.UnknownOpcode`` if the opcode is unknown.
-
-    Returns a ``text``.
-    """
-
-    text = _by_value.get(value)
-    if text is None:
-        text = str(value)
-    return text
-
-
-def is_update(flags):
-    """Is the opcode in flags UPDATE?
-
-    *flags*, an ``int``, the DNS message flags.
-
-    Returns a ``bool``.
-    """
-
-    return from_flags(flags) == UPDATE

src/dns/query.py

@@ -1,683 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2017 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""Talk to a DNS server."""
-
-from __future__ import generators
-
-import errno
-import select
-import socket
-import struct
-import sys
-import time
-
-import dns.exception
-import dns.inet
-import dns.name
-import dns.message
-import dns.rcode
-import dns.rdataclass
-import dns.rdatatype
-from ._compat import long, string_types, PY3
-
-if PY3:
-    select_error = OSError
-else:
-    select_error = select.error
-
-# Function used to create a socket.  Can be overridden if needed in special
-# situations.
-socket_factory = socket.socket
-
-class UnexpectedSource(dns.exception.DNSException):
-    """A DNS query response came from an unexpected address or port."""
-
-
-class BadResponse(dns.exception.FormError):
-    """A DNS query response does not respond to the question asked."""
-
-
-class TransferError(dns.exception.DNSException):
-    """A zone transfer response got a non-zero rcode."""
-
-    def __init__(self, rcode):
-        message = 'Zone transfer error: %s' % dns.rcode.to_text(rcode)
-        super(TransferError, self).__init__(message)
-        self.rcode = rcode
-
-
-def _compute_expiration(timeout):
-    if timeout is None:
-        return None
-    else:
-        return time.time() + timeout
-
-# This module can use either poll() or select() as the "polling backend".
-#
-# A backend function takes an fd, bools for readability, writablity, and
-# error detection, and a timeout.
-
-def _poll_for(fd, readable, writable, error, timeout):
-    """Poll polling backend."""
-
-    event_mask = 0
-    if readable:
-        event_mask |= select.POLLIN
-    if writable:
-        event_mask |= select.POLLOUT
-    if error:
-        event_mask |= select.POLLERR
-
-    pollable = select.poll()
-    pollable.register(fd, event_mask)
-
-    if timeout:
-        event_list = pollable.poll(long(timeout * 1000))
-    else:
-        event_list = pollable.poll()
-
-    return bool(event_list)
-
-
-def _select_for(fd, readable, writable, error, timeout):
-    """Select polling backend."""
-
-    rset, wset, xset = [], [], []
-
-    if readable:
-        rset = [fd]
-    if writable:
-        wset = [fd]
-    if error:
-        xset = [fd]
-
-    if timeout is None:
-        (rcount, wcount, xcount) = select.select(rset, wset, xset)
-    else:
-        (rcount, wcount, xcount) = select.select(rset, wset, xset, timeout)
-
-    return bool((rcount or wcount or xcount))
-
-
-def _wait_for(fd, readable, writable, error, expiration):
-    # Use the selected polling backend to wait for any of the specified
-    # events.  An "expiration" absolute time is converted into a relative
-    # timeout.
-
-    done = False
-    while not done:
-        if expiration is None:
-            timeout = None
-        else:
-            timeout = expiration - time.time()
-            if timeout <= 0.0:
-                raise dns.exception.Timeout
-        try:
-            if not _polling_backend(fd, readable, writable, error, timeout):
-                raise dns.exception.Timeout
-        except select_error as e:
-            if e.args[0] != errno.EINTR:
-                raise e
-        done = True
-
-
-def _set_polling_backend(fn):
-    # Internal API. Do not use.
-
-    global _polling_backend
-
-    _polling_backend = fn
-
-if hasattr(select, 'poll'):
-    # Prefer poll() on platforms that support it because it has no
-    # limits on the maximum value of a file descriptor (plus it will
-    # be more efficient for high values).
-    _polling_backend = _poll_for
-else:
-    _polling_backend = _select_for
-
-
-def _wait_for_readable(s, expiration):
-    _wait_for(s, True, False, True, expiration)
-
-
-def _wait_for_writable(s, expiration):
-    _wait_for(s, False, True, True, expiration)
-
-
-def _addresses_equal(af, a1, a2):
-    # Convert the first value of the tuple, which is a textual format
-    # address into binary form, so that we are not confused by different
-    # textual representations of the same address
-    try:
-        n1 = dns.inet.inet_pton(af, a1[0])
-        n2 = dns.inet.inet_pton(af, a2[0])
-    except dns.exception.SyntaxError:
-        return False
-    return n1 == n2 and a1[1:] == a2[1:]
-
-
-def _destination_and_source(af, where, port, source, source_port):
-    # Apply defaults and compute destination and source tuples
-    # suitable for use in connect(), sendto(), or bind().
-    if af is None:
-        try:
-            af = dns.inet.af_for_address(where)
-        except Exception:
-            af = dns.inet.AF_INET
-    if af == dns.inet.AF_INET:
-        destination = (where, port)
-        if source is not None or source_port != 0:
-            if source is None:
-                source = '0.0.0.0'
-            source = (source, source_port)
-    elif af == dns.inet.AF_INET6:
-        destination = (where, port, 0, 0)
-        if source is not None or source_port != 0:
-            if source is None:
-                source = '::'
-            source = (source, source_port, 0, 0)
-    return (af, destination, source)
-
-
-def send_udp(sock, what, destination, expiration=None):
-    """Send a DNS message to the specified UDP socket.
-
-    *sock*, a ``socket``.
-
-    *what*, a ``binary`` or ``dns.message.Message``, the message to send.
-
-    *destination*, a destination tuple appropriate for the address family
-    of the socket, specifying where to send the query.
-
-    *expiration*, a ``float`` or ``None``, the absolute time at which
-    a timeout exception should be raised.  If ``None``, no timeout will
-    occur.
-
-    Returns an ``(int, float)`` tuple of bytes sent and the sent time.
-    """
-
-    if isinstance(what, dns.message.Message):
-        what = what.to_wire()
-    _wait_for_writable(sock, expiration)
-    sent_time = time.time()
-    n = sock.sendto(what, destination)
-    return (n, sent_time)
-
-
-def receive_udp(sock, destination, expiration=None,
-                ignore_unexpected=False, one_rr_per_rrset=False,
-                keyring=None, request_mac=b'', ignore_trailing=False):
-    """Read a DNS message from a UDP socket.
-
-    *sock*, a ``socket``.
-
-    *destination*, a destination tuple appropriate for the address family
-    of the socket, specifying where the associated query was sent.
-
-    *expiration*, a ``float`` or ``None``, the absolute time at which
-    a timeout exception should be raised.  If ``None``, no timeout will
-    occur.
-
-    *ignore_unexpected*, a ``bool``.  If ``True``, ignore responses from
-    unexpected sources.
-
-    *one_rr_per_rrset*, a ``bool``.  If ``True``, put each RR into its own
-    RRset.
-
-    *keyring*, a ``dict``, the keyring to use for TSIG.
-
-    *request_mac*, a ``binary``, the MAC of the request (for TSIG).
-
-    *ignore_trailing*, a ``bool``.  If ``True``, ignore trailing
-    junk at end of the received message.
-
-    Raises if the message is malformed, if network errors occur, of if
-    there is a timeout.
-
-    Returns a ``dns.message.Message`` object.
-    """
-
-    wire = b''
-    while 1:
-        _wait_for_readable(sock, expiration)
-        (wire, from_address) = sock.recvfrom(65535)
-        if _addresses_equal(sock.family, from_address, destination) or \
-           (dns.inet.is_multicast(destination[0]) and
-            from_address[1:] == destination[1:]):
-            break
-        if not ignore_unexpected:
-            raise UnexpectedSource('got a response from '
-                                   '%s instead of %s' % (from_address,
-                                                         destination))
-    received_time = time.time()
-    r = dns.message.from_wire(wire, keyring=keyring, request_mac=request_mac,
-                              one_rr_per_rrset=one_rr_per_rrset,
-                              ignore_trailing=ignore_trailing)
-    return (r, received_time)
-
-def udp(q, where, timeout=None, port=53, af=None, source=None, source_port=0,
-        ignore_unexpected=False, one_rr_per_rrset=False, ignore_trailing=False):
-    """Return the response obtained after sending a query via UDP.
-
-    *q*, a ``dns.message.Message``, the query to send
-
-    *where*, a ``text`` containing an IPv4 or IPv6 address,  where
-    to send the message.
-
-    *timeout*, a ``float`` or ``None``, the number of seconds to wait before the
-    query times out.  If ``None``, the default, wait forever.
-
-    *port*, an ``int``, the port send the message to.  The default is 53.
-
-    *af*, an ``int``, the address family to use.  The default is ``None``,
-    which causes the address family to use to be inferred from the form of
-    *where*.  If the inference attempt fails, AF_INET is used.  This
-    parameter is historical; you need never set it.
-
-    *source*, a ``text`` containing an IPv4 or IPv6 address, specifying
-    the source address.  The default is the wildcard address.
-
-    *source_port*, an ``int``, the port from which to send the message.
-    The default is 0.
-
-    *ignore_unexpected*, a ``bool``.  If ``True``, ignore responses from
-    unexpected sources.
-
-    *one_rr_per_rrset*, a ``bool``.  If ``True``, put each RR into its own
-    RRset.
-
-    *ignore_trailing*, a ``bool``.  If ``True``, ignore trailing
-    junk at end of the received message.
-
-    Returns a ``dns.message.Message``.
-    """
-
-    wire = q.to_wire()
-    (af, destination, source) = _destination_and_source(af, where, port,
-                                                        source, source_port)
-    s = socket_factory(af, socket.SOCK_DGRAM, 0)
-    received_time = None
-    sent_time = None
-    try:
-        expiration = _compute_expiration(timeout)
-        s.setblocking(0)
-        if source is not None:
-            s.bind(source)
-        (_, sent_time) = send_udp(s, wire, destination, expiration)
-        (r, received_time) = receive_udp(s, destination, expiration,
-                                         ignore_unexpected, one_rr_per_rrset,
-                                         q.keyring, q.mac, ignore_trailing)
-    finally:
-        if sent_time is None or received_time is None:
-            response_time = 0
-        else:
-            response_time = received_time - sent_time
-        s.close()
-    r.time = response_time
-    if not q.is_response(r):
-        raise BadResponse
-    return r
-
-
-def _net_read(sock, count, expiration):
-    """Read the specified number of bytes from sock.  Keep trying until we
-    either get the desired amount, or we hit EOF.
-    A Timeout exception will be raised if the operation is not completed
-    by the expiration time.
-    """
-    s = b''
-    while count > 0:
-        _wait_for_readable(sock, expiration)
-        n = sock.recv(count)
-        if n == b'':
-            raise EOFError
-        count = count - len(n)
-        s = s + n
-    return s
-
-
-def _net_write(sock, data, expiration):
-    """Write the specified data to the socket.
-    A Timeout exception will be raised if the operation is not completed
-    by the expiration time.
-    """
-    current = 0
-    l = len(data)
-    while current < l:
-        _wait_for_writable(sock, expiration)
-        current += sock.send(data[current:])
-
-
-def send_tcp(sock, what, expiration=None):
-    """Send a DNS message to the specified TCP socket.
-
-    *sock*, a ``socket``.
-
-    *what*, a ``binary`` or ``dns.message.Message``, the message to send.
-
-    *expiration*, a ``float`` or ``None``, the absolute time at which
-    a timeout exception should be raised.  If ``None``, no timeout will
-    occur.
-
-    Returns an ``(int, float)`` tuple of bytes sent and the sent time.
-    """
-
-    if isinstance(what, dns.message.Message):
-        what = what.to_wire()
-    l = len(what)
-    # copying the wire into tcpmsg is inefficient, but lets us
-    # avoid writev() or doing a short write that would get pushed
-    # onto the net
-    tcpmsg = struct.pack("!H", l) + what
-    _wait_for_writable(sock, expiration)
-    sent_time = time.time()
-    _net_write(sock, tcpmsg, expiration)
-    return (len(tcpmsg), sent_time)
-
-def receive_tcp(sock, expiration=None, one_rr_per_rrset=False,
-                keyring=None, request_mac=b'', ignore_trailing=False):
-    """Read a DNS message from a TCP socket.
-
-    *sock*, a ``socket``.
-
-    *expiration*, a ``float`` or ``None``, the absolute time at which
-    a timeout exception should be raised.  If ``None``, no timeout will
-    occur.
-
-    *one_rr_per_rrset*, a ``bool``.  If ``True``, put each RR into its own
-    RRset.
-
-    *keyring*, a ``dict``, the keyring to use for TSIG.
-
-    *request_mac*, a ``binary``, the MAC of the request (for TSIG).
-
-    *ignore_trailing*, a ``bool``.  If ``True``, ignore trailing
-    junk at end of the received message.
-
-    Raises if the message is malformed, if network errors occur, of if
-    there is a timeout.
-
-    Returns a ``dns.message.Message`` object.
-    """
-
-    ldata = _net_read(sock, 2, expiration)
-    (l,) = struct.unpack("!H", ldata)
-    wire = _net_read(sock, l, expiration)
-    received_time = time.time()
-    r = dns.message.from_wire(wire, keyring=keyring, request_mac=request_mac,
-                              one_rr_per_rrset=one_rr_per_rrset,
-                              ignore_trailing=ignore_trailing)
-    return (r, received_time)
-
-def _connect(s, address):
-    try:
-        s.connect(address)
-    except socket.error:
-        (ty, v) = sys.exc_info()[:2]
-
-        if hasattr(v, 'errno'):
-            v_err = v.errno
-        else:
-            v_err = v[0]
-        if v_err not in [errno.EINPROGRESS, errno.EWOULDBLOCK, errno.EALREADY]:
-            raise v
-
-
-def tcp(q, where, timeout=None, port=53, af=None, source=None, source_port=0,
-        one_rr_per_rrset=False, ignore_trailing=False):
-    """Return the response obtained after sending a query via TCP.
-
-    *q*, a ``dns.message.Message``, the query to send
-
-    *where*, a ``text`` containing an IPv4 or IPv6 address,  where
-    to send the message.
-
-    *timeout*, a ``float`` or ``None``, the number of seconds to wait before the
-    query times out.  If ``None``, the default, wait forever.
-
-    *port*, an ``int``, the port send the message to.  The default is 53.
-
-    *af*, an ``int``, the address family to use.  The default is ``None``,
-    which causes the address family to use to be inferred from the form of
-    *where*.  If the inference attempt fails, AF_INET is used.  This
-    parameter is historical; you need never set it.
-
-    *source*, a ``text`` containing an IPv4 or IPv6 address, specifying
-    the source address.  The default is the wildcard address.
-
-    *source_port*, an ``int``, the port from which to send the message.
-    The default is 0.
-
-    *one_rr_per_rrset*, a ``bool``.  If ``True``, put each RR into its own
-    RRset.
-
-    *ignore_trailing*, a ``bool``.  If ``True``, ignore trailing
-    junk at end of the received message.
-
-    Returns a ``dns.message.Message``.
-    """
-
-    wire = q.to_wire()
-    (af, destination, source) = _destination_and_source(af, where, port,
-                                                        source, source_port)
-    s = socket_factory(af, socket.SOCK_STREAM, 0)
-    begin_time = None
-    received_time = None
-    try:
-        expiration = _compute_expiration(timeout)
-        s.setblocking(0)
-        begin_time = time.time()
-        if source is not None:
-            s.bind(source)
-        _connect(s, destination)
-        send_tcp(s, wire, expiration)
-        (r, received_time) = receive_tcp(s, expiration, one_rr_per_rrset,
-                                         q.keyring, q.mac, ignore_trailing)
-    finally:
-        if begin_time is None or received_time is None:
-            response_time = 0
-        else:
-            response_time = received_time - begin_time
-        s.close()
-    r.time = response_time
-    if not q.is_response(r):
-        raise BadResponse
-    return r
-
-
-def xfr(where, zone, rdtype=dns.rdatatype.AXFR, rdclass=dns.rdataclass.IN,
-        timeout=None, port=53, keyring=None, keyname=None, relativize=True,
-        af=None, lifetime=None, source=None, source_port=0, serial=0,
-        use_udp=False, keyalgorithm=dns.tsig.default_algorithm):
-    """Return a generator for the responses to a zone transfer.
-
-    *where*.  If the inference attempt fails, AF_INET is used.  This
-    parameter is historical; you need never set it.
-
-    *zone*, a ``dns.name.Name`` or ``text``, the name of the zone to transfer.
-
-    *rdtype*, an ``int`` or ``text``, the type of zone transfer.  The
-    default is ``dns.rdatatype.AXFR``.  ``dns.rdatatype.IXFR`` can be
-    used to do an incremental transfer instead.
-
-    *rdclass*, an ``int`` or ``text``, the class of the zone transfer.
-    The default is ``dns.rdataclass.IN``.
-
-    *timeout*, a ``float``, the number of seconds to wait for each
-    response message.  If None, the default, wait forever.
-
-    *port*, an ``int``, the port send the message to.  The default is 53.
-
-    *keyring*, a ``dict``, the keyring to use for TSIG.
-
-    *keyname*, a ``dns.name.Name`` or ``text``, the name of the TSIG
-    key to use.
-
-    *relativize*, a ``bool``.  If ``True``, all names in the zone will be
-    relativized to the zone origin.  It is essential that the
-    relativize setting matches the one specified to
-    ``dns.zone.from_xfr()`` if using this generator to make a zone.
-
-    *af*, an ``int``, the address family to use.  The default is ``None``,
-    which causes the address family to use to be inferred from the form of
-    *where*.  If the inference attempt fails, AF_INET is used.  This
-    parameter is historical; you need never set it.
-
-    *lifetime*, a ``float``, the total number of seconds to spend
-    doing the transfer.  If ``None``, the default, then there is no
-    limit on the time the transfer may take.
-
-    *source*, a ``text`` containing an IPv4 or IPv6 address, specifying
-    the source address.  The default is the wildcard address.
-
-    *source_port*, an ``int``, the port from which to send the message.
-    The default is 0.
-
-    *serial*, an ``int``, the SOA serial number to use as the base for
-    an IXFR diff sequence (only meaningful if *rdtype* is
-    ``dns.rdatatype.IXFR``).
-
-    *use_udp*, a ``bool``.  If ``True``, use UDP (only meaningful for IXFR).
-
-    *keyalgorithm*, a ``dns.name.Name`` or ``text``, the TSIG algorithm to use.
-
-    Raises on errors, and so does the generator.
-
-    Returns a generator of ``dns.message.Message`` objects.
-    """
-
-    if isinstance(zone, string_types):
-        zone = dns.name.from_text(zone)
-    if isinstance(rdtype, string_types):
-        rdtype = dns.rdatatype.from_text(rdtype)
-    q = dns.message.make_query(zone, rdtype, rdclass)
-    if rdtype == dns.rdatatype.IXFR:
-        rrset = dns.rrset.from_text(zone, 0, 'IN', 'SOA',
-                                    '. . %u 0 0 0 0' % serial)
-        q.authority.append(rrset)
-    if keyring is not None:
-        q.use_tsig(keyring, keyname, algorithm=keyalgorithm)
-    wire = q.to_wire()
-    (af, destination, source) = _destination_and_source(af, where, port,
-                                                        source, source_port)
-    if use_udp:
-        if rdtype != dns.rdatatype.IXFR:
-            raise ValueError('cannot do a UDP AXFR')
-        s = socket_factory(af, socket.SOCK_DGRAM, 0)
-    else:
-        s = socket_factory(af, socket.SOCK_STREAM, 0)
-    s.setblocking(0)
-    if source is not None:
-        s.bind(source)
-    expiration = _compute_expiration(lifetime)
-    _connect(s, destination)
-    l = len(wire)
-    if use_udp:
-        _wait_for_writable(s, expiration)
-        s.send(wire)
-    else:
-        tcpmsg = struct.pack("!H", l) + wire
-        _net_write(s, tcpmsg, expiration)
-    done = False
-    delete_mode = True
-    expecting_SOA = False
-    soa_rrset = None
-    if relativize:
-        origin = zone
-        oname = dns.name.empty
-    else:
-        origin = None
-        oname = zone
-    tsig_ctx = None
-    first = True
-    while not done:
-        mexpiration = _compute_expiration(timeout)
-        if mexpiration is None or mexpiration > expiration:
-            mexpiration = expiration
-        if use_udp:
-            _wait_for_readable(s, expiration)
-            (wire, from_address) = s.recvfrom(65535)
-        else:
-            ldata = _net_read(s, 2, mexpiration)
-            (l,) = struct.unpack("!H", ldata)
-            wire = _net_read(s, l, mexpiration)
-        is_ixfr = (rdtype == dns.rdatatype.IXFR)
-        r = dns.message.from_wire(wire, keyring=q.keyring, request_mac=q.mac,
-                                  xfr=True, origin=origin, tsig_ctx=tsig_ctx,
-                                  multi=True, first=first,
-                                  one_rr_per_rrset=is_ixfr)
-        rcode = r.rcode()
-        if rcode != dns.rcode.NOERROR:
-            raise TransferError(rcode)
-        tsig_ctx = r.tsig_ctx
-        first = False
-        answer_index = 0
-        if soa_rrset is None:
-            if not r.answer or r.answer[0].name != oname:
-                raise dns.exception.FormError(
-                    "No answer or RRset not for qname")
-            rrset = r.answer[0]
-            if rrset.rdtype != dns.rdatatype.SOA:
-                raise dns.exception.FormError("first RRset is not an SOA")
-            answer_index = 1
-            soa_rrset = rrset.copy()
-            if rdtype == dns.rdatatype.IXFR:
-                if soa_rrset[0].serial <= serial:
-                    #
-                    # We're already up-to-date.
-                    #
-                    done = True
-                else:
-                    expecting_SOA = True
-        #
-        # Process SOAs in the answer section (other than the initial
-        # SOA in the first message).
-        #
-        for rrset in r.answer[answer_index:]:
-            if done:
-                raise dns.exception.FormError("answers after final SOA")
-            if rrset.rdtype == dns.rdatatype.SOA and rrset.name == oname:
-                if expecting_SOA:
-                    if rrset[0].serial != serial:
-                        raise dns.exception.FormError(
-                            "IXFR base serial mismatch")
-                    expecting_SOA = False
-                elif rdtype == dns.rdatatype.IXFR:
-                    delete_mode = not delete_mode
-                #
-                # If this SOA RRset is equal to the first we saw then we're
-                # finished. If this is an IXFR we also check that we're seeing
-                # the record in the expected part of the response.
-                #
-                if rrset == soa_rrset and \
-                        (rdtype == dns.rdatatype.AXFR or
-                         (rdtype == dns.rdatatype.IXFR and delete_mode)):
-                    done = True
-            elif expecting_SOA:
-                #
-                # We made an IXFR request and are expecting another
-                # SOA RR, but saw something else, so this must be an
-                # AXFR response.
-                #
-                rdtype = dns.rdatatype.AXFR
-                expecting_SOA = False
-        if done and q.keyring and not r.had_tsig:
-            raise dns.exception.FormError("missing TSIG")
-        yield r
-    s.close()

src/dns/query.pyi

@@ -1,15 +0,0 @@
-from typing import Optional, Union, Dict, Generator, Any
-from . import message, tsig, rdatatype, rdataclass, name, message
-def tcp(q : message.Message, where : str, timeout : float = None, port=53, af : Optional[int] = None, source : Optional[str] = None, source_port : int = 0,
-        one_rr_per_rrset=False) -> message.Message:
-    pass
-
-def xfr(where : None, zone : Union[name.Name,str], rdtype=rdatatype.AXFR, rdclass=rdataclass.IN,
-        timeout : Optional[float] =None, port=53, keyring : Optional[Dict[name.Name, bytes]] =None, keyname : Union[str,name.Name]=None, relativize=True,
-        af : Optional[int] =None, lifetime : Optional[float]=None, source : Optional[str] =None, source_port=0, serial=0,
-        use_udp=False, keyalgorithm=tsig.default_algorithm) -> Generator[Any,Any,message.Message]:
-    pass
-
-def udp(q : message.Message, where : str, timeout : Optional[float] = None, port=53, af : Optional[int] = None, source : Optional[str] = None, source_port=0,
-        ignore_unexpected=False, one_rr_per_rrset=False) -> message.Message:
-    ...

src/dns/rcode.py

@@ -1,144 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2001-2017 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""DNS Result Codes."""
-
-import dns.exception
-from ._compat import long
-
-#: No error
-NOERROR = 0
-#: Form error
-FORMERR = 1
-#: Server failure
-SERVFAIL = 2
-#: Name does not exist ("Name Error" in RFC 1025 terminology).
-NXDOMAIN = 3
-#: Not implemented
-NOTIMP = 4
-#: Refused
-REFUSED = 5
-#: Name exists.
-YXDOMAIN = 6
-#: RRset exists.
-YXRRSET = 7
-#: RRset does not exist.
-NXRRSET = 8
-#: Not authoritative.
-NOTAUTH = 9
-#: Name not in zone.
-NOTZONE = 10
-#: Bad EDNS version.
-BADVERS = 16
-
-_by_text = {
-    'NOERROR': NOERROR,
-    'FORMERR': FORMERR,
-    'SERVFAIL': SERVFAIL,
-    'NXDOMAIN': NXDOMAIN,
-    'NOTIMP': NOTIMP,
-    'REFUSED': REFUSED,
-    'YXDOMAIN': YXDOMAIN,
-    'YXRRSET': YXRRSET,
-    'NXRRSET': NXRRSET,
-    'NOTAUTH': NOTAUTH,
-    'NOTZONE': NOTZONE,
-    'BADVERS': BADVERS
-}
-
-# We construct the inverse mapping programmatically to ensure that we
-# cannot make any mistakes (e.g. omissions, cut-and-paste errors) that
-# would cause the mapping not to be a true inverse.
-
-_by_value = {y: x for x, y in _by_text.items()}
-
-
-class UnknownRcode(dns.exception.DNSException):
-    """A DNS rcode is unknown."""
-
-
-def from_text(text):
-    """Convert text into an rcode.
-
-    *text*, a ``text``, the textual rcode or an integer in textual form.
-
-    Raises ``dns.rcode.UnknownRcode`` if the rcode mnemonic is unknown.
-
-    Returns an ``int``.
-    """
-
-    if text.isdigit():
-        v = int(text)
-        if v >= 0 and v <= 4095:
-            return v
-    v = _by_text.get(text.upper())
-    if v is None:
-        raise UnknownRcode
-    return v
-
-
-def from_flags(flags, ednsflags):
-    """Return the rcode value encoded by flags and ednsflags.
-
-    *flags*, an ``int``, the DNS flags field.
-
-    *ednsflags*, an ``int``, the EDNS flags field.
-
-    Raises ``ValueError`` if rcode is < 0 or > 4095
-
-    Returns an ``int``.
-    """
-
-    value = (flags & 0x000f) | ((ednsflags >> 20) & 0xff0)
-    if value < 0 or value > 4095:
-        raise ValueError('rcode must be >= 0 and <= 4095')
-    return value
-
-
-def to_flags(value):
-    """Return a (flags, ednsflags) tuple which encodes the rcode.
-
-    *value*, an ``int``, the rcode.
-
-    Raises ``ValueError`` if rcode is < 0 or > 4095.
-
-    Returns an ``(int, int)`` tuple.
-    """
-
-    if value < 0 or value > 4095:
-        raise ValueError('rcode must be >= 0 and <= 4095')
-    v = value & 0xf
-    ev = long(value & 0xff0) << 20
-    return (v, ev)
-
-
-def to_text(value):
-    """Convert rcode into text.
-
-    *value*, and ``int``, the rcode.
-
-    Raises ``ValueError`` if rcode is < 0 or > 4095.
-
-    Returns a ``text``.
-    """
-
-    if value < 0 or value > 4095:
-        raise ValueError('rcode must be >= 0 and <= 4095')
-    text = _by_value.get(value)
-    if text is None:
-        text = str(value)
-    return text

src/dns/rdata.py

@@ -1,456 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2001-2017 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""DNS rdata."""
-
-from io import BytesIO
-import base64
-import binascii
-
-import dns.exception
-import dns.name
-import dns.rdataclass
-import dns.rdatatype
-import dns.tokenizer
-import dns.wiredata
-from ._compat import xrange, string_types, text_type
-
-try:
-    import threading as _threading
-except ImportError:
-    import dummy_threading as _threading
-
-_hex_chunksize = 32
-
-
-def _hexify(data, chunksize=_hex_chunksize):
-    """Convert a binary string into its hex encoding, broken up into chunks
-    of chunksize characters separated by a space.
-    """
-
-    line = binascii.hexlify(data)
-    return b' '.join([line[i:i + chunksize]
-                      for i
-                      in range(0, len(line), chunksize)]).decode()
-
-_base64_chunksize = 32
-
-
-def _base64ify(data, chunksize=_base64_chunksize):
-    """Convert a binary string into its base64 encoding, broken up into chunks
-    of chunksize characters separated by a space.
-    """
-
-    line = base64.b64encode(data)
-    return b' '.join([line[i:i + chunksize]
-                      for i
-                      in range(0, len(line), chunksize)]).decode()
-
-__escaped = bytearray(b'"\\')
-
-def _escapify(qstring):
-    """Escape the characters in a quoted string which need it."""
-
-    if isinstance(qstring, text_type):
-        qstring = qstring.encode()
-    if not isinstance(qstring, bytearray):
-        qstring = bytearray(qstring)
-
-    text = ''
-    for c in qstring:
-        if c in __escaped:
-            text += '\\' + chr(c)
-        elif c >= 0x20 and c < 0x7F:
-            text += chr(c)
-        else:
-            text += '\\%03d' % c
-    return text
-
-
-def _truncate_bitmap(what):
-    """Determine the index of greatest byte that isn't all zeros, and
-    return the bitmap that contains all the bytes less than that index.
-    """
-
-    for i in xrange(len(what) - 1, -1, -1):
-        if what[i] != 0:
-            return what[0: i + 1]
-    return what[0:1]
-
-
-class Rdata(object):
-    """Base class for all DNS rdata types."""
-
-    __slots__ = ['rdclass', 'rdtype']
-
-    def __init__(self, rdclass, rdtype):
-        """Initialize an rdata.
-
-        *rdclass*, an ``int`` is the rdataclass of the Rdata.
-        *rdtype*, an ``int`` is the rdatatype of the Rdata.
-        """
-
-        self.rdclass = rdclass
-        self.rdtype = rdtype
-
-    def covers(self):
-        """Return the type a Rdata covers.
-
-        DNS SIG/RRSIG rdatas apply to a specific type; this type is
-        returned by the covers() function.  If the rdata type is not
-        SIG or RRSIG, dns.rdatatype.NONE is returned.  This is useful when
-        creating rdatasets, allowing the rdataset to contain only RRSIGs
-        of a particular type, e.g. RRSIG(NS).
-
-        Returns an ``int``.
-        """
-
-        return dns.rdatatype.NONE
-
-    def extended_rdatatype(self):
-        """Return a 32-bit type value, the least significant 16 bits of
-        which are the ordinary DNS type, and the upper 16 bits of which are
-        the "covered" type, if any.
-
-        Returns an ``int``.
-        """
-
-        return self.covers() << 16 | self.rdtype
-
-    def to_text(self, origin=None, relativize=True, **kw):
-        """Convert an rdata to text format.
-
-        Returns a ``text``.
-        """
-
-        raise NotImplementedError
-
-    def to_wire(self, file, compress=None, origin=None):
-        """Convert an rdata to wire format.
-
-        Returns a ``binary``.
-        """
-
-        raise NotImplementedError
-
-    def to_digestable(self, origin=None):
-        """Convert rdata to a format suitable for digesting in hashes.  This
-        is also the DNSSEC canonical form.
-
-        Returns a ``binary``.
-        """
-
-        f = BytesIO()
-        self.to_wire(f, None, origin)
-        return f.getvalue()
-
-    def validate(self):
-        """Check that the current contents of the rdata's fields are
-        valid.
-
-        If you change an rdata by assigning to its fields,
-        it is a good idea to call validate() when you are done making
-        changes.
-
-        Raises various exceptions if there are problems.
-
-        Returns ``None``.
-        """
-
-        dns.rdata.from_text(self.rdclass, self.rdtype, self.to_text())
-
-    def __repr__(self):
-        covers = self.covers()
-        if covers == dns.rdatatype.NONE:
-            ctext = ''
-        else:
-            ctext = '(' + dns.rdatatype.to_text(covers) + ')'
-        return '<DNS ' + dns.rdataclass.to_text(self.rdclass) + ' ' + \
-               dns.rdatatype.to_text(self.rdtype) + ctext + ' rdata: ' + \
-               str(self) + '>'
-
-    def __str__(self):
-        return self.to_text()
-
-    def _cmp(self, other):
-        """Compare an rdata with another rdata of the same rdtype and
-        rdclass.
-
-        Return < 0 if self < other in the DNSSEC ordering, 0 if self
-        == other, and > 0 if self > other.
-
-        """
-        our = self.to_digestable(dns.name.root)
-        their = other.to_digestable(dns.name.root)
-        if our == their:
-            return 0
-        elif our > their:
-            return 1
-        else:
-            return -1
-
-    def __eq__(self, other):
-        if not isinstance(other, Rdata):
-            return False
-        if self.rdclass != other.rdclass or self.rdtype != other.rdtype:
-            return False
-        return self._cmp(other) == 0
-
-    def __ne__(self, other):
-        if not isinstance(other, Rdata):
-            return True
-        if self.rdclass != other.rdclass or self.rdtype != other.rdtype:
-            return True
-        return self._cmp(other) != 0
-
-    def __lt__(self, other):
-        if not isinstance(other, Rdata) or \
-                self.rdclass != other.rdclass or self.rdtype != other.rdtype:
-
-            return NotImplemented
-        return self._cmp(other) < 0
-
-    def __le__(self, other):
-        if not isinstance(other, Rdata) or \
-                self.rdclass != other.rdclass or self.rdtype != other.rdtype:
-            return NotImplemented
-        return self._cmp(other) <= 0
-
-    def __ge__(self, other):
-        if not isinstance(other, Rdata) or \
-                self.rdclass != other.rdclass or self.rdtype != other.rdtype:
-            return NotImplemented
-        return self._cmp(other) >= 0
-
-    def __gt__(self, other):
-        if not isinstance(other, Rdata) or \
-                self.rdclass != other.rdclass or self.rdtype != other.rdtype:
-            return NotImplemented
-        return self._cmp(other) > 0
-
-    def __hash__(self):
-        return hash(self.to_digestable(dns.name.root))
-
-    @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        raise NotImplementedError
-
-    @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        raise NotImplementedError
-
-    def choose_relativity(self, origin=None, relativize=True):
-        """Convert any domain names in the rdata to the specified
-        relativization.
-        """
-
-class GenericRdata(Rdata):
-
-    """Generic Rdata Class
-
-    This class is used for rdata types for which we have no better
-    implementation.  It implements the DNS "unknown RRs" scheme.
-    """
-
-    __slots__ = ['data']
-
-    def __init__(self, rdclass, rdtype, data):
-        super(GenericRdata, self).__init__(rdclass, rdtype)
-        self.data = data
-
-    def to_text(self, origin=None, relativize=True, **kw):
-        return r'\# %d ' % len(self.data) + _hexify(self.data)
-
-    @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        token = tok.get()
-        if not token.is_identifier() or token.value != r'\#':
-            raise dns.exception.SyntaxError(
-                r'generic rdata does not start with \#')
-        length = tok.get_int()
-        chunks = []
-        while 1:
-            token = tok.get()
-            if token.is_eol_or_eof():
-                break
-            chunks.append(token.value.encode())
-        hex = b''.join(chunks)
-        data = binascii.unhexlify(hex)
-        if len(data) != length:
-            raise dns.exception.SyntaxError(
-                'generic rdata hex data has wrong length')
-        return cls(rdclass, rdtype, data)
-
-    def to_wire(self, file, compress=None, origin=None):
-        file.write(self.data)
-
-    @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        return cls(rdclass, rdtype, wire[current: current + rdlen])
-
-_rdata_modules = {}
-_module_prefix = 'dns.rdtypes'
-_import_lock = _threading.Lock()
-
-def get_rdata_class(rdclass, rdtype):
-
-    def import_module(name):
-        with _import_lock:
-            mod = __import__(name)
-            components = name.split('.')
-            for comp in components[1:]:
-                mod = getattr(mod, comp)
-            return mod
-
-    mod = _rdata_modules.get((rdclass, rdtype))
-    rdclass_text = dns.rdataclass.to_text(rdclass)
-    rdtype_text = dns.rdatatype.to_text(rdtype)
-    rdtype_text = rdtype_text.replace('-', '_')
-    if not mod:
-        mod = _rdata_modules.get((dns.rdatatype.ANY, rdtype))
-        if not mod:
-            try:
-                mod = import_module('.'.join([_module_prefix,
-                                              rdclass_text, rdtype_text]))
-                _rdata_modules[(rdclass, rdtype)] = mod
-            except ImportError:
-                try:
-                    mod = import_module('.'.join([_module_prefix,
-                                                  'ANY', rdtype_text]))
-                    _rdata_modules[(dns.rdataclass.ANY, rdtype)] = mod
-                except ImportError:
-                    mod = None
-    if mod:
-        cls = getattr(mod, rdtype_text)
-    else:
-        cls = GenericRdata
-    return cls
-
-
-def from_text(rdclass, rdtype, tok, origin=None, relativize=True):
-    """Build an rdata object from text format.
-
-    This function attempts to dynamically load a class which
-    implements the specified rdata class and type.  If there is no
-    class-and-type-specific implementation, the GenericRdata class
-    is used.
-
-    Once a class is chosen, its from_text() class method is called
-    with the parameters to this function.
-
-    If *tok* is a ``text``, then a tokenizer is created and the string
-    is used as its input.
-
-    *rdclass*, an ``int``, the rdataclass.
-
-    *rdtype*, an ``int``, the rdatatype.
-
-    *tok*, a ``dns.tokenizer.Tokenizer`` or a ``text``.
-
-    *origin*, a ``dns.name.Name`` (or ``None``), the
-    origin to use for relative names.
-
-    *relativize*, a ``bool``.  If true, name will be relativized to
-    the specified origin.
-
-    Returns an instance of the chosen Rdata subclass.
-    """
-
-    if isinstance(tok, string_types):
-        tok = dns.tokenizer.Tokenizer(tok)
-    cls = get_rdata_class(rdclass, rdtype)
-    if cls != GenericRdata:
-        # peek at first token
-        token = tok.get()
-        tok.unget(token)
-        if token.is_identifier() and \
-           token.value == r'\#':
-            #
-            # Known type using the generic syntax.  Extract the
-            # wire form from the generic syntax, and then run
-            # from_wire on it.
-            #
-            rdata = GenericRdata.from_text(rdclass, rdtype, tok, origin,
-                                           relativize)
-            return from_wire(rdclass, rdtype, rdata.data, 0, len(rdata.data),
-                             origin)
-    return cls.from_text(rdclass, rdtype, tok, origin, relativize)
-
-
-def from_wire(rdclass, rdtype, wire, current, rdlen, origin=None):
-    """Build an rdata object from wire format
-
-    This function attempts to dynamically load a class which
-    implements the specified rdata class and type.  If there is no
-    class-and-type-specific implementation, the GenericRdata class
-    is used.
-
-    Once a class is chosen, its from_wire() class method is called
-    with the parameters to this function.
-
-    *rdclass*, an ``int``, the rdataclass.
-
-    *rdtype*, an ``int``, the rdatatype.
-
-    *wire*, a ``binary``, the wire-format message.
-
-    *current*, an ``int``, the offset in wire of the beginning of
-    the rdata.
-
-    *rdlen*, an ``int``, the length of the wire-format rdata
-
-    *origin*, a ``dns.name.Name`` (or ``None``).  If not ``None``,
-    then names will be relativized to this origin.
-
-    Returns an instance of the chosen Rdata subclass.
-    """
-
-    wire = dns.wiredata.maybe_wrap(wire)
-    cls = get_rdata_class(rdclass, rdtype)
-    return cls.from_wire(rdclass, rdtype, wire, current, rdlen, origin)
-
-
-class RdatatypeExists(dns.exception.DNSException):
-    """DNS rdatatype already exists."""
-    supp_kwargs = {'rdclass', 'rdtype'}
-    fmt = "The rdata type with class {rdclass} and rdtype {rdtype} " + \
-        "already exists."
-
-
-def register_type(implementation, rdtype, rdtype_text, is_singleton=False,
-                  rdclass=dns.rdataclass.IN):
-    """Dynamically register a module to handle an rdatatype.
-
-    *implementation*, a module implementing the type in the usual dnspython
-    way.
-
-    *rdtype*, an ``int``, the rdatatype to register.
-
-    *rdtype_text*, a ``text``, the textual form of the rdatatype.
-
-    *is_singleton*, a ``bool``, indicating if the type is a singleton (i.e.
-    RRsets of the type can have only one member.)
-
-    *rdclass*, the rdataclass of the type, or ``dns.rdataclass.ANY`` if
-    it applies to all classes.
-    """
-
-    existing_cls = get_rdata_class(rdclass, rdtype)
-    if existing_cls != GenericRdata:
-        raise RdatatypeExists(rdclass=rdclass, rdtype=rdtype)
-    _rdata_modules[(rdclass, rdtype)] = implementation
-    dns.rdatatype.register_type(rdtype, rdtype_text, is_singleton)

src/dns/rdata.pyi

@@ -1,17 +0,0 @@
-from typing import Dict, Tuple, Any, Optional
-from .name import Name
-class Rdata:
-    def __init__(self):
-        self.address : str
-    def to_wire(self, file, compress : Optional[Dict[Name,int]], origin : Optional[Name]) -> bytes:
-        ...
-    @classmethod
-    def from_text(cls, rdclass : int, rdtype : int, tok, origin=None, relativize=True):
-        ...
-_rdata_modules : Dict[Tuple[Any,Rdata],Any]
-
-def from_text(rdclass : int, rdtype : int, tok : Optional[str], origin : Optional[Name] = None, relativize : bool = True):
-    ...
-
-def from_wire(rdclass : int, rdtype : int, wire : bytes, current : int, rdlen : int, origin : Optional[Name] = None):
-    ...

src/dns/rdataclass.py

@@ -1,122 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2001-2017 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""DNS Rdata Classes."""
-
-import re
-
-import dns.exception
-
-RESERVED0 = 0
-IN = 1
-CH = 3
-HS = 4
-NONE = 254
-ANY = 255
-
-_by_text = {
-    'RESERVED0': RESERVED0,
-    'IN': IN,
-    'CH': CH,
-    'HS': HS,
-    'NONE': NONE,
-    'ANY': ANY
-}
-
-# We construct the inverse mapping programmatically to ensure that we
-# cannot make any mistakes (e.g. omissions, cut-and-paste errors) that
-# would cause the mapping not to be true inverse.
-
-_by_value = {y: x for x, y in _by_text.items()}
-
-# Now that we've built the inverse map, we can add class aliases to
-# the _by_text mapping.
-
-_by_text.update({
-    'INTERNET': IN,
-    'CHAOS': CH,
-    'HESIOD': HS
-})
-
-_metaclasses = {
-    NONE: True,
-    ANY: True
-}
-
-_unknown_class_pattern = re.compile('CLASS([0-9]+)$', re.I)
-
-
-class UnknownRdataclass(dns.exception.DNSException):
-    """A DNS class is unknown."""
-
-
-def from_text(text):
-    """Convert text into a DNS rdata class value.
-
-    The input text can be a defined DNS RR class mnemonic or
-    instance of the DNS generic class syntax.
-
-    For example, "IN" and "CLASS1" will both result in a value of 1.
-
-    Raises ``dns.rdatatype.UnknownRdataclass`` if the class is unknown.
-
-    Raises ``ValueError`` if the rdata class value is not >= 0 and <= 65535.
-
-    Returns an ``int``.
-    """
-
-    value = _by_text.get(text.upper())
-    if value is None:
-        match = _unknown_class_pattern.match(text)
-        if match is None:
-            raise UnknownRdataclass
-        value = int(match.group(1))
-        if value < 0 or value > 65535:
-            raise ValueError("class must be between >= 0 and <= 65535")
-    return value
-
-
-def to_text(value):
-    """Convert a DNS rdata type value to text.
-
-    If the value has a known mnemonic, it will be used, otherwise the
-    DNS generic class syntax will be used.
-
-    Raises ``ValueError`` if the rdata class value is not >= 0 and <= 65535.
-
-    Returns a ``str``.
-    """
-
-    if value < 0 or value > 65535:
-        raise ValueError("class must be between >= 0 and <= 65535")
-    text = _by_value.get(value)
-    if text is None:
-        text = 'CLASS' + repr(value)
-    return text
-
-
-def is_metaclass(rdclass):
-    """True if the specified class is a metaclass.
-
-    The currently defined metaclasses are ANY and NONE.
-
-    *rdclass* is an ``int``.
-    """
-
-    if rdclass in _metaclasses:
-        return True
-    return False

src/dns/rdataset.py

@@ -1,347 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2001-2017 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""DNS rdatasets (an rdataset is a set of rdatas of a given type and class)"""
-
-import random
-from io import StringIO
-import struct
-
-import dns.exception
-import dns.rdatatype
-import dns.rdataclass
-import dns.rdata
-import dns.set
-from ._compat import string_types
-
-# define SimpleSet here for backwards compatibility
-SimpleSet = dns.set.Set
-
-
-class DifferingCovers(dns.exception.DNSException):
-    """An attempt was made to add a DNS SIG/RRSIG whose covered type
-    is not the same as that of the other rdatas in the rdataset."""
-
-
-class IncompatibleTypes(dns.exception.DNSException):
-    """An attempt was made to add DNS RR data of an incompatible type."""
-
-
-class Rdataset(dns.set.Set):
-
-    """A DNS rdataset."""
-
-    __slots__ = ['rdclass', 'rdtype', 'covers', 'ttl']
-
-    def __init__(self, rdclass, rdtype, covers=dns.rdatatype.NONE, ttl=0):
-        """Create a new rdataset of the specified class and type.
-
-        *rdclass*, an ``int``, the rdataclass.
-
-        *rdtype*, an ``int``, the rdatatype.
-
-        *covers*, an ``int``, the covered rdatatype.
-
-        *ttl*, an ``int``, the TTL.
-        """
-
-        super(Rdataset, self).__init__()
-        self.rdclass = rdclass
-        self.rdtype = rdtype
-        self.covers = covers
-        self.ttl = ttl
-
-    def _clone(self):
-        obj = super(Rdataset, self)._clone()
-        obj.rdclass = self.rdclass
-        obj.rdtype = self.rdtype
-        obj.covers = self.covers
-        obj.ttl = self.ttl
-        return obj
-
-    def update_ttl(self, ttl):
-        """Perform TTL minimization.
-
-        Set the TTL of the rdataset to be the lesser of the set's current
-        TTL or the specified TTL.  If the set contains no rdatas, set the TTL
-        to the specified TTL.
-
-        *ttl*, an ``int``.
-        """
-
-        if len(self) == 0:
-            self.ttl = ttl
-        elif ttl < self.ttl:
-            self.ttl = ttl
-
-    def add(self, rd, ttl=None):
-        """Add the specified rdata to the rdataset.
-
-        If the optional *ttl* parameter is supplied, then
-        ``self.update_ttl(ttl)`` will be called prior to adding the rdata.
-
-        *rd*, a ``dns.rdata.Rdata``, the rdata
-
-        *ttl*, an ``int``, the TTL.
-
-        Raises ``dns.rdataset.IncompatibleTypes`` if the type and class
-        do not match the type and class of the rdataset.
-
-        Raises ``dns.rdataset.DifferingCovers`` if the type is a signature
-        type and the covered type does not match that of the rdataset.
-        """
-
-        #
-        # If we're adding a signature, do some special handling to
-        # check that the signature covers the same type as the
-        # other rdatas in this rdataset.  If this is the first rdata
-        # in the set, initialize the covers field.
-        #
-        if self.rdclass != rd.rdclass or self.rdtype != rd.rdtype:
-            raise IncompatibleTypes
-        if ttl is not None:
-            self.update_ttl(ttl)
-        if self.rdtype == dns.rdatatype.RRSIG or \
-           self.rdtype == dns.rdatatype.SIG:
-            covers = rd.covers()
-            if len(self) == 0 and self.covers == dns.rdatatype.NONE:
-                self.covers = covers
-            elif self.covers != covers:
-                raise DifferingCovers
-        if dns.rdatatype.is_singleton(rd.rdtype) and len(self) > 0:
-            self.clear()
-        super(Rdataset, self).add(rd)
-
-    def union_update(self, other):
-        self.update_ttl(other.ttl)
-        super(Rdataset, self).union_update(other)
-
-    def intersection_update(self, other):
-        self.update_ttl(other.ttl)
-        super(Rdataset, self).intersection_update(other)
-
-    def update(self, other):
-        """Add all rdatas in other to self.
-
-        *other*, a ``dns.rdataset.Rdataset``, the rdataset from which
-        to update.
-        """
-
-        self.update_ttl(other.ttl)
-        super(Rdataset, self).update(other)
-
-    def __repr__(self):
-        if self.covers == 0:
-            ctext = ''
-        else:
-            ctext = '(' + dns.rdatatype.to_text(self.covers) + ')'
-        return '<DNS ' + dns.rdataclass.to_text(self.rdclass) + ' ' + \
-               dns.rdatatype.to_text(self.rdtype) + ctext + ' rdataset>'
-
-    def __str__(self):
-        return self.to_text()
-
-    def __eq__(self, other):
-        if not isinstance(other, Rdataset):
-            return False
-        if self.rdclass != other.rdclass or \
-           self.rdtype != other.rdtype or \
-           self.covers != other.covers:
-            return False
-        return super(Rdataset, self).__eq__(other)
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def to_text(self, name=None, origin=None, relativize=True,
-                override_rdclass=None, **kw):
-        """Convert the rdataset into DNS master file format.
-
-        See ``dns.name.Name.choose_relativity`` for more information
-        on how *origin* and *relativize* determine the way names
-        are emitted.
-
-        Any additional keyword arguments are passed on to the rdata
-        ``to_text()`` method.
-
-        *name*, a ``dns.name.Name``.  If name is not ``None``, emit RRs with
-        *name* as the owner name.
-
-        *origin*, a ``dns.name.Name`` or ``None``, the origin for relative
-        names.
-
-        *relativize*, a ``bool``.  If ``True``, names will be relativized
-        to *origin*.
-        """
-
-        if name is not None:
-            name = name.choose_relativity(origin, relativize)
-            ntext = str(name)
-            pad = ' '
-        else:
-            ntext = ''
-            pad = ''
-        s = StringIO()
-        if override_rdclass is not None:
-            rdclass = override_rdclass
-        else:
-            rdclass = self.rdclass
-        if len(self) == 0:
-            #
-            # Empty rdatasets are used for the question section, and in
-            # some dynamic updates, so we don't need to print out the TTL
-            # (which is meaningless anyway).
-            #
-            s.write(u'{}{}{} {}\n'.format(ntext, pad,
-                                          dns.rdataclass.to_text(rdclass),
-                                          dns.rdatatype.to_text(self.rdtype)))
-        else:
-            for rd in self:
-                s.write(u'%s%s%d %s %s %s\n' %
-                        (ntext, pad, self.ttl, dns.rdataclass.to_text(rdclass),
-                         dns.rdatatype.to_text(self.rdtype),
-                         rd.to_text(origin=origin, relativize=relativize,
-                         **kw)))
-        #
-        # We strip off the final \n for the caller's convenience in printing
-        #
-        return s.getvalue()[:-1]
-
-    def to_wire(self, name, file, compress=None, origin=None,
-                override_rdclass=None, want_shuffle=True):
-        """Convert the rdataset to wire format.
-
-        *name*, a ``dns.name.Name`` is the owner name to use.
-
-        *file* is the file where the name is emitted (typically a
-        BytesIO file).
-
-        *compress*, a ``dict``, is the compression table to use.  If
-        ``None`` (the default), names will not be compressed.
-
-        *origin* is a ``dns.name.Name`` or ``None``.  If the name is
-        relative and origin is not ``None``, then *origin* will be appended
-        to it.
-
-        *override_rdclass*, an ``int``, is used as the class instead of the
-        class of the rdataset.  This is useful when rendering rdatasets
-        associated with dynamic updates.
-
-        *want_shuffle*, a ``bool``.  If ``True``, then the order of the
-        Rdatas within the Rdataset will be shuffled before rendering.
-
-        Returns an ``int``, the number of records emitted.
-        """
-
-        if override_rdclass is not None:
-            rdclass = override_rdclass
-            want_shuffle = False
-        else:
-            rdclass = self.rdclass
-        file.seek(0, 2)
-        if len(self) == 0:
-            name.to_wire(file, compress, origin)
-            stuff = struct.pack("!HHIH", self.rdtype, rdclass, 0, 0)
-            file.write(stuff)
-            return 1
-        else:
-            if want_shuffle:
-                l = list(self)
-                random.shuffle(l)
-            else:
-                l = self
-            for rd in l:
-                name.to_wire(file, compress, origin)
-                stuff = struct.pack("!HHIH", self.rdtype, rdclass,
-                                    self.ttl, 0)
-                file.write(stuff)
-                start = file.tell()
-                rd.to_wire(file, compress, origin)
-                end = file.tell()
-                assert end - start < 65536
-                file.seek(start - 2)
-                stuff = struct.pack("!H", end - start)
-                file.write(stuff)
-                file.seek(0, 2)
-            return len(self)
-
-    def match(self, rdclass, rdtype, covers):
-        """Returns ``True`` if this rdataset matches the specified class,
-        type, and covers.
-        """
-        if self.rdclass == rdclass and \
-           self.rdtype == rdtype and \
-           self.covers == covers:
-            return True
-        return False
-
-
-def from_text_list(rdclass, rdtype, ttl, text_rdatas):
-    """Create an rdataset with the specified class, type, and TTL, and with
-    the specified list of rdatas in text format.
-
-    Returns a ``dns.rdataset.Rdataset`` object.
-    """
-
-    if isinstance(rdclass, string_types):
-        rdclass = dns.rdataclass.from_text(rdclass)
-    if isinstance(rdtype, string_types):
-        rdtype = dns.rdatatype.from_text(rdtype)
-    r = Rdataset(rdclass, rdtype)
-    r.update_ttl(ttl)
-    for t in text_rdatas:
-        rd = dns.rdata.from_text(r.rdclass, r.rdtype, t)
-        r.add(rd)
-    return r
-
-
-def from_text(rdclass, rdtype, ttl, *text_rdatas):
-    """Create an rdataset with the specified class, type, and TTL, and with
-    the specified rdatas in text format.
-
-    Returns a ``dns.rdataset.Rdataset`` object.
-    """
-
-    return from_text_list(rdclass, rdtype, ttl, text_rdatas)
-
-
-def from_rdata_list(ttl, rdatas):
-    """Create an rdataset with the specified TTL, and with
-    the specified list of rdata objects.
-
-    Returns a ``dns.rdataset.Rdataset`` object.
-    """
-
-    if len(rdatas) == 0:
-        raise ValueError("rdata list must not be empty")
-    r = None
-    for rd in rdatas:
-        if r is None:
-            r = Rdataset(rd.rdclass, rd.rdtype)
-            r.update_ttl(ttl)
-        r.add(rd)
-    return r
-
-
-def from_rdata(ttl, *rdatas):
-    """Create an rdataset with the specified TTL, and with
-    the specified rdata objects.
-
-    Returns a ``dns.rdataset.Rdataset`` object.
-    """
-
-    return from_rdata_list(ttl, rdatas)

src/dns/rdataset.pyi

@@ -1,58 +0,0 @@
-from typing import Optional, Dict, List, Union
-from io import BytesIO
-from . import exception, name, set, rdatatype, rdata, rdataset
-
-class DifferingCovers(exception.DNSException):
-    """An attempt was made to add a DNS SIG/RRSIG whose covered type
-    is not the same as that of the other rdatas in the rdataset."""
-
-
-class IncompatibleTypes(exception.DNSException):
-    """An attempt was made to add DNS RR data of an incompatible type."""
-
-
-class Rdataset(set.Set):
-    def __init__(self, rdclass, rdtype, covers=rdatatype.NONE, ttl=0):
-        self.rdclass : int = rdclass
-        self.rdtype : int = rdtype
-        self.covers : int = covers
-        self.ttl : int = ttl
-
-    def update_ttl(self, ttl : int) -> None:
-        ...
-
-    def add(self, rd : rdata.Rdata, ttl : Optional[int] =None):
-        ...
-
-    def union_update(self, other : Rdataset):
-        ...
-
-    def intersection_update(self, other : Rdataset):
-        ...
-
-    def update(self, other : Rdataset):
-        ...
-
-    def to_text(self, name : Optional[name.Name] =None, origin : Optional[name.Name] =None, relativize=True,
-                override_rdclass : Optional[int] =None, **kw) -> bytes:
-        ...
-
-    def to_wire(self, name : Optional[name.Name], file : BytesIO, compress : Optional[Dict[name.Name, int]] = None, origin : Optional[name.Name] = None,
-                override_rdclass : Optional[int] = None, want_shuffle=True) -> int:
-        ...
-
-    def match(self, rdclass : int, rdtype : int, covers : int) -> bool:
-        ...
-
-
-def from_text_list(rdclass : Union[int,str], rdtype : Union[int,str], ttl : int, text_rdatas : str) -> rdataset.Rdataset:
-    ...
-
-def from_text(rdclass : Union[int,str], rdtype : Union[int,str], ttl : int, *text_rdatas : str) -> rdataset.Rdataset:
-    ...
-
-def from_rdata_list(ttl : int, rdatas : List[rdata.Rdata]) -> rdataset.Rdataset:
-    ...
-
-def from_rdata(ttl : int, *rdatas : List[rdata.Rdata]) -> rdataset.Rdataset:
-    ...

src/dns/rdatatype.py

@@ -1,287 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2001-2017 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""DNS Rdata Types."""
-
-import re
-
-import dns.exception
-
-NONE = 0
-A = 1
-NS = 2
-MD = 3
-MF = 4
-CNAME = 5
-SOA = 6
-MB = 7
-MG = 8
-MR = 9
-NULL = 10
-WKS = 11
-PTR = 12
-HINFO = 13
-MINFO = 14
-MX = 15
-TXT = 16
-RP = 17
-AFSDB = 18
-X25 = 19
-ISDN = 20
-RT = 21
-NSAP = 22
-NSAP_PTR = 23
-SIG = 24
-KEY = 25
-PX = 26
-GPOS = 27
-AAAA = 28
-LOC = 29
-NXT = 30
-SRV = 33
-NAPTR = 35
-KX = 36
-CERT = 37
-A6 = 38
-DNAME = 39
-OPT = 41
-APL = 42
-DS = 43
-SSHFP = 44
-IPSECKEY = 45
-RRSIG = 46
-NSEC = 47
-DNSKEY = 48
-DHCID = 49
-NSEC3 = 50
-NSEC3PARAM = 51
-TLSA = 52
-HIP = 55
-CDS = 59
-CDNSKEY = 60
-OPENPGPKEY = 61
-CSYNC = 62
-SPF = 99
-UNSPEC = 103
-EUI48 = 108
-EUI64 = 109
-TKEY = 249
-TSIG = 250
-IXFR = 251
-AXFR = 252
-MAILB = 253
-MAILA = 254
-ANY = 255
-URI = 256
-CAA = 257
-AVC = 258
-TA = 32768
-DLV = 32769
-
-_by_text = {
-    'NONE': NONE,
-    'A': A,
-    'NS': NS,
-    'MD': MD,
-    'MF': MF,
-    'CNAME': CNAME,
-    'SOA': SOA,
-    'MB': MB,
-    'MG': MG,
-    'MR': MR,
-    'NULL': NULL,
-    'WKS': WKS,
-    'PTR': PTR,
-    'HINFO': HINFO,
-    'MINFO': MINFO,
-    'MX': MX,
-    'TXT': TXT,
-    'RP': RP,
-    'AFSDB': AFSDB,
-    'X25': X25,
-    'ISDN': ISDN,
-    'RT': RT,
-    'NSAP': NSAP,
-    'NSAP-PTR': NSAP_PTR,
-    'SIG': SIG,
-    'KEY': KEY,
-    'PX': PX,
-    'GPOS': GPOS,
-    'AAAA': AAAA,
-    'LOC': LOC,
-    'NXT': NXT,
-    'SRV': SRV,
-    'NAPTR': NAPTR,
-    'KX': KX,
-    'CERT': CERT,
-    'A6': A6,
-    'DNAME': DNAME,
-    'OPT': OPT,
-    'APL': APL,
-    'DS': DS,
-    'SSHFP': SSHFP,
-    'IPSECKEY': IPSECKEY,
-    'RRSIG': RRSIG,
-    'NSEC': NSEC,
-    'DNSKEY': DNSKEY,
-    'DHCID': DHCID,
-    'NSEC3': NSEC3,
-    'NSEC3PARAM': NSEC3PARAM,
-    'TLSA': TLSA,
-    'HIP': HIP,
-    'CDS': CDS,
-    'CDNSKEY': CDNSKEY,
-    'OPENPGPKEY': OPENPGPKEY,
-    'CSYNC': CSYNC,
-    'SPF': SPF,
-    'UNSPEC': UNSPEC,
-    'EUI48': EUI48,
-    'EUI64': EUI64,
-    'TKEY': TKEY,
-    'TSIG': TSIG,
-    'IXFR': IXFR,
-    'AXFR': AXFR,
-    'MAILB': MAILB,
-    'MAILA': MAILA,
-    'ANY': ANY,
-    'URI': URI,
-    'CAA': CAA,
-    'AVC': AVC,
-    'TA': TA,
-    'DLV': DLV,
-}
-
-# We construct the inverse mapping programmatically to ensure that we
-# cannot make any mistakes (e.g. omissions, cut-and-paste errors) that
-# would cause the mapping not to be true inverse.
-
-_by_value = {y: x for x, y in _by_text.items()}
-
-_metatypes = {
-    OPT: True
-}
-
-_singletons = {
-    SOA: True,
-    NXT: True,
-    DNAME: True,
-    NSEC: True,
-    CNAME: True,
-}
-
-_unknown_type_pattern = re.compile('TYPE([0-9]+)$', re.I)
-
-
-class UnknownRdatatype(dns.exception.DNSException):
-    """DNS resource record type is unknown."""
-
-
-def from_text(text):
-    """Convert text into a DNS rdata type value.
-
-    The input text can be a defined DNS RR type mnemonic or
-    instance of the DNS generic type syntax.
-
-    For example, "NS" and "TYPE2" will both result in a value of 2.
-
-    Raises ``dns.rdatatype.UnknownRdatatype`` if the type is unknown.
-
-    Raises ``ValueError`` if the rdata type value is not >= 0 and <= 65535.
-
-    Returns an ``int``.
-    """
-
-    value = _by_text.get(text.upper())
-    if value is None:
-        match = _unknown_type_pattern.match(text)
-        if match is None:
-            raise UnknownRdatatype
-        value = int(match.group(1))
-        if value < 0 or value > 65535:
-            raise ValueError("type must be between >= 0 and <= 65535")
-    return value
-
-
-def to_text(value):
-    """Convert a DNS rdata type value to text.
-
-    If the value has a known mnemonic, it will be used, otherwise the
-    DNS generic type syntax will be used.
-
-    Raises ``ValueError`` if the rdata type value is not >= 0 and <= 65535.
-
-    Returns a ``str``.
-    """
-
-    if value < 0 or value > 65535:
-        raise ValueError("type must be between >= 0 and <= 65535")
-    text = _by_value.get(value)
-    if text is None:
-        text = 'TYPE' + repr(value)
-    return text
-
-
-def is_metatype(rdtype):
-    """True if the specified type is a metatype.
-
-    *rdtype* is an ``int``.
-
-    The currently defined metatypes are TKEY, TSIG, IXFR, AXFR, MAILA,
-    MAILB, ANY, and OPT.
-
-    Returns a ``bool``.
-    """
-
-    if rdtype >= TKEY and rdtype <= ANY or rdtype in _metatypes:
-        return True
-    return False
-
-
-def is_singleton(rdtype):
-    """Is the specified type a singleton type?
-
-    Singleton types can only have a single rdata in an rdataset, or a single
-    RR in an RRset.
-
-    The currently defined singleton types are CNAME, DNAME, NSEC, NXT, and
-    SOA.
-
-    *rdtype* is an ``int``.
-
-    Returns a ``bool``.
-    """
-
-    if rdtype in _singletons:
-        return True
-    return False
-
-
-def register_type(rdtype, rdtype_text, is_singleton=False):  # pylint: disable=redefined-outer-name
-    """Dynamically register an rdatatype.
-
-    *rdtype*, an ``int``, the rdatatype to register.
-
-    *rdtype_text*, a ``text``, the textual form of the rdatatype.
-
-    *is_singleton*, a ``bool``, indicating if the type is a singleton (i.e.
-    RRsets of the type can have only one member.)
-    """
-
-    _by_text[rdtype_text] = rdtype
-    _by_value[rdtype] = rdtype_text
-    if is_singleton:
-        _singletons[rdtype] = True

src/dns/rdtypes/ANY/AFSDB.py

@@ -1,55 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import dns.rdtypes.mxbase
-
-
-class AFSDB(dns.rdtypes.mxbase.UncompressedDowncasingMX):
-
-    """AFSDB record
-
-    @ivar subtype: the subtype value
-    @type subtype: int
-    @ivar hostname: the hostname name
-    @type hostname: dns.name.Name object"""
-
-    # Use the property mechanism to make "subtype" an alias for the
-    # "preference" attribute, and "hostname" an alias for the "exchange"
-    # attribute.
-    #
-    # This lets us inherit the UncompressedMX implementation but lets
-    # the caller use appropriate attribute names for the rdata type.
-    #
-    # We probably lose some performance vs. a cut-and-paste
-    # implementation, but this way we don't copy code, and that's
-    # good.
-
-    def get_subtype(self):
-        return self.preference
-
-    def set_subtype(self, subtype):
-        self.preference = subtype
-
-    subtype = property(get_subtype, set_subtype)
-
-    def get_hostname(self):
-        return self.exchange
-
-    def set_hostname(self, hostname):
-        self.exchange = hostname
-
-    hostname = property(get_hostname, set_hostname)

src/dns/rdtypes/ANY/AVC.py

@@ -1,25 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2016 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import dns.rdtypes.txtbase
-
-
-class AVC(dns.rdtypes.txtbase.TXTBase):
-
-    """AVC record
-
-    @see: U{http://www.iana.org/assignments/dns-parameters/AVC/avc-completed-template}"""

src/dns/rdtypes/ANY/CAA.py

@@ -1,75 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import struct
-
-import dns.exception
-import dns.rdata
-import dns.tokenizer
-
-
-class CAA(dns.rdata.Rdata):
-
-    """CAA (Certification Authority Authorization) record
-
-    @ivar flags: the flags
-    @type flags: int
-    @ivar tag: the tag
-    @type tag: string
-    @ivar value: the value
-    @type value: string
-    @see: RFC 6844"""
-
-    __slots__ = ['flags', 'tag', 'value']
-
-    def __init__(self, rdclass, rdtype, flags, tag, value):
-        super(CAA, self).__init__(rdclass, rdtype)
-        self.flags = flags
-        self.tag = tag
-        self.value = value
-
-    def to_text(self, origin=None, relativize=True, **kw):
-        return '%u %s "%s"' % (self.flags,
-                               dns.rdata._escapify(self.tag),
-                               dns.rdata._escapify(self.value))
-
-    @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        flags = tok.get_uint8()
-        tag = tok.get_string().encode()
-        if len(tag) > 255:
-            raise dns.exception.SyntaxError("tag too long")
-        if not tag.isalnum():
-            raise dns.exception.SyntaxError("tag is not alphanumeric")
-        value = tok.get_string().encode()
-        return cls(rdclass, rdtype, flags, tag, value)
-
-    def to_wire(self, file, compress=None, origin=None):
-        file.write(struct.pack('!B', self.flags))
-        l = len(self.tag)
-        assert l < 256
-        file.write(struct.pack('!B', l))
-        file.write(self.tag)
-        file.write(self.value)
-
-    @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        (flags, l) = struct.unpack('!BB', wire[current: current + 2])
-        current += 2
-        tag = wire[current: current + l]
-        value = wire[current + l:current + rdlen - 2]
-        return cls(rdclass, rdtype, flags, tag, value)

src/dns/rdtypes/ANY/CDNSKEY.py

@@ -1,27 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2004-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import dns.rdtypes.dnskeybase
-from dns.rdtypes.dnskeybase import flags_to_text_set, flags_from_text_set
-
-
-__all__ = ['flags_to_text_set', 'flags_from_text_set']
-
-
-class CDNSKEY(dns.rdtypes.dnskeybase.DNSKEYBase):
-
-    """CDNSKEY record"""

src/dns/rdtypes/ANY/CDS.py

@@ -1,23 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import dns.rdtypes.dsbase
-
-
-class CDS(dns.rdtypes.dsbase.DSBase):
-
-    """CDS record"""

src/dns/rdtypes/ANY/CERT.py

@@ -1,123 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import struct
-import base64
-
-import dns.exception
-import dns.dnssec
-import dns.rdata
-import dns.tokenizer
-
-_ctype_by_value = {
-    1: 'PKIX',
-    2: 'SPKI',
-    3: 'PGP',
-    253: 'URI',
-    254: 'OID',
-}
-
-_ctype_by_name = {
-    'PKIX': 1,
-    'SPKI': 2,
-    'PGP': 3,
-    'URI': 253,
-    'OID': 254,
-}
-
-
-def _ctype_from_text(what):
-    v = _ctype_by_name.get(what)
-    if v is not None:
-        return v
-    return int(what)
-
-
-def _ctype_to_text(what):
-    v = _ctype_by_value.get(what)
-    if v is not None:
-        return v
-    return str(what)
-
-
-class CERT(dns.rdata.Rdata):
-
-    """CERT record
-
-    @ivar certificate_type: certificate type
-    @type certificate_type: int
-    @ivar key_tag: key tag
-    @type key_tag: int
-    @ivar algorithm: algorithm
-    @type algorithm: int
-    @ivar certificate: the certificate or CRL
-    @type certificate: string
-    @see: RFC 2538"""
-
-    __slots__ = ['certificate_type', 'key_tag', 'algorithm', 'certificate']
-
-    def __init__(self, rdclass, rdtype, certificate_type, key_tag, algorithm,
-                 certificate):
-        super(CERT, self).__init__(rdclass, rdtype)
-        self.certificate_type = certificate_type
-        self.key_tag = key_tag
-        self.algorithm = algorithm
-        self.certificate = certificate
-
-    def to_text(self, origin=None, relativize=True, **kw):
-        certificate_type = _ctype_to_text(self.certificate_type)
-        return "%s %d %s %s" % (certificate_type, self.key_tag,
-                                dns.dnssec.algorithm_to_text(self.algorithm),
-                                dns.rdata._base64ify(self.certificate))
-
-    @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        certificate_type = _ctype_from_text(tok.get_string())
-        key_tag = tok.get_uint16()
-        algorithm = dns.dnssec.algorithm_from_text(tok.get_string())
-        if algorithm < 0 or algorithm > 255:
-            raise dns.exception.SyntaxError("bad algorithm type")
-        chunks = []
-        while 1:
-            t = tok.get().unescape()
-            if t.is_eol_or_eof():
-                break
-            if not t.is_identifier():
-                raise dns.exception.SyntaxError
-            chunks.append(t.value.encode())
-        b64 = b''.join(chunks)
-        certificate = base64.b64decode(b64)
-        return cls(rdclass, rdtype, certificate_type, key_tag,
-                   algorithm, certificate)
-
-    def to_wire(self, file, compress=None, origin=None):
-        prefix = struct.pack("!HHB", self.certificate_type, self.key_tag,
-                             self.algorithm)
-        file.write(prefix)
-        file.write(self.certificate)
-
-    @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        prefix = wire[current: current + 5].unwrap()
-        current += 5
-        rdlen -= 5
-        if rdlen < 0:
-            raise dns.exception.FormError
-        (certificate_type, key_tag, algorithm) = struct.unpack("!HHB", prefix)
-        certificate = wire[current: current + rdlen].unwrap()
-        return cls(rdclass, rdtype, certificate_type, key_tag, algorithm,
-                   certificate)

src/dns/rdtypes/ANY/CNAME.py

@@ -1,27 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import dns.rdtypes.nsbase
-
-
-class CNAME(dns.rdtypes.nsbase.NSBase):
-
-    """CNAME record
-
-    Note: although CNAME is officially a singleton type, dnspython allows
-    non-singleton CNAME rdatasets because such sets have been commonly
-    used by BIND and other nameservers for load balancing."""

src/dns/rdtypes/ANY/CSYNC.py

@@ -1,126 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2004-2007, 2009-2011, 2016 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import struct
-
-import dns.exception
-import dns.rdata
-import dns.rdatatype
-import dns.name
-from dns._compat import xrange
-
-class CSYNC(dns.rdata.Rdata):
-
-    """CSYNC record
-
-    @ivar serial: the SOA serial number
-    @type serial: int
-    @ivar flags: the CSYNC flags
-    @type flags: int
-    @ivar windows: the windowed bitmap list
-    @type windows: list of (window number, string) tuples"""
-
-    __slots__ = ['serial', 'flags', 'windows']
-
-    def __init__(self, rdclass, rdtype, serial, flags, windows):
-        super(CSYNC, self).__init__(rdclass, rdtype)
-        self.serial = serial
-        self.flags = flags
-        self.windows = windows
-
-    def to_text(self, origin=None, relativize=True, **kw):
-        text = ''
-        for (window, bitmap) in self.windows:
-            bits = []
-            for i in xrange(0, len(bitmap)):
-                byte = bitmap[i]
-                for j in xrange(0, 8):
-                    if byte & (0x80 >> j):
-                        bits.append(dns.rdatatype.to_text(window * 256 +
-                                                          i * 8 + j))
-            text += (' ' + ' '.join(bits))
-        return '%d %d%s' % (self.serial, self.flags, text)
-
-    @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        serial = tok.get_uint32()
-        flags = tok.get_uint16()
-        rdtypes = []
-        while 1:
-            token = tok.get().unescape()
-            if token.is_eol_or_eof():
-                break
-            nrdtype = dns.rdatatype.from_text(token.value)
-            if nrdtype == 0:
-                raise dns.exception.SyntaxError("CSYNC with bit 0")
-            if nrdtype > 65535:
-                raise dns.exception.SyntaxError("CSYNC with bit > 65535")
-            rdtypes.append(nrdtype)
-        rdtypes.sort()
-        window = 0
-        octets = 0
-        prior_rdtype = 0
-        bitmap = bytearray(b'\0' * 32)
-        windows = []
-        for nrdtype in rdtypes:
-            if nrdtype == prior_rdtype:
-                continue
-            prior_rdtype = nrdtype
-            new_window = nrdtype // 256
-            if new_window != window:
-                windows.append((window, bitmap[0:octets]))
-                bitmap = bytearray(b'\0' * 32)
-                window = new_window
-            offset = nrdtype % 256
-            byte = offset // 8
-            bit = offset % 8
-            octets = byte + 1
-            bitmap[byte] = bitmap[byte] | (0x80 >> bit)
-
-        windows.append((window, bitmap[0:octets]))
-        return cls(rdclass, rdtype, serial, flags, windows)
-
-    def to_wire(self, file, compress=None, origin=None):
-        file.write(struct.pack('!IH', self.serial, self.flags))
-        for (window, bitmap) in self.windows:
-            file.write(struct.pack('!BB', window, len(bitmap)))
-            file.write(bitmap)
-
-    @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        if rdlen < 6:
-            raise dns.exception.FormError("CSYNC too short")
-        (serial, flags) = struct.unpack("!IH", wire[current: current + 6])
-        current += 6
-        rdlen -= 6
-        windows = []
-        while rdlen > 0:
-            if rdlen < 3:
-                raise dns.exception.FormError("CSYNC too short")
-            window = wire[current]
-            octets = wire[current + 1]
-            if octets == 0 or octets > 32:
-                raise dns.exception.FormError("bad CSYNC octets")
-            current += 2
-            rdlen -= 2
-            if rdlen < octets:
-                raise dns.exception.FormError("bad CSYNC bitmap length")
-            bitmap = bytearray(wire[current: current + octets].unwrap())
-            current += octets
-            rdlen -= octets
-            windows.append((window, bitmap))
-        return cls(rdclass, rdtype, serial, flags, windows)

src/dns/rdtypes/ANY/DLV.py

@@ -1,23 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import dns.rdtypes.dsbase
-
-
-class DLV(dns.rdtypes.dsbase.DSBase):
-
-    """DLV record"""

src/dns/rdtypes/ANY/DNAME.py

@@ -1,26 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import dns.rdtypes.nsbase
-
-
-class DNAME(dns.rdtypes.nsbase.UncompressedNS):
-
-    """DNAME record"""
-
-    def to_digestable(self, origin=None):
-        return self.target.to_digestable(origin)

src/dns/rdtypes/ANY/DNSKEY.py

@@ -1,27 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2004-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import dns.rdtypes.dnskeybase
-from dns.rdtypes.dnskeybase import flags_to_text_set, flags_from_text_set
-
-
-__all__ = ['flags_to_text_set', 'flags_from_text_set']
-
-
-class DNSKEY(dns.rdtypes.dnskeybase.DNSKEYBase):
-
-    """DNSKEY record"""

src/dns/rdtypes/ANY/DS.py

@@ -1,23 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import dns.rdtypes.dsbase
-
-
-class DS(dns.rdtypes.dsbase.DSBase):
-
-    """DS record"""

src/dns/rdtypes/ANY/EUI48.py

@@ -1,29 +0,0 @@
-# Copyright (C) 2015 Red Hat, Inc.
-# Author: Petr Spacek <pspacek@redhat.com>
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED 'AS IS' AND RED HAT DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import dns.rdtypes.euibase
-
-
-class EUI48(dns.rdtypes.euibase.EUIBase):
-
-    """EUI48 record
-
-    @ivar fingerprint: 48-bit Extended Unique Identifier (EUI-48)
-    @type fingerprint: string
-    @see: rfc7043.txt"""
-
-    byte_len = 6  # 0123456789ab (in hex)
-    text_len = byte_len * 3 - 1  # 01-23-45-67-89-ab

src/dns/rdtypes/ANY/EUI64.py

@@ -1,29 +0,0 @@
-# Copyright (C) 2015 Red Hat, Inc.
-# Author: Petr Spacek <pspacek@redhat.com>
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED 'AS IS' AND RED HAT DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import dns.rdtypes.euibase
-
-
-class EUI64(dns.rdtypes.euibase.EUIBase):
-
-    """EUI64 record
-
-    @ivar fingerprint: 64-bit Extended Unique Identifier (EUI-64)
-    @type fingerprint: string
-    @see: rfc7043.txt"""
-
-    byte_len = 8  # 0123456789abcdef (in hex)
-    text_len = byte_len * 3 - 1  # 01-23-45-67-89-ab-cd-ef

src/dns/rdtypes/ANY/GPOS.py

@@ -1,162 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import struct
-
-import dns.exception
-import dns.rdata
-import dns.tokenizer
-from dns._compat import long, text_type
-
-
-def _validate_float_string(what):
-    if what[0] == b'-'[0] or what[0] == b'+'[0]:
-        what = what[1:]
-    if what.isdigit():
-        return
-    (left, right) = what.split(b'.')
-    if left == b'' and right == b'':
-        raise dns.exception.FormError
-    if not left == b'' and not left.decode().isdigit():
-        raise dns.exception.FormError
-    if not right == b'' and not right.decode().isdigit():
-        raise dns.exception.FormError
-
-
-def _sanitize(value):
-    if isinstance(value, text_type):
-        return value.encode()
-    return value
-
-
-class GPOS(dns.rdata.Rdata):
-
-    """GPOS record
-
-    @ivar latitude: latitude
-    @type latitude: string
-    @ivar longitude: longitude
-    @type longitude: string
-    @ivar altitude: altitude
-    @type altitude: string
-    @see: RFC 1712"""
-
-    __slots__ = ['latitude', 'longitude', 'altitude']
-
-    def __init__(self, rdclass, rdtype, latitude, longitude, altitude):
-        super(GPOS, self).__init__(rdclass, rdtype)
-        if isinstance(latitude, float) or \
-           isinstance(latitude, int) or \
-           isinstance(latitude, long):
-            latitude = str(latitude)
-        if isinstance(longitude, float) or \
-           isinstance(longitude, int) or \
-           isinstance(longitude, long):
-            longitude = str(longitude)
-        if isinstance(altitude, float) or \
-           isinstance(altitude, int) or \
-           isinstance(altitude, long):
-            altitude = str(altitude)
-        latitude = _sanitize(latitude)
-        longitude = _sanitize(longitude)
-        altitude = _sanitize(altitude)
-        _validate_float_string(latitude)
-        _validate_float_string(longitude)
-        _validate_float_string(altitude)
-        self.latitude = latitude
-        self.longitude = longitude
-        self.altitude = altitude
-
-    def to_text(self, origin=None, relativize=True, **kw):
-        return '{} {} {}'.format(self.latitude.decode(),
-                             self.longitude.decode(),
-                             self.altitude.decode())
-
-    @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        latitude = tok.get_string()
-        longitude = tok.get_string()
-        altitude = tok.get_string()
-        tok.get_eol()
-        return cls(rdclass, rdtype, latitude, longitude, altitude)
-
-    def to_wire(self, file, compress=None, origin=None):
-        l = len(self.latitude)
-        assert l < 256
-        file.write(struct.pack('!B', l))
-        file.write(self.latitude)
-        l = len(self.longitude)
-        assert l < 256
-        file.write(struct.pack('!B', l))
-        file.write(self.longitude)
-        l = len(self.altitude)
-        assert l < 256
-        file.write(struct.pack('!B', l))
-        file.write(self.altitude)
-
-    @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        l = wire[current]
-        current += 1
-        rdlen -= 1
-        if l > rdlen:
-            raise dns.exception.FormError
-        latitude = wire[current: current + l].unwrap()
-        current += l
-        rdlen -= l
-        l = wire[current]
-        current += 1
-        rdlen -= 1
-        if l > rdlen:
-            raise dns.exception.FormError
-        longitude = wire[current: current + l].unwrap()
-        current += l
-        rdlen -= l
-        l = wire[current]
-        current += 1
-        rdlen -= 1
-        if l != rdlen:
-            raise dns.exception.FormError
-        altitude = wire[current: current + l].unwrap()
-        return cls(rdclass, rdtype, latitude, longitude, altitude)
-
-    def _get_float_latitude(self):
-        return float(self.latitude)
-
-    def _set_float_latitude(self, value):
-        self.latitude = str(value)
-
-    float_latitude = property(_get_float_latitude, _set_float_latitude,
-                              doc="latitude as a floating point value")
-
-    def _get_float_longitude(self):
-        return float(self.longitude)
-
-    def _set_float_longitude(self, value):
-        self.longitude = str(value)
-
-    float_longitude = property(_get_float_longitude, _set_float_longitude,
-                               doc="longitude as a floating point value")
-
-    def _get_float_altitude(self):
-        return float(self.altitude)
-
-    def _set_float_altitude(self, value):
-        self.altitude = str(value)
-
-    float_altitude = property(_get_float_altitude, _set_float_altitude,
-                              doc="altitude as a floating point value")

src/dns/rdtypes/ANY/HINFO.py

@@ -1,86 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import struct
-
-import dns.exception
-import dns.rdata
-import dns.tokenizer
-from dns._compat import text_type
-
-
-class HINFO(dns.rdata.Rdata):
-
-    """HINFO record
-
-    @ivar cpu: the CPU type
-    @type cpu: string
-    @ivar os: the OS type
-    @type os: string
-    @see: RFC 1035"""
-
-    __slots__ = ['cpu', 'os']
-
-    def __init__(self, rdclass, rdtype, cpu, os):
-        super(HINFO, self).__init__(rdclass, rdtype)
-        if isinstance(cpu, text_type):
-            self.cpu = cpu.encode()
-        else:
-            self.cpu = cpu
-        if isinstance(os, text_type):
-            self.os = os.encode()
-        else:
-            self.os = os
-
-    def to_text(self, origin=None, relativize=True, **kw):
-        return '"{}" "{}"'.format(dns.rdata._escapify(self.cpu),
-                                  dns.rdata._escapify(self.os))
-
-    @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        cpu = tok.get_string()
-        os = tok.get_string()
-        tok.get_eol()
-        return cls(rdclass, rdtype, cpu, os)
-
-    def to_wire(self, file, compress=None, origin=None):
-        l = len(self.cpu)
-        assert l < 256
-        file.write(struct.pack('!B', l))
-        file.write(self.cpu)
-        l = len(self.os)
-        assert l < 256
-        file.write(struct.pack('!B', l))
-        file.write(self.os)
-
-    @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        l = wire[current]
-        current += 1
-        rdlen -= 1
-        if l > rdlen:
-            raise dns.exception.FormError
-        cpu = wire[current:current + l].unwrap()
-        current += l
-        rdlen -= l
-        l = wire[current]
-        current += 1
-        rdlen -= 1
-        if l != rdlen:
-            raise dns.exception.FormError
-        os = wire[current: current + l].unwrap()
-        return cls(rdclass, rdtype, cpu, os)

src/dns/rdtypes/ANY/HIP.py

@@ -1,115 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2010, 2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import struct
-import base64
-import binascii
-
-import dns.exception
-import dns.rdata
-import dns.rdatatype
-
-
-class HIP(dns.rdata.Rdata):
-
-    """HIP record
-
-    @ivar hit: the host identity tag
-    @type hit: string
-    @ivar algorithm: the public key cryptographic algorithm
-    @type algorithm: int
-    @ivar key: the public key
-    @type key: string
-    @ivar servers: the rendezvous servers
-    @type servers: list of dns.name.Name objects
-    @see: RFC 5205"""
-
-    __slots__ = ['hit', 'algorithm', 'key', 'servers']
-
-    def __init__(self, rdclass, rdtype, hit, algorithm, key, servers):
-        super(HIP, self).__init__(rdclass, rdtype)
-        self.hit = hit
-        self.algorithm = algorithm
-        self.key = key
-        self.servers = servers
-
-    def to_text(self, origin=None, relativize=True, **kw):
-        hit = binascii.hexlify(self.hit).decode()
-        key = base64.b64encode(self.key).replace(b'\n', b'').decode()
-        text = u''
-        servers = []
-        for server in self.servers:
-            servers.append(server.choose_relativity(origin, relativize))
-        if len(servers) > 0:
-            text += (u' ' + u' '.join((x.to_unicode() for x in servers)))
-        return u'%u %s %s%s' % (self.algorithm, hit, key, text)
-
-    @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        algorithm = tok.get_uint8()
-        hit = binascii.unhexlify(tok.get_string().encode())
-        if len(hit) > 255:
-            raise dns.exception.SyntaxError("HIT too long")
-        key = base64.b64decode(tok.get_string().encode())
-        servers = []
-        while 1:
-            token = tok.get()
-            if token.is_eol_or_eof():
-                break
-            server = dns.name.from_text(token.value, origin)
-            server.choose_relativity(origin, relativize)
-            servers.append(server)
-        return cls(rdclass, rdtype, hit, algorithm, key, servers)
-
-    def to_wire(self, file, compress=None, origin=None):
-        lh = len(self.hit)
-        lk = len(self.key)
-        file.write(struct.pack("!BBH", lh, self.algorithm, lk))
-        file.write(self.hit)
-        file.write(self.key)
-        for server in self.servers:
-            server.to_wire(file, None, origin)
-
-    @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        (lh, algorithm, lk) = struct.unpack('!BBH',
-                                            wire[current: current + 4])
-        current += 4
-        rdlen -= 4
-        hit = wire[current: current + lh].unwrap()
-        current += lh
-        rdlen -= lh
-        key = wire[current: current + lk].unwrap()
-        current += lk
-        rdlen -= lk
-        servers = []
-        while rdlen > 0:
-            (server, cused) = dns.name.from_wire(wire[: current + rdlen],
-                                                 current)
-            current += cused
-            rdlen -= cused
-            if origin is not None:
-                server = server.relativize(origin)
-            servers.append(server)
-        return cls(rdclass, rdtype, hit, algorithm, key, servers)
-
-    def choose_relativity(self, origin=None, relativize=True):
-        servers = []
-        for server in self.servers:
-            server = server.choose_relativity(origin, relativize)
-            servers.append(server)
-        self.servers = servers

src/dns/rdtypes/ANY/ISDN.py

@@ -1,99 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import struct
-
-import dns.exception
-import dns.rdata
-import dns.tokenizer
-from dns._compat import text_type
-
-
-class ISDN(dns.rdata.Rdata):
-
-    """ISDN record
-
-    @ivar address: the ISDN address
-    @type address: string
-    @ivar subaddress: the ISDN subaddress (or '' if not present)
-    @type subaddress: string
-    @see: RFC 1183"""
-
-    __slots__ = ['address', 'subaddress']
-
-    def __init__(self, rdclass, rdtype, address, subaddress):
-        super(ISDN, self).__init__(rdclass, rdtype)
-        if isinstance(address, text_type):
-            self.address = address.encode()
-        else:
-            self.address = address
-        if isinstance(address, text_type):
-            self.subaddress = subaddress.encode()
-        else:
-            self.subaddress = subaddress
-
-    def to_text(self, origin=None, relativize=True, **kw):
-        if self.subaddress:
-            return '"{}" "{}"'.format(dns.rdata._escapify(self.address),
-                                  dns.rdata._escapify(self.subaddress))
-        else:
-            return '"%s"' % dns.rdata._escapify(self.address)
-
-    @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        address = tok.get_string()
-        t = tok.get()
-        if not t.is_eol_or_eof():
-            tok.unget(t)
-            subaddress = tok.get_string()
-        else:
-            tok.unget(t)
-            subaddress = ''
-        tok.get_eol()
-        return cls(rdclass, rdtype, address, subaddress)
-
-    def to_wire(self, file, compress=None, origin=None):
-        l = len(self.address)
-        assert l < 256
-        file.write(struct.pack('!B', l))
-        file.write(self.address)
-        l = len(self.subaddress)
-        if l > 0:
-            assert l < 256
-            file.write(struct.pack('!B', l))
-            file.write(self.subaddress)
-
-    @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        l = wire[current]
-        current += 1
-        rdlen -= 1
-        if l > rdlen:
-            raise dns.exception.FormError
-        address = wire[current: current + l].unwrap()
-        current += l
-        rdlen -= l
-        if rdlen > 0:
-            l = wire[current]
-            current += 1
-            rdlen -= 1
-            if l != rdlen:
-                raise dns.exception.FormError
-            subaddress = wire[current: current + l].unwrap()
-        else:
-            subaddress = ''
-        return cls(rdclass, rdtype, address, subaddress)

src/dns/rdtypes/ANY/LOC.py

@@ -1,327 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-from __future__ import division
-
-import struct
-
-import dns.exception
-import dns.rdata
-from dns._compat import long, xrange, round_py2_compat
-
-
-_pows = tuple(long(10**i) for i in range(0, 11))
-
-# default values are in centimeters
-_default_size = 100.0
-_default_hprec = 1000000.0
-_default_vprec = 1000.0
-
-
-def _exponent_of(what, desc):
-    if what == 0:
-        return 0
-    exp = None
-    for i in xrange(len(_pows)):
-        if what // _pows[i] == long(0):
-            exp = i - 1
-            break
-    if exp is None or exp < 0:
-        raise dns.exception.SyntaxError("%s value out of bounds" % desc)
-    return exp
-
-
-def _float_to_tuple(what):
-    if what < 0:
-        sign = -1
-        what *= -1
-    else:
-        sign = 1
-    what = round_py2_compat(what * 3600000)
-    degrees = int(what // 3600000)
-    what -= degrees * 3600000
-    minutes = int(what // 60000)
-    what -= minutes * 60000
-    seconds = int(what // 1000)
-    what -= int(seconds * 1000)
-    what = int(what)
-    return (degrees, minutes, seconds, what, sign)
-
-
-def _tuple_to_float(what):
-    value = float(what[0])
-    value += float(what[1]) / 60.0
-    value += float(what[2]) / 3600.0
-    value += float(what[3]) / 3600000.0
-    return float(what[4]) * value
-
-
-def _encode_size(what, desc):
-    what = long(what)
-    exponent = _exponent_of(what, desc) & 0xF
-    base = what // pow(10, exponent) & 0xF
-    return base * 16 + exponent
-
-
-def _decode_size(what, desc):
-    exponent = what & 0x0F
-    if exponent > 9:
-        raise dns.exception.SyntaxError("bad %s exponent" % desc)
-    base = (what & 0xF0) >> 4
-    if base > 9:
-        raise dns.exception.SyntaxError("bad %s base" % desc)
-    return long(base) * pow(10, exponent)
-
-
-class LOC(dns.rdata.Rdata):
-
-    """LOC record
-
-    @ivar latitude: latitude
-    @type latitude: (int, int, int, int, sign) tuple specifying the degrees, minutes,
-    seconds, milliseconds, and sign of the coordinate.
-    @ivar longitude: longitude
-    @type longitude: (int, int, int, int, sign) tuple specifying the degrees,
-    minutes, seconds, milliseconds, and sign of the coordinate.
-    @ivar altitude: altitude
-    @type altitude: float
-    @ivar size: size of the sphere
-    @type size: float
-    @ivar horizontal_precision: horizontal precision
-    @type horizontal_precision: float
-    @ivar vertical_precision: vertical precision
-    @type vertical_precision: float
-    @see: RFC 1876"""
-
-    __slots__ = ['latitude', 'longitude', 'altitude', 'size',
-                 'horizontal_precision', 'vertical_precision']
-
-    def __init__(self, rdclass, rdtype, latitude, longitude, altitude,
-                 size=_default_size, hprec=_default_hprec,
-                 vprec=_default_vprec):
-        """Initialize a LOC record instance.
-
-        The parameters I{latitude} and I{longitude} may be either a 4-tuple
-        of integers specifying (degrees, minutes, seconds, milliseconds),
-        or they may be floating point values specifying the number of
-        degrees. The other parameters are floats. Size, horizontal precision,
-        and vertical precision are specified in centimeters."""
-
-        super(LOC, self).__init__(rdclass, rdtype)
-        if isinstance(latitude, int) or isinstance(latitude, long):
-            latitude = float(latitude)
-        if isinstance(latitude, float):
-            latitude = _float_to_tuple(latitude)
-        self.latitude = latitude
-        if isinstance(longitude, int) or isinstance(longitude, long):
-            longitude = float(longitude)
-        if isinstance(longitude, float):
-            longitude = _float_to_tuple(longitude)
-        self.longitude = longitude
-        self.altitude = float(altitude)
-        self.size = float(size)
-        self.horizontal_precision = float(hprec)
-        self.vertical_precision = float(vprec)
-
-    def to_text(self, origin=None, relativize=True, **kw):
-        if self.latitude[4] > 0:
-            lat_hemisphere = 'N'
-        else:
-            lat_hemisphere = 'S'
-        if self.longitude[4] > 0:
-            long_hemisphere = 'E'
-        else:
-            long_hemisphere = 'W'
-        text = "%d %d %d.%03d %s %d %d %d.%03d %s %0.2fm" % (
-            self.latitude[0], self.latitude[1],
-            self.latitude[2], self.latitude[3], lat_hemisphere,
-            self.longitude[0], self.longitude[1], self.longitude[2],
-            self.longitude[3], long_hemisphere,
-            self.altitude / 100.0
-        )
-
-        # do not print default values
-        if self.size != _default_size or \
-            self.horizontal_precision != _default_hprec or \
-                self.vertical_precision != _default_vprec:
-            text += " {:0.2f}m {:0.2f}m {:0.2f}m".format(
-                self.size / 100.0, self.horizontal_precision / 100.0,
-                self.vertical_precision / 100.0
-            )
-        return text
-
-    @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        latitude = [0, 0, 0, 0, 1]
-        longitude = [0, 0, 0, 0, 1]
-        size = _default_size
-        hprec = _default_hprec
-        vprec = _default_vprec
-
-        latitude[0] = tok.get_int()
-        t = tok.get_string()
-        if t.isdigit():
-            latitude[1] = int(t)
-            t = tok.get_string()
-            if '.' in t:
-                (seconds, milliseconds) = t.split('.')
-                if not seconds.isdigit():
-                    raise dns.exception.SyntaxError(
-                        'bad latitude seconds value')
-                latitude[2] = int(seconds)
-                if latitude[2] >= 60:
-                    raise dns.exception.SyntaxError('latitude seconds >= 60')
-                l = len(milliseconds)
-                if l == 0 or l > 3 or not milliseconds.isdigit():
-                    raise dns.exception.SyntaxError(
-                        'bad latitude milliseconds value')
-                if l == 1:
-                    m = 100
-                elif l == 2:
-                    m = 10
-                else:
-                    m = 1
-                latitude[3] = m * int(milliseconds)
-                t = tok.get_string()
-            elif t.isdigit():
-                latitude[2] = int(t)
-                t = tok.get_string()
-        if t == 'S':
-            latitude[4] = -1
-        elif t != 'N':
-            raise dns.exception.SyntaxError('bad latitude hemisphere value')
-
-        longitude[0] = tok.get_int()
-        t = tok.get_string()
-        if t.isdigit():
-            longitude[1] = int(t)
-            t = tok.get_string()
-            if '.' in t:
-                (seconds, milliseconds) = t.split('.')
-                if not seconds.isdigit():
-                    raise dns.exception.SyntaxError(
-                        'bad longitude seconds value')
-                longitude[2] = int(seconds)
-                if longitude[2] >= 60:
-                    raise dns.exception.SyntaxError('longitude seconds >= 60')
-                l = len(milliseconds)
-                if l == 0 or l > 3 or not milliseconds.isdigit():
-                    raise dns.exception.SyntaxError(
-                        'bad longitude milliseconds value')
-                if l == 1:
-                    m = 100
-                elif l == 2:
-                    m = 10
-                else:
-                    m = 1
-                longitude[3] = m * int(milliseconds)
-                t = tok.get_string()
-            elif t.isdigit():
-                longitude[2] = int(t)
-                t = tok.get_string()
-        if t == 'W':
-            longitude[4] = -1
-        elif t != 'E':
-            raise dns.exception.SyntaxError('bad longitude hemisphere value')
-
-        t = tok.get_string()
-        if t[-1] == 'm':
-            t = t[0: -1]
-        altitude = float(t) * 100.0        # m -> cm
-
-        token = tok.get().unescape()
-        if not token.is_eol_or_eof():
-            value = token.value
-            if value[-1] == 'm':
-                value = value[0: -1]
-            size = float(value) * 100.0        # m -> cm
-            token = tok.get().unescape()
-            if not token.is_eol_or_eof():
-                value = token.value
-                if value[-1] == 'm':
-                    value = value[0: -1]
-                hprec = float(value) * 100.0        # m -> cm
-                token = tok.get().unescape()
-                if not token.is_eol_or_eof():
-                    value = token.value
-                    if value[-1] == 'm':
-                        value = value[0: -1]
-                    vprec = float(value) * 100.0        # m -> cm
-                    tok.get_eol()
-
-        return cls(rdclass, rdtype, latitude, longitude, altitude,
-                   size, hprec, vprec)
-
-    def to_wire(self, file, compress=None, origin=None):
-        milliseconds = (self.latitude[0] * 3600000 +
-                        self.latitude[1] * 60000 +
-                        self.latitude[2] * 1000 +
-                        self.latitude[3]) * self.latitude[4]
-        latitude = long(0x80000000) + milliseconds
-        milliseconds = (self.longitude[0] * 3600000 +
-                        self.longitude[1] * 60000 +
-                        self.longitude[2] * 1000 +
-                        self.longitude[3]) * self.longitude[4]
-        longitude = long(0x80000000) + milliseconds
-        altitude = long(self.altitude) + long(10000000)
-        size = _encode_size(self.size, "size")
-        hprec = _encode_size(self.horizontal_precision, "horizontal precision")
-        vprec = _encode_size(self.vertical_precision, "vertical precision")
-        wire = struct.pack("!BBBBIII", 0, size, hprec, vprec, latitude,
-                           longitude, altitude)
-        file.write(wire)
-
-    @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        (version, size, hprec, vprec, latitude, longitude, altitude) = \
-            struct.unpack("!BBBBIII", wire[current: current + rdlen])
-        if latitude > long(0x80000000):
-            latitude = float(latitude - long(0x80000000)) / 3600000
-        else:
-            latitude = -1 * float(long(0x80000000) - latitude) / 3600000
-        if latitude < -90.0 or latitude > 90.0:
-            raise dns.exception.FormError("bad latitude")
-        if longitude > long(0x80000000):
-            longitude = float(longitude - long(0x80000000)) / 3600000
-        else:
-            longitude = -1 * float(long(0x80000000) - longitude) / 3600000
-        if longitude < -180.0 or longitude > 180.0:
-            raise dns.exception.FormError("bad longitude")
-        altitude = float(altitude) - 10000000.0
-        size = _decode_size(size, "size")
-        hprec = _decode_size(hprec, "horizontal precision")
-        vprec = _decode_size(vprec, "vertical precision")
-        return cls(rdclass, rdtype, latitude, longitude, altitude,
-                   size, hprec, vprec)
-
-    def _get_float_latitude(self):
-        return _tuple_to_float(self.latitude)
-
-    def _set_float_latitude(self, value):
-        self.latitude = _float_to_tuple(value)
-
-    float_latitude = property(_get_float_latitude, _set_float_latitude,
-                              doc="latitude as a floating point value")
-
-    def _get_float_longitude(self):
-        return _tuple_to_float(self.longitude)
-
-    def _set_float_longitude(self, value):
-        self.longitude = _float_to_tuple(value)
-
-    float_longitude = property(_get_float_longitude, _set_float_longitude,
-                               doc="longitude as a floating point value")

src/dns/rdtypes/ANY/MX.py

@@ -1,23 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import dns.rdtypes.mxbase
-
-
-class MX(dns.rdtypes.mxbase.MXBase):
-
-    """MX record"""

src/dns/rdtypes/ANY/NS.py

@@ -1,23 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import dns.rdtypes.nsbase
-
-
-class NS(dns.rdtypes.nsbase.NSBase):
-
-    """NS record"""

src/dns/rdtypes/ANY/NSEC.py

@@ -1,128 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2004-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import struct
-
-import dns.exception
-import dns.rdata
-import dns.rdatatype
-import dns.name
-from dns._compat import xrange
-
-
-class NSEC(dns.rdata.Rdata):
-
-    """NSEC record
-
-    @ivar next: the next name
-    @type next: dns.name.Name object
-    @ivar windows: the windowed bitmap list
-    @type windows: list of (window number, string) tuples"""
-
-    __slots__ = ['next', 'windows']
-
-    def __init__(self, rdclass, rdtype, next, windows):
-        super(NSEC, self).__init__(rdclass, rdtype)
-        self.next = next
-        self.windows = windows
-
-    def to_text(self, origin=None, relativize=True, **kw):
-        next = self.next.choose_relativity(origin, relativize)
-        text = ''
-        for (window, bitmap) in self.windows:
-            bits = []
-            for i in xrange(0, len(bitmap)):
-                byte = bitmap[i]
-                for j in xrange(0, 8):
-                    if byte & (0x80 >> j):
-                        bits.append(dns.rdatatype.to_text(window * 256 +
-                                                          i * 8 + j))
-            text += (' ' + ' '.join(bits))
-        return '{}{}'.format(next, text)
-
-    @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        next = tok.get_name()
-        next = next.choose_relativity(origin, relativize)
-        rdtypes = []
-        while 1:
-            token = tok.get().unescape()
-            if token.is_eol_or_eof():
-                break
-            nrdtype = dns.rdatatype.from_text(token.value)
-            if nrdtype == 0:
-                raise dns.exception.SyntaxError("NSEC with bit 0")
-            if nrdtype > 65535:
-                raise dns.exception.SyntaxError("NSEC with bit > 65535")
-            rdtypes.append(nrdtype)
-        rdtypes.sort()
-        window = 0
-        octets = 0
-        prior_rdtype = 0
-        bitmap = bytearray(b'\0' * 32)
-        windows = []
-        for nrdtype in rdtypes:
-            if nrdtype == prior_rdtype:
-                continue
-            prior_rdtype = nrdtype
-            new_window = nrdtype // 256
-            if new_window != window:
-                windows.append((window, bitmap[0:octets]))
-                bitmap = bytearray(b'\0' * 32)
-                window = new_window
-            offset = nrdtype % 256
-            byte = offset // 8
-            bit = offset % 8
-            octets = byte + 1
-            bitmap[byte] = bitmap[byte] | (0x80 >> bit)
-
-        windows.append((window, bitmap[0:octets]))
-        return cls(rdclass, rdtype, next, windows)
-
-    def to_wire(self, file, compress=None, origin=None):
-        self.next.to_wire(file, None, origin)
-        for (window, bitmap) in self.windows:
-            file.write(struct.pack('!BB', window, len(bitmap)))
-            file.write(bitmap)
-
-    @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        (next, cused) = dns.name.from_wire(wire[: current + rdlen], current)
-        current += cused
-        rdlen -= cused
-        windows = []
-        while rdlen > 0:
-            if rdlen < 3:
-                raise dns.exception.FormError("NSEC too short")
-            window = wire[current]
-            octets = wire[current + 1]
-            if octets == 0 or octets > 32:
-                raise dns.exception.FormError("bad NSEC octets")
-            current += 2
-            rdlen -= 2
-            if rdlen < octets:
-                raise dns.exception.FormError("bad NSEC bitmap length")
-            bitmap = bytearray(wire[current: current + octets].unwrap())
-            current += octets
-            rdlen -= octets
-            windows.append((window, bitmap))
-        if origin is not None:
-            next = next.relativize(origin)
-        return cls(rdclass, rdtype, next, windows)
-
-    def choose_relativity(self, origin=None, relativize=True):
-        self.next = self.next.choose_relativity(origin, relativize)

src/dns/rdtypes/ANY/NSEC3.py

@@ -1,196 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2004-2017 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import base64
-import binascii
-import string
-import struct
-
-import dns.exception
-import dns.rdata
-import dns.rdatatype
-from dns._compat import xrange, text_type, PY3
-
-# pylint: disable=deprecated-string-function
-if PY3:
-    b32_hex_to_normal = bytes.maketrans(b'0123456789ABCDEFGHIJKLMNOPQRSTUV',
-                                        b'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567')
-    b32_normal_to_hex = bytes.maketrans(b'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
-                                        b'0123456789ABCDEFGHIJKLMNOPQRSTUV')
-else:
-    b32_hex_to_normal = string.maketrans('0123456789ABCDEFGHIJKLMNOPQRSTUV',
-                                         'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567')
-    b32_normal_to_hex = string.maketrans('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
-                                         '0123456789ABCDEFGHIJKLMNOPQRSTUV')
-# pylint: enable=deprecated-string-function
-
-
-# hash algorithm constants
-SHA1 = 1
-
-# flag constants
-OPTOUT = 1
-
-
-class NSEC3(dns.rdata.Rdata):
-
-    """NSEC3 record
-
-    @ivar algorithm: the hash algorithm number
-    @type algorithm: int
-    @ivar flags: the flags
-    @type flags: int
-    @ivar iterations: the number of iterations
-    @type iterations: int
-    @ivar salt: the salt
-    @type salt: string
-    @ivar next: the next name hash
-    @type next: string
-    @ivar windows: the windowed bitmap list
-    @type windows: list of (window number, string) tuples"""
-
-    __slots__ = ['algorithm', 'flags', 'iterations', 'salt', 'next', 'windows']
-
-    def __init__(self, rdclass, rdtype, algorithm, flags, iterations, salt,
-                 next, windows):
-        super(NSEC3, self).__init__(rdclass, rdtype)
-        self.algorithm = algorithm
-        self.flags = flags
-        self.iterations = iterations
-        if isinstance(salt, text_type):
-            self.salt = salt.encode()
-        else:
-            self.salt = salt
-        self.next = next
-        self.windows = windows
-
-    def to_text(self, origin=None, relativize=True, **kw):
-        next = base64.b32encode(self.next).translate(
-            b32_normal_to_hex).lower().decode()
-        if self.salt == b'':
-            salt = '-'
-        else:
-            salt = binascii.hexlify(self.salt).decode()
-        text = u''
-        for (window, bitmap) in self.windows:
-            bits = []
-            for i in xrange(0, len(bitmap)):
-                byte = bitmap[i]
-                for j in xrange(0, 8):
-                    if byte & (0x80 >> j):
-                        bits.append(dns.rdatatype.to_text(window * 256 +
-                                                          i * 8 + j))
-            text += (u' ' + u' '.join(bits))
-        return u'%u %u %u %s %s%s' % (self.algorithm, self.flags,
-                                      self.iterations, salt, next, text)
-
-    @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        algorithm = tok.get_uint8()
-        flags = tok.get_uint8()
-        iterations = tok.get_uint16()
-        salt = tok.get_string()
-        if salt == u'-':
-            salt = b''
-        else:
-            salt = binascii.unhexlify(salt.encode('ascii'))
-        next = tok.get_string().encode(
-            'ascii').upper().translate(b32_hex_to_normal)
-        next = base64.b32decode(next)
-        rdtypes = []
-        while 1:
-            token = tok.get().unescape()
-            if token.is_eol_or_eof():
-                break
-            nrdtype = dns.rdatatype.from_text(token.value)
-            if nrdtype == 0:
-                raise dns.exception.SyntaxError("NSEC3 with bit 0")
-            if nrdtype > 65535:
-                raise dns.exception.SyntaxError("NSEC3 with bit > 65535")
-            rdtypes.append(nrdtype)
-        rdtypes.sort()
-        window = 0
-        octets = 0
-        prior_rdtype = 0
-        bitmap = bytearray(b'\0' * 32)
-        windows = []
-        for nrdtype in rdtypes:
-            if nrdtype == prior_rdtype:
-                continue
-            prior_rdtype = nrdtype
-            new_window = nrdtype // 256
-            if new_window != window:
-                if octets != 0:
-                    windows.append((window, bitmap[0:octets]))
-                bitmap = bytearray(b'\0' * 32)
-                window = new_window
-            offset = nrdtype % 256
-            byte = offset // 8
-            bit = offset % 8
-            octets = byte + 1
-            bitmap[byte] = bitmap[byte] | (0x80 >> bit)
-        if octets != 0:
-            windows.append((window, bitmap[0:octets]))
-        return cls(rdclass, rdtype, algorithm, flags, iterations, salt, next,
-                   windows)
-
-    def to_wire(self, file, compress=None, origin=None):
-        l = len(self.salt)
-        file.write(struct.pack("!BBHB", self.algorithm, self.flags,
-                               self.iterations, l))
-        file.write(self.salt)
-        l = len(self.next)
-        file.write(struct.pack("!B", l))
-        file.write(self.next)
-        for (window, bitmap) in self.windows:
-            file.write(struct.pack("!BB", window, len(bitmap)))
-            file.write(bitmap)
-
-    @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        (algorithm, flags, iterations, slen) = \
-            struct.unpack('!BBHB', wire[current: current + 5])
-
-        current += 5
-        rdlen -= 5
-        salt = wire[current: current + slen].unwrap()
-        current += slen
-        rdlen -= slen
-        nlen = wire[current]
-        current += 1
-        rdlen -= 1
-        next = wire[current: current + nlen].unwrap()
-        current += nlen
-        rdlen -= nlen
-        windows = []
-        while rdlen > 0:
-            if rdlen < 3:
-                raise dns.exception.FormError("NSEC3 too short")
-            window = wire[current]
-            octets = wire[current + 1]
-            if octets == 0 or octets > 32:
-                raise dns.exception.FormError("bad NSEC3 octets")
-            current += 2
-            rdlen -= 2
-            if rdlen < octets:
-                raise dns.exception.FormError("bad NSEC3 bitmap length")
-            bitmap = bytearray(wire[current: current + octets].unwrap())
-            current += octets
-            rdlen -= octets
-            windows.append((window, bitmap))
-        return cls(rdclass, rdtype, algorithm, flags, iterations, salt, next,
-                   windows)

src/dns/rdtypes/ANY/NSEC3PARAM.py

@@ -1,90 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2004-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import struct
-import binascii
-
-import dns.exception
-import dns.rdata
-from dns._compat import text_type
-
-
-class NSEC3PARAM(dns.rdata.Rdata):
-
-    """NSEC3PARAM record
-
-    @ivar algorithm: the hash algorithm number
-    @type algorithm: int
-    @ivar flags: the flags
-    @type flags: int
-    @ivar iterations: the number of iterations
-    @type iterations: int
-    @ivar salt: the salt
-    @type salt: string"""
-
-    __slots__ = ['algorithm', 'flags', 'iterations', 'salt']
-
-    def __init__(self, rdclass, rdtype, algorithm, flags, iterations, salt):
-        super(NSEC3PARAM, self).__init__(rdclass, rdtype)
-        self.algorithm = algorithm
-        self.flags = flags
-        self.iterations = iterations
-        if isinstance(salt, text_type):
-            self.salt = salt.encode()
-        else:
-            self.salt = salt
-
-    def to_text(self, origin=None, relativize=True, **kw):
-        if self.salt == b'':
-            salt = '-'
-        else:
-            salt = binascii.hexlify(self.salt).decode()
-        return '%u %u %u %s' % (self.algorithm, self.flags, self.iterations,
-                                salt)
-
-    @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        algorithm = tok.get_uint8()
-        flags = tok.get_uint8()
-        iterations = tok.get_uint16()
-        salt = tok.get_string()
-        if salt == '-':
-            salt = ''
-        else:
-            salt = binascii.unhexlify(salt.encode())
-        tok.get_eol()
-        return cls(rdclass, rdtype, algorithm, flags, iterations, salt)
-
-    def to_wire(self, file, compress=None, origin=None):
-        l = len(self.salt)
-        file.write(struct.pack("!BBHB", self.algorithm, self.flags,
-                               self.iterations, l))
-        file.write(self.salt)
-
-    @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        (algorithm, flags, iterations, slen) = \
-             struct.unpack('!BBHB',
-                           wire[current: current + 5])
-        current += 5
-        rdlen -= 5
-        salt = wire[current: current + slen].unwrap()
-        current += slen
-        rdlen -= slen
-        if rdlen != 0:
-            raise dns.exception.FormError
-        return cls(rdclass, rdtype, algorithm, flags, iterations, salt)

src/dns/rdtypes/ANY/OPENPGPKEY.py

@@ -1,60 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2016 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import base64
-
-import dns.exception
-import dns.rdata
-import dns.tokenizer
-
-class OPENPGPKEY(dns.rdata.Rdata):
-
-    """OPENPGPKEY record
-
-    @ivar key: the key
-    @type key: bytes
-    @see: RFC 7929
-    """
-
-    def __init__(self, rdclass, rdtype, key):
-        super(OPENPGPKEY, self).__init__(rdclass, rdtype)
-        self.key = key
-
-    def to_text(self, origin=None, relativize=True, **kw):
-        return dns.rdata._base64ify(self.key)
-
-    @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        chunks = []
-        while 1:
-            t = tok.get().unescape()
-            if t.is_eol_or_eof():
-                break
-            if not t.is_identifier():
-                raise dns.exception.SyntaxError
-            chunks.append(t.value.encode())
-        b64 = b''.join(chunks)
-        key = base64.b64decode(b64)
-        return cls(rdclass, rdtype, key)
-
-    def to_wire(self, file, compress=None, origin=None):
-        file.write(self.key)
-
-    @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        key = wire[current: current + rdlen].unwrap()
-        return cls(rdclass, rdtype, key)

src/dns/rdtypes/ANY/PTR.py

@@ -1,23 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import dns.rdtypes.nsbase
-
-
-class PTR(dns.rdtypes.nsbase.NSBase):
-
-    """PTR record"""

src/dns/rdtypes/ANY/RP.py

@@ -1,82 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import dns.exception
-import dns.rdata
-import dns.name
-
-
-class RP(dns.rdata.Rdata):
-
-    """RP record
-
-    @ivar mbox: The responsible person's mailbox
-    @type mbox: dns.name.Name object
-    @ivar txt: The owner name of a node with TXT records, or the root name
-    if no TXT records are associated with this RP.
-    @type txt: dns.name.Name object
-    @see: RFC 1183"""
-
-    __slots__ = ['mbox', 'txt']
-
-    def __init__(self, rdclass, rdtype, mbox, txt):
-        super(RP, self).__init__(rdclass, rdtype)
-        self.mbox = mbox
-        self.txt = txt
-
-    def to_text(self, origin=None, relativize=True, **kw):
-        mbox = self.mbox.choose_relativity(origin, relativize)
-        txt = self.txt.choose_relativity(origin, relativize)
-        return "{} {}".format(str(mbox), str(txt))
-
-    @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        mbox = tok.get_name()
-        txt = tok.get_name()
-        mbox = mbox.choose_relativity(origin, relativize)
-        txt = txt.choose_relativity(origin, relativize)
-        tok.get_eol()
-        return cls(rdclass, rdtype, mbox, txt)
-
-    def to_wire(self, file, compress=None, origin=None):
-        self.mbox.to_wire(file, None, origin)
-        self.txt.to_wire(file, None, origin)
-
-    def to_digestable(self, origin=None):
-        return self.mbox.to_digestable(origin) + \
-            self.txt.to_digestable(origin)
-
-    @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        (mbox, cused) = dns.name.from_wire(wire[: current + rdlen],
-                                           current)
-        current += cused
-        rdlen -= cused
-        if rdlen <= 0:
-            raise dns.exception.FormError
-        (txt, cused) = dns.name.from_wire(wire[: current + rdlen],
-                                          current)
-        if cused != rdlen:
-            raise dns.exception.FormError
-        if origin is not None:
-            mbox = mbox.relativize(origin)
-            txt = txt.relativize(origin)
-        return cls(rdclass, rdtype, mbox, txt)
-
-    def choose_relativity(self, origin=None, relativize=True):
-        self.mbox = self.mbox.choose_relativity(origin, relativize)
-        self.txt = self.txt.choose_relativity(origin, relativize)

src/dns/rdtypes/ANY/RRSIG.py

@@ -1,158 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2004-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import base64
-import calendar
-import struct
-import time
-
-import dns.dnssec
-import dns.exception
-import dns.rdata
-import dns.rdatatype
-
-
-class BadSigTime(dns.exception.DNSException):
-
-    """Time in DNS SIG or RRSIG resource record cannot be parsed."""
-
-
-def sigtime_to_posixtime(what):
-    if len(what) != 14:
-        raise BadSigTime
-    year = int(what[0:4])
-    month = int(what[4:6])
-    day = int(what[6:8])
-    hour = int(what[8:10])
-    minute = int(what[10:12])
-    second = int(what[12:14])
-    return calendar.timegm((year, month, day, hour, minute, second,
-                            0, 0, 0))
-
-
-def posixtime_to_sigtime(what):
-    return time.strftime('%Y%m%d%H%M%S', time.gmtime(what))
-
-
-class RRSIG(dns.rdata.Rdata):
-
-    """RRSIG record
-
-    @ivar type_covered: the rdata type this signature covers
-    @type type_covered: int
-    @ivar algorithm: the algorithm used for the sig
-    @type algorithm: int
-    @ivar labels: number of labels
-    @type labels: int
-    @ivar original_ttl: the original TTL
-    @type original_ttl: long
-    @ivar expiration: signature expiration time
-    @type expiration: long
-    @ivar inception: signature inception time
-    @type inception: long
-    @ivar key_tag: the key tag
-    @type key_tag: int
-    @ivar signer: the signer
-    @type signer: dns.name.Name object
-    @ivar signature: the signature
-    @type signature: string"""
-
-    __slots__ = ['type_covered', 'algorithm', 'labels', 'original_ttl',
-                 'expiration', 'inception', 'key_tag', 'signer',
-                 'signature']
-
-    def __init__(self, rdclass, rdtype, type_covered, algorithm, labels,
-                 original_ttl, expiration, inception, key_tag, signer,
-                 signature):
-        super(RRSIG, self).__init__(rdclass, rdtype)
-        self.type_covered = type_covered
-        self.algorithm = algorithm
-        self.labels = labels
-        self.original_ttl = original_ttl
-        self.expiration = expiration
-        self.inception = inception
-        self.key_tag = key_tag
-        self.signer = signer
-        self.signature = signature
-
-    def covers(self):
-        return self.type_covered
-
-    def to_text(self, origin=None, relativize=True, **kw):
-        return '%s %d %d %d %s %s %d %s %s' % (
-            dns.rdatatype.to_text(self.type_covered),
-            self.algorithm,
-            self.labels,
-            self.original_ttl,
-            posixtime_to_sigtime(self.expiration),
-            posixtime_to_sigtime(self.inception),
-            self.key_tag,
-            self.signer.choose_relativity(origin, relativize),
-            dns.rdata._base64ify(self.signature)
-        )
-
-    @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        type_covered = dns.rdatatype.from_text(tok.get_string())
-        algorithm = dns.dnssec.algorithm_from_text(tok.get_string())
-        labels = tok.get_int()
-        original_ttl = tok.get_ttl()
-        expiration = sigtime_to_posixtime(tok.get_string())
-        inception = sigtime_to_posixtime(tok.get_string())
-        key_tag = tok.get_int()
-        signer = tok.get_name()
-        signer = signer.choose_relativity(origin, relativize)
-        chunks = []
-        while 1:
-            t = tok.get().unescape()
-            if t.is_eol_or_eof():
-                break
-            if not t.is_identifier():
-                raise dns.exception.SyntaxError
-            chunks.append(t.value.encode())
-        b64 = b''.join(chunks)
-        signature = base64.b64decode(b64)
-        return cls(rdclass, rdtype, type_covered, algorithm, labels,
-                   original_ttl, expiration, inception, key_tag, signer,
-                   signature)
-
-    def to_wire(self, file, compress=None, origin=None):
-        header = struct.pack('!HBBIIIH', self.type_covered,
-                             self.algorithm, self.labels,
-                             self.original_ttl, self.expiration,
-                             self.inception, self.key_tag)
-        file.write(header)
-        self.signer.to_wire(file, None, origin)
-        file.write(self.signature)
-
-    @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        header = struct.unpack('!HBBIIIH', wire[current: current + 18])
-        current += 18
-        rdlen -= 18
-        (signer, cused) = dns.name.from_wire(wire[: current + rdlen], current)
-        current += cused
-        rdlen -= cused
-        if origin is not None:
-            signer = signer.relativize(origin)
-        signature = wire[current: current + rdlen].unwrap()
-        return cls(rdclass, rdtype, header[0], header[1], header[2],
-                   header[3], header[4], header[5], header[6], signer,
-                   signature)
-
-    def choose_relativity(self, origin=None, relativize=True):
-        self.signer = self.signer.choose_relativity(origin, relativize)

src/dns/rdtypes/ANY/RT.py

@@ -1,23 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import dns.rdtypes.mxbase
-
-
-class RT(dns.rdtypes.mxbase.UncompressedDowncasingMX):
-
-    """RT record"""

src/dns/rdtypes/ANY/SOA.py

@@ -1,116 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import struct
-
-import dns.exception
-import dns.rdata
-import dns.name
-
-
-class SOA(dns.rdata.Rdata):
-
-    """SOA record
-
-    @ivar mname: the SOA MNAME (master name) field
-    @type mname: dns.name.Name object
-    @ivar rname: the SOA RNAME (responsible name) field
-    @type rname: dns.name.Name object
-    @ivar serial: The zone's serial number
-    @type serial: int
-    @ivar refresh: The zone's refresh value (in seconds)
-    @type refresh: int
-    @ivar retry: The zone's retry value (in seconds)
-    @type retry: int
-    @ivar expire: The zone's expiration value (in seconds)
-    @type expire: int
-    @ivar minimum: The zone's negative caching time (in seconds, called
-    "minimum" for historical reasons)
-    @type minimum: int
-    @see: RFC 1035"""
-
-    __slots__ = ['mname', 'rname', 'serial', 'refresh', 'retry', 'expire',
-                 'minimum']
-
-    def __init__(self, rdclass, rdtype, mname, rname, serial, refresh, retry,
-                 expire, minimum):
-        super(SOA, self).__init__(rdclass, rdtype)
-        self.mname = mname
-        self.rname = rname
-        self.serial = serial
-        self.refresh = refresh
-        self.retry = retry
-        self.expire = expire
-        self.minimum = minimum
-
-    def to_text(self, origin=None, relativize=True, **kw):
-        mname = self.mname.choose_relativity(origin, relativize)
-        rname = self.rname.choose_relativity(origin, relativize)
-        return '%s %s %d %d %d %d %d' % (
-            mname, rname, self.serial, self.refresh, self.retry,
-            self.expire, self.minimum)
-
-    @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        mname = tok.get_name()
-        rname = tok.get_name()
-        mname = mname.choose_relativity(origin, relativize)
-        rname = rname.choose_relativity(origin, relativize)
-        serial = tok.get_uint32()
-        refresh = tok.get_ttl()
-        retry = tok.get_ttl()
-        expire = tok.get_ttl()
-        minimum = tok.get_ttl()
-        tok.get_eol()
-        return cls(rdclass, rdtype, mname, rname, serial, refresh, retry,
-                   expire, minimum)
-
-    def to_wire(self, file, compress=None, origin=None):
-        self.mname.to_wire(file, compress, origin)
-        self.rname.to_wire(file, compress, origin)
-        five_ints = struct.pack('!IIIII', self.serial, self.refresh,
-                                self.retry, self.expire, self.minimum)
-        file.write(five_ints)
-
-    def to_digestable(self, origin=None):
-        return self.mname.to_digestable(origin) + \
-            self.rname.to_digestable(origin) + \
-            struct.pack('!IIIII', self.serial, self.refresh,
-                        self.retry, self.expire, self.minimum)
-
-    @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        (mname, cused) = dns.name.from_wire(wire[: current + rdlen], current)
-        current += cused
-        rdlen -= cused
-        (rname, cused) = dns.name.from_wire(wire[: current + rdlen], current)
-        current += cused
-        rdlen -= cused
-        if rdlen != 20:
-            raise dns.exception.FormError
-        five_ints = struct.unpack('!IIIII',
-                                  wire[current: current + rdlen])
-        if origin is not None:
-            mname = mname.relativize(origin)
-            rname = rname.relativize(origin)
-        return cls(rdclass, rdtype, mname, rname,
-                   five_ints[0], five_ints[1], five_ints[2], five_ints[3],
-                   five_ints[4])
-
-    def choose_relativity(self, origin=None, relativize=True):
-        self.mname = self.mname.choose_relativity(origin, relativize)
-        self.rname = self.rname.choose_relativity(origin, relativize)

src/dns/rdtypes/ANY/SPF.py

@@ -1,25 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2006, 2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import dns.rdtypes.txtbase
-
-
-class SPF(dns.rdtypes.txtbase.TXTBase):
-
-    """SPF record
-
-    @see: RFC 4408"""

src/dns/rdtypes/ANY/SSHFP.py

@@ -1,79 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2005-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import struct
-import binascii
-
-import dns.rdata
-import dns.rdatatype
-
-
-class SSHFP(dns.rdata.Rdata):
-
-    """SSHFP record
-
-    @ivar algorithm: the algorithm
-    @type algorithm: int
-    @ivar fp_type: the digest type
-    @type fp_type: int
-    @ivar fingerprint: the fingerprint
-    @type fingerprint: string
-    @see: draft-ietf-secsh-dns-05.txt"""
-
-    __slots__ = ['algorithm', 'fp_type', 'fingerprint']
-
-    def __init__(self, rdclass, rdtype, algorithm, fp_type,
-                 fingerprint):
-        super(SSHFP, self).__init__(rdclass, rdtype)
-        self.algorithm = algorithm
-        self.fp_type = fp_type
-        self.fingerprint = fingerprint
-
-    def to_text(self, origin=None, relativize=True, **kw):
-        return '%d %d %s' % (self.algorithm,
-                             self.fp_type,
-                             dns.rdata._hexify(self.fingerprint,
-                                               chunksize=128))
-
-    @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        algorithm = tok.get_uint8()
-        fp_type = tok.get_uint8()
-        chunks = []
-        while 1:
-            t = tok.get().unescape()
-            if t.is_eol_or_eof():
-                break
-            if not t.is_identifier():
-                raise dns.exception.SyntaxError
-            chunks.append(t.value.encode())
-        fingerprint = b''.join(chunks)
-        fingerprint = binascii.unhexlify(fingerprint)
-        return cls(rdclass, rdtype, algorithm, fp_type, fingerprint)
-
-    def to_wire(self, file, compress=None, origin=None):
-        header = struct.pack("!BB", self.algorithm, self.fp_type)
-        file.write(header)
-        file.write(self.fingerprint)
-
-    @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        header = struct.unpack("!BB", wire[current: current + 2])
-        current += 2
-        rdlen -= 2
-        fingerprint = wire[current: current + rdlen].unwrap()
-        return cls(rdclass, rdtype, header[0], header[1], fingerprint)