Mac changes for Subversion bundling.

Make dependent template lookups explicit.
Clang (in Xcode 4.4) is being strict about dependent lookup rules, so apply the recommended fix-it.
2012-08-12 16:59:31 +01:00 · 2012-07-31 09:01:42 +01:00
1004 changed files with 35252 additions and 200217 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,3 @@
-.*
-*~
 Makefile
 *.o
 lib*.a
@@ -14,7 +12,3 @@ CTestTestfile.cmake
 install_manifest.txt
 build*
 Build
-CMakeLists.txt.user
-3rdparty/expat_2.2.6/
-nbproject
-compile_commands.json
--- a/3rdparty/CMakeLists.txt
+++ b/3rdparty/CMakeLists.txt
@@ -1,9 +0,0 @@
-if (NOT SYSTEM_EXPAT)
-	add_subdirectory(expat)
-endif()
-
-if (NOT SYSTEM_UDNS)
-	add_subdirectory(udns)
-endif()
-
-add_subdirectory(tiny_gltf)
--- a/3rdparty/expat/CMakeLists.txt
+++ b/3rdparty/expat/CMakeLists.txt
@@ -1,66 +0,0 @@
-if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
-    check_cxx_source_compiles(
-        "#include <sys/random.h>
-        int main(void) {
-            return 0;
-        }
-        "
-        HAVE_GETRANDOM)
-
-    if (NOT HAVE_GETRANDOM)
-        # on older (GLibC < 2.25) fall back to /dev/urandom
-        set(XML_DEV_URANDOM 1)
-    else()
-        message(STATUS "Found <sys/random.h>")
-    endif()
-endif()
-
-
-configure_file (
-    "${PROJECT_SOURCE_DIR}/3rdparty/expat/expat_config_cmake.in"
-    "${PROJECT_BINARY_DIR}/3rdparty/expat/simgear_expat_config.h"
-)
-
-set(expat_sources 
-	asciitab.h
-        hashtable.h
-        iasciitab.h
-        latin1tab.h
-        nametab.h
-        utf8tab.h
-        xmldef.h
-        xmlparse.h
-        xmlrole.h
-        xmltok.h
-        xmltok_impl.h
-        hashtable.c
-        xmlparse.c
-        xmlrole.c
-        xmltok.c
-        internal.h
-        ascii.h
-        sg_expat.h
-        sg_expat_external.h 
-	)
-
-add_library(FGExpat STATIC ${expat_sources})
-
-target_include_directories(FGExpat BEFORE PUBLIC
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-    $<INSTALL_INTERFACE:include>)
-
-# for the config file above
-target_include_directories(FGExpat PRIVATE ${PROJECT_BINARY_DIR}/3rdparty/expat)
-
-target_compile_definitions(FGExpat PUBLIC HAVE_SIMGEAR_EXPAT_CONFIG_H XML_STATIC)
-
-# look like Expat found by find()
-add_library(EXPAT::EXPAT ALIAS FGExpat)
-
-# in the non-shared case, we need to export these as well
-if (NOT SIMGEAR_SHARED)
-    install(TARGETS FGExpat
-        EXPORT SimGearTargets
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-endif()
--- a/3rdparty/expat/asciitab.h
+++ b/3rdparty/expat/asciitab.h
@@ -1,66 +0,0 @@
-/*
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
-
-   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
-   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
-   Copyright (c) 2017      Sebastian Pipping <sebastian@pipping.org>
-   Licensed under the MIT license:
-
-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   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. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-/* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
-    /* 0x0C */ BT_NONXML, BT_CR, BT_NONXML, BT_NONXML,
-    /* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
-    /* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
-    /* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
-    /* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
-    /* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
-    /* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
-    /* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
-    /* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
-    /* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
-    /* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
-    /* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
-    /* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
-    /* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
-    /* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
-    /* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
-    /* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,
--- a/3rdparty/expat/iasciitab.h
+++ b/3rdparty/expat/iasciitab.h
@@ -1,67 +0,0 @@
-/*
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
-
-   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
-   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
-   Copyright (c) 2017      Sebastian Pipping <sebastian@pipping.org>
-   Licensed under the MIT license:
-
-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   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. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-/* Like asciitab.h, except that 0xD has code BT_S rather than BT_CR */
-/* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
-    /* 0x0C */ BT_NONXML, BT_S, BT_NONXML, BT_NONXML,
-    /* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
-    /* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
-    /* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
-    /* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
-    /* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
-    /* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
-    /* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
-    /* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
-    /* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
-    /* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
-    /* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
-    /* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
-    /* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
-    /* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
-    /* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
-    /* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,
--- a/3rdparty/expat/internal.h
+++ b/3rdparty/expat/internal.h
@@ -1,163 +0,0 @@
-/* internal.h
-
-   Internal definitions used by Expat.  This is not needed to compile
-   client code.
-
-   The following calling convention macros are defined for frequently
-   called functions:
-
-   FASTCALL    - Used for those internal functions that have a simple
-                 body and a low number of arguments and local variables.
-
-   PTRCALL     - Used for functions called though function pointers.
-
-   PTRFASTCALL - Like PTRCALL, but for low number of arguments.
-
-   inline      - Used for selected internal functions for which inlining
-                 may improve performance on some platforms.
-
-   Note: Use of these macros is based on judgement, not hard rules,
-         and therefore subject to change.
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
-
-   Copyright (c) 2002-2003 Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
-   Copyright (c) 2002-2006 Karl Waclawek <karl@waclawek.net>
-   Copyright (c) 2003      Greg Stein <gstein@users.sourceforge.net>
-   Copyright (c) 2016-2021 Sebastian Pipping <sebastian@pipping.org>
-   Copyright (c) 2018      Yury Gribov <tetra2005@gmail.com>
-   Copyright (c) 2019      David Loffredo <loffredo@steptools.com>
-   Licensed under the MIT license:
-
-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   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. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-#if defined(__GNUC__) && defined(__i386__) && ! defined(__MINGW32__)
-/* We'll use this version by default only where we know it helps.
-
-   regparm() generates warnings on Solaris boxes.   See SF bug #692878.
-
-   Instability reported with egcs on a RedHat Linux 7.3.
-   Let's comment out:
-   #define FASTCALL __attribute__((stdcall, regparm(3)))
-   and let's try this:
-*/
-#  define FASTCALL __attribute__((regparm(3)))
-#  define PTRFASTCALL __attribute__((regparm(3)))
-#endif
-
-/* Using __fastcall seems to have an unexpected negative effect under
-   MS VC++, especially for function pointers, so we won't use it for
-   now on that platform. It may be reconsidered for a future release
-   if it can be made more effective.
-   Likely reason: __fastcall on Windows is like stdcall, therefore
-   the compiler cannot perform stack optimizations for call clusters.
-*/
-
-/* Make sure all of these are defined if they aren't already. */
-
-#ifndef FASTCALL
-#  define FASTCALL
-#endif
-
-#ifndef PTRCALL
-#  define PTRCALL
-#endif
-
-#ifndef PTRFASTCALL
-#  define PTRFASTCALL
-#endif
-
-#ifndef XML_MIN_SIZE
-#  if ! defined(__cplusplus) && ! defined(inline)
-#    ifdef __GNUC__
-#      define inline __inline
-#    endif /* __GNUC__ */
-#  endif
-#endif /* XML_MIN_SIZE */
-
-#ifdef __cplusplus
-#  define inline inline
-#else
-#  ifndef inline
-#    define inline
-#  endif
-#endif
-
-#include <limits.h> // ULONG_MAX
-
-#if defined(_WIN32) && ! defined(__USE_MINGW_ANSI_STDIO)
-#  define EXPAT_FMT_ULL(midpart) "%" midpart "I64u"
-#  if defined(_WIN64) // Note: modifiers "td" and "zu" do not work for MinGW
-#    define EXPAT_FMT_PTRDIFF_T(midpart) "%" midpart "I64d"
-#    define EXPAT_FMT_SIZE_T(midpart) "%" midpart "I64u"
-#  else
-#    define EXPAT_FMT_PTRDIFF_T(midpart) "%" midpart "d"
-#    define EXPAT_FMT_SIZE_T(midpart) "%" midpart "u"
-#  endif
-#else
-#  define EXPAT_FMT_ULL(midpart) "%" midpart "llu"
-#  if ! defined(ULONG_MAX)
-#    error Compiler did not define ULONG_MAX for us
-#  elif ULONG_MAX == 18446744073709551615u // 2^64-1
-#    define EXPAT_FMT_PTRDIFF_T(midpart) "%" midpart "ld"
-#    define EXPAT_FMT_SIZE_T(midpart) "%" midpart "lu"
-#  else
-#    define EXPAT_FMT_PTRDIFF_T(midpart) "%" midpart "d"
-#    define EXPAT_FMT_SIZE_T(midpart) "%" midpart "u"
-#  endif
-#endif
-
-#ifndef UNUSED_P
-#  define UNUSED_P(p) (void)p
-#endif
-
-/* NOTE BEGIN If you ever patch these defaults to greater values
-              for non-attack XML payload in your environment,
-              please file a bug report with libexpat.  Thank you!
-*/
-#define EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT   \
-  100.0f
-#define EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT    \
-  8388608 // 8 MiB, 2^23
-/* NOTE END */
-
-#include "sg_expat.h" // so we can use type XML_Parser below
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void _INTERNAL_trim_to_complete_utf8_characters(const char *from,
-                                                const char **fromLimRef);
-
-#if defined(XML_DTD)
-unsigned long long testingAccountingGetCountBytesDirect(XML_Parser parser);
-unsigned long long testingAccountingGetCountBytesIndirect(XML_Parser parser);
-const char *unsignedCharToPrintable(unsigned char c);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
--- a/3rdparty/expat/latin1tab.h
+++ b/3rdparty/expat/latin1tab.h
@@ -1,66 +0,0 @@
-/*
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
-
-   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
-   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
-   Copyright (c) 2017      Sebastian Pipping <sebastian@pipping.org>
-   Licensed under the MIT license:
-
-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   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. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-/* 0x80 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0x84 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0x88 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0x8C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0x90 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0x94 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0x98 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0x9C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0xA0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0xA4 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0xA8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER,
-    /* 0xAC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0xB0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0xB4 */ BT_OTHER, BT_NMSTRT, BT_OTHER, BT_NAME,
-    /* 0xB8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER,
-    /* 0xBC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-    /* 0xC0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xC4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xC8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xCC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xD0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xD4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
-    /* 0xD8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xDC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xE0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xE4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xE8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xEC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xF0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xF4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
-    /* 0xF8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-    /* 0xFC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
--- a/3rdparty/expat/nametab.h
+++ b/3rdparty/expat/nametab.h
@@ -1,136 +0,0 @@
-/*
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
-
-   Copyright (c) 2000 Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2017 Sebastian Pipping <sebastian@pipping.org>
-   Licensed under the MIT license:
-
-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   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. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-static const unsigned namingBitmap[] = {
-    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
-    0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x04000000,
-    0x87FFFFFE, 0x07FFFFFE, 0x00000000, 0x00000000, 0xFF7FFFFF, 0xFF7FFFFF,
-    0xFFFFFFFF, 0x7FF3FFFF, 0xFFFFFDFE, 0x7FFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-    0xFFFFE00F, 0xFC31FFFF, 0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF,
-    0xFFFFFFFF, 0xF80001FF, 0x00000003, 0x00000000, 0x00000000, 0x00000000,
-    0x00000000, 0x00000000, 0xFFFFD740, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD,
-    0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF, 0xFFFF0003, 0xFFFFFFFF,
-    0xFFFF199F, 0x033FCFFF, 0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE,
-    0x0000007F, 0x00000000, 0xFFFF0000, 0x000707FF, 0x00000000, 0x07FFFFFE,
-    0x000007FE, 0xFFFE0000, 0xFFFFFFFF, 0x7CFFFFFF, 0x002F7FFF, 0x00000060,
-    0xFFFFFFE0, 0x23FFFFFF, 0xFF000000, 0x00000003, 0xFFF99FE0, 0x03C5FDFF,
-    0xB0000000, 0x00030003, 0xFFF987E0, 0x036DFDFF, 0x5E000000, 0x001C0000,
-    0xFFFBAFE0, 0x23EDFDFF, 0x00000000, 0x00000001, 0xFFF99FE0, 0x23CDFDFF,
-    0xB0000000, 0x00000003, 0xD63DC7E0, 0x03BFC718, 0x00000000, 0x00000000,
-    0xFFFDDFE0, 0x03EFFDFF, 0x00000000, 0x00000003, 0xFFFDDFE0, 0x03EFFDFF,
-    0x40000000, 0x00000003, 0xFFFDDFE0, 0x03FFFDFF, 0x00000000, 0x00000003,
-    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFE, 0x000D7FFF,
-    0x0000003F, 0x00000000, 0xFEF02596, 0x200D6CAE, 0x0000001F, 0x00000000,
-    0x00000000, 0x00000000, 0xFFFFFEFF, 0x000003FF, 0x00000000, 0x00000000,
-    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
-    0x00000000, 0xFFFFFFFF, 0xFFFF003F, 0x007FFFFF, 0x0007DAED, 0x50000000,
-    0x82315001, 0x002C62AB, 0x40000000, 0xF580C900, 0x00000007, 0x02010800,
-    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0FFFFFFF, 0xFFFFFFFF,
-    0xFFFFFFFF, 0x03FFFFFF, 0x3F3FFFFF, 0xFFFFFFFF, 0xAAFF3F3F, 0x3FFFFFFF,
-    0xFFFFFFFF, 0x5FDFFFFF, 0x0FCF1FDC, 0x1FDC1FFF, 0x00000000, 0x00004C40,
-    0x00000000, 0x00000000, 0x00000007, 0x00000000, 0x00000000, 0x00000000,
-    0x00000080, 0x000003FE, 0xFFFFFFFE, 0xFFFFFFFF, 0x001FFFFF, 0xFFFFFFFE,
-    0xFFFFFFFF, 0x07FFFFFF, 0xFFFFFFE0, 0x00001FFF, 0x00000000, 0x00000000,
-    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF,
-    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x00000000, 0x00000000,
-    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000000F,
-    0x00000000, 0x00000000, 0x00000000, 0x07FF6000, 0x87FFFFFE, 0x07FFFFFE,
-    0x00000000, 0x00800000, 0xFF7FFFFF, 0xFF7FFFFF, 0x00FFFFFF, 0x00000000,
-    0xFFFF0000, 0xFFFFFFFF, 0xFFFFFFFF, 0xF80001FF, 0x00030003, 0x00000000,
-    0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x00000003, 0xFFFFD7C0, 0xFFFFFFFB,
-    0x547F7FFF, 0x000FFFFD, 0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF,
-    0xFFFF007B, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF, 0x00000000, 0xFFFE0000,
-    0x027FFFFF, 0xFFFFFFFE, 0xFFFE007F, 0xBBFFFFFB, 0xFFFF0016, 0x000707FF,
-    0x00000000, 0x07FFFFFE, 0x0007FFFF, 0xFFFF03FF, 0xFFFFFFFF, 0x7CFFFFFF,
-    0xFFEF7FFF, 0x03FF3DFF, 0xFFFFFFEE, 0xF3FFFFFF, 0xFF1E3FFF, 0x0000FFCF,
-    0xFFF99FEE, 0xD3C5FDFF, 0xB080399F, 0x0003FFCF, 0xFFF987E4, 0xD36DFDFF,
-    0x5E003987, 0x001FFFC0, 0xFFFBAFEE, 0xF3EDFDFF, 0x00003BBF, 0x0000FFC1,
-    0xFFF99FEE, 0xF3CDFDFF, 0xB0C0398F, 0x0000FFC3, 0xD63DC7EC, 0xC3BFC718,
-    0x00803DC7, 0x0000FF80, 0xFFFDDFEE, 0xC3EFFDFF, 0x00603DDF, 0x0000FFC3,
-    0xFFFDDFEC, 0xC3EFFDFF, 0x40603DDF, 0x0000FFC3, 0xFFFDDFEC, 0xC3FFFDFF,
-    0x00803DCF, 0x0000FFC3, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
-    0xFFFFFFFE, 0x07FF7FFF, 0x03FF7FFF, 0x00000000, 0xFEF02596, 0x3BFF6CAE,
-    0x03FF3F5F, 0x00000000, 0x03000000, 0xC2A003FF, 0xFFFFFEFF, 0xFFFE03FF,
-    0xFEBF0FDF, 0x02FE3FFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
-    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1FFF0000, 0x00000002,
-    0x000000A0, 0x003EFFFE, 0xFFFFFFFE, 0xFFFFFFFF, 0x661FFFFF, 0xFFFFFFFE,
-    0xFFFFFFFF, 0x77FFFFFF,
-};
-static const unsigned char nmstrtPages[] = {
-    0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x09, 0x0A, 0x0B,
-    0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13, 0x00, 0x14, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x15, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-};
-static const unsigned char namePages[] = {
-    0x19, 0x03, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x00, 0x00, 0x1F, 0x20, 0x21,
-    0x22, 0x23, 0x24, 0x25, 0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13, 0x26, 0x14, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x27, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-};
--- a/3rdparty/expat/sg_expat_external.h
+++ b/3rdparty/expat/sg_expat_external.h
@@ -1,165 +0,0 @@
-/*
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
-
-   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
-   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2000-2004 Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
-   Copyright (c) 2001-2002 Greg Stein <gstein@users.sourceforge.net>
-   Copyright (c) 2002-2006 Karl Waclawek <karl@waclawek.net>
-   Copyright (c) 2016      Cristian Rodríguez <crrodriguez@opensuse.org>
-   Copyright (c) 2016-2019 Sebastian Pipping <sebastian@pipping.org>
-   Copyright (c) 2017      Rhodri James <rhodri@wildebeest.org.uk>
-   Copyright (c) 2018      Yury Gribov <tetra2005@gmail.com>
-   Licensed under the MIT license:
-
-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   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. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-#ifndef Expat_External_INCLUDED
-#define Expat_External_INCLUDED 1
-
-/* External API definitions */
-
-/* Expat tries very hard to make the API boundary very specifically
-   defined.  There are two macros defined to control this boundary;
-   each of these can be defined before including this header to
-   achieve some different behavior, but doing so it not recommended or
-   tested frequently.
-
-   XMLCALL    - The calling convention to use for all calls across the
-                "library boundary."  This will default to cdecl, and
-                try really hard to tell the compiler that's what we
-                want.
-
-   XMLIMPORT  - Whatever magic is needed to note that a function is
-                to be imported from a dynamically loaded library
-                (.dll, .so, or .sl, depending on your platform).
-
-   The XMLCALL macro was added in Expat 1.95.7.  The only one which is
-   expected to be directly useful in client code is XMLCALL.
-
-   Note that on at least some Unix versions, the Expat library must be
-   compiled with the cdecl calling convention as the default since
-   system headers may assume the cdecl convention.
-*/
-#ifndef XMLCALL
-#  if defined(_MSC_VER)
-#    define XMLCALL __cdecl
-#  elif defined(__GNUC__) && defined(__i386) && ! defined(__INTEL_COMPILER)
-#    define XMLCALL __attribute__((cdecl))
-#  else
-/* For any platform which uses this definition and supports more than
-   one calling convention, we need to extend this definition to
-   declare the convention used on that platform, if it's possible to
-   do so.
-
-   If this is the case for your platform, please file a bug report
-   with information on how to identify your platform via the C
-   pre-processor and how to specify the same calling convention as the
-   platform's malloc() implementation.
-*/
-#    define XMLCALL
-#  endif
-#endif /* not defined XMLCALL */
-
-#if ! defined(XML_STATIC) && ! defined(XMLIMPORT)
-#  ifndef XML_BUILDING_EXPAT
-/* using Expat from an application */
-
-#    if defined(_MSC_EXTENSIONS) && ! defined(__BEOS__) && ! defined(__CYGWIN__)
-#      define XMLIMPORT __declspec(dllimport)
-#    endif
-
-#  endif
-#endif /* not defined XML_STATIC */
-
-#ifndef XML_ENABLE_VISIBILITY
-#  define XML_ENABLE_VISIBILITY 0
-#endif
-
-#if ! defined(XMLIMPORT) && XML_ENABLE_VISIBILITY
-#  define XMLIMPORT __attribute__((visibility("default")))
-#endif
-
-/* If we didn't define it above, define it away: */
-#ifndef XMLIMPORT
-#  define XMLIMPORT
-#endif
-
-#if defined(__GNUC__)                                                          \
-    && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96))
-#  define XML_ATTR_MALLOC __attribute__((__malloc__))
-#else
-#  define XML_ATTR_MALLOC
-#endif
-
-#if defined(__GNUC__)                                                          \
-    && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
-#  define XML_ATTR_ALLOC_SIZE(x) __attribute__((__alloc_size__(x)))
-#else
-#  define XML_ATTR_ALLOC_SIZE(x)
-#endif
-
-#define XMLPARSEAPI(type) XMLIMPORT type XMLCALL
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef XML_UNICODE_WCHAR_T
-#  ifndef XML_UNICODE
-#    define XML_UNICODE
-#  endif
-#  if defined(__SIZEOF_WCHAR_T__) && (__SIZEOF_WCHAR_T__ != 2)
-#    error "sizeof(wchar_t) != 2; Need -fshort-wchar for both Expat and libc"
-#  endif
-#endif
-
-#ifdef XML_UNICODE /* Information is UTF-16 encoded. */
-#  ifdef XML_UNICODE_WCHAR_T
-typedef wchar_t XML_Char;
-typedef wchar_t XML_LChar;
-#  else
-typedef unsigned short XML_Char;
-typedef char XML_LChar;
-#  endif /* XML_UNICODE_WCHAR_T */
-#else    /* Information is UTF-8 encoded. */
-typedef char XML_Char;
-typedef char XML_LChar;
-#endif   /* XML_UNICODE */
-
-#ifdef XML_LARGE_SIZE /* Use large integers for file/stream positions. */
-typedef long long XML_Index;
-typedef unsigned long long XML_Size;
-#else
-typedef long XML_Index;
-typedef unsigned long XML_Size;
-#endif /* XML_LARGE_SIZE */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* not Expat_External_INCLUDED */
--- a/3rdparty/expat/siphash.h
+++ b/3rdparty/expat/siphash.h
@@ -1,393 +0,0 @@
-/* ==========================================================================
- * siphash.h - SipHash-2-4 in a single header file
- * --------------------------------------------------------------------------
- * Derived by William Ahern from the reference implementation[1] published[2]
- * by Jean-Philippe Aumasson and Daniel J. Berstein.
- * Minimal changes by Sebastian Pipping and Victor Stinner on top, see below.
- * Licensed under the CC0 Public Domain Dedication license.
- *
- * 1. https://www.131002.net/siphash/siphash24.c
- * 2. https://www.131002.net/siphash/
- * --------------------------------------------------------------------------
- * HISTORY:
- *
- * 2020-10-03  (Sebastian Pipping)
- *   - Drop support for Visual Studio 9.0/2008 and earlier
- *
- * 2019-08-03  (Sebastian Pipping)
- *   - Mark part of sip24_valid as to be excluded from clang-format
- *   - Re-format code using clang-format 9
- *
- * 2018-07-08  (Anton Maklakov)
- *   - Add "fall through" markers for GCC's -Wimplicit-fallthrough
- *
- * 2017-11-03  (Sebastian Pipping)
- *   - Hide sip_tobin and sip_binof unless SIPHASH_TOBIN macro is defined
- *
- * 2017-07-25  (Vadim Zeitlin)
- *   - Fix use of SIPHASH_MAIN macro
- *
- * 2017-07-05  (Sebastian Pipping)
- *   - Use _SIP_ULL macro to not require a C++11 compiler if compiled as C++
- *   - Add const qualifiers at two places
- *   - Ensure <=80 characters line length (assuming tab width 4)
- *
- * 2017-06-23  (Victor Stinner)
- *   - Address Win64 compile warnings
- *
- * 2017-06-18  (Sebastian Pipping)
- *   - Clarify license note in the header
- *   - Address C89 issues:
- *     - Stop using inline keyword (and let compiler decide)
- *     - Replace _Bool by int
- *     - Turn macro siphash24 into a function
- *     - Address invalid conversion (void pointer) by explicit cast
- *   - Address lack of stdint.h for Visual Studio 2003 to 2008
- *   - Always expose sip24_valid (for self-tests)
- *
- * 2012-11-04 - Born.  (William Ahern)
- * --------------------------------------------------------------------------
- * USAGE:
- *
- * SipHash-2-4 takes as input two 64-bit words as the key, some number of
- * message bytes, and outputs a 64-bit word as the message digest. This
- * implementation employs two data structures: a struct sipkey for
- * representing the key, and a struct siphash for representing the hash
- * state.
- *
- * For converting a 16-byte unsigned char array to a key, use either the
- * macro sip_keyof or the routine sip_tokey. The former instantiates a
- * compound literal key, while the latter requires a key object as a
- * parameter.
- *
- * 	unsigned char secret[16];
- * 	arc4random_buf(secret, sizeof secret);
- * 	struct sipkey *key = sip_keyof(secret);
- *
- * For hashing a message, use either the convenience macro siphash24 or the
- * routines sip24_init, sip24_update, and sip24_final.
- *
- * 	struct siphash state;
- * 	void *msg;
- * 	size_t len;
- * 	uint64_t hash;
- *
- * 	sip24_init(&state, key);
- * 	sip24_update(&state, msg, len);
- * 	hash = sip24_final(&state);
- *
- * or
- *
- * 	hash = siphash24(msg, len, key);
- *
- * To convert the 64-bit hash value to a canonical 8-byte little-endian
- * binary representation, use either the macro sip_binof or the routine
- * sip_tobin. The former instantiates and returns a compound literal array,
- * while the latter requires an array object as a parameter.
- * --------------------------------------------------------------------------
- * NOTES:
- *
- * o Neither sip_keyof, sip_binof, nor siphash24 will work with compilers
- *   lacking compound literal support. Instead, you must use the lower-level
- *   interfaces which take as parameters the temporary state objects.
- *
- * o Uppercase macros may evaluate parameters more than once. Lowercase
- *   macros should not exhibit any such side effects.
- * ==========================================================================
- */
-#ifndef SIPHASH_H
-#define SIPHASH_H
-
-#include <stddef.h> /* size_t */
-#include <stdint.h> /* uint64_t uint32_t uint8_t */
-
-/*
- * Workaround to not require a C++11 compiler for using ULL suffix
- * if this code is included and compiled as C++; related GCC warning is:
- * warning: use of C++11 long long integer constant [-Wlong-long]
- */
-#define _SIP_ULL(high, low) (((uint64_t)high << 32) | low)
-
-#define SIP_ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b))))
-
-#define SIP_U32TO8_LE(p, v)                                                    \
-  (p)[0] = (uint8_t)((v) >> 0);                                                \
-  (p)[1] = (uint8_t)((v) >> 8);                                                \
-  (p)[2] = (uint8_t)((v) >> 16);                                               \
-  (p)[3] = (uint8_t)((v) >> 24);
-
-#define SIP_U64TO8_LE(p, v)                                                    \
-  SIP_U32TO8_LE((p) + 0, (uint32_t)((v) >> 0));                                \
-  SIP_U32TO8_LE((p) + 4, (uint32_t)((v) >> 32));
-
-#define SIP_U8TO64_LE(p)                                                       \
-  (((uint64_t)((p)[0]) << 0) | ((uint64_t)((p)[1]) << 8)                       \
-   | ((uint64_t)((p)[2]) << 16) | ((uint64_t)((p)[3]) << 24)                   \
-   | ((uint64_t)((p)[4]) << 32) | ((uint64_t)((p)[5]) << 40)                   \
-   | ((uint64_t)((p)[6]) << 48) | ((uint64_t)((p)[7]) << 56))
-
-#define SIPHASH_INITIALIZER                                                    \
-  { 0, 0, 0, 0, {0}, 0, 0 }
-
-struct siphash {
-  uint64_t v0, v1, v2, v3;
-
-  unsigned char buf[8], *p;
-  uint64_t c;
-}; /* struct siphash */
-
-#define SIP_KEYLEN 16
-
-struct sipkey {
-  uint64_t k[2];
-}; /* struct sipkey */
-
-#define sip_keyof(k) sip_tokey(&(struct sipkey){{0}}, (k))
-
-static struct sipkey *
-sip_tokey(struct sipkey *key, const void *src) {
-  key->k[0] = SIP_U8TO64_LE((const unsigned char *)src);
-  key->k[1] = SIP_U8TO64_LE((const unsigned char *)src + 8);
-  return key;
-} /* sip_tokey() */
-
-#ifdef SIPHASH_TOBIN
-
-#  define sip_binof(v) sip_tobin((unsigned char[8]){0}, (v))
-
-static void *
-sip_tobin(void *dst, uint64_t u64) {
-  SIP_U64TO8_LE((unsigned char *)dst, u64);
-  return dst;
-} /* sip_tobin() */
-
-#endif /* SIPHASH_TOBIN */
-
-static void
-sip_round(struct siphash *H, const int rounds) {
-  int i;
-
-  for (i = 0; i < rounds; i++) {
-    H->v0 += H->v1;
-    H->v1 = SIP_ROTL(H->v1, 13);
-    H->v1 ^= H->v0;
-    H->v0 = SIP_ROTL(H->v0, 32);
-
-    H->v2 += H->v3;
-    H->v3 = SIP_ROTL(H->v3, 16);
-    H->v3 ^= H->v2;
-
-    H->v0 += H->v3;
-    H->v3 = SIP_ROTL(H->v3, 21);
-    H->v3 ^= H->v0;
-
-    H->v2 += H->v1;
-    H->v1 = SIP_ROTL(H->v1, 17);
-    H->v1 ^= H->v2;
-    H->v2 = SIP_ROTL(H->v2, 32);
-  }
-} /* sip_round() */
-
-static struct siphash *
-sip24_init(struct siphash *H, const struct sipkey *key) {
-  H->v0 = _SIP_ULL(0x736f6d65U, 0x70736575U) ^ key->k[0];
-  H->v1 = _SIP_ULL(0x646f7261U, 0x6e646f6dU) ^ key->k[1];
-  H->v2 = _SIP_ULL(0x6c796765U, 0x6e657261U) ^ key->k[0];
-  H->v3 = _SIP_ULL(0x74656462U, 0x79746573U) ^ key->k[1];
-
-  H->p = H->buf;
-  H->c = 0;
-
-  return H;
-} /* sip24_init() */
-
-#define sip_endof(a) (&(a)[sizeof(a) / sizeof *(a)])
-
-static struct siphash *
-sip24_update(struct siphash *H, const void *src, size_t len) {
-  const unsigned char *p = (const unsigned char *)src, *pe = p + len;
-  uint64_t m;
-
-  do {
-    while (p < pe && H->p < sip_endof(H->buf))
-      *H->p++ = *p++;
-
-    if (H->p < sip_endof(H->buf))
-      break;
-
-    m = SIP_U8TO64_LE(H->buf);
-    H->v3 ^= m;
-    sip_round(H, 2);
-    H->v0 ^= m;
-
-    H->p = H->buf;
-    H->c += 8;
-  } while (p < pe);
-
-  return H;
-} /* sip24_update() */
-
-static uint64_t
-sip24_final(struct siphash *H) {
-  const char left = (char)(H->p - H->buf);
-  uint64_t b = (H->c + left) << 56;
-
-  switch (left) {
-  case 7:
-    b |= (uint64_t)H->buf[6] << 48;
-    /* fall through */
-  case 6:
-    b |= (uint64_t)H->buf[5] << 40;
-    /* fall through */
-  case 5:
-    b |= (uint64_t)H->buf[4] << 32;
-    /* fall through */
-  case 4:
-    b |= (uint64_t)H->buf[3] << 24;
-    /* fall through */
-  case 3:
-    b |= (uint64_t)H->buf[2] << 16;
-    /* fall through */
-  case 2:
-    b |= (uint64_t)H->buf[1] << 8;
-    /* fall through */
-  case 1:
-    b |= (uint64_t)H->buf[0] << 0;
-    /* fall through */
-  case 0:
-    break;
-  }
-
-  H->v3 ^= b;
-  sip_round(H, 2);
-  H->v0 ^= b;
-  H->v2 ^= 0xff;
-  sip_round(H, 4);
-
-  return H->v0 ^ H->v1 ^ H->v2 ^ H->v3;
-} /* sip24_final() */
-
-static uint64_t
-siphash24(const void *src, size_t len, const struct sipkey *key) {
-  struct siphash state = SIPHASH_INITIALIZER;
-  return sip24_final(sip24_update(sip24_init(&state, key), src, len));
-} /* siphash24() */
-
-/*
- * SipHash-2-4 output with
- * k = 00 01 02 ...
- * and
- * in = (empty string)
- * in = 00 (1 byte)
- * in = 00 01 (2 bytes)
- * in = 00 01 02 (3 bytes)
- * ...
- * in = 00 01 02 ... 3e (63 bytes)
- */
-static int
-sip24_valid(void) {
-  /* clang-format off */
-  static const unsigned char vectors[64][8] = {
-    { 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, },
-    { 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, },
-    { 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d, },
-    { 0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85, },
-    { 0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf, },
-    { 0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18, },
-    { 0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb, },
-    { 0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab, },
-    { 0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93, },
-    { 0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e, },
-    { 0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a, },
-    { 0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4, },
-    { 0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75, },
-    { 0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14, },
-    { 0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7, },
-    { 0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1, },
-    { 0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f, },
-    { 0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69, },
-    { 0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b, },
-    { 0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb, },
-    { 0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe, },
-    { 0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0, },
-    { 0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93, },
-    { 0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8, },
-    { 0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8, },
-    { 0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc, },
-    { 0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17, },
-    { 0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f, },
-    { 0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde, },
-    { 0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6, },
-    { 0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad, },
-    { 0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32, },
-    { 0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71, },
-    { 0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7, },
-    { 0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12, },
-    { 0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15, },
-    { 0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31, },
-    { 0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02, },
-    { 0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca, },
-    { 0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a, },
-    { 0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e, },
-    { 0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad, },
-    { 0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18, },
-    { 0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4, },
-    { 0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9, },
-    { 0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9, },
-    { 0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb, },
-    { 0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0, },
-    { 0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6, },
-    { 0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7, },
-    { 0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee, },
-    { 0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1, },
-    { 0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a, },
-    { 0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81, },
-    { 0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f, },
-    { 0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24, },
-    { 0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7, },
-    { 0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea, },
-    { 0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60, },
-    { 0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66, },
-    { 0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c, },
-    { 0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f, },
-    { 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5, },
-    { 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95, }
-  };
-  /* clang-format on */
-
-  unsigned char in[64];
-  struct sipkey k;
-  size_t i;
-
-  sip_tokey(&k, "\000\001\002\003\004\005\006\007\010\011"
-                "\012\013\014\015\016\017");
-
-  for (i = 0; i < sizeof in; ++i) {
-    in[i] = (unsigned char)i;
-
-    if (siphash24(in, i, &k) != SIP_U8TO64_LE(vectors[i]))
-      return 0;
-  }
-
-  return 1;
-} /* sip24_valid() */
-
-#ifdef SIPHASH_MAIN
-
-#  include <stdio.h>
-
-int
-main(void) {
-  const int ok = sip24_valid();
-
-  if (ok)
-    puts("OK");
-  else
-    puts("FAIL");
-
-  return ! ok;
-} /* main() */
-
-#endif /* SIPHASH_MAIN */
-
-#endif /* SIPHASH_H */
--- a/3rdparty/expat/utf8tab.h
+++ b/3rdparty/expat/utf8tab.h
@@ -1,66 +0,0 @@
-/*
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
-
-   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
-   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
-   Copyright (c) 2017      Sebastian Pipping <sebastian@pipping.org>
-   Licensed under the MIT license:
-
-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   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. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-/* 0x80 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0x84 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0x88 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0x8C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0x90 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0x94 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0x98 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0x9C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0xA0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0xA4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0xA8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0xAC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0xB0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0xB4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0xB8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0xBC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-    /* 0xC0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-    /* 0xC4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-    /* 0xC8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-    /* 0xCC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-    /* 0xD0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-    /* 0xD4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-    /* 0xD8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-    /* 0xDC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-    /* 0xE0 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
-    /* 0xE4 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
-    /* 0xE8 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
-    /* 0xEC */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
-    /* 0xF0 */ BT_LEAD4, BT_LEAD4, BT_LEAD4, BT_LEAD4,
-    /* 0xF4 */ BT_LEAD4, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0xF8 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-    /* 0xFC */ BT_NONXML, BT_NONXML, BT_MALFORM, BT_MALFORM,
--- a/3rdparty/expat/winconfig.h
+++ b/3rdparty/expat/winconfig.h
@@ -1,45 +0,0 @@
-/*
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
-
-   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2002      Greg Stein <gstein@users.sourceforge.net>
-   Copyright (c) 2005      Karl Waclawek <karl@waclawek.net>
-   Copyright (c) 2017-2021 Sebastian Pipping <sebastian@pipping.org>
-   Licensed under the MIT license:
-
-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   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. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-#ifndef WINCONFIG_H
-#define WINCONFIG_H
-
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#undef WIN32_LEAN_AND_MEAN
-
-#include <memory.h>
-#include <string.h>
-
-#endif /* ndef WINCONFIG_H */
--- a/3rdparty/expat/xmlparse.c
+++ b/3rdparty/expat/xmlparse.c
--- a/3rdparty/expat/xmltok.c
+++ b/3rdparty/expat/xmltok.c
--- a/3rdparty/expat/xmltok.h
+++ b/3rdparty/expat/xmltok.h
@@ -1,319 +0,0 @@
-/*
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
-
-   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
-   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
-   Copyright (c) 2002-2005 Karl Waclawek <karl@waclawek.net>
-   Copyright (c) 2016-2017 Sebastian Pipping <sebastian@pipping.org>
-   Copyright (c) 2017      Rhodri James <rhodri@wildebeest.org.uk>
-   Licensed under the MIT license:
-
-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   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. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-#ifndef XmlTok_INCLUDED
-#define XmlTok_INCLUDED 1
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* The following token may be returned by XmlContentTok */
-#define XML_TOK_TRAILING_RSQB                                                  \
-  -5 /* ] or ]] at the end of the scan; might be                               \
-        start of illegal ]]> sequence */
-/* The following tokens may be returned by both XmlPrologTok and
-   XmlContentTok.
-*/
-#define XML_TOK_NONE -4 /* The string to be scanned is empty */
-#define XML_TOK_TRAILING_CR                                                    \
-  -3                            /* A CR at the end of the scan;                \
-                                   might be part of CRLF sequence */
-#define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */
-#define XML_TOK_PARTIAL -1      /* only part of a token */
-#define XML_TOK_INVALID 0
-
-/* The following tokens are returned by XmlContentTok; some are also
-   returned by XmlAttributeValueTok, XmlEntityTok, XmlCdataSectionTok.
-*/
-#define XML_TOK_START_TAG_WITH_ATTS 1
-#define XML_TOK_START_TAG_NO_ATTS 2
-#define XML_TOK_EMPTY_ELEMENT_WITH_ATTS 3 /* empty element tag <e/> */
-#define XML_TOK_EMPTY_ELEMENT_NO_ATTS 4
-#define XML_TOK_END_TAG 5
-#define XML_TOK_DATA_CHARS 6
-#define XML_TOK_DATA_NEWLINE 7
-#define XML_TOK_CDATA_SECT_OPEN 8
-#define XML_TOK_ENTITY_REF 9
-#define XML_TOK_CHAR_REF 10 /* numeric character reference */
-
-/* The following tokens may be returned by both XmlPrologTok and
-   XmlContentTok.
-*/
-#define XML_TOK_PI 11       /* processing instruction */
-#define XML_TOK_XML_DECL 12 /* XML decl or text decl */
-#define XML_TOK_COMMENT 13
-#define XML_TOK_BOM 14 /* Byte order mark */
-
-/* The following tokens are returned only by XmlPrologTok */
-#define XML_TOK_PROLOG_S 15
-#define XML_TOK_DECL_OPEN 16  /* <!foo */
-#define XML_TOK_DECL_CLOSE 17 /* > */
-#define XML_TOK_NAME 18
-#define XML_TOK_NMTOKEN 19
-#define XML_TOK_POUND_NAME 20 /* #name */
-#define XML_TOK_OR 21         /* | */
-#define XML_TOK_PERCENT 22
-#define XML_TOK_OPEN_PAREN 23
-#define XML_TOK_CLOSE_PAREN 24
-#define XML_TOK_OPEN_BRACKET 25
-#define XML_TOK_CLOSE_BRACKET 26
-#define XML_TOK_LITERAL 27
-#define XML_TOK_PARAM_ENTITY_REF 28
-#define XML_TOK_INSTANCE_START 29
-
-/* The following occur only in element type declarations */
-#define XML_TOK_NAME_QUESTION 30        /* name? */
-#define XML_TOK_NAME_ASTERISK 31        /* name* */
-#define XML_TOK_NAME_PLUS 32            /* name+ */
-#define XML_TOK_COND_SECT_OPEN 33       /* <![ */
-#define XML_TOK_COND_SECT_CLOSE 34      /* ]]> */
-#define XML_TOK_CLOSE_PAREN_QUESTION 35 /* )? */
-#define XML_TOK_CLOSE_PAREN_ASTERISK 36 /* )* */
-#define XML_TOK_CLOSE_PAREN_PLUS 37     /* )+ */
-#define XML_TOK_COMMA 38
-
-/* The following token is returned only by XmlAttributeValueTok */
-#define XML_TOK_ATTRIBUTE_VALUE_S 39
-
-/* The following token is returned only by XmlCdataSectionTok */
-#define XML_TOK_CDATA_SECT_CLOSE 40
-
-/* With namespace processing this is returned by XmlPrologTok for a
-   name with a colon.
-*/
-#define XML_TOK_PREFIXED_NAME 41
-
-#ifdef XML_DTD
-#  define XML_TOK_IGNORE_SECT 42
-#endif /* XML_DTD */
-
-#ifdef XML_DTD
-#  define XML_N_STATES 4
-#else /* not XML_DTD */
-#  define XML_N_STATES 3
-#endif /* not XML_DTD */
-
-#define XML_PROLOG_STATE 0
-#define XML_CONTENT_STATE 1
-#define XML_CDATA_SECTION_STATE 2
-#ifdef XML_DTD
-#  define XML_IGNORE_SECTION_STATE 3
-#endif /* XML_DTD */
-
-#define XML_N_LITERAL_TYPES 2
-#define XML_ATTRIBUTE_VALUE_LITERAL 0
-#define XML_ENTITY_VALUE_LITERAL 1
-
-/* The size of the buffer passed to XmlUtf8Encode must be at least this. */
-#define XML_UTF8_ENCODE_MAX 4
-/* The size of the buffer passed to XmlUtf16Encode must be at least this. */
-#define XML_UTF16_ENCODE_MAX 2
-
-typedef struct position {
-  /* first line and first column are 0 not 1 */
-  XML_Size lineNumber;
-  XML_Size columnNumber;
-} POSITION;
-
-typedef struct {
-  const char *name;
-  const char *valuePtr;
-  const char *valueEnd;
-  char normalized;
-} ATTRIBUTE;
-
-struct encoding;
-typedef struct encoding ENCODING;
-
-typedef int(PTRCALL *SCANNER)(const ENCODING *, const char *, const char *,
-                              const char **);
-
-enum XML_Convert_Result {
-  XML_CONVERT_COMPLETED = 0,
-  XML_CONVERT_INPUT_INCOMPLETE = 1,
-  XML_CONVERT_OUTPUT_EXHAUSTED
-  = 2 /* and therefore potentially input remaining as well */
-};
-
-struct encoding {
-  SCANNER scanners[XML_N_STATES];
-  SCANNER literalScanners[XML_N_LITERAL_TYPES];
-  int(PTRCALL *nameMatchesAscii)(const ENCODING *, const char *, const char *,
-                                 const char *);
-  int(PTRFASTCALL *nameLength)(const ENCODING *, const char *);
-  const char *(PTRFASTCALL *skipS)(const ENCODING *, const char *);
-  int(PTRCALL *getAtts)(const ENCODING *enc, const char *ptr, int attsMax,
-                        ATTRIBUTE *atts);
-  int(PTRFASTCALL *charRefNumber)(const ENCODING *enc, const char *ptr);
-  int(PTRCALL *predefinedEntityName)(const ENCODING *, const char *,
-                                     const char *);
-  void(PTRCALL *updatePosition)(const ENCODING *, const char *ptr,
-                                const char *end, POSITION *);
-  int(PTRCALL *isPublicId)(const ENCODING *enc, const char *ptr,
-                           const char *end, const char **badPtr);
-  enum XML_Convert_Result(PTRCALL *utf8Convert)(const ENCODING *enc,
-                                                const char **fromP,
-                                                const char *fromLim, char **toP,
-                                                const char *toLim);
-  enum XML_Convert_Result(PTRCALL *utf16Convert)(const ENCODING *enc,
-                                                 const char **fromP,
-                                                 const char *fromLim,
-                                                 unsigned short **toP,
-                                                 const unsigned short *toLim);
-  int minBytesPerChar;
-  char isUtf8;
-  char isUtf16;
-};
-
-/* Scan the string starting at ptr until the end of the next complete
-   token, but do not scan past eptr.  Return an integer giving the
-   type of token.
-
-   Return XML_TOK_NONE when ptr == eptr; nextTokPtr will not be set.
-
-   Return XML_TOK_PARTIAL when the string does not contain a complete
-   token; nextTokPtr will not be set.
-
-   Return XML_TOK_INVALID when the string does not start a valid
-   token; nextTokPtr will be set to point to the character which made
-   the token invalid.
-
-   Otherwise the string starts with a valid token; nextTokPtr will be
-   set to point to the character following the end of that token.
-
-   Each data character counts as a single token, but adjacent data
-   characters may be returned together.  Similarly for characters in
-   the prolog outside literals, comments and processing instructions.
-*/
-
-#define XmlTok(enc, state, ptr, end, nextTokPtr)                               \
-  (((enc)->scanners[state])(enc, ptr, end, nextTokPtr))
-
-#define XmlPrologTok(enc, ptr, end, nextTokPtr)                                \
-  XmlTok(enc, XML_PROLOG_STATE, ptr, end, nextTokPtr)
-
-#define XmlContentTok(enc, ptr, end, nextTokPtr)                               \
-  XmlTok(enc, XML_CONTENT_STATE, ptr, end, nextTokPtr)
-
-#define XmlCdataSectionTok(enc, ptr, end, nextTokPtr)                          \
-  XmlTok(enc, XML_CDATA_SECTION_STATE, ptr, end, nextTokPtr)
-
-#ifdef XML_DTD
-
-#  define XmlIgnoreSectionTok(enc, ptr, end, nextTokPtr)                       \
-    XmlTok(enc, XML_IGNORE_SECTION_STATE, ptr, end, nextTokPtr)
-
-#endif /* XML_DTD */
-
-/* This is used for performing a 2nd-level tokenization on the content
-   of a literal that has already been returned by XmlTok.
-*/
-#define XmlLiteralTok(enc, literalType, ptr, end, nextTokPtr)                  \
-  (((enc)->literalScanners[literalType])(enc, ptr, end, nextTokPtr))
-
-#define XmlAttributeValueTok(enc, ptr, end, nextTokPtr)                        \
-  XmlLiteralTok(enc, XML_ATTRIBUTE_VALUE_LITERAL, ptr, end, nextTokPtr)
-
-#define XmlEntityValueTok(enc, ptr, end, nextTokPtr)                           \
-  XmlLiteralTok(enc, XML_ENTITY_VALUE_LITERAL, ptr, end, nextTokPtr)
-
-#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)                             \
-  (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2))
-
-#define XmlNameLength(enc, ptr) (((enc)->nameLength)(enc, ptr))
-
-#define XmlSkipS(enc, ptr) (((enc)->skipS)(enc, ptr))
-
-#define XmlGetAttributes(enc, ptr, attsMax, atts)                              \
-  (((enc)->getAtts)(enc, ptr, attsMax, atts))
-
-#define XmlCharRefNumber(enc, ptr) (((enc)->charRefNumber)(enc, ptr))
-
-#define XmlPredefinedEntityName(enc, ptr, end)                                 \
-  (((enc)->predefinedEntityName)(enc, ptr, end))
-
-#define XmlUpdatePosition(enc, ptr, end, pos)                                  \
-  (((enc)->updatePosition)(enc, ptr, end, pos))
-
-#define XmlIsPublicId(enc, ptr, end, badPtr)                                   \
-  (((enc)->isPublicId)(enc, ptr, end, badPtr))
-
-#define XmlUtf8Convert(enc, fromP, fromLim, toP, toLim)                        \
-  (((enc)->utf8Convert)(enc, fromP, fromLim, toP, toLim))
-
-#define XmlUtf16Convert(enc, fromP, fromLim, toP, toLim)                       \
-  (((enc)->utf16Convert)(enc, fromP, fromLim, toP, toLim))
-
-typedef struct {
-  ENCODING initEnc;
-  const ENCODING **encPtr;
-} INIT_ENCODING;
-
-int XmlParseXmlDecl(int isGeneralTextEntity, const ENCODING *enc,
-                    const char *ptr, const char *end, const char **badPtr,
-                    const char **versionPtr, const char **versionEndPtr,
-                    const char **encodingNamePtr,
-                    const ENCODING **namedEncodingPtr, int *standalonePtr);
-
-int XmlInitEncoding(INIT_ENCODING *, const ENCODING **, const char *name);
-const ENCODING *XmlGetUtf8InternalEncoding(void);
-const ENCODING *XmlGetUtf16InternalEncoding(void);
-int FASTCALL XmlUtf8Encode(int charNumber, char *buf);
-int FASTCALL XmlUtf16Encode(int charNumber, unsigned short *buf);
-int XmlSizeOfUnknownEncoding(void);
-
-typedef int(XMLCALL *CONVERTER)(void *userData, const char *p);
-
-ENCODING *XmlInitUnknownEncoding(void *mem, int *table, CONVERTER convert,
-                                 void *userData);
-
-int XmlParseXmlDeclNS(int isGeneralTextEntity, const ENCODING *enc,
-                      const char *ptr, const char *end, const char **badPtr,
-                      const char **versionPtr, const char **versionEndPtr,
-                      const char **encodingNamePtr,
-                      const ENCODING **namedEncodingPtr, int *standalonePtr);
-
-int XmlInitEncodingNS(INIT_ENCODING *, const ENCODING **, const char *name);
-const ENCODING *XmlGetUtf8InternalEncodingNS(void);
-const ENCODING *XmlGetUtf16InternalEncodingNS(void);
-ENCODING *XmlInitUnknownEncodingNS(void *mem, int *table, CONVERTER convert,
-                                   void *userData);
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* not XmlTok_INCLUDED */
--- a/3rdparty/expat/xmltok_impl.c
+++ b/3rdparty/expat/xmltok_impl.c
--- a/3rdparty/expat/xmltok_impl.h
+++ b/3rdparty/expat/xmltok_impl.h
@@ -1,74 +0,0 @@
-/*
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
-
-   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
-   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2017-2019 Sebastian Pipping <sebastian@pipping.org>
-   Licensed under the MIT license:
-
-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   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. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-enum {
-  BT_NONXML,   /* e.g. noncharacter-FFFF */
-  BT_MALFORM,  /* illegal, with regard to encoding */
-  BT_LT,       /* less than = "<" */
-  BT_AMP,      /* ampersand = "&" */
-  BT_RSQB,     /* right square bracket = "[" */
-  BT_LEAD2,    /* lead byte of a 2-byte UTF-8 character */
-  BT_LEAD3,    /* lead byte of a 3-byte UTF-8 character */
-  BT_LEAD4,    /* lead byte of a 4-byte UTF-8 character */
-  BT_TRAIL,    /* trailing unit, e.g. second 16-bit unit of a 4-byte char. */
-  BT_CR,       /* carriage return = "\r" */
-  BT_LF,       /* line feed = "\n" */
-  BT_GT,       /* greater than = ">" */
-  BT_QUOT,     /* quotation character = "\"" */
-  BT_APOS,     /* aposthrophe = "'" */
-  BT_EQUALS,   /* equal sign = "=" */
-  BT_QUEST,    /* question mark = "?" */
-  BT_EXCL,     /* exclamation mark = "!" */
-  BT_SOL,      /* solidus, slash = "/" */
-  BT_SEMI,     /* semicolon = ";" */
-  BT_NUM,      /* number sign = "#" */
-  BT_LSQB,     /* left square bracket = "[" */
-  BT_S,        /* white space, e.g. "\t", " "[, "\r"] */
-  BT_NMSTRT,   /* non-hex name start letter = "G".."Z" + "g".."z" + "_" */
-  BT_COLON,    /* colon = ":" */
-  BT_HEX,      /* hex letter = "A".."F" + "a".."f" */
-  BT_DIGIT,    /* digit = "0".."9" */
-  BT_NAME,     /* dot and middle dot = "." + chr(0xb7) */
-  BT_MINUS,    /* minus = "-" */
-  BT_OTHER,    /* known not to be a name or name start character */
-  BT_NONASCII, /* might be a name or name start character */
-  BT_PERCNT,   /* percent sign = "%" */
-  BT_LPAR,     /* left parenthesis = "(" */
-  BT_RPAR,     /* right parenthesis = "(" */
-  BT_AST,      /* asterisk = "*" */
-  BT_PLUS,     /* plus sign = "+" */
-  BT_COMMA,    /* comma = "," */
-  BT_VERBAR    /* vertical bar = "|" */
-};
-
-#include <stddef.h>
--- a/3rdparty/expat/xmltok_ns.c
+++ b/3rdparty/expat/xmltok_ns.c
@@ -1,122 +0,0 @@
-/* This file is included!
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
-
-   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
-   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
-   Copyright (c) 2002      Greg Stein <gstein@users.sourceforge.net>
-   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
-   Copyright (c) 2002-2006 Karl Waclawek <karl@waclawek.net>
-   Copyright (c) 2017-2021 Sebastian Pipping <sebastian@pipping.org>
-   Licensed under the MIT license:
-
-   Permission is  hereby granted,  free of charge,  to any  person obtaining
-   a  copy  of  this  software   and  associated  documentation  files  (the
-   "Software"),  to  deal in  the  Software  without restriction,  including
-   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. IN
-   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
-   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-   USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-#ifdef XML_TOK_NS_C
-
-const ENCODING *
-NS(XmlGetUtf8InternalEncoding)(void) {
-  return &ns(internal_utf8_encoding).enc;
-}
-
-const ENCODING *
-NS(XmlGetUtf16InternalEncoding)(void) {
-#  if BYTEORDER == 1234
-  return &ns(internal_little2_encoding).enc;
-#  elif BYTEORDER == 4321
-  return &ns(internal_big2_encoding).enc;
-#  else
-  const short n = 1;
-  return (*(const char *)&n ? &ns(internal_little2_encoding).enc
-                            : &ns(internal_big2_encoding).enc);
-#  endif
-}
-
-static const ENCODING *const NS(encodings)[] = {
-    &ns(latin1_encoding).enc, &ns(ascii_encoding).enc,
-    &ns(utf8_encoding).enc,   &ns(big2_encoding).enc,
-    &ns(big2_encoding).enc,   &ns(little2_encoding).enc,
-    &ns(utf8_encoding).enc /* NO_ENC */
-};
-
-static int PTRCALL
-NS(initScanProlog)(const ENCODING *enc, const char *ptr, const char *end,
-                   const char **nextTokPtr) {
-  return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_PROLOG_STATE,
-                  ptr, end, nextTokPtr);
-}
-
-static int PTRCALL
-NS(initScanContent)(const ENCODING *enc, const char *ptr, const char *end,
-                    const char **nextTokPtr) {
-  return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_CONTENT_STATE,
-                  ptr, end, nextTokPtr);
-}
-
-int
-NS(XmlInitEncoding)(INIT_ENCODING *p, const ENCODING **encPtr,
-                    const char *name) {
-  int i = getEncodingIndex(name);
-  if (i == UNKNOWN_ENC)
-    return 0;
-  SET_INIT_ENC_INDEX(p, i);
-  p->initEnc.scanners[XML_PROLOG_STATE] = NS(initScanProlog);
-  p->initEnc.scanners[XML_CONTENT_STATE] = NS(initScanContent);
-  p->initEnc.updatePosition = initUpdatePosition;
-  p->encPtr = encPtr;
-  *encPtr = &(p->initEnc);
-  return 1;
-}
-
-static const ENCODING *
-NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end) {
-#  define ENCODING_MAX 128
-  char buf[ENCODING_MAX] = "";
-  char *p = buf;
-  int i;
-  XmlUtf8Convert(enc, &ptr, end, &p, p + ENCODING_MAX - 1);
-  if (ptr != end)
-    return 0;
-  *p = 0;
-  if (streqci(buf, KW_UTF_16) && enc->minBytesPerChar == 2)
-    return enc;
-  i = getEncodingIndex(buf);
-  if (i == UNKNOWN_ENC)
-    return 0;
-  return NS(encodings)[i];
-}
-
-int
-NS(XmlParseXmlDecl)(int isGeneralTextEntity, const ENCODING *enc,
-                    const char *ptr, const char *end, const char **badPtr,
-                    const char **versionPtr, const char **versionEndPtr,
-                    const char **encodingName, const ENCODING **encoding,
-                    int *standalone) {
-  return doParseXmlDecl(NS(findEncoding), isGeneralTextEntity, enc, ptr, end,
-                        badPtr, versionPtr, versionEndPtr, encodingName,
-                        encoding, standalone);
-}
-
-#endif /* XML_TOK_NS_C */
--- a/3rdparty/tiny_gltf/CMakeLists.txt
+++ b/3rdparty/tiny_gltf/CMakeLists.txt
@@ -1,14 +0,0 @@
-add_library(FGTinyGLTF INTERFACE)
-
-target_include_directories(FGTinyGLTF
-  INTERFACE
-  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-  $<INSTALL_INTERFACE:include>)
-
-# in the non-shared case, we need to export these as well
-if (NOT SIMGEAR_SHARED)
-  install(TARGETS FGTinyGLTF
-    EXPORT SimGearTargets
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-endif()
--- a/3rdparty/tiny_gltf/json.hpp
+++ b/3rdparty/tiny_gltf/json.hpp
--- a/3rdparty/tiny_gltf/tiny_gltf.h
+++ b/3rdparty/tiny_gltf/tiny_gltf.h
--- a/3rdparty/udns/CMakeLists.txt
+++ b/3rdparty/udns/CMakeLists.txt
@@ -1,57 +0,0 @@
-include (SimGearComponent)
-INCLUDE (CheckFunctionExists)
-INCLUDE (CheckSymbolExists) 
-include (CheckIncludeFile)
-
-
-CHECK_FUNCTION_EXISTS(poll HAVE_POLL)
-CHECK_FUNCTION_EXISTS(getopt HAVE_GETOPT)
-CHECK_FUNCTION_EXISTS(inet_ntop HAVE_INET_PTON_NTOP)
-CHECK_SYMBOL_EXISTS(AF_INET6 "netinet/in.h" HAVE_IPv6) 
-# WINDOWS should be defined by msvc, should it?
-# somehow it is not, if somebody know a better way to define WINDOWS, please fix
-check_include_file(windows.h  WINDOWS)
-
-CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/config.h.in ${CMAKE_BINARY_DIR}/config.h)
-
-set(HEADERS
-)
-
-set(SOURCES
-    udns_resolver.c
-    udns_dn.c
-    udns_dntosp.c
-    udns_parse.c
-    udns_resolver.c
-    udns_init.c
-    udns_misc.c
-    udns_rr_a.c
-    udns_rr_ptr.c
-    udns_rr_mx.c
-    udns_rr_txt.c
-    udns_bl.c
-    udns_rr_srv.c
-    udns_rr_naptr.c
-    udns_codes.c
-    udns_jran.c
-    udns_XtoX.c
-)
-
-add_library(FGUdns STATIC ${SOURCES})
-
-target_include_directories(FGUdns BEFORE PUBLIC
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-    $<INSTALL_INTERFACE:include>)
-    
-target_include_directories(FGUdns PRIVATE ${CMAKE_BINARY_DIR})
-
-# match the name of imported UDns 
-add_librarY(Udns::Udns ALIAS FGUdns)
-
-# in the non-shared case, we need to export these as well
-if (NOT SIMGEAR_SHARED)
-    install(TARGETS FGUdns
-        EXPORT SimGearTargets
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-endif()
--- a/3rdparty/udns/COPYING.LGPL
+++ b/3rdparty/udns/COPYING.LGPL
@@ -1,502 +0,0 @@
-                  GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 2.1, February 1999
-
- Copyright (C) 1991, 1999 Free Software Foundation, Inc.
- 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-[This is the first released version of the Lesser GPL.  It also counts
- as the successor of the GNU Library Public License, version 2, hence
- the version number 2.1.]
-
-                            Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
-  This license, the Lesser General Public License, applies to some
-specially designated software packages--typically libraries--of the
-Free Software Foundation and other authors who decide to use it.  You
-can use it too, but we suggest you first think carefully about whether
-this license or the ordinary General Public License is the better
-strategy to use in any particular case, based on the explanations below.
-
-  When we speak of free software, we are referring to freedom of use,
-not price.  Our General Public Licenses are designed to make sure that
-you have the freedom to distribute copies of free software (and charge
-for this service if you wish); that you receive source code or can get
-it if you want it; that you can change the software and use pieces of
-it in new free programs; and that you are informed that you can do
-these things.
-
-  To protect your rights, we need to make restrictions that forbid
-distributors to deny you these rights or to ask you to surrender these
-rights.  These restrictions translate to certain responsibilities for
-you if you distribute copies of the library or if you modify it.
-
-  For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you.  You must make sure that they, too, receive or can get the source
-code.  If you link other code with the library, you must provide
-complete object files to the recipients, so that they can relink them
-with the library after making changes to the library and recompiling
-it.  And you must show them these terms so they know their rights.
-
-  We protect your rights with a two-step method: (1) we copyright the
-library, and (2) we offer you this license, which gives you legal
-permission to copy, distribute and/or modify the library.
-
-  To protect each distributor, we want to make it very clear that
-there is no warranty for the free library.  Also, if the library is
-modified by someone else and passed on, the recipients should know
-that what they have is not the original version, so that the original
-author's reputation will not be affected by problems that might be
-introduced by others.
-
-  Finally, software patents pose a constant threat to the existence of
-any free program.  We wish to make sure that a company cannot
-effectively restrict the users of a free program by obtaining a
-restrictive license from a patent holder.  Therefore, we insist that
-any patent license obtained for a version of the library must be
-consistent with the full freedom of use specified in this license.
-
-  Most GNU software, including some libraries, is covered by the
-ordinary GNU General Public License.  This license, the GNU Lesser
-General Public License, applies to certain designated libraries, and
-is quite different from the ordinary General Public License.  We use
-this license for certain libraries in order to permit linking those
-libraries into non-free programs.
-
-  When a program is linked with a library, whether statically or using
-a shared library, the combination of the two is legally speaking a
-combined work, a derivative of the original library.  The ordinary
-General Public License therefore permits such linking only if the
-entire combination fits its criteria of freedom.  The Lesser General
-Public License permits more lax criteria for linking other code with
-the library.
-
-  We call this license the "Lesser" General Public License because it
-does Less to protect the user's freedom than the ordinary General
-Public License.  It also provides other free software developers Less
-of an advantage over competing non-free programs.  These disadvantages
-are the reason we use the ordinary General Public License for many
-libraries.  However, the Lesser license provides advantages in certain
-special circumstances.
-
-  For example, on rare occasions, there may be a special need to
-encourage the widest possible use of a certain library, so that it becomes
-a de-facto standard.  To achieve this, non-free programs must be
-allowed to use the library.  A more frequent case is that a free
-library does the same job as widely used non-free libraries.  In this
-case, there is little to gain by limiting the free library to free
-software only, so we use the Lesser General Public License.
-
-  In other cases, permission to use a particular library in non-free
-programs enables a greater number of people to use a large body of
-free software.  For example, permission to use the GNU C Library in
-non-free programs enables many more people to use the whole GNU
-operating system, as well as its variant, the GNU/Linux operating
-system.
-
-  Although the Lesser General Public License is Less protective of the
-users' freedom, it does ensure that the user of a program that is
-linked with the Library has the freedom and the wherewithal to run
-that program using a modified version of the Library.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.  Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library".  The
-former contains code derived from the library, whereas the latter must
-be combined with the library in order to run.
-
-                  GNU LESSER GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License Agreement applies to any software library or other
-program which contains a notice placed by the copyright holder or
-other authorized party saying it may be distributed under the terms of
-this Lesser General Public License (also called "this License").
-Each licensee is addressed as "you".
-
-  A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
-  The "Library", below, refers to any such software library or work
-which has been distributed under these terms.  A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language.  (Hereinafter, translation is
-included without limitation in the term "modification".)
-
-  "Source code" for a work means the preferred form of the work for
-making modifications to it.  For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control compilation
-and installation of the library.
-
-  Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it).  Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-
-  1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
-  You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-
-  2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) The modified work must itself be a software library.
-
-    b) You must cause the files modified to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    c) You must cause the whole of the work to be licensed at no
-    charge to all third parties under the terms of this License.
-
-    d) If a facility in the modified Library refers to a function or a
-    table of data to be supplied by an application program that uses
-    the facility, other than as an argument passed when the facility
-    is invoked, then you must make a good faith effort to ensure that,
-    in the event an application does not supply such function or
-    table, the facility still operates, and performs whatever part of
-    its purpose remains meaningful.
-
-    (For example, a function in a library to compute square roots has
-    a purpose that is entirely well-defined independent of the
-    application.  Therefore, Subsection 2d requires that any
-    application-supplied function or table used by this function must
-    be optional: if the application does not supply it, the square
-    root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library.  To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License.  (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.)  Do not make any other change in
-these notices.
-
-  Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
-  This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
-  4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
-  If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library".  Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
-  However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library".  The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
-  When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library.  The
-threshold for this to be true is not precisely defined by law.
-
-  If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work.  (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
-  Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-
-  6. As an exception to the Sections above, you may also combine or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
-  You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License.  You must supply a copy of this License.  If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License.  Also, you must do one
-of these things:
-
-    a) Accompany the work with the complete corresponding
-    machine-readable source code for the Library including whatever
-    changes were used in the work (which must be distributed under
-    Sections 1 and 2 above); and, if the work is an executable linked
-    with the Library, with the complete machine-readable "work that
-    uses the Library", as object code and/or source code, so that the
-    user can modify the Library and then relink to produce a modified
-    executable containing the modified Library.  (It is understood
-    that the user who changes the contents of definitions files in the
-    Library will not necessarily be able to recompile the application
-    to use the modified definitions.)
-
-    b) Use a suitable shared library mechanism for linking with the
-    Library.  A suitable mechanism is one that (1) uses at run time a
-    copy of the library already present on the user's computer system,
-    rather than copying library functions into the executable, and (2)
-    will operate properly with a modified version of the library, if
-    the user installs one, as long as the modified version is
-    interface-compatible with the version that the work was made with.
-
-    c) Accompany the work with a written offer, valid for at
-    least three years, to give the same user the materials
-    specified in Subsection 6a, above, for a charge no more
-    than the cost of performing this distribution.
-
-    d) If distribution of the work is made by offering access to copy
-    from a designated place, offer equivalent access to copy the above
-    specified materials from the same place.
-
-    e) Verify that the user has already received a copy of these
-    materials or that you have already sent this user a copy.
-
-  For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it.  However, as a special exception,
-the materials to be distributed need not include anything that is
-normally distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
-  It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system.  Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-
-  7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
-    a) Accompany the combined library with a copy of the same work
-    based on the Library, uncombined with any other library
-    facilities.  This must be distributed under the terms of the
-    Sections above.
-
-    b) Give prominent notice with the combined library of the fact
-    that part of it is a work based on the Library, and explaining
-    where to find the accompanying uncombined form of the same work.
-
-  8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License.  Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License.  However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
-  9. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Library or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
-  10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties with
-this License.
-
-  11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License may add
-an explicit geographical distribution limitation excluding those countries,
-so that distribution is permitted only in or among countries not thus
-excluded.  In such case, this License incorporates the limitation as if
-written in the body of this License.
-
-  13. The Free Software Foundation may publish revised and/or new
-versions of the Lesser General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation.  If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-
-  14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission.  For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this.  Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
-                            NO WARRANTY
-
-  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
-                     END OF TERMS AND CONDITIONS
-
-           How to Apply These Terms to Your New Libraries
-
-  If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change.  You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms of the
-ordinary General Public License).
-
-  To apply these terms, attach the following notices to the library.  It is
-safest to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least the
-"copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the library's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the library, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the
-  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
-
-  <signature of Ty Coon>, 1 April 1990
-  Ty Coon, President of Vice
-
-That's all there is to it!
--- a/3rdparty/udns/Makefile.in
+++ b/3rdparty/udns/Makefile.in
@@ -1,197 +0,0 @@
-#! /usr/bin/make -rf
-# Makefile.in
-# libudns Makefile
-#
-# Copyright (C) 2005  Michael Tokarev <mjt@corpit.ru>
-# This file is part of UDNS library, an async DNS stub resolver.
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library, in file named COPYING.LGPL; if not,
-# write to the Free Software Foundation, Inc., 59 Temple Place,
-# Suite 330, Boston, MA  02111-1307  USA
-
-NAME   = udns
-VERS   = 0.4
-SOVER  = 0
-
-SRCS   = udns_dn.c udns_dntosp.c udns_parse.c udns_resolver.c udns_init.c \
-	udns_misc.c udns_XtoX.c \
-	udns_rr_a.c udns_rr_ptr.c udns_rr_mx.c udns_rr_txt.c udns_bl.c \
-	udns_rr_srv.c udns_rr_naptr.c udns_codes.c udns_jran.c
-USRCS  = dnsget.c rblcheck.c ex-rdns.c
-DIST   = COPYING.LGPL udns.h udns.3 dnsget.1 rblcheck.1 $(SRCS) $(USRCS) \
-	 NEWS TODO NOTES Makefile.in configure configure.lib \
-	 inet_XtoX.c getopt.c
-
-OBJS   = $(SRCS:.c=.o) $(GEN:.c=.o)
-LIB    = lib$(NAME).a
-LIBFL  = -L. -l$(NAME)
-
-SOBJS  = $(OBJS:.o=.lo)
-SOLIB  = lib$(NAME)_s.so
-SOLIBV = lib$(NAME).so.$(SOVER)
-SOLIBFL= -L. -l$(NAME)_s
-
-UTILS   = $(USRCS:.c=)
-UOBJS   = $(USRCS:.c=.o)
-SOUTILS = $(USRCS:.c=_s)
-
-NAMEPFX = $(NAME)-$(VERS)
-
-CC = @CC@
-CFLAGS = @CFLAGS@
-CDEFS = @CDEFS@
-LD = @LD@
-LDFLAGS = @LDFLAGS@
-LIBS = @LIBS@
-LDSHARED = $(LD) -shared
-PICFLAGS = -fPIC
-AWK = awk
-TAR = tar
-
-all: static
-
-.SUFFIXES: .c .o .lo
-
-static: $(LIB) $(UTILS)
-staticlib: $(LIB)
-$(LIB): $(OBJS)
-	-rm -f $@
-	$(AR) rv $@ $(OBJS)
-.c.o:
-	$(CC) $(CFLAGS) $(CDEFS) -c $<
-
-shared: $(SOLIBV) $(SOUTILS)
-sharedlib: $(SOLIBV)
-
-$(SOLIBV): $(SOBJS)
-	$(LDSHARED) -Wl,--soname,$(SOLIBV) -o $@ $(SOBJS) $(LDFLAGS) $(LIBS)
-$(SOLIB): $(SOLIBV)
-	rm -f $@
-	ln -s $(SOLIBV) $@
-.c.lo:
-	$(CC) $(CFLAGS) $(PICFLAGS) $(CDEFS) -o $@ -c $<
-
-# udns_codes.c is generated from udns.h
-udns_codes.c: udns.h
-	@echo Generating $@
-	@set -e; exec >$@.tmp; \
-	set T type C class R rcode; \
-	echo "/* Automatically generated. */"; \
-	echo "#include \"udns.h\""; \
-	while [ "$$1" ]; do \
-	 echo; \
-	 echo "const struct dns_nameval dns_$${2}tab[] = {"; \
-	 $(AWK) "/^  DNS_$${1}_[A-Z0-9_]+[ 	]*=/ \
-	  { printf \" {%s,\\\"%s\\\"},\\n\", \$$1, substr(\$$1,7) }" \
-	  udns.h ; \
-	 echo " {0,0}};"; \
-	 echo "const char *dns_$${2}name(enum dns_$${2} code) {"; \
-	 echo " static char nm[20];"; \
-	 echo " switch(code) {"; \
-	 $(AWK) "BEGIN{i=0} \
-	   /^  DNS_$${1}_[A-Z0-9_]+[ 	]*=/ \
-	   {printf \" case %s: return dns_$${2}tab[%d].name;\\n\",\$$1,i++}\
-	   " udns.h ; \
-	 echo " }"; \
-	 echo " return _dns_format_code(nm,\"$$2\",code);"; \
-	 echo "}"; \
-	 shift 2; \
-	done
-	@mv $@.tmp $@
-
-udns.3.html: udns.3
-	groff -man -Thtml udns.3 > $@.tmp
-	mv $@.tmp $@
-
-dist: $(NAMEPFX).tar.gz
-$(NAMEPFX).tar.gz: $(DIST)
-	$(TAR) -cv -f $@ -z --transform 's|^|$(NAMEPFX)/|' $(DIST)
-
-subdist:
-	cp -p $(DIST) $(TARGET)/
-
-clean:
-	rm -f $(OBJS)
-	rm -f $(SOBJS)
-	rm -f $(UOBJS)
-	rm -f config.log
-distclean: clean
-	rm -f $(LIB) $(SOLIB) $(SOLIBV) udns.3.html
-	rm -f $(UTILS) $(SOUTILS)
-	rm -f config.status config.h Makefile
-
-
-Makefile: configure configure.lib Makefile.in
-	./configure
-	@echo
-	@echo Please rerun make >&2
-	@exit 1
-
-.PHONY: all static staticlib shared sharedlib dist clean distclean subdist \
-  depend dep deps
-
-depend dep deps: $(SRCS) $(USRC)
-	@echo Generating deps for:
-	@echo \ $(SRCS)
-	@echo \ $(USRCS)
-	@sed '/^# depend/q' Makefile.in > Makefile.tmp
-	@set -e; \
-	for f in $(SRCS) $(USRCS); do \
-	 echo $${f%.c}.o $${f%.c}.lo: $$f \
-	  `sed -n 's/^#[ 	]*include[ 	]*"\(.*\)".*/\1/p' $$f`; \
-	done >> Makefile.tmp; \
-	for f in $(USRCS:.c=.o); do \
-	 echo "$${f%.?}: $$f \$$(LIB)"; \
-	 echo "	\$$(LD) \$$(LDLAGS) -o \$$@ $$f \$$(LIBFL) \$$(LIBS)"; \
-	 echo "$${f%.?}_s: $$f \$$(SOLIB)"; \
-	 echo "	\$$(LD) \$$(LDFLAGS) -o \$$@ $$f \$$(SOLIBFL)"; \
-	done >> Makefile.tmp ; \
-	if cmp Makefile.tmp Makefile.in >/dev/null 2>&1 ; then \
-	 echo Makefile.in unchanged; rm -f Makefile.tmp; \
-	else \
-	 echo Updating Makfile.in; mv -f Makefile.tmp Makefile.in ; \
-	fi
-
-# depend
-udns_dn.o udns_dn.lo: udns_dn.c udns.h
-udns_dntosp.o udns_dntosp.lo: udns_dntosp.c udns.h
-udns_parse.o udns_parse.lo: udns_parse.c udns.h
-udns_resolver.o udns_resolver.lo: udns_resolver.c config.h udns.h
-udns_init.o udns_init.lo: udns_init.c config.h udns.h
-udns_misc.o udns_misc.lo: udns_misc.c udns.h
-udns_XtoX.o udns_XtoX.lo: udns_XtoX.c config.h udns.h inet_XtoX.c
-udns_rr_a.o udns_rr_a.lo: udns_rr_a.c udns.h
-udns_rr_ptr.o udns_rr_ptr.lo: udns_rr_ptr.c udns.h
-udns_rr_mx.o udns_rr_mx.lo: udns_rr_mx.c udns.h
-udns_rr_txt.o udns_rr_txt.lo: udns_rr_txt.c udns.h
-udns_bl.o udns_bl.lo: udns_bl.c udns.h
-udns_rr_srv.o udns_rr_srv.lo: udns_rr_srv.c udns.h
-udns_rr_naptr.o udns_rr_naptr.lo: udns_rr_naptr.c udns.h
-udns_codes.o udns_codes.lo: udns_codes.c udns.h
-udns_jran.o udns_jran.lo: udns_jran.c udns.h
-dnsget.o dnsget.lo: dnsget.c config.h udns.h getopt.c
-rblcheck.o rblcheck.lo: rblcheck.c config.h udns.h getopt.c
-ex-rdns.o ex-rdns.lo: ex-rdns.c udns.h
-dnsget: dnsget.o $(LIB)
-	$(LD) $(LDLAGS) -o $@ dnsget.o $(LIBFL) $(LIBS)
-dnsget_s: dnsget.o $(SOLIB)
-	$(LD) $(LDFLAGS) -o $@ dnsget.o $(SOLIBFL)
-rblcheck: rblcheck.o $(LIB)
-	$(LD) $(LDLAGS) -o $@ rblcheck.o $(LIBFL) $(LIBS)
-rblcheck_s: rblcheck.o $(SOLIB)
-	$(LD) $(LDFLAGS) -o $@ rblcheck.o $(SOLIBFL)
-ex-rdns: ex-rdns.o $(LIB)
-	$(LD) $(LDLAGS) -o $@ ex-rdns.o $(LIBFL) $(LIBS)
-ex-rdns_s: ex-rdns.o $(SOLIB)
-	$(LD) $(LDFLAGS) -o $@ ex-rdns.o $(SOLIBFL)
--- a/3rdparty/udns/NEWS
+++ b/3rdparty/udns/NEWS
@@ -1,136 +0,0 @@
-NEWS
-User-visible changes in udns library.  Recent changes on top.
-
-0.4 (Jan 2014)
-
- - bugfix: fix a bug in new list code introduced in 0.3
- - portability: use $(LD)/$(LDFLAGS)/$(LIBS)
-
-0.3 (Jan 2014)
-
- - bugfix: refactor double-linked list implementation in udns_resolver.c
-   (internal to the library) to be more strict-aliasing-friendly, because
-   old code were miscompiled by gcc.
-
- - bugfix: forgotten strdup() in rblcheck
-
-0.2 (Dec 2011)
-
- - bugfix: SRV RR handling: fix domain name parsing and crash in case
-   if no port is specified on input for SRV record query
-
- - (trivial api) dns_set_opts() now returns number of unrecognized 
-   options instead of always returning 0
-
- - dnsget: combine -f and -o options in dnsget (and stop documenting -f),
-   and report unknown/invalid -o options (and error out)
-
- - dnsget: pretty-print SSHFP RRs
-
- 0.1 (Dec 2010)
-
- - bugfix: udns_new(old) - when actually cloning another context -
-   makes the new context referencing memory from old, which leads
-   to crashes when old is modified later
-
- - use random queue IDs (the 16bit qID) in queries instead of sequentional
-   ones, based on simple pseudo-random RNG by Bob Jenkins (udns_jran.[ch]).
-   Some people believe that this improves security (CVE-2008-1447).  I'm
-   still not convinced (see comments in udns_resolver.c), but it isn't
-   difficult to add after all.
-
- - deprecate dns_random16() function which was declared in udns.h
-   (not anymore) but never documented.  In order to keep ABI compatible
-   it is still exported.
-
- - library has a way now to set query flags (DNS_SET_DO; DNS_SET_CD).
-
- - dnsget now prints non-printable chars in all strings in DNS RRs using
-   decimal escape sequences (\%03u) instead of hexadecimal (\%02x) when
-   before - other DNS software does it like this.
-
- - recognize a few more record types in dnsget, notable some DNSSEC RRs;
-   add -f option for dnsget to set query flags.
-
- - udns is not a Debian native package anymore (was a wrong idea)
-
-0.0.9 (16 Jan 2007)
-
- - incompat: minor API changes in dns_init() &friends.  dns_init()
-   now requires extra `struct dns_ctx *' argument.  Not bumped
-   soversion yet - I only expect one "release" with this change.
-
- - many small bugfixes, here and there
-
- - more robust FORMERR replies handling - not only such replies are now
-   recognized, but udns retries queries without EDNS0 extensions if tried
-   with, but server reported FORMERR
-
- - portability changes, udns now includes getopt() implementation fo
-   the systems lacking it (mostly windows), and dns_ntop()&dns_pton(),
-   which are either just wrappers for system functions or reimplementations.
-
- - build is now based on autoconf-like configuration
-
- - NAPTR (RFC3403) RR decoding support
-
- - new file NOTES which complements TODO somewhat, and includes some
-   important shortcomings
-
- - many internal cleanups, including some preparations for better error
-   recovery, security and robustness (and thus API changes)
-
- - removed some #defines which are now unused (like DNS_MAXSRCH)
-
- - changed WIN32 to WINDOWS everywhere in preprocessor tests,
-   to be able to build it on win64 as well
-
-0.0.8 (12 Sep 2005)
-
- - added SRV records (rfc2782) parsing,
-   thanks to Thadeu Lima de Souza Cascardo for implementation.
-
- - bugfixes:
-   o use uninitialized value when no reply, library died with assertion:
-     assert((status < 0 && result == 0) || (status >= 0 && result != 0)).
-   o on some OSes, struct sockaddr_in has additional fields, so
-     memcmp'ing two sockaddresses does not work.
-
- - rblcheck(.1)
-
-0.0.7 (20 Apr 2005)
-
- - dnsget.1 manpage and several enhancements to dnsget.
-
- - allow nameserver names for -n option of dnsget.
-
- - API change: all dns_submit*() routines now does not expect
-   last `now' argument, since requests aren't sent immediately
-   anymore.
-
- - API change: different application timer callback mechanism.
-   Udns now uses single per-context timer instead of per-query.
-
- - don't assume DNS replies only contain backward DN pointers,
-   allow forward pointers too.  Change parsing API.
-
- - debianize
-
-0.0.6 (08 Apr 2005)
-
- - use double sorted list for requests (sorted by deadline).
-   This should significantly speed up timeout processing for
-   large number of requests.
-
- - changed debugging interface, so it is finally useable
-   (still not documented).
-
- - dnsget routine is now Officially Useable, and sometimes
-   even more useable than `host' from BIND distribution
-   (and sometimes not - dnsget does not have -C option
-   and TCP mode)
-
- - Debian packaging in debian/ -- udns is now maintained as a
-   native Debian package.
-
- - alot (and I really mean alot) of code cleanups all over.
--- a/3rdparty/udns/NOTES
+++ b/3rdparty/udns/NOTES
@@ -1,226 +0,0 @@
-Assorted notes about udns (library).
-
-UDP-only mode
-~~~~~~~~~~~~~
-
-First of all, since udns is (currently) UDP-only, there are some
-shortcomings.
-
-It assumes that a reply will fit into a UDP buffer.  With adoption of EDNS0,
-and general robustness of IP stacks, in most cases it's not an issue.  But
-in some cases there may be problems:
-
- - if an RRset is "very large" so it does not fit even in buffer of size
-   requested by the library (current default is 4096; some servers limits
-   it further), we will not see the reply, or will only see "damaged"
-   reply (depending on the server).
-
- - many DNS servers ignores EDNS0 option requests.  In this case, no matter
-   which buffer size udns library will request, such servers reply is limited
-   to 512 bytes (standard pre-EDNS0 DNS packet size).  (Udns falls back to
-   non-EDNO0 query if EDNS0-enabled one received FORMERR or NOTIMPL error).
-
-The problem is that with this, udns currently will not consider replies with
-TC (truncation) bit set, and will treat such replies the same way as it
-treats SERVFAIL replies, thus trying next server, or temp-failing the query
-if no more servers to try.  In other words, if the reply is really large, or
-if the servers you're using don't support EDNS0, your application will be
-unable to resolve a given name.
-
-Yet it's not common situation - in practice, it's very rare.
-
-Implementing TCP mode isn't difficult, but it complicates API significantly.
-Currently udns uses only single UDP socket (or - maybe in the future - two,
-see below), but in case of TCP, it will need to open and close sockets for
-TCP connections left and right, and that have to be integrated into an
-application's event loop in an easy and efficient way.  Plus all the
-timeouts - different for connect(), write, and several stages of read.
-
-IPv6 vs IPv4 usage
-~~~~~~~~~~~~~~~~~~
-
-This is only relevant for nameservers reachable over IPv6, NOT for IPv6
-queries.  I.e., if you've IPv6 addresses in 'nameservers' line in your
-/etc/resolv.conf file.  Even more: if you have BOTH IPv6 AND IPv4 addresses
-there.  Or pass them to udns initialization routines.
-
-Since udns uses a single UDP socket to communicate with all nameservers,
-it should support both v4 and v6 communications.  Most current platforms
-supports this mode - using PF_INET6 socket and V4MAPPED addresses, i.e,
-"tunnelling" IPv4 inside IPv6.  But not all systems supports this.  And
-more, it has been said that such mode is deprecated.
-
-So, list only IPv4 or only IPv6 addresses, but don't mix them, in your
-/etc/resolv.conf.
-
-An alternative is to use two sockets instead of 1 - one for IPv6 and one
-for IPv4.  For now I'm not sure if it's worth the complexity - again, of
-the API, not the library itself (but this will not simplify library either).
-
-Single socket for all queries
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Using single UDP socket for sending queries to all nameservers has obvious
-advantages.  First it's, again, trivial, simple to use API.  And simple
-library too.  Also, after sending queries to all nameservers (in case first
-didn't reply in time), we will be able to receive late reply from first
-nameserver and accept it.
-
-But this mode has disadvantages too.  Most important is that it's much easier
-to send fake reply to us, as the UDP port where we expects the reply to come
-to is constant during the whole lifetime of an application.  More secure
-implementations uses random port for every single query.  While port number
-(16 bits integer) can not hold much randomness, it's still of some help.
-Ok, udns is a stub resolver, so it expects sorta friendly environment, but
-on LAN it's usually much easier to fire an attack, due to the speed of local
-network, where a bad guy can generate alot of packets in a short time.
-
-Spoofing of replies (Kaminsky attack, CVE-2008-1447)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-While udns uses random numbers for query IDs, it uses single UDP port for
-all queries (see previous item).  And even if it used random UDP port for
-each query, the attack described in CVE-2008-1447 is still quite trivial.
-This is not specific to udns library unfortunately - it is inherent property
-of the protocol.  Udns is designed to work in a LAN, it needs full recursive
-resolver nearby, and modern LAN usually uses high-bandwidth equipment which
-makes the Kaminsky attack trivial.  The problem is that even with qID (16
-bits) and random UDP port (about 20 bits available to a regular process)
-combined still can not hold enough randomness, so on a fast network it is
-still easy to flood the target with fake replies and hit the "right" reply
-before real reply comes.  So random qIDs don't add much protection anyway,
-even if this feature is implemented in udns, and using all available
-techniques wont solve it either.
-
-See also long comment in udns_resolver.c, udns_newid().
-
-Assumptions about RRs returned
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Currently udns processes records in the reply it received sequentially.
-This means that order of the records is significant.  For example, if
-we asked for foo.bar A, but the server returned that foo.bar is a CNAME
-(alias) for bar.baz, and bar.baz, in turn, has address 1.2.3.4, when
-the CNAME should come first in reply, followed by A.  While DNS specs
-does not say anything about order of records - it's an rrSET - unordered, -
-I think an implementation which returns the records in "wrong" order is
-somewhat insane...
-
-CNAME recursion
-~~~~~~~~~~~~~~~
-
-Another interesting point is the handling of CNAMEs returned as replies
-to non-CNAME queries.  If we asked for foo.bar A, but it's a CNAME, udns
-expects BOTH the CNAME itself and the target DN to be present in the reply.
-In other words, udns DOES NOT RECURSE CNAMES.  If we asked for foo.bar A,
-but only record in reply was that foo.bar is a CNAME for bar.baz, udns will
-return no records to an application (NXDOMAIN).  Strictly speaking, udns
-should repeat the query asking for bar.baz A, and recurse.  But since it's
-stub resolver, recursive resolver should recurse for us instead.
-
-It's not very difficult to implement, however.  Probably with some (global?)
-flag to en/dis-able the feature.  Provided there's some demand for it.
-
-To clarify: udns handles CNAME recursion in a single reply packet just fine.
-
-Note also that standard gethostbyname() routine does not recurse in this
-situation, too.
-
-Error reporting
-~~~~~~~~~~~~~~~
-
-Too many places in the code (various failure paths) sets generic "TEMPFAIL"
-error condition.  For example, if no nameserver replied to our query, an
-application will get generic TEMPFAIL, instead of something like TIMEDOUT.
-This probably should be fixed, but most applications don't care about the
-exact reasons of failure - 4 common cases are already too much:
-  - query returned some valid data
-  - NXDOMAIN
-  - valid domain but no data of requested type - =NXDOMAIN in most cases
-  - temporary error - this one sometimes (incorrectly!) treated as NXDOMAIN
-    by (naive) applications.
-DNS isn't yes/no, it's at least 3 variants, temp err being the 3rd important
-case!  And adding more variations for the temp error case is complicating things
-even more - again, from an application writer standpoint.  For diagnostics,
-such more specific error cases are of good help.
-
-Planned API changes
-~~~~~~~~~~~~~~~~~~~
-
-At least one thing I want to change for some future version is a way how
-queries are submitted and how replies are handled.
-
-I want to made dns_query object to be owned by an application.  So that instead
-of udns library allocating it for the lifetime of query, it will be pre-
-allocated by an application.  This simplifies and enhances query submitting
-interface, and complicates it a bit too, in simplest cases.
-
-Currently, we have:
-
-dns_submit_dn(dn, cls, typ, flags, parse, cbck, data)
-dns_submit_p(name, cls, typ, flags, parse, cbck, data)
-dns_submit_a4(ctx, name, flags, cbck, data)
-
-and so on -- with many parameters missed for type-specific cases, but generic
-cases being too complex for most common usage.
-
-Instead, with dns_query being owned by an app, we will be able to separately
-set up various parts of the query - domain name (various forms), type&class,
-parser, flags, callback...  and even change them at runtime.  And we will also
-be able to reuse query structures, instead of allocating/freeing them every
-time.  So the whole thing will look something like:
-
- q = dns_alloc_query();
- dns_submit(dns_q_flags(dns_q_a4(q, name, cbck), DNS_F_NOSRCH), data);
-
-The idea is to have a set of functions accepting struct dns_query* and
-returning it (so the calls can be "nested" like the above), to set up
-relevant parts of the query - specific type of callback, conversion from
-(type-specific) query parameters into a domain name (this is for type-
-specific query initializers), and setting various flags and options and
-type&class things.
-
-One example where this is almost essential - if we want to support
-per-query set of nameservers (which isn't at all useless: imagine a
-high-volume mail server, were we want to direct DNSBL queries to a separate
-set of nameservers, and rDNS queries to their own set and so on).  Adding
-another argument (set of nameservers to use) to EVERY query submitting
-routine is.. insane.  Especially since in 99% cases it will be set to
-default NULL.  But with such "nesting" of query initializers, it becomes
-trivial.
-
-This change (the way how queries gets submitted) will NOT break API/ABI
-compatibility with old versions, since the new submitting API works in
-parallel with current (and current will use the new one as building
-blocks, instead of doing all work at once).
-
-Another way to do the same is to manipulate query object right after a
-query has been submitted, but before any events processing (during this
-time, query object is allocated and initialized, but no actual network
-packets were sent - it will happen on the next event processing).  But
-this way it become impossible to perform syncronous resolver calls, since
-those calls hide query objects they use internally.
-
-Speaking of replies handling - the planned change is to stop using dynamic
-memory (malloc) inside the library.  That is, instead of allocating a buffer
-for a reply dynamically in a parsing routine (or memdup'ing the raw reply
-packet if no parsing routine is specified), I want udns to return the packet
-buffer it uses internally, and change parsing routines to expect a buffer
-for result.  When parsing, a routine will return true amount of memory it
-will need to place the result, regardless of whenever it has enough room
-or not, so that an application can (re)allocate properly sized buffer and
-call a parsing routine again.
-
-This, in theory, also can be done without breaking current API/ABI, but in
-that case we'll again need a parallel set of routines (parsing included),
-which makes the library more complicated with too many ways of doing the
-same thing.  Still, code reuse is at good level.
-
-Another modification I plan to include is to have an ability to work in
-terms of domain names (DNs) as used with on-wire DNS packets, not only
-with asciiz representations of them.  For this to work, the above two
-changes (query submission and result passing) have to be completed first
-(esp. the query submission part), so that it will be possible to specify
-some additional query flags (for example) to request domain names instead
-of the text strings, and to allow easy query submissions with either DNs
-or text strings.
--- a/3rdparty/udns/TODO
+++ b/3rdparty/udns/TODO
@@ -1,59 +0,0 @@
-TODO
-
-The following is mostly an internal, not user-visible stuff.
-
-* rearrange an API to make dns_query object owned by application,
-  so that it'll look like this:
-   struct dns_query *q;
-   q = dns_query_alloc(ctx);
-   dns_query_set(q, options, domain_name, flags, ...);
-   dns_query_submit(ctx, q);
-  For more information see NOTES file, section "Planned API changes".
-
-* allow NULL callbacks?  Or provide separate resolver
-  context list of queries which are done but wich did not
-  have callback, and dns_pick() routine to retrieve results
-  from this query, i.e. allow non-callback usage?  The
-  non-callback usage may be handy sometimes (any *good*
-  example?), but it will be difficult to provide type-safe
-  non-callback interface due to various RR-specific types
-  in use.
-
-* DNS_OPT_FLAGS should be DNS_OPT_ADDFLAGS and DNS_OPT_SETFLAGS.
-  Currently one can't add a single flag bit but preserve
-  existing bits... at least not without retrieving all current
-  flags before, which isn't that bad anyway.
-
-* dns_set_opts() may process flags too (such as aaonly etc)
-
-* a way to disable $NSCACHEIP et al processing?
-  (with now separate dns_init() and dns_reset(), it has finer
-  control, but still no way to init from system files but ignore
-  environment variables and the like)
-
-* initialize/open the context automatically, and be more
-  liberal about initialization in general?
-
-* dns_init(ctx, do_open) - make the parameter opposite, aka
-  dns_init(ctx, skip_open) ?
-
-* allow TCP queue?
-
-* more accurate error reporting.  Currently, udns always returns TEMPFAIL,
-  but don't specify why it happened (ENOMEM, timeout, etc).
-
-* check the error value returned by recvfrom() and
-  sendto() and determine which errors to ignore.
-
-* maybe merge dns_timeouts() and dns_ioevent(), to have
-  only one entry point for everything?  For traditional
-  select-loop-based eventloop it may be easier, but for
-  callback-driven event loops the two should be separate.
-  Provide an option, or a single dns_events() entry point
-  for select-loop approach, or just call dns_ioevent()
-  from within dns_timeouts() (probably after renaming
-  it to be dns_events()) ?
-
-* implement /etc/hosts lookup too, ala [c-]ares??
-
-* sortlist support?
--- a/3rdparty/udns/config.h.in
+++ b/3rdparty/udns/config.h.in
@@ -1,5 +0,0 @@
-#cmakedefine HAVE_POLL
-#cmakedefine HAVE_GETOPT
-#cmakedefine HAVE_INET_PTON_NTOP
-#cmakedefine HAVE_IPv6
-#cmakedefine WINDOWS
--- a/3rdparty/udns/configure
+++ b/3rdparty/udns/configure
@@ -1,165 +0,0 @@
-#! /bin/sh
-# autoconf-style configuration script
-#
-
-set -e
-
-name=udns
-
-if [ -f udns.h -a -f udns_resolver.c ] ; then :
-else
-  echo "configure: error: sources not found at `pwd`" >&2
-  exit 1
-fi
-
-options="ipv6"
-
-for opt in $options; do
-  eval enable_$opt=
-done
-
-if [ -f config.status ]; then
-  . ./config.status
-fi
-
-enable() {
-  opt=`echo "$1" | sed 's/^--[^-]*-//'`
-  case "$opt" in
-    ipv6) ;;
-    *) echo "configure: unrecognized option \`$1'" >&2; exit 1;;
-  esac
-  eval enable_$opt=$2
-}
-
-while [ $# -gt 0 ]; do
-  case "$1" in
-    --disable-*|--without-*|--no-*) enable "$1" n;;
-    --enable-*|--with-*) enable "$1" y;;
-    --help | --hel | --he | --h | -help | -hel | -he | -h )
-      cat <<EOF
-configure: configure $name package.
-Usage: ./configure [options]
-where options are:
- --enable-option, --with-option --
-   enable the named option/feature
- --disable-option, --without-option, --no-option --
-   disable the named option/feature
- --help - print this help and exit
-Optional features (all enabled by default if system supports a feature):
-  ipv6 - enable/disable IP version 6 (IPv6) support
-EOF
-      exit 0
-      ;;
-    *) echo "configure: unknown option \`$1'" >&2; exit 1 ;;
-  esac
-  shift
-done
-
-. ./configure.lib
-
-ac_msg "configure"
-ac_result "$name package"
-
-ac_prog_c_compiler_v
-ac_prog_ranlib_v
-
-ac_ign ac_yesno "for getopt()" ac_have GETOPT ac_link <<EOF
-#include <stdio.h>
-extern int optind;
-extern char *optarg;
-extern int getopt(int, char **, char *);
-int main(int argc, char **argv) {
-  getopt(argc, argv, "abc");
-  return optarg ? optind : 0;
-}
-EOF
-
-if ac_library_find_v 'socket and connect' "" "-lsocket -lnsl" <<EOF
-int main() { socket(); connect(); return 0; }
-EOF
-then :
-else
-  ac_fatal "cannot find libraries needed for sockets"
-fi
-
-ac_ign \
- ac_yesno "for inet_pton() && inet_ntop()" \
- ac_have INET_PTON_NTOP \
- ac_link <<EOF
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <arpa/inet.h>
-int main() {
-  char buf[64];
-  long x = 0;
-  inet_pton(AF_INET, &x, buf);
-  return inet_ntop(AF_INET, &x, buf, sizeof(buf));
-} 
-EOF
-
-if ac_yesno "for socklen_t" ac_compile <<EOF
-#include <sys/types.h>
-#include <sys/socket.h>
-int foo() { socklen_t len; len = 0; return len; }
-EOF
-then :
-else
-  ac_define socklen_t int
-fi
-
-if [ n != "$enable_ipv6" ]; then
-if ac_yesno "for IPv6" ac_have IPv6 ac_compile <<EOF
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-int main() {
-  struct sockaddr_in6 sa;
-  sa.sin6_family = AF_INET6;
-  return 0;
-}
-EOF
-then :
-elif [ "$enable_ipv6" ]; then
-  ac_fatal "IPv6 is requested but not available"
-fi
-fi # !disable_ipv6?
-
-if ac_yesno "for poll()" ac_have POLL ac_link <<EOF
-#include <sys/types.h>
-#include <sys/poll.h>
-int main() {
-  struct pollfd pfd[2];
-  return poll(pfd, 2, 10);
-}
-EOF
-then :
-else
-  ac_ign ac_yesno "for sys/select.h" ac_have SYS_SELECT_H ac_cpp <<EOF
-#include <sys/types.h>
-#include <sys/select.h>
-EOF
-fi
-
-ac_config_h
-ac_output Makefile
-ac_msg "creating config.status"
-rm -f config.status
-{
-echo "# automatically generated by configure to hold command-line options"
-echo
-found=
-for opt in $options; do
-  eval val=\$enable_$opt
-  if [ -n "$val" ]; then
-    echo enable_$opt=$val
-    found=y
-  fi
-done
-if [ ! "$found" ]; then
-  echo "# (no options encountered)"
-fi
-} > config.status
-ac_result ok
-
-ac_result "all done."
-exit 0
--- a/3rdparty/udns/configure.lib
+++ b/3rdparty/udns/configure.lib
@@ -1,268 +0,0 @@
-# configure.lib
-# a library of shell routines for simple autoconf system
-#
-
-set -e
-ac_substitutes=
-rm -f conftest* config.log
-exec 5>config.log
-cat <<EOF >&5
-This file contains any messages produced by compilers etc while
-running configure, to aid debugging if configure script makes a mistake.
-
-EOF
-
-case `echo "a\c"` in
-  *c*) ac_en=-n ac_ec= ;;
-  *)   ac_en= ac_ec='\c' ;;
-esac
-
-##### Messages
-ac_msg() {
-  echo $ac_en "$*... $ac_ec"
-  echo ">>> $*" >&5
-}
-ac_checking() {
-  echo $ac_en "checking $*... $ac_ec"
-  echo ">>> checking $*" >&5
-}
-ac_result() {
-  echo "$1"
-  echo "=== $1" >&5
-}
-ac_fatal() {
-  echo "configure: fatal: $*" >&2
-  echo "=== FATAL: $*" >&5
-  exit 1
-}
-ac_warning() {
-  echo "configure: warning: $*" >&2
-  echo "=== WARNING: $*" >&5
-}
-ac_ign() {
-  "$@" || :
-}
-
-# ac_run command...
-# captures output in conftest.out
-ac_run() {
-  # apparently UnixWare (for one) /bin/sh optimizes the following "if"
-  # "away", by checking if there's such a command BEFORE redirecting
-  # output.  So error message (like "gcc: command not found") goes
-  # to stderr instead of to conftest.out, and `cat conftest.out' below
-  # fails.
-  if "$@" >conftest.out 2>&1; then
-    return 0
-  else
-    echo "==== Command invocation failed. Command line was:" >&5
-    echo "$*" >&5
-    echo "==== compiler input was:" >&5
-    cat conftest.c >&5
-    echo "==== output was:" >&5
-    cat conftest.out >&5
-    echo "====" >&5
-    return 1
-  fi
-}
-
-# common case for ac_verbose: yes/no result
-ac_yesno() {
-  ac_checking "$1"
-  shift
-  if "$@"; then
-    ac_result yes
-    return 0
-  else
-    ac_result no
-    return 1
-  fi
-}
-
-ac_subst() {
-  ac_substitutes="$ac_substitutes $*"
-}
-
-ac_define() {
-  CDEFS="$CDEFS -D$1=${2:-1}"
-}
-
-ac_have() {
-  ac_what=$1; shift
-  if "$@"; then
-    ac_define HAVE_$ac_what
-    eval ac_have_$ac_what=yes
-    return 0
-  else
-    eval ac_have_$ac_what=no
-    return 1
-  fi
-}
-
-##### Compiling, linking
-
-# run a compiler
-ac_run_compiler() {
-  rm -f conftest*; cat >conftest.c
-  ac_run $CC $CFLAGS $CDEFS "$@" conftest.c
-}
-
-ac_compile() {
-  ac_run_compiler -c
-}
-
-ac_link() {
-  ac_run_compiler -o conftest $LIBS "$@"
-}
-
-ac_cpp() {
-  ac_run_compiler -E "$@"
-}
-
-### check for C compiler.  Set $CC, $CFLAGS etc
-ac_prog_c_compiler_v() {
-  ac_checking "for C compiler"
-  rm -f conftest*
-  echo 'int main(int argc, char **argv) { return 0; }' >conftest.c
-
-  if [ -n "$CC" ]; then
-    if ac_run $CC -o conftest conftest.c && ac_run ./conftest; then
-      ac_result "\$CC ($CC)"
-    else
-      ac_result no
-      ac_fatal "\$CC ($CC) is not a working compiler"
-    fi
-  else
-    for cc in gcc cc ; do
-      if ac_run $cc -o conftest conftest.c && ac_run ./conftest; then
-        ac_result "$cc"
-        CC=$cc
-        break
-      fi
-    done
-    if [ -z "$CC" ]; then
-      ac_result no
-      ac_fatal "no working C compiler found in \$PATH. please set \$CC variable"
-    fi
-  fi
-  if [ -z "$CFLAGS" ]; then
-    if ac_yesno "whenever C compiler ($CC) is GNU CC" \
-        ac_grep_cpp yEs_mAsTeR <<EOF
-#ifdef __GNUC__
-  yEs_mAsTeR;
-#endif
-EOF
-    then
-      CFLAGS="-Wall -W -O2 -pipe"
-    else
-      CFLAGS=-O
-    fi
-  fi
-  cc="$CC $CFLAGS"
-  ccld="$cc"
-  if [ -n "$LDFLAGS" ]; then ccld="$ccld $LDFLAGS"; fi
-  if [ -n "$LIBS" ]; then ccld="$ccld $LIBS"; fi
-  if ac_yesno "whenever the C compiler ($ccld)
-           can produce executables" \
-     ac_compile_run <<EOF
-int main() { return 0; }
-EOF
-  then :
-  else
-    ac_fatal "no working C compiler found"
-  fi
-  LD='$(CC)'
-  [ -n "$AR" ] || AR=ar
-  [ -n "$ARFLAGS" ] || ARFLAGS=rv
-  [ -n "$AWK" ] || AWK=awk
-  ac_substitutes="$ac_substitutes CC CFLAGS CDEFS LD LDFLAGS LIBS AR ARFLAGS AWK"
-}
-
-
-ac_prog_ranlib_v() {
-  ac_checking "for ranlib"
-  if [ -n "$RANLIB" ]; then
-    ac_result "\$RANLIB ($RANLIB)"
-  else
-    ifs="$IFS"
-    IFS=:
-    for dir in $PATH; do
-      [ -n "$dir" ] || dir=.
-      if [ -f $dir/ranlib ]; then
-        RANLIB=ranlib
-        break
-      fi
-    done
-    IFS="$ifs"
-    if [ -z "$RANLIB" ]; then ac_result no; RANLIB=:
-    else ac_result "$RANLIB"
-    fi
-  fi
-  ac_substitutes="$ac_substitutes RANLIB"
-}
-
-ac_library_find_v() {
-  ac_checking "for libraries needed for $1"
-  shift
-  fond=
-  rm -f conftest*; cat >conftest.c
-  for lib in "$@"; do
-    if ac_run $CC $CFLAGS $LDFLAGS conftest.c -o conftest $LIBS $lib; then
-      found=y
-      break
-    fi
-  done
-  if [ ! "$found" ]; then
-    ac_result "not found"
-    return 1
-  fi
-  if [ -z "$lib" ]; then
-    ac_result "ok (none needed)"
-  else
-    ac_result "ok ($lib)"
-    LIBS="$LIBS $lib"
-  fi
-}
-
-ac_compile_run() {
-  ac_link "$@" && ac_run ./conftest
-}
-
-ac_grep_cpp() {
-  pattern="$1"; shift
-  ac_cpp "$@" && grep "$pattern" conftest.out >/dev/null
-}
-
-ac_output() {
-  for var in $ac_substitutes; do
-    eval echo "\"s|@$var@|\$$var|\""
-  done >conftest.sed
-  for file in "$@"; do
-    ac_msg "creating $file"
-    if [ -f $file.in ]; then
-      sed -f conftest.sed $file.in > $file.tmp
-      mv -f $file.tmp $file
-      ac_result ok
-    else
-      ac_result failed
-      ac_fatal "$file.in not found"
-    fi
-  done
-  rm -f conftest*
-}
-
-ac_config_h() {
-  h=${1:-config.h}
-  ac_msg "creating $h"
-  rm -f $1.tmp
-  echo "/* automatically generated by configure. */" > $h.tmp
-  echo "$CDEFS" | tr ' ' '
-' | sed -e 's/^-D/#define /' -e 's/=/ /' >> $h.tmp
-  if [ -f $h ] && cmp -s $h.tmp $h ; then
-    rm -f $h.tmp
-    ac_result unchanged
-  else
-    mv -f $h.tmp $h
-    ac_result ok
-  fi
-  CDEFS=-DHAVE_CONFIG_H
-}
--- a/3rdparty/udns/dnsget.1
+++ b/3rdparty/udns/dnsget.1
@@ -1,195 +0,0 @@
-.\" dnsget.1: dnsget manpage
-.\"
-.\" Copyright (C) 2005-2014  Michael Tokarev <mjt+udns@tls.msk.ru>
-.\" This file is part of UDNS library, an async DNS stub resolver.
-.\"
-.\" This library is free software; you can redistribute it and/or
-.\" modify it under the terms of the GNU Lesser General Public
-.\" License as published by the Free Software Foundation; either
-.\" version 2.1 of the License, or (at your option) any later version.
-.\"
-.\" This library is distributed in the hope that it will be useful,
-.\" but WITHOUT ANY WARRANTY; without even the implied warranty of
-.\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-.\" Lesser General Public License for more details.
-.\"
-.\" You should have received a copy of the GNU Lesser General Public
-.\" License along with this library, in file named COPYING.LGPL; if not,
-.\" write to the Free Software Foundation, Inc., 59 Temple Place,
-.\" Suite 330, Boston, MA  02111-1307  USA
-
-.TH dnsget 1 "Jan 2014" "User Utilities"
-
-.SH NAME
-dnsget \- DNS lookup utility
-
-.SH SYNOPSYS
-.B dnsget
-.RB [\| \-v \||\| \-q \|]
-.RB [\| \-c
-.IR class \|]
-.RB [\| \-t
-.IR type \|]
-.RB [\| \-o
-.IR opt , opt ,...]
-.IR name \|.\|.\|.
-
-.SH DESCRIPTION
-.B dnsget
-is a simple command-line to perform DNS lookups, similar to
-.BR host (1)
-and
-.BR dig (1).
-It is useable for both interactive/debugging scenarious and
-in scripts.
-The program is implemented using
-.BR udns (3)
-library.
-
-.PP
-By default,
-.B dnsget
-produces a human-readable output, similar to
-.RS
-.nf
-alias.example.com. CNAME www.example.com.
-www.example.com. A 192.168.1.1
-www.example.com. MX 10 mx.example.com.
-.fi
-.RE
-which is just sufficient to see how a given name resolves.
-Output format is controllable with
-.B \-v
-and
-.B \-q
-options -- the former increases verbosity level up to printing
-the whole DNS contents of all packets sent and received, which
-is suitable for debugging DNS problems, while the latter reduces
-the level, making output more quiet, up to bare result with no
-error messages, which is good for scripts.
-
-.SH OPTIONS
-
-The following options are recognized by
-.BR dnsget :
-
-.TP
-.B \-v
-produce more detailed output.  More
-.BR \-v 's
-means more details will be produced.  With single
-.BR \-v , dnsget
-will print contents of all received DNS packets (in a readable format),
-while with
-.BR \-vv ,
-it will output all outgoing DNS packets too.
-
-.TP
-.B \-q
-the opposite for \fB\-v\fR -- produce less detailed output.
-With single
-.BR \-q , dnsget
-will only show (decoded) data from final DNS resource records (RR),
-while
-.B \-qq
-also suppresses error messages.
-
-.TP
-\fB\-t \fItype\fR
-request record(s) of the given type \fItype\fR.  By default,
-.B dnsget
-will ask for IPv4 address (A) record, or for PTR record if the
-argument in question is an IPv4 or IPv6 address.  Recognized
-types include A, AAAA, MX, TXT, CNAME, PTR, NS, SOA, ANY and
-others.
-
-.TP
-\fB\-c \fIclass\fR
-request DNS record(s) of the given class \fIclass\fR.  By
-default
-.B dnsget
-uses IN class.  Valid classes include IN, CH, HS, ANY.
-
-.TP
-.B \-a
-(compatibility option).  Equivalent to setting query type to
-.B ANY
-and increasing verbosity level
-.RB ( \-v ).
-
-.TP
-.B \-C
-(planned)
-
-.TP
-.B \-x
-(planned)
-
-.TP
-\fB\-o \fIopt\fR,\fIopt\fR,...
-(may be specified several times).
-Set resolver options (in a form \fIoption\fR:\fIvalue\fR) as if they
-were set in
-.RB $ RES_OPTIONS
-environment variable, or set query flags:
-.RS
-.TP
-\fBtimeout\fR:\fIsec\fR
-Set initial query timeout to \fIsec\fR.
-.TP
-\fBattempts\fR:\fInum\fR
-(re)try every query \fInum\fR times before failing.
-.TP
-\fBudpbuf\fR:\fIbytes\fR
-set DNS UDP buffer size to \fIbytes\fR bytes.  Valid values
-are from 512 to 65535.  If \fIbytes\fR is greather than 512,
-EDNS0 (RFC 2671) extensions will be used.
-.TP
-\fBport\fR:\fInum\fR
-Use given UDP port number \fInum\fR instead of the default port 53 (domain).
-.TP
-\fBaa\fR
-set AA (auth only) query bit.
-.TP
-\fBnord\fR
-do not set RD (recursion desired) query bit (set by default).
-.TP
-\fBdnssec\fR or \fBdo\fR
-set DNSSEC OK (DO) query flag (\fBdnsget\fR does not verify DNSSEC signatures,
-only displays them; this is set in EDNS RR).
-.TP
-\fBcd\fR
-set CD (checking disabled) query bit.
-.RE
-
-.TP
-\fB\-n \fInameserver\fR
-Use the given nameserver(s) (may be specified more than once)
-instead of the default.  Using this option has the same same effect as 
-.RB $ NSCACHEIP
-or
-.RB $ NAMESERVERS
-environment variables, with the only difference that only IPv4 addresses
-are recognized for now, and it is possible to specify names (which will
-be resolved using default settings) instead of IP addresses.
-
-.TP
-.B \-h
-print short help and exit.
-
-.SH "RETURN VALUE"
-When all names where resovled successefully,
-.B dnsget
-exits with zero exit status.  If at least one name was not found,
-.B dnsget
-will exit with return code 100.  If some other error occured during
-name resolution, it will exit with code 99.  In case of usage or
-initialization error,
-.B dnsget
-will return 1.
-
-.SH "SEE ALSO"
-.BR host (1)
-.BR dig (1)
-.BR resolv.conf (5)
-.BR udns (3).
--- a/3rdparty/udns/dnsget.c
+++ b/3rdparty/udns/dnsget.c
@@ -1,759 +0,0 @@
-/* dnsget.c
-   simple host/dig-like application using UDNS library
-
-   Copyright (C) 2005  Michael Tokarev <mjt@corpit.ru>
-   This file is part of UDNS library, an async DNS stub resolver.
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this library, in file named COPYING.LGPL; if not,
-   write to the Free Software Foundation, Inc., 59 Temple Place,
-   Suite 330, Boston, MA  02111-1307  USA
-
- */
-
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
-#ifdef WINDOWS
-#include <windows.h>
-#include <winsock2.h>
-#else
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <sys/time.h>
-#include <unistd.h>
-#endif
-#include <time.h>
-#include <stdarg.h>
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "udns.h"
-
-#ifndef HAVE_GETOPT
-# include "getopt.c"
-#endif
-
-#ifndef AF_INET6
-# define AF_INET6 10
-#endif
-
-static char *progname;
-static int verbose = 1;
-static int errors;
-static int notfound;
-
-/* verbosity level:
- * <0 - bare result
- *  0 - bare result and error messages
- *  1 - readable result
- *  2 - received packet contents and `trying ...' stuff
- *  3 - sent and received packet contents
- */
-
-static void die(int errnum, const char *fmt, ...) {
-  va_list ap;
-  fprintf(stderr, "%s: ", progname);
-  va_start(ap, fmt); vfprintf(stderr, fmt, ap); va_end(ap);
-  if (errnum) fprintf(stderr, ": %s\n", strerror(errnum));
-  else putc('\n', stderr);
-  fflush(stderr);
-  exit(1);
-}
-
-static const char *dns_xntop(int af, const void *src) {
-  static char buf[6*5+4*4];
-  return dns_ntop(af, src, buf, sizeof(buf));
-}
-
-struct query {
-  const char *name;		/* original query string */
-  unsigned char *dn;		/* the DN being looked up */
-  enum dns_type qtyp;		/* type of the query */
-};
-
-static void query_free(struct query *q) {
-  free(q->dn);
-  free(q);
-}
-
-static struct query *
-query_new(const char *name, const unsigned char *dn, enum dns_type qtyp) {
-  struct query *q = malloc(sizeof(*q));
-  unsigned l = dns_dnlen(dn);
-  unsigned char *cdn = malloc(l);
-  if (!q || !cdn) die(0, "out of memory");
-  memcpy(cdn, dn, l);
-  q->name = name;
-  q->dn = cdn;
-  q->qtyp = qtyp;
-  return q;
-}
-
-static enum dns_class qcls = DNS_C_IN;
-
-static void
-dnserror(struct query *q, int errnum) {
-  if (verbose >= 0)
-    fprintf(stderr, "%s: unable to lookup %s record for %s: %s\n", progname,
-            dns_typename(q->qtyp), dns_dntosp(q->dn), dns_strerror(errnum));
-  if (errnum == DNS_E_NXDOMAIN || errnum == DNS_E_NODATA)
-    ++notfound;
-  else
-    ++errors;
-  query_free(q);
-}
-
-static const unsigned char *
-printtxt(const unsigned char *c) {
-  unsigned n = *c++;
-  const unsigned char *e = c + n;
-  if (verbose > 0) while(c < e) {
-    if (*c < ' ' || *c >= 127) printf("\\%03u", *c);
-    else if (*c == '\\' || *c == '"') printf("\\%c", *c);
-    else putchar(*c);
-    ++c;
-  }
-  else
-   fwrite(c, n, 1, stdout);
-  return e;
-}
-
-static void
-printhex(const unsigned char *c, const unsigned char *e) {
-  while(c < e)
-    printf("%02x", *c++);
-}
-
-static unsigned char to_b64[] =
-"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-static void
-printb64(const unsigned char *c, const unsigned char *e) {
-  while(c < e) {
-    putchar(to_b64[c[0] >> 2]);
-    if (c+1 < e) {
-      putchar(to_b64[(c[0] & 0x3) << 4 | c[1] >> 4]);
-      if (c+2 < e) {
-        putchar(to_b64[(c[1] & 0xf) << 2 | c[2] >> 6]);
-        putchar(to_b64[c[2] & 0x3f]);
-      }
-      else {
-        putchar(to_b64[(c[1] & 0xf) << 2]);
-	putchar('=');
-	break;
-      }
-    }
-    else {
-      putchar(to_b64[(c[0] & 0x3) << 4]);
-      putchar('=');
-      putchar('=');
-      break;
-    }
-    c += 3;
-  }
-}
-
-static void
-printdate(time_t time) {
-  struct tm *tm = gmtime(&time);
-  printf("%04d%02d%02d%02d%02d%02d",
-    tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
-    tm->tm_hour, tm->tm_min, tm->tm_sec);
-}
-
-static void
-printrr(const struct dns_parse *p, struct dns_rr *rr) {
-  const unsigned char *pkt = p->dnsp_pkt;
-  const unsigned char *end = p->dnsp_end;
-  const unsigned char *dptr = rr->dnsrr_dptr;
-  const unsigned char *dend = rr->dnsrr_dend;
-  unsigned char *dn = rr->dnsrr_dn;
-  const unsigned char *c;
-  unsigned n;
-
-  if (verbose > 0) {
-    if (verbose > 1) {
-      if (!p->dnsp_rrl && !rr->dnsrr_dn[0] && rr->dnsrr_typ == DNS_T_OPT) {
-        printf(";EDNS%d OPT record (UDPsize: %d, ERcode: %d, Flags: 0x%02x): %d bytes\n",
-               (rr->dnsrr_ttl>>16) & 0xff,	/* version */
-               rr->dnsrr_cls,			/* udp size */
-               (rr->dnsrr_ttl>>24) & 0xff,	/* extended rcode */
-               rr->dnsrr_ttl & 0xffff,		/* flags */
-               rr->dnsrr_dsz);
-        return;
-      }
-      n = printf("%s.", dns_dntosp(rr->dnsrr_dn));
-      printf("%s%u\t%s\t%s\t",
-             n > 15 ? "\t" : n > 7 ? "\t\t" : "\t\t\t",
-             rr->dnsrr_ttl,
-             dns_classname(rr->dnsrr_cls),
-             dns_typename(rr->dnsrr_typ));
-    }
-    else
-      printf("%s. %s ", dns_dntosp(rr->dnsrr_dn), dns_typename(rr->dnsrr_typ));
-  }
-
-  switch(rr->dnsrr_typ) {
-
-  case DNS_T_CNAME:
-  case DNS_T_PTR:
-  case DNS_T_NS:
-  case DNS_T_MB:
-  case DNS_T_MD:
-  case DNS_T_MF:
-  case DNS_T_MG:
-  case DNS_T_MR:
-    if (dns_getdn(pkt, &dptr, end, dn, DNS_MAXDN) <= 0) goto xperr;
-    printf("%s.", dns_dntosp(dn));
-    break;
-
-  case DNS_T_A:
-    if (rr->dnsrr_dsz != 4) goto xperr;
-    printf("%d.%d.%d.%d", dptr[0], dptr[1], dptr[2], dptr[3]);
-    break;
-
-  case DNS_T_AAAA:
-    if (rr->dnsrr_dsz != 16) goto xperr;
-    printf("%s", dns_xntop(AF_INET6, dptr));
-    break;
-
-  case DNS_T_MX:
-    c = dptr + 2;
-    if (dns_getdn(pkt, &c, end, dn, DNS_MAXDN) <= 0 || c != dend) goto xperr;
-    printf("%d %s.", dns_get16(dptr), dns_dntosp(dn));
-    break;
-
-  case DNS_T_TXT:
-    /* first verify it */
-    for(c = dptr; c < dend; c += n) {
-      n = *c++;
-      if (c + n > dend) goto xperr;
-    }
-    c = dptr; n = 0;
-    while (c < dend) {
-      if (verbose > 0) printf(n++ ? "\" \"":"\"");
-      c = printtxt(c);
-    }
-    if (verbose > 0) putchar('"');
-    break;
-
-  case DNS_T_HINFO:	/* CPU, OS */
-    c = dptr;
-    n = *c++; if ((c += n) >= dend) goto xperr;
-    n = *c++; if ((c += n) != dend) goto xperr;
-    c = dptr;
-    if (verbose > 0) putchar('"');
-    c = printtxt(c);
-    if (verbose > 0) printf("\" \""); else putchar(' ');
-    printtxt(c);
-    if (verbose > 0) putchar('"');
-    break;
-
-  case DNS_T_WKS:
-    c = dptr;
-    if (dptr + 4 + 2 >= end) goto xperr;
-    printf("%s %d", dns_xntop(AF_INET, dptr), dptr[4]);
-    c = dptr + 5;
-    for (n = 0; c < dend; ++c, n += 8) {
-      if (*c) {
-        unsigned b;
-        for (b = 0; b < 8; ++b)
-          if (*c & (1 << (7-b))) printf(" %d", n + b);
-      }
-    }
-    break;
-
-  case DNS_T_SRV:	/* prio weight port targetDN */
-    c = dptr;
-    c += 2 + 2 + 2;
-    if (dns_getdn(pkt, &c, end, dn, DNS_MAXDN) <= 0 || c != dend) goto xperr;
-    c = dptr;
-    printf("%d %d %d %s.",
-           dns_get16(c+0), dns_get16(c+2), dns_get16(c+4),
-           dns_dntosp(dn));
-    break;
-
-  case DNS_T_NAPTR:	/* order pref flags serv regexp repl */
-    c = dptr;
-    c += 4;	/* order, pref */
-    for (n = 0; n < 3; ++n)
-      if (c >= dend) goto xperr;
-      else c += *c + 1;
-    if (dns_getdn(pkt, &c, end, dn, DNS_MAXDN) <= 0 || c != dend) goto xperr;
-    c = dptr;
-    printf("%u %u", dns_get16(c+0), dns_get16(c+2));
-    c += 4;
-    for(n = 0; n < 3; ++n) {
-      putchar(' ');
-      if (verbose > 0) putchar('"');
-      c = printtxt(c);
-      if (verbose > 0) putchar('"');
-    } 
-    printf(" %s.", dns_dntosp(dn));
-    break;
-
-  case DNS_T_KEY:
-  case DNS_T_DNSKEY:
-    /* flags(2) proto(1) algo(1) pubkey */
-  case DNS_T_DS:
-  case DNS_T_DLV:
-    /* ktag(2) proto(1) algo(1) pubkey */
-    c = dptr;
-    if (c + 2 + 1 + 1 > dend) goto xperr;
-    printf("%d %d %d", dns_get16(c), c[2], c[3]);
-    c += 2 + 1 + 1;
-    if (c < dend) {
-      putchar(' ');
-      printb64(c, dend);
-    }
-    break;
-
-  case DNS_T_SIG:
-  case DNS_T_RRSIG:
-    /* type(2) algo(1) labels(1) ottl(4) sexp(4) sinc(4) tag(2) sdn sig */
-    c = dptr;
-    c += 2 + 1 + 1 + 4 + 4 + 4 + 2;
-    if (dns_getdn(pkt, &c, end, dn, DNS_MAXDN) <= 0) goto xperr;
-    printf("%s %u %u %u ",
-           dns_typename(dns_get16(dptr)), dptr[2], dptr[3], dns_get32(dptr+4));
-    printdate(dns_get32(dptr+8));
-    putchar(' ');
-    printdate(dns_get32(dptr+12));
-    printf(" %d %s. ", dns_get16(dptr+10), dns_dntosp(dn));
-    printb64(c, dend);
-    break;
-
-  case DNS_T_SSHFP: /* algo(1), fp type(1), fp... */
-    if (dend < dptr + 3) goto xperr;
-    printf("%u %u ", dptr[0], dptr[1]); /* algo, fp type */
-    printhex(dptr + 2, dend);
-    break;
-
-#if 0	/* unused RR types? */
-  case DNS_T_NSEC: /* nextDN bitmaps */
-    c = dptr;
-    if (dns_getdn(pkt, &c, end, dn, DNS_MAXDN) <= 0) goto xperr;
-    printf("%s.", dns_dntosp(dn));
-    unfinished.
-    break;
-#endif
-
-
-  case DNS_T_SOA:
-    c = dptr;
-    if (dns_getdn(pkt, &c, end, dn, DNS_MAXDN) <= 0 ||
-        dns_getdn(pkt, &c, end, dn, DNS_MAXDN) <= 0 ||
-        c + 4*5 != dend)
-      goto xperr;
-    dns_getdn(pkt, &dptr, end, dn, DNS_MAXDN);
-    printf("%s. ", dns_dntosp(dn));
-    dns_getdn(pkt, &dptr, end, dn, DNS_MAXDN);
-    printf("%s. ", dns_dntosp(dn));
-    printf("%u %u %u %u %u",
-           dns_get32(dptr), dns_get32(dptr+4), dns_get32(dptr+8),
-           dns_get32(dptr+12), dns_get32(dptr+16));
-    break;
-
-  case DNS_T_MINFO:
-    c = dptr;
-    if (dns_getdn(pkt, &c, end, dn, DNS_MAXDN) <= 0 ||
-        dns_getdn(pkt, &c, end, dn, DNS_MAXDN) <= 0 ||
-	c != dend)
-      goto xperr;
-    dns_getdn(pkt, &dptr, end, dn, DNS_MAXDN);
-    printf("%s. ", dns_dntosp(dn));
-    dns_getdn(pkt, &dptr, end, dn, DNS_MAXDN);
-    printf("%s.", dns_dntosp(dn));
-    break;
-
-  case DNS_T_NULL:
-  default:
-    printhex(dptr, dend);
-    break;
-  }
-  putchar('\n');
-  return;
-
-xperr:
-  printf("<parse error>\n");
-  ++errors;
-}
-
-static int
-printsection(struct dns_parse *p, int nrr, const char *sname) {
-  struct dns_rr rr;
-  int r;
-  if (!nrr) return 0;
-  if (verbose > 1) printf("\n;; %s section (%d):\n", sname, nrr);
-
-  p->dnsp_rrl = nrr;
-  while((r = dns_nextrr(p, &rr)) > 0)
-    printrr(p, &rr);
-  if (r < 0) printf("<<ERROR>>\n");
-  return r;
-}
-
-/* dbgcb will only be called if verbose > 1 */
-static void
-dbgcb(int code, const struct sockaddr *sa, unsigned slen,
-      const unsigned char *pkt, int r,
-      const struct dns_query *unused_q, void *unused_data) {
-  struct dns_parse p;
-  const unsigned char *cur, *end;
-  int numqd;
-
-  if (code > 0)	{
-    printf(";; trying %s.\n", dns_dntosp(dns_payload(pkt)));
-    printf(";; sending %d bytes query to ", r);
-  }
-  else
-    printf(";; received %d bytes response from ", r);
-  if (sa->sa_family == AF_INET && slen >= sizeof(struct sockaddr_in))
-    printf("%s port %d\n",
-           dns_xntop(AF_INET, &((struct sockaddr_in*)sa)->sin_addr),
-           htons(((struct sockaddr_in*)sa)->sin_port));
-#ifdef HAVE_IPv6
-  else if (sa->sa_family == AF_INET6 && slen >= sizeof(struct sockaddr_in6))
-    printf("%s port %d\n",
-           dns_xntop(AF_INET6, &((struct sockaddr_in6*)sa)->sin6_addr),
-           htons(((struct sockaddr_in6*)sa)->sin6_port));
-#endif
-  else
-    printf("<<unknown socket type %d>>\n", sa->sa_family);
-  if (code > 0 && verbose < 3) {
-    putchar('\n');
-    return;
-  }
-
-  if (code == -2) printf(";; reply from unexpected source\n");
-  if (code == -5) printf(";; reply to a query we didn't sent (or old)\n");
-  if (r < DNS_HSIZE) {
-    printf(";; short packet (%d bytes)\n", r);
-    return;
-  }
-  if (dns_opcode(pkt) != 0)
-    printf(";; unexpected opcode %d\n", dns_opcode(pkt));
-  if (dns_tc(pkt) != 0)
-    printf(";; warning: TC bit set, probably incomplete reply\n");
-
-  printf(";; ->>HEADER<<- opcode: ");
-  switch(dns_opcode(pkt)) {
-  case 0: printf("QUERY"); break;
-  case 1: printf("IQUERY"); break;
-  case 2: printf("STATUS"); break;
-  default: printf("UNKNOWN(%u)", dns_opcode(pkt)); break;
-  }
-  printf(", status: %s, id: %d, size: %d\n;; flags:",
-         dns_rcodename(dns_rcode(pkt)), dns_qid(pkt), r);
-  if (dns_qr(pkt)) printf(" qr");
-  if (dns_aa(pkt)) printf(" aa");
-  if (dns_tc(pkt)) printf(" tc");
-  if (dns_rd(pkt)) printf(" rd");
-  if (dns_ra(pkt)) printf(" ra");
-  /* if (dns_z(pkt))  printf(" z"); only one reserved bit left */
-  if (dns_ad(pkt)) printf(" ad");
-  if (dns_cd(pkt)) printf(" cd");
-  numqd = dns_numqd(pkt);
-  printf("; QUERY: %d, ANSWER: %d, AUTHORITY: %d, ADDITIONAL: %d\n",
-         numqd, dns_numan(pkt), dns_numns(pkt), dns_numar(pkt));
-  if (numqd != 1)
-    printf(";; unexpected number of entries in QUERY section: %d\n",
-           numqd);
-  printf("\n;; QUERY SECTION (%d):\n", numqd);
-  cur = dns_payload(pkt);
-  end = pkt + r;
-  while(numqd--) {
-    if (dns_getdn(pkt, &cur, end, p.dnsp_dnbuf, DNS_MAXDN) <= 0 ||
-        cur + 4 > end) {
-      printf("; invalid query section\n");
-      return;
-    }
-    r = printf(";%s.", dns_dntosp(p.dnsp_dnbuf));
-    printf("%s%s\t%s\n",
-           r > 23 ? "\t" : r > 15 ? "\t\t" : r > 7 ? "\t\t\t" : "\t\t\t\t",
-           dns_classname(dns_get16(cur+2)), dns_typename(dns_get16(cur)));
-    cur += 4;
-  }
-
-  p.dnsp_pkt = pkt;
-  p.dnsp_cur = p.dnsp_ans = cur;
-  p.dnsp_end = end;
-  p.dnsp_qdn = NULL;
-  p.dnsp_qcls = p.dnsp_qtyp = 0;
-  p.dnsp_ttl = 0xffffffffu;
-  p.dnsp_nrr = 0;
-
-  r = printsection(&p, dns_numan(pkt), "ANSWER");
-  if (r == 0)
-    r = printsection(&p, dns_numns(pkt), "AUTHORITY");
-  if (r == 0)
-    r = printsection(&p, dns_numar(pkt), "ADDITIONAL");
-  putchar('\n');
-}
-
-static void dnscb(struct dns_ctx *ctx, void *result, void *data) {
-  int r = dns_status(ctx);
-  struct query *q = data;
-  struct dns_parse p;
-  struct dns_rr rr;
-  unsigned nrr;
-  unsigned char dn[DNS_MAXDN];
-  const unsigned char *pkt, *cur, *end;
-  if (!result) {
-    dnserror(q, r);
-    return;
-  }
-  pkt = result; end = pkt + r; cur = dns_payload(pkt);
-  dns_getdn(pkt, &cur, end, dn, sizeof(dn));
-  dns_initparse(&p, NULL, pkt, cur, end);
-  p.dnsp_qcls = p.dnsp_qtyp = 0;
-  nrr = 0;
-  while((r = dns_nextrr(&p, &rr)) > 0) {
-    if (!dns_dnequal(dn, rr.dnsrr_dn)) continue;
-    if ((qcls == DNS_C_ANY || qcls == rr.dnsrr_cls) &&
-        (q->qtyp == DNS_T_ANY || q->qtyp == rr.dnsrr_typ))
-      ++nrr;
-    else if (rr.dnsrr_typ == DNS_T_CNAME && !nrr) {
-      if (dns_getdn(pkt, &rr.dnsrr_dptr, end,
-                    p.dnsp_dnbuf, sizeof(p.dnsp_dnbuf)) <= 0 ||
-          rr.dnsrr_dptr != rr.dnsrr_dend) {
-        r = DNS_E_PROTOCOL;
-        break;
-      }
-      else {
-        if (verbose == 1) {
-          printf("%s.", dns_dntosp(dn));
-          printf(" CNAME %s.\n", dns_dntosp(p.dnsp_dnbuf));
-        }
-        dns_dntodn(p.dnsp_dnbuf, dn, sizeof(dn));
-      }
-    }
-  }
-  if (!r && !nrr)
-    r = DNS_E_NODATA;
-  if (r < 0) {
-    dnserror(q, r);
-    free(result);
-    return;
-  }
-  if (verbose < 2) {	/* else it is already printed by dbgfn */
-    dns_rewind(&p, NULL);
-    p.dnsp_qtyp = q->qtyp == DNS_T_ANY ? 0 : q->qtyp;
-    p.dnsp_qcls = qcls == DNS_C_ANY ? 0 : qcls;
-    while(dns_nextrr(&p, &rr))
-      printrr(&p, &rr);
-  }
-  free(result);
-  query_free(q);
-}
-
-int main(int argc, char **argv) {
-  int i;
-  int fd;
-  fd_set fds;
-  struct timeval tv;
-  time_t now;
-  char *ns[DNS_MAXSERV];
-  int nns = 0;
-  struct query *q;
-  enum dns_type qtyp = 0;
-  struct dns_ctx *nctx = NULL;
-  int flags = 0;
-
-  if (!(progname = strrchr(argv[0], '/'))) progname = argv[0];
-  else argv[0] = ++progname;
-
-  if (argc <= 1)
-    die(0, "try `%s -h' for help", progname);
-
-  if (dns_init(NULL, 0) < 0 || !(nctx = dns_new(NULL)))
-    die(errno, "unable to initialize dns library");
-  /* we keep two dns contexts: one may be needed to resolve
-   * nameservers if given as names, using default options.
-   */
-
-  while((i = getopt(argc, argv, "vqt:c:an:o:f:h")) != EOF) switch(i) {
-  case 'v': ++verbose; break;
-  case 'q': --verbose; break;
-  case 't':
-    if (optarg[0] == '*' && !optarg[1])
-      i = DNS_T_ANY;
-    else if ((i = dns_findtypename(optarg)) <= 0)
-      die(0, "unrecognized query type `%s'", optarg);
-    qtyp = i;
-    break;
-  case 'c':
-    if (optarg[0] == '*' && !optarg[1])
-      i = DNS_C_ANY;
-    else if ((i = dns_findclassname(optarg)) < 0)
-      die(0, "unrecognized query class `%s'", optarg);
-    qcls = i;
-    break;
-  case 'a':
-    qtyp = DNS_T_ANY;
-    ++verbose;
-    break;
-  case 'n':
-    if (nns >= DNS_MAXSERV)
-      die(0, "too many nameservers, %d max", DNS_MAXSERV);
-    ns[nns++] = optarg;
-    break;
-  case 'o':
-  case 'f': {
-    char *opt;
-    const char *const delim = " \t,;";
-    for(opt = strtok(optarg, delim); opt != NULL; opt = strtok(NULL, delim)) {
-      if (dns_set_opts(NULL, optarg) == 0)
-        ;
-      else if (strcmp(opt, "aa") == 0) flags |= DNS_AAONLY;
-      else if (strcmp(optarg, "nord") == 0) flags |= DNS_NORD;
-      else if (strcmp(optarg, "dnssec") == 0) flags |= DNS_SET_DO;
-      else if (strcmp(optarg, "do")     == 0) flags |= DNS_SET_DO;
-      else if (strcmp(optarg, "cd") == 0) flags |= DNS_SET_CD;
-      else
-        die(0, "invalid option: `%s'", opt);
-    }
-    break;
-  }
-  case 'h':
-    printf(
-"%s: simple DNS query tool (using udns version %s)\n"
-"Usage: %s [options] domain-name...\n"
-"where options are:\n"
-" -h - print this help and exit\n"
-" -v - be more verbose\n"
-" -q - be less verbose\n"
-" -t type - set query type (A, AAA, PTR etc)\n"
-" -c class - set query class (IN (default), CH, HS, *)\n"
-" -a - equivalent to -t ANY -v\n"
-" -n ns - use given nameserver(s) instead of default\n"
-"  (may be specified multiple times)\n"
-" -o opt,opt,... (comma- or space-separated list,\n"
-"                 may be specified more than once):\n"
-"  set resovler options (the same as setting $RES_OPTIONS):\n"
-"   timeout:sec  - initial query timeout\n"
-"   attempts:num - number of attempt to resovle a query\n"
-"   ndots:num    - if name has more than num dots, lookup it before search\n"
-"   port:num     - port number for queries instead of default 53\n"
-"   udpbuf:num   - size of UDP buffer (use EDNS0 if >512)\n"
-"  or query flags:\n"
-"   aa,nord,dnssec,do,cd - set query flag (auth-only, no recursion,\n"
-"     enable DNSSEC (DNSSEC Ok), check disabled)\n"
-      , progname, dns_version(), progname);
-    return 0;
-  default:
-    die(0, "try `%s -h' for help", progname);
-  }
-
-  argc -= optind; argv += optind;
-  if (!argc)
-    die(0, "no name(s) to query specified");
-
-  if (nns) {
-    /* if nameservers given as names, resolve them.
-     * We only allow IPv4 nameservers as names for now.
-     * Ok, it is easy enouth to try both AAAA and A,
-     * but the question is what to do by default.
-     */
-    struct sockaddr_in sin;
-    int j, r = 0, opened = 0;
-    memset(&sin, 0, sizeof(sin));
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(dns_set_opt(NULL, DNS_OPT_PORT, -1));
-    dns_add_serv(NULL, NULL);
-    for(i = 0; i < nns; ++i) {
-      if (dns_pton(AF_INET, ns[i], &sin.sin_addr) <= 0) {
-        struct dns_rr_a4 *rr;
-        if (!opened) {
-          if (dns_open(nctx) < 0)
-            die(errno, "unable to initialize dns context");
-          opened = 1;
-        }
-        rr = dns_resolve_a4(nctx, ns[i], 0);
-        if (!rr)
-          die(0, "unable to resolve nameserver %s: %s",
-              ns[i], dns_strerror(dns_status(nctx)));
-        for(j = 0; j < rr->dnsa4_nrr; ++j) {
-          sin.sin_addr = rr->dnsa4_addr[j];
-          if ((r = dns_add_serv_s(NULL, (struct sockaddr *)&sin)) < 0)
-            break;
-        }
-        free(rr);
-      }
-      else
-        r = dns_add_serv_s(NULL, (struct sockaddr *)&sin);
-      if (r < 0)
-        die(errno, "unable to add nameserver %s",
-             dns_xntop(AF_INET, &sin.sin_addr));
-    }
-  }
-  dns_free(nctx);
-
-  fd = dns_open(NULL);
-  if (fd < 0)
-    die(errno, "unable to initialize dns context");
-
-  if (verbose > 1)
-    dns_set_dbgfn(NULL, dbgcb);
-
-  if (flags)
-    dns_set_opt(NULL, DNS_OPT_FLAGS, flags);
-
-  for (i = 0; i < argc; ++i) {
-    char *name = argv[i];
-    union {
-      struct in_addr addr;
-      struct in6_addr addr6;
-    } a;
-    unsigned char dn[DNS_MAXDN];
-    enum dns_type l_qtyp = 0;
-    int abs;
-    if (dns_pton(AF_INET, name, &a.addr) > 0) {
-      dns_a4todn(&a.addr, 0, dn, sizeof(dn));
-      l_qtyp = DNS_T_PTR;
-      abs = 1;
-    }
-#ifdef HAVE_IPv6
-    else if (dns_pton(AF_INET6, name, &a.addr6) > 0) {
-      dns_a6todn(&a.addr6, 0, dn, sizeof(dn));
-      l_qtyp = DNS_T_PTR;
-      abs = 1;
-    }
-#endif
-    else if (!dns_ptodn(name, strlen(name), dn, sizeof(dn), &abs))
-      die(0, "invalid name `%s'\n", name);
-    else
-      l_qtyp = DNS_T_A;
-    if (qtyp) l_qtyp = qtyp;
-    q = query_new(name, dn, l_qtyp);
-    if (abs) abs = DNS_NOSRCH;
-    if (!dns_submit_dn(NULL, dn, qcls, l_qtyp, abs, 0, dnscb, q))
-      dnserror(q, dns_status(NULL));
-  }
-
-  FD_ZERO(&fds);
-  now = 0;
-  while((i = dns_timeouts(NULL, -1, now)) > 0) {
-    FD_SET(fd, &fds);
-    tv.tv_sec = i;
-    tv.tv_usec = 0;
-    i = select(fd+1, &fds, 0, 0, &tv);
-    now = time(NULL);
-    if (i > 0) dns_ioevent(NULL, now);
-  }
-
-  return errors ? 1 : notfound ? 100 : 0;
-}
--- a/3rdparty/udns/ex-rdns.c
+++ b/3rdparty/udns/ex-rdns.c
@@ -1,114 +0,0 @@
-/* ex-rdns.c
-   parallel rDNS resolver example - read IP addresses from stdin,
-   write domain names to stdout
- 
-   Copyright (C) 2005  Michael Tokarev <mjt@corpit.ru>
-   This file is part of UDNS library, an async DNS stub resolver.
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this library, in file named COPYING.LGPL; if not,
-   write to the Free Software Foundation, Inc., 59 Temple Place,
-   Suite 330, Boston, MA  02111-1307  USA
-
- */
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <sys/poll.h>
-#include <unistd.h>
-#include <stdio.h>
-#include <time.h>
-#include <stdlib.h>
-#include <string.h>
-#include "udns.h"
-
-static int curq;
-
-static const char *n2ip(const unsigned char *c) {
-  static char b[sizeof("255.255.255.255")];
-  sprintf(b, "%u.%u.%u.%u", c[0], c[1], c[2], c[3]);
-  return b;
-}
-static void dnscb(struct dns_ctx *ctx, struct dns_rr_ptr *rr, void *data) {
-  const char *ip = n2ip((unsigned char *)&data);
-  int i;
-  --curq;
-  if (rr) {
-    printf("%s", ip);
-    for(i = 0; i < rr->dnsptr_nrr; ++i)
-      printf(" %s", rr->dnsptr_ptr[i]);
-    putchar('\n');
-    free(rr);
-  }
-  else
-    fprintf(stderr, "%s: %s\n", ip, dns_strerror(dns_status(ctx)));
-}
-
-int main(int argc, char **argv) {
-  int c;
-  time_t now;
-  int maxq = 10;
-  struct pollfd pfd;
-  char linebuf[1024];
-  char *eol;
-  int eof;
-
-  if (dns_init(NULL, 1) < 0) {
-    fprintf(stderr, "unable to initialize dns library\n");
-    return 1;
-  }
-  while((c = getopt(argc, argv, "m:r")) != EOF) switch(c) {
-  case 'm': maxq = atoi(optarg); break;
-  case 'r':
-     dns_set_opt(0, DNS_OPT_FLAGS,
-                 dns_set_opt(0, DNS_OPT_FLAGS, -1) | DNS_NORD);
-     break;
-  default: return 1;
-  }
-  if (argc != optind) return 1;
-
-  pfd.fd = dns_sock(0);
-  pfd.events = POLLIN;
-  now = time(NULL);
-  c = optind;
-  eof = 0;
-  while(curq || !eof) {
-    if (!eof && curq < maxq) {
-      union { struct in_addr a; void *p; } pa;
-      if (!fgets(linebuf, sizeof(linebuf), stdin)) {
-        eof = 1;
-        continue;
-      }
-      eol = strchr(linebuf, '\n');
-      if (eol) *eol = '\0';
-      if (!linebuf[0]) continue;
-      if (dns_pton(AF_INET, linebuf, &pa.a) <= 0)
-        fprintf(stderr, "%s: invalid address\n", linebuf);
-      else if (dns_submit_a4ptr(0, &pa.a, dnscb, pa.p) == 0)
-        fprintf(stderr, "%s: unable to submit query: %s\n",
-                linebuf, dns_strerror(dns_status(0)));
-      else
-        ++curq;
-      continue;
-    }
-    if (curq) {
-      c = dns_timeouts(0, -1, now);
-      c = poll(&pfd, 1, c < 0 ? -1 : c * 1000);
-      now = time(NULL);
-      if (c)
-        dns_ioevent(0, now);
-    }
-  }
-  return 0;
-}
--- a/3rdparty/udns/getopt.c
+++ b/3rdparty/udns/getopt.c
@@ -1,165 +0,0 @@
-/* getopt.c
- * Simple getopt() implementation.
- *
- * Standard interface:
- *  extern int getopt(int argc, char *const *argv, const char *opts);
- *  extern int optind;    current index in argv[]
- *  extern char *optarg;  argument for the current option
- *  extern int optopt;    the current option
- *  extern int opterr;    to control error printing
- *
- * Some minor extensions:
- *  ignores leading `+' sign in opts[] (unemplemented GNU extension)
- *  handles optional arguments, in form "x::" in opts[]
- *  if opts[] starts with `:', will return `:' in case of missing required
- *    argument, instead of '?'.
- *
- * Compile with -DGETOPT_NO_OPTERR to never print errors internally.
- * Compile with -DGETOPT_NO_STDIO to use write() calls instead of fprintf() for
- *  error reporting (ignored with -DGETOPT_NO_OPTERR).
- * Compile with -DGETOPT_CLASS=static to get static linkage.
- * Compile with -DGETOPT_MY to redefine all visible symbols to be prefixed
- *  with "my_", like my_getopt instead of getopt.
- * Compile with -DTEST to get a test executable.
- *
- * Written by Michael Tokarev.  Public domain.
- */
-
-#include <string.h>
-
-#ifndef GETOPT_CLASS
-# define GETOPT_CLASS
-#endif
-#ifdef GETOPT_MY
-# define optarg my_optarg
-# define optind my_optind
-# define opterr my_opterr
-# define optopt my_optopt
-# define getopt my_getopt
-#endif
-
-GETOPT_CLASS char *optarg /* = NULL */;
-GETOPT_CLASS int optind = 1;
-GETOPT_CLASS int opterr = 1;
-GETOPT_CLASS int optopt;
-
-static char *nextc /* = NULL */;
-
-#if defined(GETOPT_NO_OPTERR)
-
-#define printerr(argv, msg)
-
-#elif defined(GETOPT_NO_STDIO)
-
-extern int write(int, void *, int);
-
-static void printerr(char *const *argv, const char *msg) {
-  if (opterr) {
-    char buf[64];
-    unsigned pl = strlen(argv[0]);
-    unsigned ml = strlen(msg);
-    char *p;
-    if (pl + /*": "*/2 + ml + /*" -- c\n"*/6 > sizeof(buf)) {
-      write(2, argv[0], pl);
-      p = buf;
-    }
-    else {
-      memcpy(buf, argv[0], ml);
-      p = buf + pl;
-    }
-    *p++ = ':'; *p++ = ' ';
-    memcpy(p, msg, ml); p += ml;
-    *p++ = ' '; *p++ = '-'; *p++ = '-'; *p++ = ' ';
-    *p++ = optopt;
-    *p++ = '\n';
-    write(2, buf, p - buf);
-  }
-}
-
-#else
-
-#include <stdio.h>
-static void printerr(char *const *argv, const char *msg) {
-  if (opterr)
-     fprintf(stderr, "%s: %s -- %c\n", argv[0], msg, optopt);
-}
-
-#endif
-
-GETOPT_CLASS int getopt(int argc, char *const *argv, const char *opts) {
-  char *p;
-
-  optarg = 0;
-  if (*opts == '+') /* GNU extension (permutation) - isn't supported */
-    ++opts;
-
-  if (!optind) {  /* a way to reset things */
-    nextc = 0;
-    optind = 1;
-  }
-
-  if (!nextc || !*nextc) {   /* advance to the next argv element */
-    /* done scanning? */
-    if (optind >= argc)
-      return -1;
-    /* not an optional argument */
-    if (argv[optind][0] != '-')
-      return -1;
-    /* bare `-' */
-    if (argv[optind][1] == '\0')
-      return -1;
-    /* special case `--' argument */
-    if (argv[optind][1] == '-' && argv[optind][2] == '\0') {
-      ++optind;
-      return -1;
-    }
-    nextc = argv[optind] + 1;
-  }
-
-  optopt = *nextc++;
-  if (!*nextc)
-    ++optind;
-  p = strchr(opts, optopt);
-  if (!p || optopt == ':') {
-    printerr(argv, "illegal option");
-    return '?';
-  }
-  if (p[1] == ':') {
-    if (*nextc) {
-      optarg = nextc;
-      nextc = NULL;
-      ++optind;
-    }
-    else if (p[2] != ':') {	/* required argument */
-      if (optind >= argc) {
-        printerr(argv, "option requires an argument");
-        return *opts == ':' ? ':' : '?';
-      }
-      else
-        optarg = argv[optind++];
-    }
-  }
-  return optopt;
-}
-
-#ifdef TEST
-
-#include <stdio.h>
-
-int main(int argc, char **argv) {
-  int c;
-  while((c = getopt(argc, argv, "ab:c::")) != -1) switch(c) {
-  case 'a':
-  case 'b':
-  case 'c':
-    printf("option %c %s\n", c, optarg ? optarg : "(none)");
-    break;
-  default:
-    return -1;
-  }
-  for(c = optind; c < argc; ++c)
-    printf("non-opt: %s\n", argv[c]);
-  return 0;
-}
-
-#endif
--- a/3rdparty/udns/inet_XtoX.c
+++ b/3rdparty/udns/inet_XtoX.c
@@ -1,327 +0,0 @@
-/* inet_XtoX.c
- * Simple implementation of the following functions:
- *  inet_ntop(), inet_ntoa(), inet_pton(), inet_aton().
- *
- * Differences from traditional implementaitons:
- *  o modifies destination buffers even on error return.
- *  o no fancy (hex, or 1.2) input support in inet_aton()
- *  o inet_aton() does not accept junk after an IP address.
- *  o inet_ntop(AF_INET) requires at least 16 bytes in dest,
- *    and inet_ntop(AF_INET6) at least 40 bytes
- *    (traditional inet_ntop() will try to fit anyway)
- *
- * Compile with -Dinet_XtoX_prefix=pfx_ to have pfx_*() instead of inet_*()
- * Compile with -Dinet_XtoX_no_ntop or -Dinet_XtoX_no_pton
- *  to disable net2str or str2net conversions.
- *
- * #define inet_XtoX_prototypes and #include "this_file.c"
- * to get function prototypes only (but not for inet_ntoa()).
- * #define inet_XtoX_decl to be `static' for static visibility,
- * or use __declspec(dllexport) or somesuch...
- *
- * Compile with -DTEST to test against stock implementation.
- *
- * Written by Michael Tokarev.  Public domain.
- */
-
-#ifdef inet_XtoX_prototypes
-
-struct in_addr;
-
-#else
-
-#include <errno.h>
-
-#ifdef TEST
-
-# include <netinet/in.h>
-# include <sys/socket.h>
-# include <arpa/inet.h>
-# include <stdio.h>
-# include <stdlib.h>
-# include <unistd.h>
-# include <string.h>
-# undef inet_XtoX_prefix
-# define inet_XtoX_prefix mjt_inet_
-# undef inet_XtoX_no_ntop
-# undef inet_XtoX_no_pton
-
-#else /* !TEST */
-
-struct in_addr {	/* declare it here to avoid messing with headers */
-  unsigned char x[4];
-};
-
-#endif /* TEST */
-
-#endif /* inet_XtoX_prototypes */
-
-#ifndef inet_XtoX_prefix
-# define inet_XtoX_prefix inet_
-#endif
-#ifndef inet_XtoX_decl
-# define inet_XtoX_decl /*empty*/
-#endif
-
-#define cc2_(x,y) cc2__(x,y)
-#define cc2__(x,y) x##y
-#define fn(x) cc2_(inet_XtoX_prefix,x)
-
-#ifndef inet_XtoX_no_ntop
-
-inet_XtoX_decl const char *
-fn(ntop)(int af, const void *src, char *dst, unsigned size);
-
-#ifndef inet_XtoX_prototypes
-
-static int mjt_ntop4(const void *_src, char *dst, int size) {
-  unsigned i, x, r;
-  char *p;
-  const unsigned char *s = _src;
-  if (size < 4*4)	/* for simplicity, disallow non-max-size buffer */
-    return 0;
-  for (i = 0, p = dst; i < 4; ++i) {
-    if (i) *p++ = '.';
-    x = r = s[i];
-    if (x > 99) { *p++ = (char)(r / 100 + '0'); r %= 100; }
-    if (x > 9) { *p++ = (char)(r / 10 + '0'); r %= 10; }
-    *p++ = (char)(r + '0');
-  }
-  *p = '\0';
-  return 1;
-}
-
-static char *hexc(char *p, unsigned x) {
-  static char hex[16] = "0123456789abcdef";
-  if (x > 0x0fff) *p++ = hex[(x >>12) & 15];
-  if (x > 0x00ff) *p++ = hex[(x >> 8) & 15];
-  if (x > 0x000f) *p++ = hex[(x >> 4) & 15];
-  *p++ = hex[x & 15];
-  return p;
-}
-
-static int mjt_ntop6(const void *_src, char *dst, int size) {
-  unsigned i;
-  unsigned short w[8];
-  unsigned bs = 0, cs = 0;
-  unsigned bl = 0, cl = 0;
-  char *p;
-  const unsigned char *s = _src;
-
-  if (size < 40)	/* for simplicity, disallow non-max-size buffer */
-    return 0;
-
-  for(i = 0; i < 8; ++i, s += 2) {
-    w[i] = (((unsigned short)(s[0])) << 8) | s[1];
-    if (!w[i]) {
-      if (!cl++) cs = i;
-    }
-    else {
-      if (cl > bl) bl = cl, bs = cs;
-    }
-  }
-  if (cl > bl) bl = cl, bs = cs;
-  p = dst;
-  if (bl == 1)
-    bl = 0;
-  if (bl) {
-    for(i = 0; i < bs; ++i) {
-      if (i) *p++ = ':';
-      p = hexc(p, w[i]);
-    }
-    *p++ = ':';
-    i += bl;
-    if (i == 8)
-      *p++ = ':';
-  }
-  else
-    i = 0;
-  for(; i < 8; ++i) {
-    if (i) *p++ = ':';
-    if (i == 6 && !bs && (bl == 6 || (bl == 5 && w[5] == 0xffff)))
-      return mjt_ntop4(s - 4, p, size - (p - dst));
-    p = hexc(p, w[i]);
-  }
-  *p = '\0';
-  return 1;
-}
-
-inet_XtoX_decl const char *
-fn(ntop)(int af, const void *src, char *dst, unsigned size) {
-  switch(af) {
-  /* don't use AF_*: don't mess with headers */
-  case 2:  /* AF_INET */  if (mjt_ntop4(src, dst, size)) return dst; break;
-  case 10: /* AF_INET6 */ if (mjt_ntop6(src, dst, size)) return dst; break;
-  default: errno = EAFNOSUPPORT; return (char*)0;
-  }
-  errno = ENOSPC;
-  return (char*)0;
-}
-
-inet_XtoX_decl const char *
-fn(ntoa)(struct in_addr addr) {
-  static char buf[4*4];
-  mjt_ntop4(&addr, buf, sizeof(buf));
-  return buf;
-}
-
-#endif /* inet_XtoX_prototypes */
-#endif /* inet_XtoX_no_ntop */
-
-#ifndef inet_XtoX_no_pton
-
-inet_XtoX_decl int fn(pton)(int af, const char *src, void *dst);
-inet_XtoX_decl int fn(aton)(const char *src, struct in_addr *addr);
-
-#ifndef inet_XtoX_prototypes
-
-static int mjt_pton4(const char *c, void *dst) {
-  unsigned char *a = dst;
-  unsigned n, o;
-  for (n = 0; n < 4; ++n) {
-    if (*c < '0' || *c > '9')
-      return 0;
-    o = *c++ - '0';
-    while(*c >= '0' && *c <= '9')
-      if ((o = o * 10 + (*c++ - '0')) > 255)
-        return 0;
-    if (*c++ != (n == 3 ? '\0' : '.'))
-      return 0;
-    *a++ = (unsigned char)o;
-  }
-  return 1;
-}
-
-static int mjt_pton6(const char *c, void *dst) {
-  unsigned short w[8], *a = w, *z, *i;
-  unsigned v, o;
-  const char *sc;
-  unsigned char *d = dst;
-  if (*c != ':') z = (unsigned short*)0;
-  else if (*++c != ':') return 0;
-  else ++c, z = a;
-  i = 0;
-  for(;;) {
-    v = 0;
-    sc = c;
-    for(;;) {
-      if (*c >= '0' && *c <= '9') o = *c - '0';
-      else if (*c >= 'a' && *c <= 'f') o = *c - 'a' + 10;
-      else if (*c >= 'A' && *c <= 'F') o = *c - 'A' + 10;
-      else break;
-      v = (v << 4) | o;
-      if (v > 0xffff) return 0;
-      ++c;
-    }
-    if (sc == c) {
-      if (z == a && !*c)
-        break;
-      else
-        return 0;
-    }
-    if (*c == ':') {
-      if (a >= w + 8)
-        return 0;
-      *a++ = v;
-      if (*++c == ':') {
-        if (z)
-          return 0;
-        z = a;
-        if (!*++c)
-          break;
-      }
-    }
-    else if (!*c) {
-      if (a >= w + 8)
-        return 0;
-      *a++ = v;
-      break;
-    }
-    else if (*c == '.') {
-      if (a > w + 6)
-        return 0;
-      if (!mjt_pton4(sc, d))
-        return 0;
-      *a++ = ((unsigned)(d[0]) << 8) | d[1];
-      *a++ = ((unsigned)(d[2]) << 8) | d[3];
-      break;
-    }
-    else
-      return 0;
-  }
-  v = w + 8 - a;
-  if ((v && !z) || (!v && z))
-    return 0;
-  for(i = w; ; ++i) {
-    if (i == z)
-      while(v--) { *d++ = '\0'; *d++ = '\0'; }
-    if (i >= a)
-      break;
-    *d++ = (unsigned char)((*i >> 8) & 255);
-    *d++ = (unsigned char)(*i & 255);
-  }
-  return 1;
-}
-
-inet_XtoX_decl int fn(pton)(int af, const char *src, void *dst) {
-  switch(af) {
-  /* don't use AF_*: don't mess with headers */
-  case 2  /* AF_INET  */: return mjt_pton4(src, dst);
-  case 10 /* AF_INET6 */: return mjt_pton6(src, dst);
-  default: errno = EAFNOSUPPORT; return -1;
-  }
-}
-
-inet_XtoX_decl int fn(aton)(const char *src, struct in_addr *addr) {
-  return mjt_pton4(src, addr);
-}
-
-#endif /* inet_XtoX_prototypes */
-
-#endif /* inet_XtoX_no_pton */
-
-#ifdef TEST
-
-int main(int argc, char **argv) {
-  int i;
-  char n0[16], n1[16];
-  char p0[64], p1[64];
-  int af = AF_INET;
-  int pl = sizeof(p0);
-  int r0, r1;
-  const char *s0, *s1;
-
-  while((i = getopt(argc, argv, "46a:p:")) != EOF) switch(i) {
-  case '4': af = AF_INET;  break;
-  case '6': af = AF_INET6; break;
-  case 'a': case 'p': pl = atoi(optarg); break;
-  default: return 1;
-  }
-  for(i = optind; i < argc; ++i) {
-    char *a = argv[i];
-
-    printf("%s:\n", a);
-    r0 = inet_pton(af, a, n0);
-    printf(" p2n stock: %s\n",
-     (r0 < 0 ? "(notsupp)" : !r0 ? "(inval)" : fn(ntop)(af,n0,p0,sizeof(p0))));
-    r1 = fn(pton)(af, a, n1);
-    printf(" p2n this : %s\n",
-     (r1 < 0 ? "(notsupp)" : !r1 ? "(inval)" : fn(ntop)(af,n1,p1,sizeof(p1))));
-
-    if ((r0 > 0) != (r1 > 0) ||
-        (r0 > 0 && r1 > 0 && memcmp(n0, n1, af == AF_INET ? 4 : 16) != 0))
-      printf(" DIFFER!\n");
-
-    s0 = inet_ntop(af, n1, p0, pl);
-    printf(" n2p stock: %s\n", s0 ? s0 : "(inval)");
-    s1 = fn(ntop)(af, n1, p1, pl);
-    printf(" n2p this : %s\n", s1 ? s1 : "(inval)");
-    if ((s0 != 0) != (s1 != 0) ||
-        (s0 && s1 && strcmp(s0, s1) != 0))
-      printf(" DIFFER!\n");
-
-  }
-  return 0;
-}
-
-#endif /* TEST */
--- a/3rdparty/udns/rblcheck.1
+++ b/3rdparty/udns/rblcheck.1
@@ -1,151 +0,0 @@
-.\" rblcheck.1
-.\" rblckeck manpage
-.\"
-.\" Copyright (C) 2005  Michael Tokarev <mjt@corpit.ru>
-.\" This file is part of UDNS library, an async DNS stub resolver.
-.\"
-.\" This library is free software; you can redistribute it and/or
-.\" modify it under the terms of the GNU Lesser General Public
-.\" License as published by the Free Software Foundation; either
-.\" version 2.1 of the License, or (at your option) any later version.
-.\"
-.\" This library is distributed in the hope that it will be useful,
-.\" but WITHOUT ANY WARRANTY; without even the implied warranty of
-.\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-.\" Lesser General Public License for more details.
-.\"
-.\" You should have received a copy of the GNU Lesser General Public
-.\" License along with this library, in file named COPYING.LGPL; if not,
-.\" write to the Free Software Foundation, Inc., 59 Temple Place,
-.\" Suite 330, Boston, MA  02111-1307  USA
-
-.TH rblckeck 1 "Apr 2005" "User Utilities"
-
-.SH NAME
-rblckeck \- DNSBL lookup utility
-
-.SH SYNOPSYS
-.B rblcheck
-.RB [\| \-s
-.IR zone \|]
-.RB [\| \-S
-.IR zone\-file \|]
-.RB [\| \-c \|]
-.RB [\| \-tmvq \|]
-.RB [\| \-n
-.IR nsaddr \|]
-.IR address \|.\|.\|.
-
-.SH DESCRIPTION
-.B rblcheck
-is a simple command-line to perform DNSBL (DNS-based blocklists) lookups.
-For every IP address (or a name, in which case it will be resolved to an
-address first), the utility verifies whenever it is listed in a (list of)
-DNS blocklists specified with
-.B \-s
-or
-.B \-S
-options, optionally obtains text assotiated with the listing (usually it
-is either some description about the reason of the listing or an URL
-referring to such a description), and displays results on standard output.
-.PP
-The program is implemented on top of
-.BR udns (3)
-library.
-
-.SH OPTIONS
-
-The following options are recognized by
-.BR rblcheck :
-
-.TP
-.B \-s \fIzone\fR
-add the given \fIzone\fR DNSBL name to the list of active zones.
-.TP
-.B \-S \fIzone-file\fR
-add list of zones from the named \fIzone-file\fR to the list of
-active zones (the file specifies one zone as the first word on a
-line, empty lines and lines starting with `#' character are ignored).
-.TP
-.B \-c
-reset active zone list.
-.TP
-.B \-v
-be more verbose, produce more detailed output.
-.TP
-.B \-q
-the opposite for \fB\-v\fR -- produce less detailed output.
-.TP
-.B \-t
-obtain text for listed addresses.
-.TP
-.B \-n \fInsaddr\fR
-Use the given nameserver (given as IPv4 or IPv6 address) instead of the
-default.  The same effect may be achieved by setting $NSCACHEIP environment
-variable.
-.TP
-.B \-m
-stop after first hit, ie after the first address which is found to be
-listed.
-
-.TP
-.B \-h
-print short help and exit.
-
-.PP
-If no
-.BR \-s ,
-.BR \-S
-and
-.B \-c
-options are given,
-.B rblcheck
-will try to obtain list of zones using $RBLCHECK_ZONES environment variable,
-or ~/.rblcheckrc, or /etc/rblckechrc files, in that order.  If no zones are
-found, it will exit unsuccessefully.
-
-.SH "RETURN VALUE"
-When no addresses given are listed and no errors occured,
-.B rblcheck
-exits with code 0.  If at least one address is listed,
-.B rblcheck
-returns 100.  In case of DNS errors,
-.B rblcheck
-returns 2.
-
-.SH ENVIRONMENT
-
-.TP
-.B $RBLCHECK_ZONES
-if no
-.BR \-s ,
-.B \-S
-or
-.B \-c
-option is given,
-.B rblcheck
-tries this variable to obtain list of DNSBL zones to check against.
-
-.SH FILES
-
-.TP
-$HOME/.rblcheckrc and /etc/rblcheckrc
-if no
-.BR \-s ,
-.B \-S
-or
-.B \-c
-option is given, and no $RBLCHECK_ZONES environment variable is set,
-.B rblcheck
-will try the two files (the first one that exists) to obtain list of
-DNSBL zones to check against.
-Each line specifies one zone (only first word in each line is used).
-Empty lines and lines starting with `#' character are ignored.
-
-.SH "SEE ALSO"
-.BR dnsget (1)
-.BR resolv.conf (5)
-.BR udns (3).
-
-.SH AUTHOR
-This program and manual pages are written by Michael Tokarev.
--- a/3rdparty/udns/rblcheck.c
+++ b/3rdparty/udns/rblcheck.c
@@ -1,380 +0,0 @@
-/* rblcheck.c
-   dnsbl (rbl) checker application
-
-   Copyright (C) 2005  Michael Tokarev <mjt@corpit.ru>
-   This file is part of UDNS library, an async DNS stub resolver.
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this library, in file named COPYING.LGPL; if not,
-   write to the Free Software Foundation, Inc., 59 Temple Place,
-   Suite 330, Boston, MA  02111-1307  USA
-
- */
-
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#ifdef WINDOWS
-# include <winsock2.h>
-#else
-# include <unistd.h>
-# include <sys/types.h>
-# include <sys/socket.h>
-# include <netinet/in.h>
-#endif
-#include <time.h>
-#include <errno.h>
-#include <stdarg.h>
-#include "udns.h"
-
-#ifndef HAVE_GETOPT
-# include "getopt.c"
-#endif
-
-static const char *version = "udns-rblcheck 0.4";
-static char *progname;
-
-static void error(int die, const char *fmt, ...) {
-  va_list ap;
-  fprintf(stderr, "%s: ", progname);
-  va_start(ap, fmt); vfprintf(stderr, fmt, ap); va_end(ap);
-  putc('\n', stderr);
-  fflush(stderr);
-  if (die)
-    exit(1);
-}
-
-struct rblookup {
-  struct ipcheck *parent;
-  struct in_addr key;
-  const char *zone;
-  struct dns_rr_a4  *addr;
-  struct dns_rr_txt *txt;
-};
-
-struct ipcheck {
-  const char *name;
-  int naddr;
-  int listed;
-  struct rblookup *lookup;
-};
-
-#define notlisted ((void*)1)
-
-static int nzones, nzalloc;
-static const char **zones;
-
-static int do_txt;
-static int stopfirst;
-static int verbose = 1;
-/* verbosity level:
- * <0 - only bare As/TXTs
- * 0 - what RBL result
- * 1(default) - what is listed by RBL: result
- * 2          - what is[not ]listed by RBL: result, name lookups
- */
-
-static int listed;
-static int failures;
-
-static void *ecalloc(int size, int cnt) {
-  void *t = calloc(size, cnt);
-  if (!t)
-    error(1, "out of memory");
-  return t;
-}
-
-static void addzone(const char *zone) {
-  if (nzones >= nzalloc) {
-    const char **zs = (const char**)ecalloc(sizeof(char*), (nzalloc += 16));
-    if (zones) {
-      memcpy(zs, zones, nzones * sizeof(char*));
-      free(zones);
-    }
-    zones = zs;
-  }
-  zones[nzones++] = zone;
-}
-
-static int addzonefile(const char *fname) {
-  FILE *f = fopen(fname, "r");
-  char linebuf[2048];
-  if (!f)
-    return 0;
-  while(fgets(linebuf, sizeof(linebuf), f)) {
-    char *p = linebuf, *e;
-    while(*p == ' ' || *p == '\t') ++p;
-    if (*p == '#' || *p == '\n') continue;
-    e = p;
-    while(*e && *e != ' ' && *e != '\t' && *e != '\n')
-      ++e;
-    *e++ = '\0';
-    p = memcpy(ecalloc(e - p, 1), p, e - p); // strdup
-    addzone(p);
-  }
-  fclose(f);
-  return 1;
-}
-
-static void dnserror(struct rblookup *ipl, const char *what) {
-  char buf[4*4];
-  error(0, "unable to %s for %s (%s): %s",
-          what, dns_ntop(AF_INET, &ipl->key, buf, sizeof(buf)),
-          ipl->zone, dns_strerror(dns_status(0)));
-  ++failures;
-}
-
-static void display_result(struct ipcheck *ipc) {
-  int j;
-  struct rblookup *l, *le;
-  char buf[4*4];
-  if (!ipc->naddr) return;
-  for (l = ipc->lookup, le = l + nzones * ipc->naddr; l < le; ++l) {
-    if (!l->addr) continue;
-    if (verbose < 2 && l->addr == notlisted) continue;
-    if (verbose >= 0) {
-      dns_ntop(AF_INET, &l->key, buf, sizeof(buf));
-      if (ipc->name) printf("%s[%s]", ipc->name, buf);
-      else printf("%s", buf);
-    }
-    if (l->addr == notlisted) {
-      printf(" is NOT listed by %s\n", l->zone);
-      continue;
-    }
-    else if (verbose >= 1)
-      printf(" is listed by %s: ", l->zone);
-    else if (verbose >= 0)
-      printf(" %s ", l->zone);
-    if (verbose >= 1 || !do_txt)
-      for (j = 0; j < l->addr->dnsa4_nrr; ++j)
-        printf("%s%s", j ? " " : "",
-               dns_ntop(AF_INET, &l->addr->dnsa4_addr[j], buf, sizeof(buf)));
-    if (!do_txt) ;
-    else if (l->txt) {
-      for(j = 0; j < l->txt->dnstxt_nrr; ++j) {
-        unsigned char *t = l->txt->dnstxt_txt[j].txt;
-        unsigned char *e = t + l->txt->dnstxt_txt[j].len;
-        printf("%s\"", verbose > 0 ? "\n\t" : j ? " " : "");
-        while(t < e) {
-          if (*t < ' ' || *t >= 127) printf("\\x%02x", *t);
-          else if (*t == '\\' || *t == '"') printf("\\%c", *t);
-          else putchar(*t);
-          ++t;
-        }
-        putchar('"');
-      }
-      free(l->txt);
-    }
-    else
-      printf("%s<no text available>", verbose > 0 ? "\n\t" : "");
-    free(l->addr);
-    putchar('\n');
-  }
-  free(ipc->lookup);
-}
-
-static void txtcb(struct dns_ctx *ctx, struct dns_rr_txt *r, void *data) {
-  struct rblookup *ipl = data;
-  if (r) {
-    ipl->txt = r;
-    ++ipl->parent->listed;
-  }
-  else if (dns_status(ctx) != DNS_E_NXDOMAIN)
-    dnserror(ipl, "lookup DNSBL TXT record");
-}
-
-static void a4cb(struct dns_ctx *ctx, struct dns_rr_a4 *r, void *data) {
-  struct rblookup *ipl = data;
-  if (r) {
-    ipl->addr = r;
-    ++listed;
-    if (do_txt) {
-      if (dns_submit_a4dnsbl_txt(0, &ipl->key, ipl->zone, txtcb, ipl))
-        return;
-      dnserror(ipl, "submit DNSBL TXT record");
-    }
-    ++ipl->parent->listed;
-  }
-  else if (dns_status(ctx) != DNS_E_NXDOMAIN)
-    dnserror(ipl, "lookup DNSBL A record");
-  else
-    ipl->addr = notlisted;
-}
-
-static int
-submit_a_queries(struct ipcheck *ipc,
-                 int naddr, const struct in_addr *addr) {
-  int z, a;
-  struct rblookup *rl = ecalloc(sizeof(*rl), nzones * naddr);
-  ipc->lookup = rl;
-  ipc->naddr = naddr;
-  for(a = 0; a < naddr; ++a) {
-    for(z = 0; z < nzones; ++z) {
-      rl->key = addr[a];
-      rl->zone = zones[z];
-      rl->parent = ipc;
-      if (!dns_submit_a4dnsbl(0, &rl->key, rl->zone, a4cb, rl))
-        dnserror(rl, "submit DNSBL A query");
-      ++rl;
-    }
-  }
-  return 0;
-}
-
-static void namecb(struct dns_ctx *ctx, struct dns_rr_a4 *rr, void *data) {
-  struct ipcheck *ipc = data;
-  if (rr) {
-    submit_a_queries(ipc, rr->dnsa4_nrr, rr->dnsa4_addr);
-    free(rr);
-  }
-  else {
-    error(0, "unable to lookup `%s': %s",
-          ipc->name, dns_strerror(dns_status(ctx)));
-    ++failures;
-  }
-}
-
-static int submit(struct ipcheck *ipc) {
-  struct in_addr addr;
-  if (dns_pton(AF_INET, ipc->name, &addr) > 0) {
-    submit_a_queries(ipc, 1, &addr);
-    ipc->name = NULL;
-  }
-  else if (!dns_submit_a4(0, ipc->name, 0, namecb, ipc)) {
-    error(0, "unable to submit name query for %s: %s\n",
-          ipc->name, dns_strerror(dns_status(0)));
-    ++failures;
-  }
-  return 0;
-}
-
-static void waitdns(struct ipcheck *ipc) {
-  struct timeval tv;
-  fd_set fds;
-  int c;
-  int fd = dns_sock(NULL);
-  time_t now = 0;
-  FD_ZERO(&fds);
-  while((c = dns_timeouts(NULL, -1, now)) > 0) {
-    FD_SET(fd, &fds);
-    tv.tv_sec = c;
-    tv.tv_usec = 0;
-    c = select(fd+1, &fds, NULL, NULL, &tv);
-    now = time(NULL);
-    if (c > 0)
-      dns_ioevent(NULL, now);
-    if (stopfirst && ipc->listed)
-      break;
-  }
-}
-
-int main(int argc, char **argv) {
-  int c;
-  struct ipcheck ipc;
-  char *nameserver = NULL;
-  int zgiven = 0;
-
-  if (!(progname = strrchr(argv[0], '/'))) progname = argv[0];
-  else argv[0] = ++progname;
-
-  while((c = getopt(argc, argv, "hqtvms:S:cn:")) != EOF) switch(c) {
-  case 's': ++zgiven; addzone(optarg); break;
-  case 'S':
-    ++zgiven;
-    if (addzonefile(optarg)) break;
-    error(1, "unable to read zonefile `%s'", optarg);
-  case 'c': ++zgiven; nzones = 0; break;
-  case 'q': --verbose; break;
-  case 'v': ++verbose; break;
-  case 't': do_txt = 1; break;
-  case 'n': nameserver = optarg; break;
-  case 'm': ++stopfirst; break;
-  case 'h':
-    printf("%s: %s (udns library version %s).\n",
-           progname, version, dns_version());
-    printf("Usage is: %s [options] address..\n", progname);
-    printf(
-"Where options are:\n"
-" -h - print this help and exit\n"
-" -s service - add the service (DNSBL zone) to the serice list\n"
-" -S service-file - add the DNSBL zone(s) read from the given file\n"
-" -c - clear service list\n"
-" -v - increase verbosity level (more -vs => more verbose)\n"
-" -q - decrease verbosity level (opposite of -v)\n"
-" -t - obtain and print TXT records if any\n"
-" -m - stop checking after first address match in any list\n"
-" -n ipaddr - use the given nameserver instead of the default\n"
-"(if no -s or -S option is given, use $RBLCHECK_ZONES, ~/.rblcheckrc\n"
-"or /etc/rblcheckrc in that order)\n"
-    );
-    return 0;
-  default:
-    error(1, "use `%s -h' for help", progname);
-  }
-
-  if (!zgiven) {
-    char *s = getenv("RBLCHECK_ZONES");
-    if (s) {
-      char *k;
-      s = strdup(s);
-      for(k = strtok(s, " \t"); k; k = strtok(NULL, " \t"))
-        addzone(k);
-      free(s);
-    }
-    else {	/* probably worthless on windows? */
-      char *path;
-      char *home = getenv("HOME");
-      if (!home) home = ".";
-      path = malloc(strlen(home) + 1 + sizeof(".rblcheckrc"));
-      if (path) {
-        sprintf(path, "%s/.rblcheckrc", home);
-        if (!addzonefile(path))
-          addzonefile("/etc/rblcheckrc");
-        free(path);
-      }
-    }
-  }
-  if (!nzones)
-    error(1, "no service (zone) list specified (-s or -S option)");
-
-  argv += optind;
-  argc -= optind;
-
-  if (!argc)
-    return 0;
-
-  if (dns_init(NULL, 0) < 0)
-    error(1, "unable to initialize DNS library: %s", strerror(errno));
-  if (nameserver) {
-    dns_add_serv(NULL, NULL);
-    if (dns_add_serv(NULL, nameserver) < 0)
-      error(1, "wrong IP address for a nameserver: `%s'", nameserver);
-  }
-  if (dns_open(NULL) < 0)
-    error(1, "unable to initialize DNS library: %s", strerror(errno));
-
-  for (c = 0; c < argc; ++c) {
-    if (c && (verbose > 1 || (verbose == 1 && do_txt))) putchar('\n');
-    memset(&ipc, 0, sizeof(ipc));
-    ipc.name = argv[c];
-    submit(&ipc);
-    waitdns(&ipc);
-    display_result(&ipc);
-    if (stopfirst > 1 && listed) break;
-  }
-
-  return listed ? 100 : failures ? 2 : 0;
-}
--- a/3rdparty/udns/udns.3
+++ b/3rdparty/udns/udns.3
--- a/3rdparty/udns/udns.h
+++ b/3rdparty/udns/udns.h
@@ -1,779 +0,0 @@
-/* udns.h
-   header file for the UDNS library.
-
-   Copyright (C) 2005  Michael Tokarev <mjt@corpit.ru>
-   This file is part of UDNS library, an async DNS stub resolver.
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this library, in file named COPYING.LGPL; if not,
-   write to the Free Software Foundation, Inc., 59 Temple Place,
-   Suite 330, Boston, MA  02111-1307  USA
-
- */
-
-#ifndef UDNS_VERSION	/* include guard */
-
-#define UDNS_VERSION "0.4"
-
-#ifdef WINDOWS
-# ifdef UDNS_DYNAMIC_LIBRARY
-#  ifdef DNS_LIBRARY_BUILD
-#   define UDNS_API __declspec(dllexport)
-#   define UDNS_DATA_API __declspec(dllexport)
-#  else
-#   define UDNS_API __declspec(dllimport)
-#   define UDNS_DATA_API __declspec(dllimport)
-#  endif
-# endif
-#endif
-
-#ifndef UDNS_API
-# define UDNS_API
-#endif
-#ifndef UDNS_DATA_API
-# define UDNS_DATA_API
-#endif
-
-#include <sys/types.h>		/* for time_t */
-#include <time.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* forward declarations if sockets stuff isn't #include'd */
-struct in_addr;
-struct in6_addr;
-struct sockaddr;
-
-/**************************************************************************/
-/**************** Common definitions **************************************/
-
-UDNS_API const char *
-dns_version(void);
-
-struct dns_ctx;
-struct dns_query;
-
-/* shorthand for [const] unsigned char */
-typedef unsigned char dnsc_t;
-typedef const unsigned char dnscc_t;
-
-#define DNS_MAXDN	255	/* max DN length */
-#define DNS_DNPAD	1	/* padding for DN buffers */
-#define DNS_MAXLABEL	63	/* max DN label length */
-#define DNS_MAXNAME	1024	/* max asciiz domain name length */
-#define DNS_HSIZE	12	/* DNS packet header size */
-#define DNS_PORT	53	/* default domain port */
-#define DNS_MAXSERV	6	/* max servers to consult */
-#define DNS_MAXPACKET	512	/* max traditional-DNS UDP packet size */
-#define DNS_EDNS0PACKET	4096	/* EDNS0 packet size to use */
-
-enum dns_class {	/* DNS RR Classes */
-  DNS_C_INVALID	= 0,	/* invalid class */
-  DNS_C_IN	= 1,	/* Internet */
-  DNS_C_CH	= 3,	/* CHAOS */
-  DNS_C_HS	= 4,	/* HESIOD */
-  DNS_C_ANY	= 255	/* wildcard */
-};
-
-enum dns_type {		/* DNS RR Types */
-  DNS_T_INVALID		= 0,	/* Cookie. */
-  DNS_T_A		= 1,	/* Host address. */
-  DNS_T_NS		= 2,	/* Authoritative server. */
-  DNS_T_MD		= 3,	/* Mail destination. */
-  DNS_T_MF		= 4,	/* Mail forwarder. */
-  DNS_T_CNAME		= 5,	/* Canonical name. */
-  DNS_T_SOA		= 6,	/* Start of authority zone. */
-  DNS_T_MB		= 7,	/* Mailbox domain name. */
-  DNS_T_MG		= 8,	/* Mail group member. */
-  DNS_T_MR		= 9,	/* Mail rename name. */
-  DNS_T_NULL		= 10,	/* Null resource record. */
-  DNS_T_WKS		= 11,	/* Well known service. */
-  DNS_T_PTR		= 12,	/* Domain name pointer. */
-  DNS_T_HINFO		= 13,	/* Host information. */
-  DNS_T_MINFO		= 14,	/* Mailbox information. */
-  DNS_T_MX		= 15,	/* Mail routing information. */
-  DNS_T_TXT		= 16,	/* Text strings. */
-  DNS_T_RP		= 17,	/* Responsible person. */
-  DNS_T_AFSDB		= 18,	/* AFS cell database. */
-  DNS_T_X25		= 19,	/* X_25 calling address. */
-  DNS_T_ISDN		= 20,	/* ISDN calling address. */
-  DNS_T_RT		= 21,	/* Router. */
-  DNS_T_NSAP		= 22,	/* NSAP address. */
-  DNS_T_NSAP_PTR	= 23,	/* Reverse NSAP lookup (deprecated). */
-  DNS_T_SIG		= 24,	/* Security signature. */
-  DNS_T_KEY		= 25,	/* Security key. */
-  DNS_T_PX		= 26,	/* X.400 mail mapping. */
-  DNS_T_GPOS		= 27,	/* Geographical position (withdrawn). */
-  DNS_T_AAAA		= 28,	/* Ip6 Address. */
-  DNS_T_LOC		= 29,	/* Location Information. */
-  DNS_T_NXT		= 30,	/* Next domain (security). */
-  DNS_T_EID		= 31,	/* Endpoint identifier. */
-  DNS_T_NIMLOC		= 32,	/* Nimrod Locator. */
-  DNS_T_SRV		= 33,	/* Server Selection. */
-  DNS_T_ATMA		= 34,	/* ATM Address */
-  DNS_T_NAPTR		= 35,	/* Naming Authority PoinTeR */
-  DNS_T_KX		= 36,	/* Key Exchange */
-  DNS_T_CERT		= 37,	/* Certification record */
-  DNS_T_A6		= 38,	/* IPv6 address (deprecates AAAA) */
-  DNS_T_DNAME		= 39,	/* Non-terminal DNAME (for IPv6) */
-  DNS_T_SINK		= 40,	/* Kitchen sink (experimentatl) */
-  DNS_T_OPT		= 41,	/* EDNS0 option (meta-RR) */
-  DNS_T_DS		= 43,	/* DNSSEC */
-  DNS_T_SSHFP		= 44,
-  DNS_T_IPSECKEY	= 45,
-  DNS_T_RRSIG		= 46,	/* DNSSEC */
-  DNS_T_NSEC		= 47,	/* DNSSEC */
-  DNS_T_DNSKEY		= 48,
-  DNS_T_DHCID		= 49,
-  DNS_T_NSEC3		= 50,
-  DNS_T_NSEC3PARAMS	= 51,
-  DNS_T_TALINK		= 58, /* draft-ietf-dnsop-trust-history */
-  DNS_T_SPF		= 99,
-  DNS_T_UINFO		= 100,
-  DNS_T_UID		= 101,
-  DNS_T_GID		= 102,
-  DNS_T_UNSPEC		= 103,
-  DNS_T_TSIG		= 250,	/* Transaction signature. */
-  DNS_T_IXFR		= 251,	/* Incremental zone transfer. */
-  DNS_T_AXFR		= 252,	/* Transfer zone of authority. */
-  DNS_T_MAILB		= 253,	/* Transfer mailbox records. */
-  DNS_T_MAILA		= 254,	/* Transfer mail agent records. */
-  DNS_T_ANY		= 255,	/* Wildcard match. */
-  DNS_T_ZXFR		= 256,	/* BIND-specific, nonstandard. */
-  DNS_T_DLV		= 32769, /* RFC 4431, 5074, DNSSEC Lookaside Validation */
-  DNS_T_MAX		= 65536
-};
-
-/**************************************************************************/
-/**************** Domain Names (DNs) **************************************/
-
-/* return length of the DN */
-UDNS_API unsigned
-dns_dnlen(dnscc_t *dn);
-
-/* return #of labels in a DN */
-UDNS_API unsigned
-dns_dnlabels(dnscc_t *dn);
-
-/* lower- and uppercase single DN char */
-#define DNS_DNLC(c) ((c) >= 'A' && (c) <= 'Z' ? (c) - 'A' + 'a' : (c))
-#define DNS_DNUC(c) ((c) >= 'a' && (c) <= 'z' ? (c) - 'a' + 'A' : (c))
-
-/* compare the DNs, return dnlen of equal or 0 if not */
-UDNS_API unsigned
-dns_dnequal(dnscc_t *dn1, dnscc_t *dn2);
-
-/* copy one DN to another, size checking */
-UDNS_API unsigned
-dns_dntodn(dnscc_t *sdn, dnsc_t *ddn, unsigned ddnsiz);
-
-/* convert asciiz string of length namelen (0 to use strlen) to DN */
-UDNS_API int
-dns_ptodn(const char *name, unsigned namelen,
-          dnsc_t *dn, unsigned dnsiz, int *isabs);
-
-/* simpler form of dns_ptodn() */
-#define dns_sptodn(name,dn,dnsiz) dns_ptodn((name),0,(dn),(dnsiz),0)
-
-UDNS_DATA_API extern dnscc_t dns_inaddr_arpa_dn[14];
-#define DNS_A4RSIZE	30
-UDNS_API int
-dns_a4todn(const struct in_addr *addr, dnscc_t *tdn,
-           dnsc_t *dn, unsigned dnsiz);
-UDNS_API int
-dns_a4ptodn(const struct in_addr *addr, const char *tname,
-            dnsc_t *dn, unsigned dnsiz);
-UDNS_API dnsc_t *
-dns_a4todn_(const struct in_addr *addr, dnsc_t *dn, dnsc_t *dne);
-
-UDNS_DATA_API extern dnscc_t dns_ip6_arpa_dn[10];
-#define DNS_A6RSIZE	74
-UDNS_API int
-dns_a6todn(const struct in6_addr *addr, dnscc_t *tdn,
-           dnsc_t *dn, unsigned dnsiz);
-UDNS_API int
-dns_a6ptodn(const struct in6_addr *addr, const char *tname,
-            dnsc_t *dn, unsigned dnsiz);
-UDNS_API dnsc_t *
-dns_a6todn_(const struct in6_addr *addr, dnsc_t *dn, dnsc_t *dne);
-
-/* convert DN into asciiz string */
-UDNS_API int
-dns_dntop(dnscc_t *dn, char *name, unsigned namesiz);
-
-/* convert DN into asciiz string, using static buffer (NOT thread-safe!) */
-UDNS_API const char *
-dns_dntosp(dnscc_t *dn);
-
-/* return buffer size (incl. null byte) required for asciiz form of a DN */
-UDNS_API unsigned
-dns_dntop_size(dnscc_t *dn);
-
-/* either wrappers or reimplementations for inet_ntop() and inet_pton() */
-UDNS_API const char *dns_ntop(int af, const void *src, char *dst, int size);
-UDNS_API int dns_pton(int af, const char *src, void *dst);
-
-/**************************************************************************/
-/**************** DNS raw packet layout ***********************************/
-
-enum dns_rcode {	/* reply codes */
-  DNS_R_NOERROR		= 0,	/* ok, no error */
-  DNS_R_FORMERR		= 1,	/* format error */
-  DNS_R_SERVFAIL	= 2,	/* server failed */
-  DNS_R_NXDOMAIN	= 3,	/* domain does not exists */
-  DNS_R_NOTIMPL		= 4,	/* not implemented */
-  DNS_R_REFUSED		= 5,	/* query refused */
-  /* these are for BIND_UPDATE */
-  DNS_R_YXDOMAIN	= 6,	/* Name exists */
-  DNS_R_YXRRSET		= 7,	/* RRset exists */
-  DNS_R_NXRRSET		= 8,	/* RRset does not exist */
-  DNS_R_NOTAUTH		= 9,	/* Not authoritative for zone */
-  DNS_R_NOTZONE		= 10,	/* Zone of record different from zone section */
-  /*ns_r_max = 11,*/
-  /* The following are TSIG extended errors */
-  DNS_R_BADSIG		= 16,
-  DNS_R_BADKEY		= 17,
-  DNS_R_BADTIME		= 18
-};
-
-static __inline unsigned dns_get16(dnscc_t *s) {
-  return ((unsigned)s[0]<<8) | s[1];
-}
-static __inline unsigned dns_get32(dnscc_t *s) {
-  return ((unsigned)s[0]<<24) | ((unsigned)s[1]<<16)
-        | ((unsigned)s[2]<<8) | s[3];
-}
-static __inline dnsc_t *dns_put16(dnsc_t *d, unsigned n) {
-  *d++ = (dnsc_t)((n >> 8) & 255); *d++ = (dnsc_t)(n & 255); return d;
-}
-static __inline dnsc_t *dns_put32(dnsc_t *d, unsigned n) {
-  *d++ = (dnsc_t)((n >> 24) & 255); *d++ = (dnsc_t)((n >> 16) & 255);
-  *d++ = (dnsc_t)((n >>  8) & 255); *d++ = (dnsc_t)(n & 255);
-  return d;
-}
-
-/* DNS Header layout */
-enum {
- /* bytes 0:1 - query ID */
-  DNS_H_QID1	= 0,
-  DNS_H_QID2	= 1,
-  DNS_H_QID	= DNS_H_QID1,
-#define dns_qid(pkt)	dns_get16((pkt)+DNS_H_QID)
- /* byte 2: flags1 */
-  DNS_H_F1	= 2,
-  DNS_HF1_QR	= 0x80,	/* query response flag */
-#define dns_qr(pkt)	((pkt)[DNS_H_F1]&DNS_HF1_QR)
-  DNS_HF1_OPCODE = 0x78, /* opcode, 0 = query */
-#define dns_opcode(pkt)	(((pkt)[DNS_H_F1]&DNS_HF1_OPCODE)>>3)
-  DNS_HF1_AA	= 0x04,	/* auth answer */
-#define dns_aa(pkt)	((pkt)[DNS_H_F1]&DNS_HF1_AA)
-  DNS_HF1_TC	= 0x02,	/* truncation flag */
-#define dns_tc(pkt)	((pkt)[DNS_H_F1]&DNS_HF1_TC)
-  DNS_HF1_RD	= 0x01,	/* recursion desired (may be set in query) */
-#define dns_rd(pkt)	((pkt)[DNS_H_F1]&DNS_HF1_RD)
- /* byte 3: flags2 */
-  DNS_H_F2	= 3,
-  DNS_HF2_RA	= 0x80,	/* recursion available */
-#define dns_ra(pkt)	((pkt)[DNS_H_F2]&DNS_HF2_RA)
-  DNS_HF2_Z	= 0x40,	/* reserved */
-  DNS_HF2_AD	= 0x20, /* DNSSEC: authentic data */
-#define dns_ad(pkt)	((pkt)[DNS_H_F2]&DNS_HF2_AD)
-  DNS_HF2_CD	= 0x10, /* DNSSEC: checking disabled */
-#define dns_cd(pkt)	((pkt)[DNS_H_F2]&DNS_HF2_CD)
-  DNS_HF2_RCODE	= 0x0f,	/* response code, DNS_R_XXX above */
-#define dns_rcode(pkt)	((pkt)[DNS_H_F2]&DNS_HF2_RCODE)
- /* bytes 4:5: qdcount, numqueries */
-  DNS_H_QDCNT1	= 4,
-  DNS_H_QDCNT2	= 5,
-  DNS_H_QDCNT	= DNS_H_QDCNT1,
-#define dns_numqd(pkt)	dns_get16((pkt)+4)
- /* bytes 6:7: ancount, numanswers */
-  DNS_H_ANCNT1	= 6,
-  DNS_H_ANCNT2	= 7,
-  DNS_H_ANCNT	= DNS_H_ANCNT1,
-#define dns_numan(pkt)	dns_get16((pkt)+6)
- /* bytes 8:9: nscount, numauthority */
-  DNS_H_NSCNT1	= 8,
-  DNS_H_NSCNT2	= 9,
-  DNS_H_NSCNT	= DNS_H_NSCNT1,
-#define dns_numns(pkt)	dns_get16((pkt)+8)
- /* bytes 10:11: arcount, numadditional */
-  DNS_H_ARCNT1	= 10,
-  DNS_H_ARCNT2	= 11,
-  DNS_H_ARCNT	= DNS_H_ARCNT1,
-#define dns_numar(pkt)	dns_get16((pkt)+10)
-#define dns_payload(pkt) ((pkt)+DNS_HSIZE)
-  /* EDNS0 (OPT RR) flags (Ext. Flags) */
-  DNS_EF1_DO	= 0x80, /* DNSSEC OK */
-};
-
-/* packet buffer: start at pkt, end before pkte, current pos *curp.
- * extract a DN and set *curp to the next byte after DN in packet.
- * return -1 on error, 0 if dnsiz is too small, or dnlen on ok.
- */
-UDNS_API int
-dns_getdn(dnscc_t *pkt, dnscc_t **curp, dnscc_t *end,
-          dnsc_t *dn, unsigned dnsiz);
-
-/* skip the DN at position cur in packet ending before pkte,
- * return pointer to the next byte after the DN or NULL on error */
-UDNS_API dnscc_t *
-dns_skipdn(dnscc_t *end, dnscc_t *cur);
-
-struct dns_rr {		/* DNS Resource Record */
-  dnsc_t dnsrr_dn[DNS_MAXDN];	/* the DN of the RR */
-  enum dns_class dnsrr_cls;	/* Class */
-  enum dns_type  dnsrr_typ;	/* Type */
-  unsigned dnsrr_ttl;		/* Time-To-Live (TTL) */
-  unsigned dnsrr_dsz;		/* data size */
-  dnscc_t *dnsrr_dptr;		/* pointer to start of data */
-  dnscc_t *dnsrr_dend;		/* past end of data */
-};
-
-struct dns_parse {	/* RR/packet parsing state */
-  dnscc_t *dnsp_pkt;		/* start of the packet */
-  dnscc_t *dnsp_end;		/* end of the packet */
-  dnscc_t *dnsp_cur;		/* current packet position */
-  dnscc_t *dnsp_ans;		/* start of answer section */
-  int dnsp_rrl;			/* number of RRs left to go */
-  int dnsp_nrr;			/* RR count so far */
-  unsigned dnsp_ttl;		/* TTL value so far */
-  dnscc_t *dnsp_qdn;		/* the RR DN we're looking for */
-  enum dns_class dnsp_qcls;	/* RR class we're looking for or 0 */
-  enum dns_type  dnsp_qtyp;	/* RR type we're looking for or 0 */
-  dnsc_t dnsp_dnbuf[DNS_MAXDN];	/* domain buffer */
-};
-
-/* initialize the parse structure */
-UDNS_API void
-dns_initparse(struct dns_parse *p, dnscc_t *qdn,
-              dnscc_t *pkt, dnscc_t *cur, dnscc_t *end);
-
-/* search next RR, <0=error, 0=no more RRs, >0 = found. */
-UDNS_API int
-dns_nextrr(struct dns_parse *p, struct dns_rr *rr);
-
-UDNS_API void
-dns_rewind(struct dns_parse *p, dnscc_t *qdn);
-
-
-/**************************************************************************/
-/**************** Resolver Context ****************************************/
-
-/* default resolver context */
-UDNS_DATA_API extern struct dns_ctx dns_defctx;
-
-/* reset resolver context to default state, close it if open, drop queries */
-UDNS_API void
-dns_reset(struct dns_ctx *ctx);
-
-/* reset resolver context and read in system configuration */
-UDNS_API int
-dns_init(struct dns_ctx *ctx, int do_open);
-
-/* return new resolver context with the same settings as copy */
-UDNS_API struct dns_ctx *
-dns_new(const struct dns_ctx *copy);
-
-/* free resolver context returned by dns_new(); all queries are dropped */
-UDNS_API void
-dns_free(struct dns_ctx *ctx);
-
-/* add nameserver for a resolver context (or reset nslist if serv==NULL) */
-UDNS_API int
-dns_add_serv(struct dns_ctx *ctx, const char *serv);
-
-/* add nameserver using struct sockaddr structure (with ports) */
-UDNS_API int
-dns_add_serv_s(struct dns_ctx *ctx, const struct sockaddr *sa);
-
-/* add search list element for a resolver context (or reset it if srch==NULL) */
-UDNS_API int
-dns_add_srch(struct dns_ctx *ctx, const char *srch);
-
-/* set options for a resolver context */
-UDNS_API int
-dns_set_opts(struct dns_ctx *ctx, const char *opts);
-
-enum dns_opt {		/* options */
-  DNS_OPT_FLAGS,	/* flags, DNS_F_XXX */
-  DNS_OPT_TIMEOUT,	/* timeout in secounds */
-  DNS_OPT_NTRIES,	/* number of retries */
-  DNS_OPT_NDOTS,	/* ndots */
-  DNS_OPT_UDPSIZE,	/* EDNS0 UDP size */
-  DNS_OPT_PORT,		/* port to use */
-};
-
-/* set or get (if val<0) an option */
-UDNS_API int
-dns_set_opt(struct dns_ctx *ctx, enum dns_opt opt, int val);
-
-enum dns_flags {
-  DNS_NOSRCH	= 0x00010000,	/* do not perform search */
-  DNS_NORD	= 0x00020000,	/* request no recursion */
-  DNS_AAONLY	= 0x00040000,	/* set AA flag in queries */
-  DNS_SET_DO	= 0x00080000,	/* set EDNS0 "DO" bit (DNSSEC OK) */
-  DNS_SET_CD	= 0x00100000,	/* set CD bit (DNSSEC: checking disabled) */
-};
-
-/* set the debug function pointer */
-typedef void
-(dns_dbgfn)(int code, const struct sockaddr *sa, unsigned salen,
-            dnscc_t *pkt, int plen,
-            const struct dns_query *q, void *data);
-UDNS_API void
-dns_set_dbgfn(struct dns_ctx *ctx, dns_dbgfn *dbgfn);
-
-/* open and return UDP socket */
-UDNS_API int
-dns_open(struct dns_ctx *ctx);
-
-/* return UDP socket or -1 if not open */
-UDNS_API int
-dns_sock(const struct dns_ctx *ctx);
-
-/* close the UDP socket */
-UDNS_API void
-dns_close(struct dns_ctx *ctx);
-
-/* return number of requests queued */
-UDNS_API int
-dns_active(const struct dns_ctx *ctx);
-
-/* return status of the last operation */
-UDNS_API int
-dns_status(const struct dns_ctx *ctx);
-UDNS_API void
-dns_setstatus(struct dns_ctx *ctx, int status);
-
-/* handle I/O event on UDP socket */
-UDNS_API void
-dns_ioevent(struct dns_ctx *ctx, time_t now);
-
-/* process any timeouts, return time in secounds to the
- * next timeout (or -1 if none) but not greather than maxwait */
-UDNS_API int
-dns_timeouts(struct dns_ctx *ctx, int maxwait, time_t now);
-
-/* define timer requesting routine to use */
-typedef void dns_utm_fn(struct dns_ctx *ctx, int timeout, void *data);
-UDNS_API void
-dns_set_tmcbck(struct dns_ctx *ctx, dns_utm_fn *fn, void *data);
-
-/**************************************************************************/
-/**************** Making Queries ******************************************/
-
-/* query callback routine */
-typedef void dns_query_fn(struct dns_ctx *ctx, void *result, void *data);
-
-/* query parse routine: raw DNS => application structure */
-typedef int
-dns_parse_fn(dnscc_t *qdn, dnscc_t *pkt, dnscc_t *cur, dnscc_t *end,
-             void **res);
-
-enum dns_status {
-  DNS_E_NOERROR		= 0,	/* ok, not an error */
-  DNS_E_TEMPFAIL	= -1,	/* timeout, SERVFAIL or similar */
-  DNS_E_PROTOCOL	= -2,	/* got garbled reply */
-  DNS_E_NXDOMAIN	= -3,	/* domain does not exists */
-  DNS_E_NODATA		= -4,	/* domain exists but no data of reqd type */
-  DNS_E_NOMEM		= -5,	/* out of memory while processing */
-  DNS_E_BADQUERY	= -6	/* the query is malformed */
-};
-
-/* submit generic DN query */
-UDNS_API struct dns_query *
-dns_submit_dn(struct dns_ctx *ctx,
-              dnscc_t *dn, int qcls, int qtyp, int flags,
-              dns_parse_fn *parse, dns_query_fn *cbck, void *data);
-/* submit generic name query */
-UDNS_API struct dns_query *
-dns_submit_p(struct dns_ctx *ctx,
-             const char *name, int qcls, int qtyp, int flags,
-             dns_parse_fn *parse, dns_query_fn *cbck, void *data);
-
-/* cancel the given async query in progress */
-UDNS_API int
-dns_cancel(struct dns_ctx *ctx, struct dns_query *q);
-
-/* resolve a generic query, return the answer */
-UDNS_API void *
-dns_resolve_dn(struct dns_ctx *ctx,
-               dnscc_t *qdn, int qcls, int qtyp, int flags,
-               dns_parse_fn *parse);
-UDNS_API void *
-dns_resolve_p(struct dns_ctx *ctx,
-              const char *qname, int qcls, int qtyp, int flags,
-              dns_parse_fn *parse);
-UDNS_API void *
-dns_resolve(struct dns_ctx *ctx, struct dns_query *q);
-
-
-/* Specific RR handlers */
-
-#define dns_rr_common(prefix)						\
-  char *prefix##_cname;		/* canonical name */			\
-  char *prefix##_qname;		/* original query name */		\
-  unsigned prefix##_ttl;	/* TTL value */				\
-  int prefix##_nrr		/* number of records */
-
-struct dns_rr_null {		/* NULL RRset, aka RRset template */
-  dns_rr_common(dnsn);
-};
-
-UDNS_API int
-dns_stdrr_size(const struct dns_parse *p);
-UDNS_API void *
-dns_stdrr_finish(struct dns_rr_null *ret, char *cp, const struct dns_parse *p);
-
-struct dns_rr_a4 {		/* the A RRset */
-  dns_rr_common(dnsa4);
-  struct in_addr *dnsa4_addr;	/* array of addresses, naddr elements */
-};
-
-UDNS_API dns_parse_fn dns_parse_a4;	/* A RR parsing routine */
-typedef void				/* A query callback routine */
-dns_query_a4_fn(struct dns_ctx *ctx, struct dns_rr_a4 *result, void *data);
-
-/* submit A IN query */
-UDNS_API struct dns_query *
-dns_submit_a4(struct dns_ctx *ctx, const char *name, int flags,
-              dns_query_a4_fn *cbck, void *data);
-
-/* resolve A IN query */
-UDNS_API struct dns_rr_a4 *
-dns_resolve_a4(struct dns_ctx *ctx, const char *name, int flags);
-
-
-struct dns_rr_a6 {		/* the AAAA RRset */
-  dns_rr_common(dnsa6);
-  struct in6_addr *dnsa6_addr;	/* array of addresses, naddr elements */
-};
-
-UDNS_API dns_parse_fn dns_parse_a6;	/* A RR parsing routine */
-typedef void				/* A query callback routine */
-dns_query_a6_fn(struct dns_ctx *ctx, struct dns_rr_a6 *result, void *data);
-
-/* submit AAAA IN query */
-UDNS_API struct dns_query *
-dns_submit_a6(struct dns_ctx *ctx, const char *name, int flags,
-              dns_query_a6_fn *cbck, void *data);
-
-/* resolve AAAA IN query */
-UDNS_API struct dns_rr_a6 *
-dns_resolve_a6(struct dns_ctx *ctx, const char *name, int flags);
-
-
-struct dns_rr_ptr {		/* the PTR RRset */
-  dns_rr_common(dnsptr);
-  char **dnsptr_ptr;		/* array of PTRs */
-};
-
-UDNS_API dns_parse_fn dns_parse_ptr;	/* PTR RR parsing routine */
-typedef void				/* PTR query callback */
-dns_query_ptr_fn(struct dns_ctx *ctx, struct dns_rr_ptr *result, void *data);
-/* submit PTR IN in-addr.arpa query */
-UDNS_API struct dns_query *
-dns_submit_a4ptr(struct dns_ctx *ctx, const struct in_addr *addr,
-                 dns_query_ptr_fn *cbck, void *data);
-/* resolve PTR IN in-addr.arpa query */
-UDNS_API struct dns_rr_ptr *
-dns_resolve_a4ptr(struct dns_ctx *ctx, const struct in_addr *addr);
-
-/* the same as above, but for ip6.arpa */
-UDNS_API struct dns_query *
-dns_submit_a6ptr(struct dns_ctx *ctx, const struct in6_addr *addr,
-                 dns_query_ptr_fn *cbck, void *data);
-UDNS_API struct dns_rr_ptr *
-dns_resolve_a6ptr(struct dns_ctx *ctx, const struct in6_addr *addr);
-
-
-struct dns_mx {		/* single MX RR */
-  int priority;		/* MX priority */
-  char *name;		/* MX name */
-};
-struct dns_rr_mx {		/* the MX RRset */
-  dns_rr_common(dnsmx);
-  struct dns_mx *dnsmx_mx;	/* array of MXes */
-};
-UDNS_API dns_parse_fn dns_parse_mx;	/* MX RR parsing routine */
-typedef void				/* MX RR callback */
-dns_query_mx_fn(struct dns_ctx *ctx, struct dns_rr_mx *result, void *data);
-/* submit MX IN query */
-UDNS_API struct dns_query *
-dns_submit_mx(struct dns_ctx *ctx, const char *name, int flags,
-              dns_query_mx_fn *cbck, void *data);
-/* resolve MX IN query */
-UDNS_API struct dns_rr_mx *
-dns_resolve_mx(struct dns_ctx *ctx, const char *name, int flags);
-
-
-struct dns_txt {	/* single TXT record */
-  int len;		/* length of the text */
-  dnsc_t *txt;	/* pointer to text buffer. May contain nulls. */
-};
-struct dns_rr_txt {		/* the TXT RRset */
-  dns_rr_common(dnstxt);
-  struct dns_txt *dnstxt_txt;	/* array of TXT records */
-};
-UDNS_API dns_parse_fn dns_parse_txt;	/* TXT RR parsing routine */
-typedef void				/* TXT RR callback */
-dns_query_txt_fn(struct dns_ctx *ctx, struct dns_rr_txt *result, void *data);
-/* submit TXT query */
-UDNS_API struct dns_query *
-dns_submit_txt(struct dns_ctx *ctx, const char *name, int qcls, int flags,
-               dns_query_txt_fn *cbck, void *data);
-/* resolve TXT query */
-UDNS_API struct dns_rr_txt *
-dns_resolve_txt(struct dns_ctx *ctx, const char *name, int qcls, int flags);
-
-
-struct dns_srv {	/* single SRV RR */
-  int priority;		/* SRV priority */
-  int weight;		/* SRV weight */
-  int port;		/* SRV port */
-  char *name;		/* SRV name */
-};
-struct dns_rr_srv {		/* the SRV RRset */
-  dns_rr_common(dnssrv);
-  struct dns_srv *dnssrv_srv;	/* array of SRVes */
-};
-UDNS_API dns_parse_fn dns_parse_srv;	/* SRV RR parsing routine */
-typedef void				/* SRV RR callback */
-dns_query_srv_fn(struct dns_ctx *ctx, struct dns_rr_srv *result, void *data);
-/* submit SRV IN query */
-UDNS_API struct dns_query *
-dns_submit_srv(struct dns_ctx *ctx,
-               const char *name, const char *srv, const char *proto,
-               int flags, dns_query_srv_fn *cbck, void *data);
-/* resolve SRV IN query */
-UDNS_API struct dns_rr_srv *
-dns_resolve_srv(struct dns_ctx *ctx,
-                const char *name, const char *srv, const char *proto,
-                int flags);
-
-/* NAPTR (RFC3403) RR type */
-struct dns_naptr {	/* single NAPTR RR */
-  int order;		/* NAPTR order */
-  int preference;	/* NAPTR preference */
-  char *flags;		/* NAPTR flags */
-  char *service;	/* NAPTR service */
-  char *regexp;		/* NAPTR regexp */
-  char *replacement;	/* NAPTR replacement */
-};
-
-struct dns_rr_naptr {		/* the NAPTR RRset */
-  dns_rr_common(dnsnaptr);
-  struct dns_naptr *dnsnaptr_naptr;	/* array of NAPTRes */
-};
-UDNS_API dns_parse_fn dns_parse_naptr;	/* NAPTR RR parsing routine */
-typedef void				/* NAPTR RR callback */
-dns_query_naptr_fn(struct dns_ctx *ctx,
-                   struct dns_rr_naptr *result, void *data);
-/* submit NAPTR IN query */
-UDNS_API struct dns_query *
-dns_submit_naptr(struct dns_ctx *ctx, const char *name, int flags,
-                 dns_query_naptr_fn *cbck, void *data);
-/* resolve NAPTR IN query */
-UDNS_API struct dns_rr_naptr *
-dns_resolve_naptr(struct dns_ctx *ctx, const char *name, int flags);
-
-
-UDNS_API struct dns_query *
-dns_submit_a4dnsbl(struct dns_ctx *ctx,
-                   const struct in_addr *addr, const char *dnsbl,
-                   dns_query_a4_fn *cbck, void *data);
-UDNS_API struct dns_query *
-dns_submit_a4dnsbl_txt(struct dns_ctx *ctx,
-                       const struct in_addr *addr, const char *dnsbl,
-                       dns_query_txt_fn *cbck, void *data);
-UDNS_API struct dns_rr_a4 *
-dns_resolve_a4dnsbl(struct dns_ctx *ctx,
-                    const struct in_addr *addr, const char *dnsbl);
-UDNS_API struct dns_rr_txt *
-dns_resolve_a4dnsbl_txt(struct dns_ctx *ctx,
-                        const struct in_addr *addr, const char *dnsbl);
-
-UDNS_API struct dns_query *
-dns_submit_a6dnsbl(struct dns_ctx *ctx,
-                   const struct in6_addr *addr, const char *dnsbl,
-                   dns_query_a4_fn *cbck, void *data);
-UDNS_API struct dns_query *
-dns_submit_a6dnsbl_txt(struct dns_ctx *ctx,
-                       const struct in6_addr *addr, const char *dnsbl,
-                       dns_query_txt_fn *cbck, void *data);
-UDNS_API struct dns_rr_a4 *
-dns_resolve_a6dnsbl(struct dns_ctx *ctx,
-                    const struct in6_addr *addr, const char *dnsbl);
-UDNS_API struct dns_rr_txt *
-dns_resolve_a6dnsbl_txt(struct dns_ctx *ctx,
-                        const struct in6_addr *addr, const char *dnsbl);
-
-UDNS_API struct dns_query *
-dns_submit_rhsbl(struct dns_ctx *ctx,
-                 const char *name, const char *rhsbl,
-                 dns_query_a4_fn *cbck, void *data);
-UDNS_API struct dns_query *
-dns_submit_rhsbl_txt(struct dns_ctx *ctx,
-                     const char *name, const char *rhsbl,
-                     dns_query_txt_fn *cbck, void *data);
-UDNS_API struct dns_rr_a4 *
-dns_resolve_rhsbl(struct dns_ctx *ctx, const char *name, const char *rhsbl);
-UDNS_API struct dns_rr_txt *
-dns_resolve_rhsbl_txt(struct dns_ctx *ctx, const char *name, const char *rhsbl);
-
-/**************************************************************************/
-/**************** Names, Names ********************************************/
-
-struct dns_nameval {
-  int val;
-  const char *name;
-};
-
-UDNS_DATA_API extern const struct dns_nameval dns_classtab[];
-UDNS_DATA_API extern const struct dns_nameval dns_typetab[];
-UDNS_DATA_API extern const struct dns_nameval dns_rcodetab[];
-UDNS_API int
-dns_findname(const struct dns_nameval *nv, const char *name);
-#define dns_findclassname(cls) dns_findname(dns_classtab, (cls))
-#define dns_findtypename(type) dns_findname(dns_typetab, (type))
-#define dns_findrcodename(rcode) dns_findname(dns_rcodetab, (rcode))
-
-UDNS_API const char *dns_classname(enum dns_class cls);
-UDNS_API const char *dns_typename(enum dns_type type);
-UDNS_API const char *dns_rcodename(enum dns_rcode rcode);
-const char *_dns_format_code(char *buf, const char *prefix, int code);
-
-UDNS_API const char *dns_strerror(int errnum);
-
-/* simple pseudo-random number generator, code by Bob Jenkins */
-
-struct udns_jranctx {	/* the context */
-  unsigned a, b, c, d;
-};
-
-/* initialize the RNG with a given seed */
-UDNS_API void
-udns_jraninit(struct udns_jranctx *x, unsigned seed);
-
-/* return next random number.  32bits on most platforms so far. */
-UDNS_API unsigned
-udns_jranval(struct udns_jranctx *x);
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif	/* include guard */
--- a/3rdparty/udns/udns_XtoX.c
+++ b/3rdparty/udns/udns_XtoX.c
@@ -1,50 +0,0 @@
-/* udns_XtoX.c
-   udns_ntop() and udns_pton() routines, which are either
-     - wrappers for inet_ntop() and inet_pton() or
-     - reimplementations of those routines.
-
-   Copyright (C) 2005  Michael Tokarev <mjt@corpit.ru>
-   This file is part of UDNS library, an async DNS stub resolver.
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this library, in file named COPYING.LGPL; if not,
-   write to the Free Software Foundation, Inc., 59 Temple Place,
-   Suite 330, Boston, MA  02111-1307  USA
-
- */
-
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
-#include "udns.h"
-
-#ifdef HAVE_INET_PTON_NTOP
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <arpa/inet.h>
-
-const char *dns_ntop(int af, const void *src, char *dst, int size) {
-  return inet_ntop(af, src, dst, size);
-}
-
-int dns_pton(int af, const char *src, void *dst) {
-  return inet_pton(af, src, dst);
-}
-
-#else
-#define inet_XtoX_no_ntop
-#define inet_XtoX_prefix dns_
-#include "inet_XtoX.c"
-
-#endif
--- a/3rdparty/udns/udns_bl.c
+++ b/3rdparty/udns/udns_bl.c
@@ -1,160 +0,0 @@
-/* udns_bl.c
-   DNSBL stuff
-
-   Copyright (C) 2005  Michael Tokarev <mjt@corpit.ru>
-   This file is part of UDNS library, an async DNS stub resolver.
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this library, in file named COPYING.LGPL; if not,
-   write to the Free Software Foundation, Inc., 59 Temple Place,
-   Suite 330, Boston, MA  02111-1307  USA
-
- */
-
-#include "udns.h"
-#ifndef NULL
-# define NULL 0
-#endif
-
-struct dns_query *
-dns_submit_a4dnsbl(struct dns_ctx *ctx,
-                   const struct in_addr *addr, const char *dnsbl,
-                   dns_query_a4_fn *cbck, void *data) {
-  dnsc_t dn[DNS_MAXDN];
-  if (dns_a4ptodn(addr, dnsbl, dn, sizeof(dn)) <= 0) {
-    dns_setstatus(ctx, DNS_E_BADQUERY);
-    return NULL;
-  }
-  return
-    dns_submit_dn(ctx, dn, DNS_C_IN, DNS_T_A, DNS_NOSRCH,
-                  dns_parse_a4, (dns_query_fn*)cbck, data);
-}
-
-struct dns_query *
-dns_submit_a4dnsbl_txt(struct dns_ctx *ctx,
-                       const struct in_addr *addr, const char *dnsbl,
-                       dns_query_txt_fn *cbck, void *data) {
-  dnsc_t dn[DNS_MAXDN];
-  if (dns_a4ptodn(addr, dnsbl, dn, sizeof(dn)) <= 0) {
-    dns_setstatus(ctx, DNS_E_BADQUERY);
-    return NULL;
-  }
-  return
-    dns_submit_dn(ctx, dn, DNS_C_IN, DNS_T_TXT, DNS_NOSRCH,
-                  dns_parse_txt, (dns_query_fn*)cbck, data);
-}
-
-struct dns_rr_a4 *
-dns_resolve_a4dnsbl(struct dns_ctx *ctx,
-                    const struct in_addr *addr, const char *dnsbl) {
-  return (struct dns_rr_a4 *)
-    dns_resolve(ctx, dns_submit_a4dnsbl(ctx, addr, dnsbl, 0, 0));
-}
-
-struct dns_rr_txt *
-dns_resolve_a4dnsbl_txt(struct dns_ctx *ctx,
-                        const struct in_addr *addr, const char *dnsbl) {
-  return (struct dns_rr_txt *)
-    dns_resolve(ctx, dns_submit_a4dnsbl_txt(ctx, addr, dnsbl, 0, 0));
-}
-
-
-struct dns_query *
-dns_submit_a6dnsbl(struct dns_ctx *ctx,
-                   const struct in6_addr *addr, const char *dnsbl,
-                   dns_query_a4_fn *cbck, void *data) {
-  dnsc_t dn[DNS_MAXDN];
-  if (dns_a6ptodn(addr, dnsbl, dn, sizeof(dn)) <= 0) {
-    dns_setstatus(ctx, DNS_E_BADQUERY);
-    return NULL;
-  }
-  return
-    dns_submit_dn(ctx, dn, DNS_C_IN, DNS_T_A, DNS_NOSRCH,
-                  dns_parse_a4, (dns_query_fn*)cbck, data);
-}
-
-struct dns_query *
-dns_submit_a6dnsbl_txt(struct dns_ctx *ctx,
-                       const struct in6_addr *addr, const char *dnsbl,
-                       dns_query_txt_fn *cbck, void *data) {
-  dnsc_t dn[DNS_MAXDN];
-  if (dns_a6ptodn(addr, dnsbl, dn, sizeof(dn)) <= 0) {
-    dns_setstatus(ctx, DNS_E_BADQUERY);
-    return NULL;
-  }
-  return
-    dns_submit_dn(ctx, dn, DNS_C_IN, DNS_T_TXT, DNS_NOSRCH,
-                  dns_parse_txt, (dns_query_fn*)cbck, data);
-}
-
-struct dns_rr_a4 *
-dns_resolve_a6dnsbl(struct dns_ctx *ctx,
-                    const struct in6_addr *addr, const char *dnsbl) {
-  return (struct dns_rr_a4 *)
-    dns_resolve(ctx, dns_submit_a6dnsbl(ctx, addr, dnsbl, 0, 0));
-}
-
-struct dns_rr_txt *
-dns_resolve_a6dnsbl_txt(struct dns_ctx *ctx,
-                        const struct in6_addr *addr, const char *dnsbl) {
-  return (struct dns_rr_txt *)
-    dns_resolve(ctx, dns_submit_a6dnsbl_txt(ctx, addr, dnsbl, 0, 0));
-}
-
-static int
-dns_rhsbltodn(const char *name, const char *rhsbl, dnsc_t dn[DNS_MAXDN])
-{
-  int l = dns_sptodn(name, dn, DNS_MAXDN);
-  if (l <= 0) return 0;
-  l = dns_sptodn(rhsbl, dn+l-1, DNS_MAXDN-l+1);
-  if (l <= 0) return 0;
-  return 1;
-}
-
-struct dns_query *
-dns_submit_rhsbl(struct dns_ctx *ctx, const char *name, const char *rhsbl,
-                 dns_query_a4_fn *cbck, void *data) {
-  dnsc_t dn[DNS_MAXDN];
-  if (!dns_rhsbltodn(name, rhsbl, dn)) {
-    dns_setstatus(ctx, DNS_E_BADQUERY);
-    return NULL;
-  }
-  return
-    dns_submit_dn(ctx, dn, DNS_C_IN, DNS_T_A, DNS_NOSRCH,
-                  dns_parse_a4, (dns_query_fn*)cbck, data);
-}
-struct dns_query *
-dns_submit_rhsbl_txt(struct dns_ctx *ctx, const char *name, const char *rhsbl,
-                     dns_query_txt_fn *cbck, void *data) {
-  dnsc_t dn[DNS_MAXDN];
-  if (!dns_rhsbltodn(name, rhsbl, dn)) {
-    dns_setstatus(ctx, DNS_E_BADQUERY);
-    return NULL;
-  }
-  return
-    dns_submit_dn(ctx, dn, DNS_C_IN, DNS_T_TXT, DNS_NOSRCH,
-                  dns_parse_txt, (dns_query_fn*)cbck, data);
-}
-
-struct dns_rr_a4 *
-dns_resolve_rhsbl(struct dns_ctx *ctx, const char *name, const char *rhsbl) {
-  return (struct dns_rr_a4*)
-    dns_resolve(ctx, dns_submit_rhsbl(ctx, name, rhsbl, 0, 0));
-}
-
-struct dns_rr_txt *
-dns_resolve_rhsbl_txt(struct dns_ctx *ctx, const char *name, const char *rhsbl)
-{
-  return (struct dns_rr_txt*)
-    dns_resolve(ctx, dns_submit_rhsbl_txt(ctx, name, rhsbl, 0, 0));
-}
--- a/3rdparty/udns/udns_codes.c
+++ b/3rdparty/udns/udns_codes.c
@@ -1,199 +0,0 @@
-/* Automatically generated. */
-#include "udns.h"
-
-const struct dns_nameval dns_typetab[] = {
- {DNS_T_INVALID,"INVALID"},
- {DNS_T_A,"A"},
- {DNS_T_NS,"NS"},
- {DNS_T_MD,"MD"},
- {DNS_T_MF,"MF"},
- {DNS_T_CNAME,"CNAME"},
- {DNS_T_SOA,"SOA"},
- {DNS_T_MB,"MB"},
- {DNS_T_MG,"MG"},
- {DNS_T_MR,"MR"},
- {DNS_T_NULL,"NULL"},
- {DNS_T_WKS,"WKS"},
- {DNS_T_PTR,"PTR"},
- {DNS_T_HINFO,"HINFO"},
- {DNS_T_MINFO,"MINFO"},
- {DNS_T_MX,"MX"},
- {DNS_T_TXT,"TXT"},
- {DNS_T_RP,"RP"},
- {DNS_T_AFSDB,"AFSDB"},
- {DNS_T_X25,"X25"},
- {DNS_T_ISDN,"ISDN"},
- {DNS_T_RT,"RT"},
- {DNS_T_NSAP,"NSAP"},
- {DNS_T_NSAP_PTR,"NSAP_PTR"},
- {DNS_T_SIG,"SIG"},
- {DNS_T_KEY,"KEY"},
- {DNS_T_PX,"PX"},
- {DNS_T_GPOS,"GPOS"},
- {DNS_T_AAAA,"AAAA"},
- {DNS_T_LOC,"LOC"},
- {DNS_T_NXT,"NXT"},
- {DNS_T_EID,"EID"},
- {DNS_T_NIMLOC,"NIMLOC"},
- {DNS_T_SRV,"SRV"},
- {DNS_T_ATMA,"ATMA"},
- {DNS_T_NAPTR,"NAPTR"},
- {DNS_T_KX,"KX"},
- {DNS_T_CERT,"CERT"},
- {DNS_T_A6,"A6"},
- {DNS_T_DNAME,"DNAME"},
- {DNS_T_SINK,"SINK"},
- {DNS_T_OPT,"OPT"},
- {DNS_T_DS,"DS"},
- {DNS_T_SSHFP,"SSHFP"},
- {DNS_T_IPSECKEY,"IPSECKEY"},
- {DNS_T_RRSIG,"RRSIG"},
- {DNS_T_NSEC,"NSEC"},
- {DNS_T_DNSKEY,"DNSKEY"},
- {DNS_T_DHCID,"DHCID"},
- {DNS_T_NSEC3,"NSEC3"},
- {DNS_T_NSEC3PARAMS,"NSEC3PARAMS"},
- {DNS_T_TALINK,"TALINK"},
- {DNS_T_SPF,"SPF"},
- {DNS_T_UINFO,"UINFO"},
- {DNS_T_UID,"UID"},
- {DNS_T_GID,"GID"},
- {DNS_T_UNSPEC,"UNSPEC"},
- {DNS_T_TSIG,"TSIG"},
- {DNS_T_IXFR,"IXFR"},
- {DNS_T_AXFR,"AXFR"},
- {DNS_T_MAILB,"MAILB"},
- {DNS_T_MAILA,"MAILA"},
- {DNS_T_ANY,"ANY"},
- {DNS_T_ZXFR,"ZXFR"},
- {DNS_T_DLV,"DLV"},
- {DNS_T_MAX,"MAX"},
- {0,0}};
-const char *dns_typename(enum dns_type code) {
- static char nm[20];
- switch(code) {
- case DNS_T_INVALID: return dns_typetab[0].name;
- case DNS_T_A: return dns_typetab[1].name;
- case DNS_T_NS: return dns_typetab[2].name;
- case DNS_T_MD: return dns_typetab[3].name;
- case DNS_T_MF: return dns_typetab[4].name;
- case DNS_T_CNAME: return dns_typetab[5].name;
- case DNS_T_SOA: return dns_typetab[6].name;
- case DNS_T_MB: return dns_typetab[7].name;
- case DNS_T_MG: return dns_typetab[8].name;
- case DNS_T_MR: return dns_typetab[9].name;
- case DNS_T_NULL: return dns_typetab[10].name;
- case DNS_T_WKS: return dns_typetab[11].name;
- case DNS_T_PTR: return dns_typetab[12].name;
- case DNS_T_HINFO: return dns_typetab[13].name;
- case DNS_T_MINFO: return dns_typetab[14].name;
- case DNS_T_MX: return dns_typetab[15].name;
- case DNS_T_TXT: return dns_typetab[16].name;
- case DNS_T_RP: return dns_typetab[17].name;
- case DNS_T_AFSDB: return dns_typetab[18].name;
- case DNS_T_X25: return dns_typetab[19].name;
- case DNS_T_ISDN: return dns_typetab[20].name;
- case DNS_T_RT: return dns_typetab[21].name;
- case DNS_T_NSAP: return dns_typetab[22].name;
- case DNS_T_NSAP_PTR: return dns_typetab[23].name;
- case DNS_T_SIG: return dns_typetab[24].name;
- case DNS_T_KEY: return dns_typetab[25].name;
- case DNS_T_PX: return dns_typetab[26].name;
- case DNS_T_GPOS: return dns_typetab[27].name;
- case DNS_T_AAAA: return dns_typetab[28].name;
- case DNS_T_LOC: return dns_typetab[29].name;
- case DNS_T_NXT: return dns_typetab[30].name;
- case DNS_T_EID: return dns_typetab[31].name;
- case DNS_T_NIMLOC: return dns_typetab[32].name;
- case DNS_T_SRV: return dns_typetab[33].name;
- case DNS_T_ATMA: return dns_typetab[34].name;
- case DNS_T_NAPTR: return dns_typetab[35].name;
- case DNS_T_KX: return dns_typetab[36].name;
- case DNS_T_CERT: return dns_typetab[37].name;
- case DNS_T_A6: return dns_typetab[38].name;
- case DNS_T_DNAME: return dns_typetab[39].name;
- case DNS_T_SINK: return dns_typetab[40].name;
- case DNS_T_OPT: return dns_typetab[41].name;
- case DNS_T_DS: return dns_typetab[42].name;
- case DNS_T_SSHFP: return dns_typetab[43].name;
- case DNS_T_IPSECKEY: return dns_typetab[44].name;
- case DNS_T_RRSIG: return dns_typetab[45].name;
- case DNS_T_NSEC: return dns_typetab[46].name;
- case DNS_T_DNSKEY: return dns_typetab[47].name;
- case DNS_T_DHCID: return dns_typetab[48].name;
- case DNS_T_NSEC3: return dns_typetab[49].name;
- case DNS_T_NSEC3PARAMS: return dns_typetab[50].name;
- case DNS_T_TALINK: return dns_typetab[51].name;
- case DNS_T_SPF: return dns_typetab[52].name;
- case DNS_T_UINFO: return dns_typetab[53].name;
- case DNS_T_UID: return dns_typetab[54].name;
- case DNS_T_GID: return dns_typetab[55].name;
- case DNS_T_UNSPEC: return dns_typetab[56].name;
- case DNS_T_TSIG: return dns_typetab[57].name;
- case DNS_T_IXFR: return dns_typetab[58].name;
- case DNS_T_AXFR: return dns_typetab[59].name;
- case DNS_T_MAILB: return dns_typetab[60].name;
- case DNS_T_MAILA: return dns_typetab[61].name;
- case DNS_T_ANY: return dns_typetab[62].name;
- case DNS_T_ZXFR: return dns_typetab[63].name;
- case DNS_T_DLV: return dns_typetab[64].name;
- case DNS_T_MAX: return dns_typetab[65].name;
- }
- return _dns_format_code(nm,"type",code);
-}
-
-const struct dns_nameval dns_classtab[] = {
- {DNS_C_INVALID,"INVALID"},
- {DNS_C_IN,"IN"},
- {DNS_C_CH,"CH"},
- {DNS_C_HS,"HS"},
- {DNS_C_ANY,"ANY"},
- {0,0}};
-const char *dns_classname(enum dns_class code) {
- static char nm[20];
- switch(code) {
- case DNS_C_INVALID: return dns_classtab[0].name;
- case DNS_C_IN: return dns_classtab[1].name;
- case DNS_C_CH: return dns_classtab[2].name;
- case DNS_C_HS: return dns_classtab[3].name;
- case DNS_C_ANY: return dns_classtab[4].name;
- }
- return _dns_format_code(nm,"class",code);
-}
-
-const struct dns_nameval dns_rcodetab[] = {
- {DNS_R_NOERROR,"NOERROR"},
- {DNS_R_FORMERR,"FORMERR"},
- {DNS_R_SERVFAIL,"SERVFAIL"},
- {DNS_R_NXDOMAIN,"NXDOMAIN"},
- {DNS_R_NOTIMPL,"NOTIMPL"},
- {DNS_R_REFUSED,"REFUSED"},
- {DNS_R_YXDOMAIN,"YXDOMAIN"},
- {DNS_R_YXRRSET,"YXRRSET"},
- {DNS_R_NXRRSET,"NXRRSET"},
- {DNS_R_NOTAUTH,"NOTAUTH"},
- {DNS_R_NOTZONE,"NOTZONE"},
- {DNS_R_BADSIG,"BADSIG"},
- {DNS_R_BADKEY,"BADKEY"},
- {DNS_R_BADTIME,"BADTIME"},
- {0,0}};
-const char *dns_rcodename(enum dns_rcode code) {
- static char nm[20];
- switch(code) {
- case DNS_R_NOERROR: return dns_rcodetab[0].name;
- case DNS_R_FORMERR: return dns_rcodetab[1].name;
- case DNS_R_SERVFAIL: return dns_rcodetab[2].name;
- case DNS_R_NXDOMAIN: return dns_rcodetab[3].name;
- case DNS_R_NOTIMPL: return dns_rcodetab[4].name;
- case DNS_R_REFUSED: return dns_rcodetab[5].name;
- case DNS_R_YXDOMAIN: return dns_rcodetab[6].name;
- case DNS_R_YXRRSET: return dns_rcodetab[7].name;
- case DNS_R_NXRRSET: return dns_rcodetab[8].name;
- case DNS_R_NOTAUTH: return dns_rcodetab[9].name;
- case DNS_R_NOTZONE: return dns_rcodetab[10].name;
- case DNS_R_BADSIG: return dns_rcodetab[11].name;
- case DNS_R_BADKEY: return dns_rcodetab[12].name;
- case DNS_R_BADTIME: return dns_rcodetab[13].name;
- }
- return _dns_format_code(nm,"rcode",code);
-}
--- a/3rdparty/udns/udns_dn.c
+++ b/3rdparty/udns/udns_dn.c
@@ -1,379 +0,0 @@
-/* udns_dn.c
-   domain names manipulation routines
-
-   Copyright (C) 2005  Michael Tokarev <mjt@corpit.ru>
-   This file is part of UDNS library, an async DNS stub resolver.
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this library, in file named COPYING.LGPL; if not,
-   write to the Free Software Foundation, Inc., 59 Temple Place,
-   Suite 330, Boston, MA  02111-1307  USA
-
- */
-
-#include <string.h>
-#include "udns.h"
-
-unsigned dns_dnlen(dnscc_t *dn) {
-  register dnscc_t *d = dn;
-  while(*d)
-    d += 1 + *d;
-  return (unsigned)(d - dn) + 1;
-}
-
-unsigned dns_dnlabels(register dnscc_t *dn) {
-  register unsigned l = 0;
-  while(*dn)
-    ++l, dn += 1 + *dn;
-  return l;
-}
-
-unsigned dns_dnequal(register dnscc_t *dn1, register dnscc_t *dn2) {
-  register unsigned c;
-  dnscc_t *dn = dn1;
-  for(;;) {
-    if ((c = *dn1++) != *dn2++)
-      return 0;
-    if (!c)
-      return (unsigned)(dn1 - dn);
-    while(c--) {
-      if (DNS_DNLC(*dn1) != DNS_DNLC(*dn2))
-        return 0;
-      ++dn1; ++dn2;
-    }
-  }
-}
-
-unsigned
-dns_dntodn(dnscc_t *sdn, dnsc_t *ddn, unsigned ddnsiz) {
-  unsigned sdnlen = dns_dnlen(sdn);
-  if (ddnsiz < sdnlen)
-    return 0;
-  memcpy(ddn, sdn, sdnlen);
-  return sdnlen;
-}
-
-int
-dns_ptodn(const char *name, unsigned namelen,
-          dnsc_t *dn, unsigned dnsiz, int *isabs)
-{
-  dnsc_t *dp;		/* current position in dn (len byte first) */
-  dnsc_t *const de	/* end of dn: last byte that can be filled up */
-      = dn + (dnsiz >= DNS_MAXDN ? DNS_MAXDN : dnsiz) - 1;
-  dnscc_t *np = (dnscc_t *)name;
-  dnscc_t *ne = np + (namelen ? namelen : strlen((char*)np));
-  dnsc_t *llab;		/* start of last label (llab[-1] will be length) */
-  unsigned c;		/* next input character, or length of last label */
-
-  if (!dnsiz)
-    return 0;
-  dp = llab = dn + 1;
-
-  while(np < ne) {
-
-    if (*np == '.') {	/* label delimiter */
-      c = dp - llab;		/* length of the label */
-      if (!c) {			/* empty label */
-        if (np == (dnscc_t *)name && np + 1 == ne) {
-          /* special case for root dn, aka `.' */
-          ++np;
-          break;
-        }
-        return -1;		/* zero label */
-      }
-      if (c > DNS_MAXLABEL)
-        return -1;		/* label too long */
-      llab[-1] = (dnsc_t)c;	/* update len of last label */
-      llab = ++dp; /* start new label, llab[-1] will be len of it */
-      ++np;
-      continue;
-    }
-
-    /* check whenever we may put out one more byte */
-    if (dp >= de) /* too long? */
-      return dnsiz >= DNS_MAXDN ? -1 : 0;
-    if (*np != '\\') { /* non-escape, simple case */
-      *dp++ = *np++;
-      continue;
-    }
-    /* handle \-style escape */
-    /* note that traditionally, domain names (gethostbyname etc)
-     * used decimal \dd notation, not octal \ooo (RFC1035), so
-     * we're following this tradition here.
-     */
-    if (++np == ne)
-      return -1;			/* bad escape */
-    else if (*np >= '0' && *np <= '9') { /* decimal number */
-      /* we allow not only exactly 3 digits as per RFC1035,
-       * but also 2 or 1, for better usability. */
-      c = *np++ - '0';
-      if (np < ne && *np >= '0' && *np <= '9') { /* 2digits */
-        c = c * 10 + *np++ - '0';
-        if (np < ne && *np >= '0' && *np <= '9') {
-          c = c * 10 + *np++ - '0';
-          if (c > 255)
-            return -1;			/* bad escape */
-        }
-      }
-    }
-    else
-      c = *np++;
-    *dp++ = (dnsc_t)c;	/* place next out byte */
-  }
-
-  if ((c = dp - llab) > DNS_MAXLABEL)
-    return -1;				/* label too long */
-  if ((llab[-1] = (dnsc_t)c) != 0) {
-    *dp++ = 0;
-    if (isabs)
-      *isabs = 0;
-  }
-  else if (isabs)
-    *isabs = 1;
-
-  return dp - dn;
-}
-
-dnscc_t dns_inaddr_arpa_dn[14] = "\07in-addr\04arpa";
-
-dnsc_t *
-dns_a4todn_(const struct in_addr *addr, dnsc_t *dn, dnsc_t *dne) {
-  const unsigned char *s = ((const unsigned char *)addr) + 4;
-  while(s > (const unsigned char *)addr) {
-    unsigned n = *--s;
-    dnsc_t *p = dn + 1;
-    if (n > 99) {
-      if (p + 2 > dne) return 0;
-      *p++ = n / 100 + '0';
-      *p++ = (n % 100 / 10) + '0';
-      *p = n % 10 + '0';
-    }
-    else if (n > 9) {
-      if (p + 1 > dne) return 0;
-      *p++ = n / 10 + '0';
-      *p = n % 10 + '0';
-    }
-    else {
-      if (p > dne) return 0;
-      *p = n + '0';
-    }
-    *dn = p - dn;
-    dn = p + 1;
-  }
-  return dn;
-}
-
-int dns_a4todn(const struct in_addr *addr, dnscc_t *tdn,
-               dnsc_t *dn, unsigned dnsiz) {
-  dnsc_t *dne = dn + (dnsiz > DNS_MAXDN ? DNS_MAXDN : dnsiz);
-  dnsc_t *p;
-  unsigned l;
-  p = dns_a4todn_(addr, dn, dne);
-  if (!p) return 0;
-  if (!tdn)
-    tdn = dns_inaddr_arpa_dn;
-  l = dns_dnlen(tdn);
-  if (p + l > dne) return dnsiz >= DNS_MAXDN ? -1 : 0;
-  memcpy(p, tdn, l);
-  return (p + l) - dn;
-}
-
-int dns_a4ptodn(const struct in_addr *addr, const char *tname,
-                dnsc_t *dn, unsigned dnsiz) {
-  dnsc_t *p;
-  int r;
-  if (!tname)
-    return dns_a4todn(addr, NULL, dn, dnsiz);
-  p = dns_a4todn_(addr, dn, dn + dnsiz);
-  if (!p) return 0;
-  r = dns_sptodn(tname, p, dnsiz - (p - dn));
-  return r != 0 ? r : dnsiz >= DNS_MAXDN ? -1 : 0;
-}
-
-dnscc_t dns_ip6_arpa_dn[10] = "\03ip6\04arpa";
-
-dnsc_t *
-dns_a6todn_(const struct in6_addr *addr, dnsc_t *dn, dnsc_t *dne) {
-  const unsigned char *s = ((const unsigned char *)addr) + 16;
-  if (dn + 64 > dne) return 0;
-  while(s > (const unsigned char *)addr) {
-    unsigned n = *--s & 0x0f;
-    *dn++ = 1;
-    *dn++ = n > 9 ? n + 'a' - 10 : n + '0';
-    *dn++ = 1;
-    n = *s >> 4;
-    *dn++ = n > 9 ? n + 'a' - 10 : n + '0';
-  }
-  return dn;
-}
-
-int dns_a6todn(const struct in6_addr *addr, dnscc_t *tdn,
-               dnsc_t *dn, unsigned dnsiz) {
-  dnsc_t *dne = dn + (dnsiz > DNS_MAXDN ? DNS_MAXDN : dnsiz);
-  dnsc_t *p;
-  unsigned l;
-  p = dns_a6todn_(addr, dn, dne);
-  if (!p) return 0;
-  if (!tdn)
-    tdn = dns_ip6_arpa_dn;
-  l = dns_dnlen(tdn);
-  if (p + l > dne) return dnsiz >= DNS_MAXDN ? -1 : 0;
-  memcpy(p, tdn, l);
-  return (p + l) - dn;
-}
-
-int dns_a6ptodn(const struct in6_addr *addr, const char *tname,
-                dnsc_t *dn, unsigned dnsiz) {
-  dnsc_t *p;
-  int r;
-  if (!tname)
-    return dns_a6todn(addr, NULL, dn, dnsiz);
-  p = dns_a6todn_(addr, dn, dn + dnsiz);
-  if (!p) return 0;
-  r = dns_sptodn(tname, p, dnsiz - (p - dn));
-  return r != 0 ? r : dnsiz >= DNS_MAXDN ? -1 : 0;
-}
-
-/* return size of buffer required to convert the dn into asciiz string.
- * Keep in sync with dns_dntop() below.
- */
-unsigned dns_dntop_size(dnscc_t *dn) {
-  unsigned size = 0;		/* the size reqd */
-  dnscc_t *le;			/* label end */
-
-  while(*dn) {
-    /* *dn is the length of the next label, non-zero */
-    if (size)
-      ++size;		/* for the dot */
-    le = dn + *dn + 1;
-    ++dn;
-    do {
-      switch(*dn) {
-      case '.':
-      case '\\':
-      /* Special modifiers in zone files. */
-      case '"':
-      case ';':
-      case '@':
-      case '$':
-        size += 2;
-        break;
-      default:
-        if (*dn <= 0x20 || *dn >= 0x7f)
-          /* \ddd decimal notation */
-          size += 4;
-        else
-          size += 1;
-      }
-    } while(++dn < le);
-  }
-  size += 1;	/* zero byte at the end - string terminator */
-  return size > DNS_MAXNAME ? 0 : size;
-}
-
-/* Convert the dn into asciiz string.
- * Keep in sync with dns_dntop_size() above.
- */
-int dns_dntop(dnscc_t *dn, char *name, unsigned namesiz) {
-  char *np = name;			/* current name ptr */
-  char *const ne = name + namesiz;	/* end of name */
-  dnscc_t *le;		/* label end */
-
-  while(*dn) {
-    /* *dn is the length of the next label, non-zero */
-    if (np != name) {
-      if (np >= ne) goto toolong;
-      *np++ = '.';
-    }
-    le = dn + *dn + 1;
-    ++dn;
-    do {
-      switch(*dn) {
-      case '.':
-      case '\\':
-      /* Special modifiers in zone files. */
-      case '"':
-      case ';':
-      case '@':
-      case '$':
-        if (np + 2 > ne) goto toolong;
-        *np++ = '\\';
-        *np++ = *dn;
-        break;
-      default:
-        if (*dn <= 0x20 || *dn >= 0x7f) {
-          /* \ddd decimal notation */
-          if (np + 4 >= ne) goto toolong;
-          *np++ = '\\';
-          *np++ = '0' + (*dn / 100);
-          *np++ = '0' + ((*dn % 100) / 10);
-          *np++ = '0' + (*dn % 10);
-        }
-        else {
-          if (np >= ne) goto toolong;
-          *np++ = *dn;
-        }
-      }
-    } while(++dn < le);
-  }
-  if (np >= ne) goto toolong;
-  *np++ = '\0';
-  return np - name;
-toolong:
-  return namesiz >= DNS_MAXNAME ? -1 : 0;
-}
-
-#ifdef TEST
-#include <stdio.h>
-#include <stdlib.h>
-
-int main(int argc, char **argv) {
-  int i;
-  int sz;
-  dnsc_t dn[DNS_MAXDN+10];
-  dnsc_t *dl, *dp;
-  int isabs;
-
-  sz = (argc > 1) ? atoi(argv[1]) : 0;
-
-  for(i = 2; i < argc; ++i) {
-    int r = dns_ptodn(argv[i], 0, dn, sz, &isabs);
-    printf("%s: ", argv[i]);
-    if (r < 0) printf("error\n");
-    else if (!r) printf("buffer too small\n");
-    else {
-      printf("len=%d dnlen=%d size=%d name:",
-             r, dns_dnlen(dn), dns_dntop_size(dn));
-      dl = dn;
-      while(*dl) {
-        printf(" %d=", *dl);
-        dp = dl + 1;
-        dl = dp + *dl;
-        while(dp < dl) {
-          if (*dp <= ' ' || *dp >= 0x7f)
-            printf("\\%03d", *dp);
-          else if (*dp == '.' || *dp == '\\')
-            printf("\\%c", *dp);
-          else
-            putchar(*dp);
-          ++dp;
-        }
-      }
-      if (isabs) putchar('.');
-      putchar('\n');
-    }
-  }
-  return 0;
-}
-
-#endif /* TEST */
--- a/3rdparty/udns/udns_dntosp.c
+++ b/3rdparty/udns/udns_dntosp.c
@@ -1,30 +0,0 @@
-/* udns_dntosp.c
-   dns_dntosp() = convert DN to asciiz string using static buffer
-
-   Copyright (C) 2005  Michael Tokarev <mjt@corpit.ru>
-   This file is part of UDNS library, an async DNS stub resolver.
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this library, in file named COPYING.LGPL; if not,
-   write to the Free Software Foundation, Inc., 59 Temple Place,
-   Suite 330, Boston, MA  02111-1307  USA
-
- */
-
-#include "udns.h"
-
-static char name[DNS_MAXNAME];
-
-const char *dns_dntosp(dnscc_t *dn) {
-  return dns_dntop(dn, name, sizeof(name)) > 0 ? name : 0;
-}
--- a/3rdparty/udns/udns_init.c
+++ b/3rdparty/udns/udns_init.c
@@ -1,231 +0,0 @@
-/* udns_init.c
-   resolver initialisation stuff
-
-   Copyright (C) 2006  Michael Tokarev <mjt@corpit.ru>
-   This file is part of UDNS library, an async DNS stub resolver.
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this library, in file named COPYING.LGPL; if not,
-   write to the Free Software Foundation, Inc., 59 Temple Place,
-   Suite 330, Boston, MA  02111-1307  USA
-
- */
-
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
-#if defined(_WINDOWS) || defined(WINDOWS)
-# include <winsock2.h>          /* includes <windows.h> */
-# include <iphlpapi.h>		/* for dns server addresses etc */
-#else
-# include <sys/types.h>
-# include <unistd.h>
-# include <fcntl.h>
-#endif	/* !WINDOWS */
-
-#include <stdlib.h>
-#include <string.h>
-#include "udns.h"
-
-#define ISSPACE(x) (x == ' ' || x == '\t' || x == '\r' || x == '\n')
-
-static const char space[] = " \t\r\n";
-
-static void dns_set_serv_internal(struct dns_ctx *ctx, char *serv) {
-  dns_add_serv(ctx, NULL);
-  for(serv = strtok(serv, space); serv; serv = strtok(NULL, space))
-    dns_add_serv(ctx, serv);
-}
-
-static void dns_set_srch_internal(struct dns_ctx *ctx, char *srch) {
-  dns_add_srch(ctx, NULL);
-  for(srch = strtok(srch, space); srch; srch = strtok(NULL, space))
-    dns_add_srch(ctx, srch);
-}
-
-#if defined(_WINDOWS) || defined(WINDOWS)
-
-#ifndef NO_IPHLPAPI
-/* Apparently, some systems does not have proper headers for IPHLPAIP to work.
- * The best is to upgrade headers, but here's another, ugly workaround for
- * this: compile with -DNO_IPHLPAPI.
- */
-
-typedef DWORD (WINAPI *GetAdaptersAddressesFunc)(
-  ULONG Family, DWORD Flags, PVOID Reserved,
-  PIP_ADAPTER_ADDRESSES pAdapterAddresses,
-  PULONG pOutBufLen);
-
-static int dns_initns_iphlpapi(struct dns_ctx *ctx) {
-  HANDLE h_iphlpapi;
-  GetAdaptersAddressesFunc pfnGetAdAddrs;
-  PIP_ADAPTER_ADDRESSES pAddr, pAddrBuf;
-  PIP_ADAPTER_DNS_SERVER_ADDRESS pDnsAddr;
-  ULONG ulOutBufLen;
-  DWORD dwRetVal;
-  int ret = -1;
-
-  h_iphlpapi = LoadLibrary("iphlpapi.dll");
-  if (!h_iphlpapi)
-    return -1;
-  pfnGetAdAddrs = (GetAdaptersAddressesFunc)
-    GetProcAddress(h_iphlpapi, "GetAdaptersAddresses");
-  if (!pfnGetAdAddrs) goto freelib;
-  ulOutBufLen = 0;
-  dwRetVal = pfnGetAdAddrs(AF_UNSPEC, 0, NULL, NULL, &ulOutBufLen);
-  if (dwRetVal != ERROR_BUFFER_OVERFLOW) goto freelib;
-  pAddrBuf = malloc(ulOutBufLen);
-  if (!pAddrBuf) goto freelib;
-  dwRetVal = pfnGetAdAddrs(AF_UNSPEC, 0, NULL, pAddrBuf, &ulOutBufLen);
-  if (dwRetVal != ERROR_SUCCESS) goto freemem;
-  for (pAddr = pAddrBuf; pAddr; pAddr = pAddr->Next)
-    for (pDnsAddr = pAddr->FirstDnsServerAddress;
-	 pDnsAddr;
-	 pDnsAddr = pDnsAddr->Next)
-      dns_add_serv_s(ctx, pDnsAddr->Address.lpSockaddr);
-  ret = 0;
-freemem:
-  free(pAddrBuf);
-freelib:
-  FreeLibrary(h_iphlpapi);
-  return ret;
-}
-
-#else /* NO_IPHLPAPI */
-
-#define dns_initns_iphlpapi(ctx) (-1)
-
-#endif /* NO_IPHLPAPI */
-
-static int dns_initns_registry(struct dns_ctx *ctx) {
-  LONG res;
-  HKEY hk;
-  DWORD type = REG_EXPAND_SZ | REG_SZ;
-  DWORD len;
-  char valBuf[1024];
-
-#define REGKEY_WINNT "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters"
-#define REGKEY_WIN9x "SYSTEM\\CurrentControlSet\\Services\\VxD\\MSTCP"
-  res = RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGKEY_WINNT, 0, KEY_QUERY_VALUE, &hk);
-  if (res != ERROR_SUCCESS)
-    res = RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGKEY_WIN9x,
-                       0, KEY_QUERY_VALUE, &hk);
-  if (res != ERROR_SUCCESS)
-    return -1;
-  len = sizeof(valBuf) - 1;
-  res = RegQueryValueEx(hk, "NameServer", NULL, &type, (BYTE*)valBuf, &len);
-  if (res != ERROR_SUCCESS || !len || !valBuf[0]) {
-    len = sizeof(valBuf) - 1;
-    res = RegQueryValueEx(hk, "DhcpNameServer", NULL, &type,
-                          (BYTE*)valBuf, &len);
-  }
-  RegCloseKey(hk);
-  if (res != ERROR_SUCCESS || !len || !valBuf[0])
-    return -1;
-  valBuf[len] = '\0';
-  /* nameservers are stored as a whitespace-seperate list:
-   * "192.168.1.1 123.21.32.12" */
-  dns_set_serv_internal(ctx, valBuf);
-  return 0;
-}
-
-#else /* !WINDOWS */
-
-static int dns_init_resolvconf(struct dns_ctx *ctx) {
-  char *v;
-  char buf[2049];	/* this buffer is used to hold /etc/resolv.conf */
-  int has_srch = 0;
-
-  /* read resolv.conf... */
-  { int fd = open("/etc/resolv.conf", O_RDONLY);
-    if (fd >= 0) {
-      int l = read(fd, buf, sizeof(buf) - 1);
-      close(fd);
-      buf[l < 0 ? 0 : l] = '\0';
-    }
-    else
-      buf[0] = '\0';
-  }
-  if (buf[0]) {	/* ...and parse it */
-    char *line, *nextline;
-    line = buf;
-    do {
-      nextline = strchr(line, '\n');
-      if (nextline) *nextline++ = '\0';
-      v = line;
-      while(*v && !ISSPACE(*v)) ++v;
-      if (!*v) continue;
-      *v++ = '\0';
-      while(ISSPACE(*v)) ++v;
-      if (!*v) continue;
-      if (strcmp(line, "domain") == 0) {
-        dns_set_srch_internal(ctx, strtok(v, space));
-	has_srch = 1;
-      }
-      else if (strcmp(line, "search") == 0) {
-        dns_set_srch_internal(ctx, v);
-	has_srch = 1;
-      }
-      else if (strcmp(line, "nameserver") == 0)
-        dns_add_serv(ctx, strtok(v, space));
-      else if (strcmp(line, "options") == 0)
-        dns_set_opts(ctx, v);
-    } while((line = nextline) != NULL);
-  }
-
-  buf[sizeof(buf)-1] = '\0';
-
-  /* get list of nameservers from env. vars. */
-  if ((v = getenv("NSCACHEIP")) != NULL ||
-      (v = getenv("NAMESERVERS")) != NULL) {
-    strncpy(buf, v, sizeof(buf) - 1);
-    dns_set_serv_internal(ctx, buf);
-  }
-  /* if $LOCALDOMAIN is set, use it for search list */
-  if ((v = getenv("LOCALDOMAIN")) != NULL) {
-    strncpy(buf, v, sizeof(buf) - 1);
-    dns_set_srch_internal(ctx, buf);
-    has_srch = 1;
-  }
-  if ((v = getenv("RES_OPTIONS")) != NULL)
-    dns_set_opts(ctx, v);
-
-  /* if still no search list, use local domain name */
-  if (has_srch &&
-      gethostname(buf, sizeof(buf) - 1) == 0 &&
-      (v = strchr(buf, '.')) != NULL &&
-      *++v != '\0')
-    dns_add_srch(ctx, v);
-
-  return 0;
-}
-
-#endif /* !WINDOWS */
-
-int dns_init(struct dns_ctx *ctx, int do_open) {
-  if (!ctx)
-    ctx = &dns_defctx;
-  dns_reset(ctx);
-
-#if defined(_WINDOWS) || defined(WINDOWS)
-  if (dns_initns_iphlpapi(ctx) != 0)
-    dns_initns_registry(ctx);
-  /*XXX WINDOWS: probably good to get default domain and search list too...
-   * And options.  Something is in registry. */
-  /*XXX WINDOWS: maybe environment variables are also useful? */
-#else
-  dns_init_resolvconf(ctx);
-#endif
-
-  return do_open ? dns_open(ctx) : 0;
-}
--- a/3rdparty/udns/udns_jran.c
+++ b/3rdparty/udns/udns_jran.c
@@ -1,52 +0,0 @@
-/* udns_jran.c: small non-cryptographic random number generator
- * taken from http://burtleburtle.net/bob/rand/smallprng.html
- * by Bob Jenkins, Public domain.
- */
-
-#include "udns.h"
-
-#define rot32(x,k) (((x) << (k)) | ((x) >> (32-(k))))
-#define rot64(x,k) (((x) << (k)) | ((x) >> (64-(k))))
-#define tr32(x) ((x)&0xffffffffu)
-
-unsigned udns_jranval(struct udns_jranctx *x) {
-  /* This routine can be made to work with either 32 or 64bit words -
-   * if JRAN_32_64 is defined when compiling the file.
-   * We use if() instead of #if since there's no good
-   * portable way to check sizeof() in preprocessor without
-   * introducing some ugly configure-time checks.
-   * Most compilers will optimize the wrong branches away anyway.
-   * By default it assumes 32bit integers
-   */
-#ifdef JRAN_32_64
-  if (sizeof(unsigned) == 4) {
-#endif
-    unsigned e = tr32(x->a - rot32(x->b, 27));
-    x->a = tr32(x->b ^ rot32(x->c, 17));
-    x->b = tr32(x->c + x->d);
-    x->c = tr32(x->d + e);
-    x->d = tr32(e + x->a);
-#ifdef JRAN_32_64
-  }
-  else if (sizeof(unsigned) == 8) { /* assuming it's 64bits */
-    unsigned e = x->a - rot64(x->b, 7);
-    x->a = x->b ^ rot64(x->c, 13);
-    x->b = x->c + rot64(x->d, 37);
-    x->c = x->d + e;
-    x->d = e + x->a;
-  }
-  else {
-    unsigned e = 0;
-    x->d = 1/e; /* bail */
-  }
-#endif
-  return x->d;
-}
-
-void udns_jraninit(struct udns_jranctx *x, unsigned seed) {
-  unsigned i;
-  x->a = 0xf1ea5eed;
-  x->b = x->c = x->d = seed;
-  for (i = 0; i < 20; ++i)
-     (void)udns_jranval(x);
-}
--- a/3rdparty/udns/udns_misc.c
+++ b/3rdparty/udns/udns_misc.c
@@ -1,67 +0,0 @@
-/* udns_misc.c
-   miscellaneous routines
-
-   Copyright (C) 2005  Michael Tokarev <mjt@corpit.ru>
-   This file is part of UDNS library, an async DNS stub resolver.
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this library, in file named COPYING.LGPL; if not,
-   write to the Free Software Foundation, Inc., 59 Temple Place,
-   Suite 330, Boston, MA  02111-1307  USA
-
- */
-
-#include "udns.h"
-
-int dns_findname(const struct dns_nameval *nv, const char *name) {
-  register const char *a, *b;
-  for(; nv->name; ++nv)
-    for(a = name, b = nv->name; ; ++a, ++b)
-      if (DNS_DNUC(*a) != *b) break;
-      else if (!*a) return nv->val;
-  return -1;
-}
-
-const char *_dns_format_code(char *buf, const char *prefix, int code) {
-  char *bp = buf;
-  unsigned c, n;
-  do *bp++ = DNS_DNUC(*prefix);
-  while(*++prefix);
-  *bp++ = '#';
-  if (code < 0) code = -code, *bp++ = '-';
-  n = 0; c = code;
-  do ++n;
-  while((c /= 10));
-  c = code;
-  bp[n--] = '\0';
-  do bp[n--] = c % 10 + '0';
-  while((c /= 10));
-  return buf;
-}
-
-const char *dns_strerror(int err) {
-  if (err >= 0) return "successeful completion";
-  switch(err) {
-  case DNS_E_TEMPFAIL:	return "temporary failure in name resolution";
-  case DNS_E_PROTOCOL:	return "protocol error";
-  case DNS_E_NXDOMAIN:	return "domain name does not exist";
-  case DNS_E_NODATA:	return "valid domain but no data of requested type";
-  case DNS_E_NOMEM:	return "out of memory";
-  case DNS_E_BADQUERY:	return "malformed query";
-  default:		return "unknown error";
-  }
-}
-
-const char *dns_version(void) {
-  return UDNS_VERSION;
-}
--- a/3rdparty/udns/udns_parse.c
+++ b/3rdparty/udns/udns_parse.c
@@ -1,169 +0,0 @@
-/* udns_parse.c
-   raw DNS packet parsing routines
-
-   Copyright (C) 2005  Michael Tokarev <mjt@corpit.ru>
-   This file is part of UDNS library, an async DNS stub resolver.
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this library, in file named COPYING.LGPL; if not,
-   write to the Free Software Foundation, Inc., 59 Temple Place,
-   Suite 330, Boston, MA  02111-1307  USA
-
- */
-
-#include <string.h>
-#include <assert.h>
-#include "udns.h"
-
-dnscc_t *dns_skipdn(dnscc_t *cur, dnscc_t *end) {
-  unsigned c;
-  for(;;) {
-    if (cur >= end)
-      return NULL;
-    c = *cur++;
-    if (!c)
-      return cur;
-    if (c & 192)		/* jump */
-      return cur + 1 >= end ? NULL : cur + 1;
-    cur += c;
-  }
-}
-
-int
-dns_getdn(dnscc_t *pkt, dnscc_t **cur, dnscc_t *end,
-          register dnsc_t *dn, unsigned dnsiz) {
-  unsigned c;
-  dnscc_t *pp = *cur;		/* current packet pointer */
-  dnsc_t *dp = dn;		/* current dn pointer */
-  dnsc_t *const de		/* end of the DN dest */
-       = dn + (dnsiz < DNS_MAXDN ? dnsiz : DNS_MAXDN);
-  dnscc_t *jump = NULL;		/* ptr after first jump if any */
-  unsigned loop = 100;		/* jump loop counter */
-
-  for(;;) {		/* loop by labels */
-    if (pp >= end)		/* reached end of packet? */
-      return -1;
-    c = *pp++;			/* length of the label */
-    if (!c) {			/* empty label: terminate */
-      if (dn >= de)		/* can't fit terminator */
-        goto noroom;
-      *dp++ = 0;
-      /* return next pos: either after the first jump or current */
-      *cur = jump ? jump : pp;
-      return dp - dn;
-    }
-    if (c & 192) {		/* jump */
-      if (pp >= end)		/* eop instead of jump pos */
-        return -1;
-      if (!jump) jump = pp + 1;	/* remember first jump */
-      else if (!--loop) return -1; /* too many jumps */
-      c = ((c & ~192) << 8) | *pp; /* new pos */
-      if (c < DNS_HSIZE)	/* don't allow jump into the header */
-        return -1;
-      pp = pkt + c;
-      continue;
-    }
-    if (c > DNS_MAXLABEL)	/* too long label? */
-      return -1;
-    if (pp + c > end)		/* label does not fit in packet? */
-      return -1;
-    if (dp + c + 1 > de)	/* if enouth room for the label */
-      goto noroom;
-    *dp++ = c;			/* label length */
-    memcpy(dp, pp, c);		/* and the label itself */
-    dp += c;
-    pp += c;			/* advance to the next label */
-  }
-noroom:
-  return dnsiz < DNS_MAXDN ? 0 : -1;
-}
-
-void dns_rewind(struct dns_parse *p, dnscc_t *qdn) {
-  p->dnsp_qdn = qdn;
-  p->dnsp_cur = p->dnsp_ans;
-  p->dnsp_rrl = dns_numan(p->dnsp_pkt);
-  p->dnsp_ttl = 0xffffffffu;
-  p->dnsp_nrr = 0;
-}
-
-void
-dns_initparse(struct dns_parse *p, dnscc_t *qdn,
-              dnscc_t *pkt, dnscc_t *cur, dnscc_t *end) {
-  p->dnsp_pkt = pkt;
-  p->dnsp_end = end;
-  p->dnsp_rrl = dns_numan(pkt);
-  p->dnsp_qdn = qdn;
-  assert(cur + 4 <= end);
-  if ((p->dnsp_qtyp = dns_get16(cur+0)) == DNS_T_ANY) p->dnsp_qtyp = 0;
-  if ((p->dnsp_qcls = dns_get16(cur+2)) == DNS_C_ANY) p->dnsp_qcls = 0;
-  p->dnsp_cur = p->dnsp_ans = cur + 4;
-  p->dnsp_ttl = 0xffffffffu;
-  p->dnsp_nrr = 0;
-}
-
-int dns_nextrr(struct dns_parse *p, struct dns_rr *rr) {
-  dnscc_t *cur = p->dnsp_cur;
-  while(p->dnsp_rrl > 0) {
-    --p->dnsp_rrl;
-    if (dns_getdn(p->dnsp_pkt, &cur, p->dnsp_end,
-                  rr->dnsrr_dn, sizeof(rr->dnsrr_dn)) <= 0)
-      return -1;
-    if (cur + 10 > p->dnsp_end)
-      return -1;
-    rr->dnsrr_typ = dns_get16(cur);
-    rr->dnsrr_cls = dns_get16(cur+2);
-    rr->dnsrr_ttl = dns_get32(cur+4);
-    rr->dnsrr_dsz = dns_get16(cur+8);
-    rr->dnsrr_dptr = cur = cur + 10;
-    rr->dnsrr_dend = cur = cur + rr->dnsrr_dsz;
-    if (cur > p->dnsp_end)
-      return -1;
-    if (p->dnsp_qdn && !dns_dnequal(p->dnsp_qdn, rr->dnsrr_dn))
-      continue;
-    if ((!p->dnsp_qcls || p->dnsp_qcls == rr->dnsrr_cls) &&
-        (!p->dnsp_qtyp || p->dnsp_qtyp == rr->dnsrr_typ)) {
-      p->dnsp_cur = cur;
-      ++p->dnsp_nrr;
-      if (p->dnsp_ttl > rr->dnsrr_ttl) p->dnsp_ttl = rr->dnsrr_ttl;
-      return 1;
-    }
-    if (p->dnsp_qdn && rr->dnsrr_typ == DNS_T_CNAME && !p->dnsp_nrr) {
-      if (dns_getdn(p->dnsp_pkt, &rr->dnsrr_dptr, p->dnsp_end,
-                    p->dnsp_dnbuf, sizeof(p->dnsp_dnbuf)) <= 0 ||
-          rr->dnsrr_dptr != rr->dnsrr_dend)
-        return -1;
-      p->dnsp_qdn = p->dnsp_dnbuf;
-      if (p->dnsp_ttl > rr->dnsrr_ttl) p->dnsp_ttl = rr->dnsrr_ttl;
-    }
-  }
-  p->dnsp_cur = cur;
-  return 0;
-}
-
-int dns_stdrr_size(const struct dns_parse *p) {
-  return
-    dns_dntop_size(p->dnsp_qdn) +
-    (p->dnsp_qdn == dns_payload(p->dnsp_pkt) ? 0 :
-     dns_dntop_size(dns_payload(p->dnsp_pkt)));
-}
-
-void *dns_stdrr_finish(struct dns_rr_null *ret, char *cp,
-                       const struct dns_parse *p) {
-  cp += dns_dntop(p->dnsp_qdn, (ret->dnsn_cname = cp), DNS_MAXNAME);
-  if (p->dnsp_qdn == dns_payload(p->dnsp_pkt))
-    ret->dnsn_qname = ret->dnsn_cname;
-  else
-    dns_dntop(dns_payload(p->dnsp_pkt), (ret->dnsn_qname = cp), DNS_MAXNAME);
-  ret->dnsn_ttl = p->dnsp_ttl;
-  return ret;
-}
--- a/3rdparty/udns/udns_resolver.c
+++ b/3rdparty/udns/udns_resolver.c
--- a/3rdparty/udns/udns_rr_a.c
+++ b/3rdparty/udns/udns_rr_a.c
@@ -1,126 +0,0 @@
-/* udns_rr_a.c
-   parse/query A/AAAA IN records
-
-   Copyright (C) 2005  Michael Tokarev <mjt@corpit.ru>
-   This file is part of UDNS library, an async DNS stub resolver.
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this library, in file named COPYING.LGPL; if not,
-   write to the Free Software Foundation, Inc., 59 Temple Place,
-   Suite 330, Boston, MA  02111-1307  USA
-
- */
-
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
-#include <string.h>
-#include <stdlib.h>
-#include <assert.h>
-#if !defined(_WINDOWS) && !defined(WINDOWS)
-# include <sys/types.h>
-# include <netinet/in.h>
-#endif
-#include "udns.h"
-
-/* here, we use common routine to parse both IPv4 and IPv6 addresses.
- */
-
-/* this structure should match dns_rr_a[46] */
-struct dns_rr_a {
-  dns_rr_common(dnsa);
-  unsigned char *dnsa_addr;
-};
-
-static int
-dns_parse_a(dnscc_t *qdn, dnscc_t *pkt, dnscc_t *cur, dnscc_t *end,
-            void **result, unsigned dsize) {
-  struct dns_rr_a *ret;
-  struct dns_parse p;
-  struct dns_rr rr;
-  int r;
-
-  /* first, validate and count number of addresses */
-  dns_initparse(&p, qdn, pkt, cur, end);
-  while((r = dns_nextrr(&p, &rr)) > 0)
-    if (rr.dnsrr_dsz != dsize)
-      return DNS_E_PROTOCOL;
-  if (r < 0)
-    return DNS_E_PROTOCOL;
-  else if (!p.dnsp_nrr)
-    return DNS_E_NODATA;
-
-  ret = malloc(sizeof(*ret) + dsize * p.dnsp_nrr + dns_stdrr_size(&p));
-  if (!ret)
-    return DNS_E_NOMEM;
-
-  ret->dnsa_nrr = p.dnsp_nrr;
-  ret->dnsa_addr = (unsigned char*)(ret+1);
-
-  /* copy the RRs */
-  for (dns_rewind(&p, qdn), r = 0; dns_nextrr(&p, &rr); ++r)
-    memcpy(ret->dnsa_addr + dsize * r, rr.dnsrr_dptr, dsize);
-
-  dns_stdrr_finish((struct dns_rr_null *)ret,
-                   (char *)(ret->dnsa_addr + dsize * p.dnsp_nrr), &p);
-  *result = ret;
-  return 0;
-}
-
-int
-dns_parse_a4(dnscc_t *qdn, dnscc_t *pkt, dnscc_t *cur, dnscc_t *end,
-             void **result) {
-#ifdef AF_INET
-  assert(sizeof(struct in_addr) == 4);
-#endif
-  assert(dns_get16(cur+2) == DNS_C_IN && dns_get16(cur+0) == DNS_T_A);
-  return dns_parse_a(qdn, pkt, cur, end, result, 4);
-}
-
-struct dns_query *
-dns_submit_a4(struct dns_ctx *ctx, const char *name, int flags,
-              dns_query_a4_fn *cbck, void *data) {
-  return
-    dns_submit_p(ctx, name, DNS_C_IN, DNS_T_A, flags,
-                 dns_parse_a4, (dns_query_fn*)cbck, data);
-}
-
-struct dns_rr_a4 *
-dns_resolve_a4(struct dns_ctx *ctx, const char *name, int flags) {
-  return (struct dns_rr_a4 *)
-    dns_resolve_p(ctx, name, DNS_C_IN, DNS_T_A, flags, dns_parse_a4);
-}
-
-int
-dns_parse_a6(dnscc_t *qdn, dnscc_t *pkt, dnscc_t *cur, dnscc_t *end,
-             void **result) {
-#ifdef AF_INET6
-  assert(sizeof(struct in6_addr) == 16);
-#endif
-  assert(dns_get16(cur+2) == DNS_C_IN && dns_get16(cur+0) == DNS_T_AAAA);
-  return dns_parse_a(qdn, pkt, cur, end, result, 16);
-}
-
-struct dns_query *
-dns_submit_a6(struct dns_ctx *ctx, const char *name, int flags,
-              dns_query_a6_fn *cbck, void *data) {
-  return
-    dns_submit_p(ctx, name, DNS_C_IN, DNS_T_AAAA, flags,
-                 dns_parse_a6, (dns_query_fn*)cbck, data);
-}
-
-struct dns_rr_a6 *
-dns_resolve_a6(struct dns_ctx *ctx, const char *name, int flags) {
-  return (struct dns_rr_a6 *)
-    dns_resolve_p(ctx, name, DNS_C_IN, DNS_T_AAAA, flags, dns_parse_a6);
-}
--- a/3rdparty/udns/udns_rr_mx.c
+++ b/3rdparty/udns/udns_rr_mx.c
@@ -1,91 +0,0 @@
-/* udns_rr_mx.c
-   parse/query MX IN records
-
-   Copyright (C) 2005  Michael Tokarev <mjt@corpit.ru>
-   This file is part of UDNS library, an async DNS stub resolver.
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this library, in file named COPYING.LGPL; if not,
-   write to the Free Software Foundation, Inc., 59 Temple Place,
-   Suite 330, Boston, MA  02111-1307  USA
-
- */
-
-#include <string.h>
-#include <stdlib.h>
-#include <assert.h>
-#include "udns.h"
-
-int
-dns_parse_mx(dnscc_t *qdn, dnscc_t *pkt, dnscc_t *cur, dnscc_t *end,
-             void **result) {
-  struct dns_rr_mx *ret;
-  struct dns_parse p;
-  struct dns_rr rr;
-  int r, l;
-  char *sp;
-  dnsc_t mx[DNS_MAXDN];
-
-  assert(dns_get16(cur+2) == DNS_C_IN && dns_get16(cur+0) == DNS_T_MX);
-
-  /* first, validate the answer and count size of the result */
-  l = 0;
-  dns_initparse(&p, qdn, pkt, cur, end);
-  while((r = dns_nextrr(&p, &rr)) > 0) {
-    cur = rr.dnsrr_dptr + 2;
-    r = dns_getdn(pkt, &cur, end, mx, sizeof(mx));
-    if (r <= 0 || cur != rr.dnsrr_dend)
-      return DNS_E_PROTOCOL;
-    l += dns_dntop_size(mx);
-  }
-  if (r < 0)
-    return DNS_E_PROTOCOL;
-  if (!p.dnsp_nrr)
-    return DNS_E_NODATA;
-
-  /* next, allocate and set up result */
-  l += dns_stdrr_size(&p);
-  ret = malloc(sizeof(*ret) + sizeof(struct dns_mx) * p.dnsp_nrr + l);
-  if (!ret)
-    return DNS_E_NOMEM;
-  ret->dnsmx_nrr = p.dnsp_nrr;
-  ret->dnsmx_mx = (struct dns_mx *)(ret+1);
-
-  /* and 3rd, fill in result, finally */
-  sp = (char*)(ret->dnsmx_mx + p.dnsp_nrr);
-  for (dns_rewind(&p, qdn), r = 0; dns_nextrr(&p, &rr); ++r) {
-    ret->dnsmx_mx[r].name = sp;
-    cur = rr.dnsrr_dptr;
-    ret->dnsmx_mx[r].priority = dns_get16(cur);
-    cur += 2;
-    dns_getdn(pkt, &cur, end, mx, sizeof(mx));
-    sp += dns_dntop(mx, sp, DNS_MAXNAME);
-  }
-  dns_stdrr_finish((struct dns_rr_null *)ret, sp, &p);
-  *result = ret;
-  return 0;
-}
-
-struct dns_query *
-dns_submit_mx(struct dns_ctx *ctx, const char *name, int flags,
-              dns_query_mx_fn *cbck, void *data) {
-  return
-    dns_submit_p(ctx, name, DNS_C_IN, DNS_T_MX, flags,
-                 dns_parse_mx, (dns_query_fn *)cbck, data);
-}
-
-struct dns_rr_mx *
-dns_resolve_mx(struct dns_ctx *ctx, const char *name, int flags) {
-  return (struct dns_rr_mx *)
-    dns_resolve_p(ctx, name, DNS_C_IN, DNS_T_MX, flags, dns_parse_mx);
-}
--- a/3rdparty/udns/udns_rr_naptr.c
+++ b/3rdparty/udns/udns_rr_naptr.c
@@ -1,128 +0,0 @@
-/* udns_rr_naptr.c
-   parse/query NAPTR IN records
-
-   Copyright (C) 2005  Michael Tokarev <mjt@corpit.ru>
-   Copyright (C) 2006  Mikael Magnusson <mikma@users.sourceforge.net>
-   This file is part of UDNS library, an async DNS stub resolver.
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this library, in file named COPYING.LGPL; if not,
-   write to the Free Software Foundation, Inc., 59 Temple Place,
-   Suite 330, Boston, MA  02111-1307  USA
-
- */
-
-#include <string.h>
-#include <stdlib.h>
-#include <assert.h>
-#include "udns.h"
-
-/* Get a single string for NAPTR record, pretty much like a DN label.
- * String length is in first byte in *cur, so it can't be >255.
- */
-static int dns_getstr(dnscc_t **cur, dnscc_t *ep, char *buf)
-{
-  unsigned l;
-  dnscc_t *cp = *cur;
-
-  l = *cp++;
-  if (cp + l > ep)
-    return DNS_E_PROTOCOL;
-  if (buf) {
-    memcpy(buf, cp, l);
-    buf[l] = '\0';
-  }
-  cp += l;
-
-  *cur = cp;
-  return l + 1;
-}
-
-int
-dns_parse_naptr(dnscc_t *qdn, dnscc_t *pkt, dnscc_t *cur, dnscc_t *end,
-                void **result) {
-  struct dns_rr_naptr *ret;
-  struct dns_parse p;
-  struct dns_rr rr;
-  int r, l;
-  char *sp;
-  dnsc_t dn[DNS_MAXDN];
-
-  assert(dns_get16(cur+2) == DNS_C_IN && dns_get16(cur+0) == DNS_T_NAPTR);
-
-  /* first, validate the answer and count size of the result */
-  l = 0;
-  dns_initparse(&p, qdn, pkt, cur, end);
-  while((r = dns_nextrr(&p, &rr)) > 0) {
-    int i;
-    dnscc_t *ep = rr.dnsrr_dend;
-
-    /* first 4 bytes: order & preference */
-    cur = rr.dnsrr_dptr + 4;
-
-    /* flags, services and regexp */
-    for (i = 0; i < 3; i++) {
-      r = dns_getstr(&cur, ep, NULL);
-      if (r < 0)
-        return r;
-      l += r;
-    }
-    /* replacement */
-    r = dns_getdn(pkt, &cur, end, dn, sizeof(dn));
-    if (r <= 0 || cur != rr.dnsrr_dend)
-      return DNS_E_PROTOCOL;
-    l += dns_dntop_size(dn);
-  }
-  if (r < 0)
-    return DNS_E_PROTOCOL;
-  if (!p.dnsp_nrr)
-    return DNS_E_NODATA;
-
-  /* next, allocate and set up result */
-  l += dns_stdrr_size(&p);
-  ret = malloc(sizeof(*ret) + sizeof(struct dns_naptr) * p.dnsp_nrr + l);
-  if (!ret)
-    return DNS_E_NOMEM;
-  ret->dnsnaptr_nrr = p.dnsp_nrr;
-  ret->dnsnaptr_naptr = (struct dns_naptr *)(ret+1);
-
-  /* and 3rd, fill in result, finally */
-  sp = (char*)(&ret->dnsnaptr_naptr[p.dnsp_nrr]);
-  for (dns_rewind(&p, qdn), r = 0; dns_nextrr(&p, &rr); ++r) {
-    cur = rr.dnsrr_dptr;
-    ret->dnsnaptr_naptr[r].order = dns_get16(cur); cur += 2;
-    ret->dnsnaptr_naptr[r].preference = dns_get16(cur); cur += 2;
-    sp += dns_getstr(&cur, end, (ret->dnsnaptr_naptr[r].flags = sp));
-    sp += dns_getstr(&cur, end, (ret->dnsnaptr_naptr[r].service = sp));
-    sp += dns_getstr(&cur, end, (ret->dnsnaptr_naptr[r].regexp = sp));
-    dns_getdn(pkt, &cur, end, dn, sizeof(dn));
-    sp += dns_dntop(dn, (ret->dnsnaptr_naptr[r].replacement = sp), DNS_MAXNAME);
-  }
-  dns_stdrr_finish((struct dns_rr_null *)ret, sp, &p);
-  *result = ret;
-  return 0;
-}
-
-struct dns_query *
-dns_submit_naptr(struct dns_ctx *ctx, const char *name, int flags,
-                 dns_query_naptr_fn *cbck, void *data) {
-  return
-    dns_submit_p(ctx, name, DNS_C_IN, DNS_T_NAPTR, flags,
-                 dns_parse_naptr, (dns_query_fn *)cbck, data);
-}
-
-struct dns_rr_naptr *
-dns_resolve_naptr(struct dns_ctx *ctx, const char *name, int flags) {
-  return (struct dns_rr_naptr *)
-    dns_resolve_p(ctx, name, DNS_C_IN, DNS_T_NAPTR, flags, dns_parse_naptr);
-}
--- a/3rdparty/udns/udns_rr_ptr.c
+++ b/3rdparty/udns/udns_rr_ptr.c
@@ -1,109 +0,0 @@
-/* udns_rr_ptr.c
-   parse/query PTR records
-
-   Copyright (C) 2005  Michael Tokarev <mjt@corpit.ru>
-   This file is part of UDNS library, an async DNS stub resolver.
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this library, in file named COPYING.LGPL; if not,
-   write to the Free Software Foundation, Inc., 59 Temple Place,
-   Suite 330, Boston, MA  02111-1307  USA
-
- */
-
-#include <stdlib.h>
-#include <assert.h>
-#include "udns.h"
-
-int
-dns_parse_ptr(dnscc_t *qdn, dnscc_t *pkt, dnscc_t *cur, dnscc_t *end,
-              void **result) {
-  struct dns_rr_ptr *ret;
-  struct dns_parse p;
-  struct dns_rr rr;
-  int r, l, c;
-  char *sp;
-  dnsc_t ptr[DNS_MAXDN];
-
-  assert(dns_get16(cur+2) == DNS_C_IN && dns_get16(cur+0) == DNS_T_PTR);
-
-  /* first, validate the answer and count size of the result */
-  l = c = 0;
-  dns_initparse(&p, qdn, pkt, cur, end);
-  while((r = dns_nextrr(&p, &rr)) > 0) {
-    cur = rr.dnsrr_dptr;
-    r = dns_getdn(pkt, &cur, end, ptr, sizeof(ptr));
-    if (r <= 0 || cur != rr.dnsrr_dend)
-      return DNS_E_PROTOCOL;
-    l += dns_dntop_size(ptr);
-    ++c;
-  }
-  if (r < 0)
-    return DNS_E_PROTOCOL;
-  if (!c)
-    return DNS_E_NODATA;
-
-  /* next, allocate and set up result */
-  ret = malloc(sizeof(*ret) + sizeof(char **) * c + l + dns_stdrr_size(&p));
-  if (!ret)
-    return DNS_E_NOMEM;
-  ret->dnsptr_nrr = c;
-  ret->dnsptr_ptr = (char **)(ret+1);
-
-  /* and 3rd, fill in result, finally */
-  sp = (char*)(ret->dnsptr_ptr + c);
-  c = 0;
-  dns_rewind(&p, qdn);
-  while((r = dns_nextrr(&p, &rr)) > 0) {
-    ret->dnsptr_ptr[c] = sp;
-    cur = rr.dnsrr_dptr;
-    dns_getdn(pkt, &cur, end, ptr, sizeof(ptr));
-    sp += dns_dntop(ptr, sp, DNS_MAXNAME);
-    ++c;
-  }
-  dns_stdrr_finish((struct dns_rr_null *)ret, sp, &p);
-  *result = ret;
-  return 0;
-}
-
-struct dns_query *
-dns_submit_a4ptr(struct dns_ctx *ctx, const struct in_addr *addr,
-                 dns_query_ptr_fn *cbck, void *data) {
-  dnsc_t dn[DNS_A4RSIZE];
-  dns_a4todn(addr, 0, dn, sizeof(dn));
-  return
-    dns_submit_dn(ctx, dn, DNS_C_IN, DNS_T_PTR, DNS_NOSRCH,
-                  dns_parse_ptr, (dns_query_fn *)cbck, data);
-}
-
-struct dns_rr_ptr *
-dns_resolve_a4ptr(struct dns_ctx *ctx, const struct in_addr *addr) {
-  return (struct dns_rr_ptr *)
-    dns_resolve(ctx, dns_submit_a4ptr(ctx, addr, NULL, NULL));
-}
-
-struct dns_query *
-dns_submit_a6ptr(struct dns_ctx *ctx, const struct in6_addr *addr,
-                 dns_query_ptr_fn *cbck, void *data) {
-  dnsc_t dn[DNS_A6RSIZE];
-  dns_a6todn(addr, 0, dn, sizeof(dn));
-  return
-    dns_submit_dn(ctx, dn, DNS_C_IN, DNS_T_PTR, DNS_NOSRCH,
-                  dns_parse_ptr, (dns_query_fn *)cbck, data);
-}
-
-struct dns_rr_ptr *
-dns_resolve_a6ptr(struct dns_ctx *ctx, const struct in6_addr *addr) {
-  return (struct dns_rr_ptr *)
-    dns_resolve(ctx, dns_submit_a6ptr(ctx, addr, NULL, NULL));
-}
--- a/3rdparty/udns/udns_rr_srv.c
+++ b/3rdparty/udns/udns_rr_srv.c
@@ -1,155 +0,0 @@
-/* udns_rr_srv.c
-   parse/query SRV IN (rfc2782) records
-
-   Copyright (C) 2005  Michael Tokarev <mjt@corpit.ru>
-   This file is part of UDNS library, an async DNS stub resolver.
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this library, in file named COPYING.LGPL; if not,
-   write to the Free Software Foundation, Inc., 59 Temple Place,
-   Suite 330, Boston, MA  02111-1307  USA
-
-   Copyright 2005 Thadeu Lima de Souza Cascardo <cascardo@minaslivre.org>
-
-   2005-09-11:
-   Changed MX parser file into a SRV parser file
-
- */
-
-#include <string.h>
-#include <stdlib.h>
-#include <assert.h>
-#include "udns.h"
-
-int
-dns_parse_srv(dnscc_t *qdn, dnscc_t *pkt, dnscc_t *cur, dnscc_t *end,
-              void **result) {
-  struct dns_rr_srv *ret;
-  struct dns_parse p;
-  struct dns_rr rr;
-  int r, l;
-  char *sp;
-  dnsc_t srv[DNS_MAXDN];
-
-  assert(dns_get16(cur+2) == DNS_C_IN && dns_get16(cur+0) == DNS_T_SRV);
-
-  /* first, validate the answer and count size of the result */
-  l = 0;
-  dns_initparse(&p, qdn, pkt, cur, end);
-  while((r = dns_nextrr(&p, &rr)) > 0) {
-    cur = rr.dnsrr_dptr + 6;
-    r = dns_getdn(pkt, &cur, end, srv, sizeof(srv));
-    if (r <= 0 || cur != rr.dnsrr_dend)
-      return DNS_E_PROTOCOL;
-    l += dns_dntop_size(srv);
-  }
-  if (r < 0)
-    return DNS_E_PROTOCOL;
-  if (!p.dnsp_nrr)
-    return DNS_E_NODATA;
-
-  /* next, allocate and set up result */
-  l += dns_stdrr_size(&p);
-  ret = malloc(sizeof(*ret) + sizeof(struct dns_srv) * p.dnsp_nrr + l);
-  if (!ret)
-    return DNS_E_NOMEM;
-  ret->dnssrv_nrr = p.dnsp_nrr;
-  ret->dnssrv_srv = (struct dns_srv *)(ret+1);
-
-  /* and 3rd, fill in result, finally */
-  sp = (char*)(ret->dnssrv_srv + p.dnsp_nrr);
-  for (dns_rewind(&p, qdn), r = 0; dns_nextrr(&p, &rr); ++r) {
-    ret->dnssrv_srv[r].name = sp;
-    cur = rr.dnsrr_dptr;
-    ret->dnssrv_srv[r].priority = dns_get16(cur);
-    ret->dnssrv_srv[r].weight = dns_get16(cur+2);
-    ret->dnssrv_srv[r].port = dns_get16(cur+4);
-    cur += 6;
-    dns_getdn(pkt, &cur, end, srv, sizeof(srv));
-    sp += dns_dntop(srv, sp, DNS_MAXNAME);
-  }
-  dns_stdrr_finish((struct dns_rr_null *)ret, sp, &p);
-  *result = ret;
-  return 0;
-}
-
-/* Add a single service or proto name prepending an undescore (_),
- * according to rfc2782 rules.
- * Return 0 or the label length.
- * Routing assumes dn holds enouth space for a single DN label. */
-static int add_sname(dnsc_t *dn, const char *sn) {
-  int l = dns_ptodn(sn, 0, dn + 1, DNS_MAXLABEL-1, NULL);
-  if (l <= 1 || l - 2 != dn[1])
-    /* Should we really check if sn is exactly one label?  Do we care? */
-    return 0;
-  dn[0] = l - 1;
-  dn[1] = '_';
-  return l;
-}
-
-/* Construct a domain name for SRV query from the given name, service and proto.
- * The code allows any combinations of srv and proto (both are non-NULL,
- * both NULL, or either one is non-NULL).  Whenever it makes any sense or not
- * is left as an exercise to programmer.
- * Return negative value on error (malformed query) or addition query flag(s).
- */
-static int
-build_srv_dn(dnsc_t *dn, const char *name, const char *srv, const char *proto)
-{
-  int p = 0, l, isabs;
-  if (srv) {
-    l = add_sname(dn + p, srv);
-    if (!l)
-      return -1;
-    p += l;
-  }
-  if (proto) {
-    l = add_sname(dn + p, proto);
-    if (!l)
-      return -1;
-    p += l;
-  }
-  l = dns_ptodn(name, 0, dn + p, DNS_MAXDN - p, &isabs);
-  if (l < 0)
-    return -1;
-  return isabs ? DNS_NOSRCH : 0;
-}
-
-struct dns_query *
-dns_submit_srv(struct dns_ctx *ctx,
-               const char *name, const char *srv, const char *proto,
-               int flags, dns_query_srv_fn *cbck, void *data) {
-  dnsc_t dn[DNS_MAXDN];
-  int r = build_srv_dn(dn, name, srv, proto);
-  if (r < 0) {
-    dns_setstatus (ctx, DNS_E_BADQUERY);
-    return NULL;
-  }
-  return
-    dns_submit_dn(ctx, dn, DNS_C_IN, DNS_T_SRV, flags | r,
-                  dns_parse_srv, (dns_query_fn *)cbck, data);
-}
-
-struct dns_rr_srv *
-dns_resolve_srv(struct dns_ctx *ctx,
-                const char *name, const char *srv, const char *proto, int flags)
-{
-  dnsc_t dn[DNS_MAXDN];
-  int r = build_srv_dn(dn, name, srv, proto);
-  if (r < 0) {
-    dns_setstatus(ctx, DNS_E_BADQUERY);
-    return NULL;
-  }
-  return (struct dns_rr_srv *)
-    dns_resolve_dn(ctx, dn, DNS_C_IN, DNS_T_SRV, flags | r, dns_parse_srv);
-}
--- a/3rdparty/udns/udns_rr_txt.c
+++ b/3rdparty/udns/udns_rr_txt.c
@@ -1,98 +0,0 @@
-/* udns_rr_txt.c
-   parse/query TXT records
-
-   Copyright (C) 2005  Michael Tokarev <mjt@corpit.ru>
-   This file is part of UDNS library, an async DNS stub resolver.
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this library, in file named COPYING.LGPL; if not,
-   write to the Free Software Foundation, Inc., 59 Temple Place,
-   Suite 330, Boston, MA  02111-1307  USA
-
- */
-
-#include <string.h>
-#include <stdlib.h>
-#include <assert.h>
-#include "udns.h"
-
-int
-dns_parse_txt(dnscc_t *qdn, dnscc_t *pkt, dnscc_t *cur, dnscc_t *end,
-              void **result) {
-  struct dns_rr_txt *ret;
-  struct dns_parse p;
-  struct dns_rr rr;
-  int r, l;
-  dnsc_t *sp;
-  dnscc_t *cp, *ep;
-
-  assert(dns_get16(cur+0) == DNS_T_TXT);
-
-  /* first, validate the answer and count size of the result */
-  l = 0;
-  dns_initparse(&p, qdn, pkt, cur, end);
-  while((r = dns_nextrr(&p, &rr)) > 0) {
-    cp = rr.dnsrr_dptr; ep = rr.dnsrr_dend;
-    while(cp < ep) {
-      r = *cp++;
-      if (cp + r > ep)
-        return DNS_E_PROTOCOL;
-      l += r;
-      cp += r;
-    }
-  }
-  if (r < 0)
-    return DNS_E_PROTOCOL;
-  if (!p.dnsp_nrr)
-    return DNS_E_NODATA;
-
-  /* next, allocate and set up result */
-  l +=  (sizeof(struct dns_txt) + 1) * p.dnsp_nrr + dns_stdrr_size(&p);
-  ret = malloc(sizeof(*ret) + l);
-  if (!ret)
-    return DNS_E_NOMEM;
-  ret->dnstxt_nrr = p.dnsp_nrr;
-  ret->dnstxt_txt = (struct dns_txt *)(ret+1);
-
-  /* and 3rd, fill in result, finally */
-  sp = (dnsc_t*)(ret->dnstxt_txt + p.dnsp_nrr);
-  for(dns_rewind(&p, qdn), r = 0; dns_nextrr(&p, &rr) > 0; ++r) {
-    ret->dnstxt_txt[r].txt = sp;
-    cp = rr.dnsrr_dptr; ep = rr.dnsrr_dend;
-    while(cp < ep) {
-      l = *cp++;
-      memcpy(sp, cp, l);
-      sp += l;
-      cp += l;
-    }
-    ret->dnstxt_txt[r].len = sp - ret->dnstxt_txt[r].txt;
-    *sp++ = '\0';
-  }
-  dns_stdrr_finish((struct dns_rr_null *)ret, (char*)sp, &p);
-  *result = ret;
-  return 0;
-}
-
-struct dns_query *
-dns_submit_txt(struct dns_ctx *ctx, const char *name, int qcls, int flags,
-               dns_query_txt_fn *cbck, void *data) {
-  return
-    dns_submit_p(ctx, name, qcls, DNS_T_TXT, flags,
-                 dns_parse_txt, (dns_query_fn *)cbck, data);
-}
-
-struct dns_rr_txt *
-dns_resolve_txt(struct dns_ctx *ctx, const char *name, int qcls, int flags) {
-  return (struct dns_rr_txt *)
-    dns_resolve_p(ctx, name, qcls, DNS_T_TXT, flags, dns_parse_txt);
-}
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,65 +1,47 @@
-cmake_minimum_required (VERSION 3.10)
-
-if(POLICY CMP0072)
-  cmake_policy(SET CMP0072 NEW)
-endif()
-
-if(POLICY CMP0093)
-  cmake_policy(SET CMP0093 NEW)
-endif()
-
-message(STATUS "CMAKE Build type: ${CMAKE_BUILD_TYPE}")
-# Set a default build type if none was specified
-if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
-  message(STATUS "Setting build type to 'Debug' as none was specified.")
-  set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build." FORCE)
-  # Set the possible values of build type for cmake-gui
-  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release"
-    "MinSizeRel" "RelWithDebInfo")
-endif()
-
+cmake_minimum_required (VERSION 2.6.4)
 include (CheckFunctionExists)
 include (CheckIncludeFile)
-include (CheckLibraryExists)
 include (CheckCXXSourceCompiles)
-include (CheckCXXCompilerFlag)
-include (GenerateExportHeader)

-# only relevant for building shared libs but let's set it regardless
-set(CMAKE_OSX_RPATH 1)
-set(CMAKE_OSX_DEPLOYMENT_TARGET "10.12" CACHE STRING "Minimum OS X deployment version")

-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED YES)
+project(SimGear)

 # read 'version' file into a variable (stripping any newlines or spaces)
-file(READ simgear-version versionFile)
+file(READ version versionFile)
 string(STRIP ${versionFile} SIMGEAR_VERSION)

-project(SimGear VERSION ${SIMGEAR_VERSION} LANGUAGES C CXX)
-
-# add a dependency on the version file
-set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS version)
-
-set_property(GLOBAL PROPERTY FIND_LIBRARY_USE_LIB64_PATHS TRUE)
-
 # use simgear version also as the SO version (if building SOs)
 SET(SIMGEAR_SOVERSION ${SIMGEAR_VERSION})

-# Warning when build is not an out-of-source build.
-string(COMPARE EQUAL "${CMAKE_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" InSourceBuild)
-if(InSourceBuild)
-    message(WARNING  "Avoid building inside the source tree!")
-    message(WARNING  "Create a separate build directory instead (i.e. 'sgbuild') and call CMake from there: ")
-    message(WARNING  "  mkdir ../sgbuild && cd ../sgbuild && cmake ${CMAKE_SOURCE_DIR}")
-endif(InSourceBuild)
+#packaging
+SET(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/COPYING")
+SET(CPACK_RESOURCE_FILE_README "${PROJECT_SOURCE_DIR}/README")
+SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Simulation support libraries for FlightGear and related projects")
+SET(CPACK_PACKAGE_VENDOR "The FlightGear project")
+SET(CPACK_GENERATOR "TBZ2")
+SET(CPACK_INSTALL_CMAKE_PROJECTS  ${CMAKE_CURRENT_BINARY_DIR};SimGear;ALL;/)


+# split version string into components, note CMAKE_MATCH_0 is the entire regexp match
+string(REGEX MATCH "([0-9]+)\\.([0-9]+)\\.([0-9]+)" CPACK_PACKAGE_VERSION ${SIMGEAR_VERSION} )
+set(CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1}) 
+set(CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
+set(CPACK_PACKAGE_VERSION_PATCH ${CMAKE_MATCH_3})
+
+message(STATUS "version is ${CPACK_PACKAGE_VERSION_MAJOR} dot ${CPACK_PACKAGE_VERSION_MINOR} dot ${CPACK_PACKAGE_VERSION_PATCH}")
+
+set(CPACK_SOURCE_GENERATOR TBZ2)
+set(CPACK_SOURCE_PACKAGE_FILE_NAME "simgear-${SIMGEAR_VERSION}" CACHE INTERNAL "tarball basename")
+set(CPACK_SOURCE_IGNORE_FILES
+  "^${PROJECT_SOURCE_DIR}/.git;\\\\.gitignore;Makefile.am;~$;${CPACK_SOURCE_IGNORE_FILES}")
+
+message(STATUS "ignoring: ${CPACK_SOURCE_IGNORE_FILES}")
+
+include (CPack)
+
 # We have some custom .cmake scripts not in the official distribution.
 set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/CMakeModules;${CMAKE_MODULE_PATH}")

-include(Packaging)
-
 # Change the default build type to something fast
 if(NOT CMAKE_BUILD_TYPE)
  set(CMAKE_BUILD_TYPE Release CACHE STRING
@@ -70,235 +52,158 @@ endif(NOT CMAKE_BUILD_TYPE)
 # Determine name of library installation directory, i.e. "lib" vs "lib64", which
 # differs between all Debian-based vs all other Linux distros.
 # See cmake bug #11964, http://cmake.org/gitweb?p=cmake.git;a=commit;h=126c993d
-include(GNUInstallDirs)
+# GNUInstallDirs requires CMake >= 2.8.5, use own file for older cmake
+if(${CMAKE_VERSION} VERSION_GREATER 2.8.4)
+  include(GNUInstallDirs)
+else(${CMAKE_VERSION} VERSION_GREATER 2.8.4)
+  include(OldGNUInstallDirs)
+endif(${CMAKE_VERSION} VERSION_GREATER 2.8.4)
 message(STATUS "Library installation directory: ${CMAKE_INSTALL_LIBDIR}")

-#####################################################################################
-# Configure library search paths
-#####################################################################################
-
-if (NOT MSVC)
 option(SIMGEAR_SHARED   "Set to ON to build SimGear as a shared library/framework" OFF)
-option(SYSTEM_EXPAT     "Set to ON to build SimGear using the system expat library" OFF)
-option(SYSTEM_UDNS      "Set to ON to build SimGear using the system udns library" OFF)
-else()
-# Building SimGear DLLs is currently not supported for MSVC.
-set(SIMGEAR_SHARED OFF)
-# Using external 3rd party libraries is currently not supported for MSVC - it would require shared simgear (DLL).
-set(SYSTEM_EXPAT OFF)
-set(SYSTEM_UDNS OFF)
-endif()
-
 option(SIMGEAR_HEADLESS "Set to ON to build SimGear without GUI/graphics support" OFF)
-option(ENABLE_CYCLONE   "Set to ON to build SimGear with Cyclone Data Distribution Service support" ON)
+option(JPEG_FACTORY     "Enable JPEG-factory support" OFF)
+option(ENABLE_LIBSVN    "Set to ON to build SimGear with libsvnclient support" ON)
 option(ENABLE_RTI       "Set to ON to build SimGear with RTI support" OFF)
-option(ENABLE_GDAL      "Set to ON to build SimGear with GDAL support" OFF)
 option(ENABLE_TESTS     "Set to OFF to disable building SimGear's test applications" ON)
-option(ENABLE_SOUND     "Set to OFF to disable building SimGear's sound support" ON)
-option(USE_SHADERVG     "Set to ON to use SHaderVG instead of ShivaVG" OFF)
-option(USE_AEONWAVE     "Set to ON to use AeonWave instead of OpenAL" ON)
-option(USE_OPENALSOFT   "Set to ON to use OpenAL from OpenAL-soft" OFF)
-
-option(ENABLE_PKGUTIL   "Set to ON to build the sg_pkgutil application (default)" ON)
-option(ENABLE_SIMD      "Enable SSE/SSE2 support for compilers" ON)
-option(ENABLE_SIMD_CODE	"Enable SSE/SSE2 support code for compilers" OFF)
-option(ENABLE_ASAN      "Set to ON to build SimGear with LLVM AddressSanitizer (ASan) support" OFF)
-option(ENABLE_VIDEO_RECORD "Set to ON to build SimGear with video recording" ON)
-
-if (NOT ENABLE_SIMD AND ENABLE_SIMD_CODE)
-  set(ENABLE_SIMD_CODE OFF)
-endif()
-
-if (USE_SHADERVG)
-  set(OPENVG ShaderVG)
-else()
-  set(OPENVG ShivaVG)
-endif()
-message(STATUS "OpenVG: ${OPENVG}")
-
-include (DetectArch)
-include (ExportDebugSymbols)
-
-# until the fstream fix is applied and generally available in OSG,
-# keep the compatability link option as the default
-option(OSG_FSTREAM_EXPORT_FIXED "Set to ON if the osgDB fstream export patch is applied" OFF)

 if (MSVC)
-  # override CMake default RelWithDebInfo flags. This is important to ensure
-  # good performance
-  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "/Zi /O2 /Ob2 /D NDEBUG")
-  set(CMAKE_C_FLAGS_RELWITHDEBINFO "/Zi /O2 /Ob2 /D NDEBUG")
-endif ()
+  GET_FILENAME_COMPONENT(PARENT_DIR ${PROJECT_SOURCE_DIR} PATH)
+  if (CMAKE_CL_64)
+    SET(TEST_3RDPARTY_DIR "${PARENT_DIR}/3rdparty.x64")
+  else (CMAKE_CL_64)
+    SET(TEST_3RDPARTY_DIR "${PARENT_DIR}/3rdparty")
+  endif (CMAKE_CL_64)
+  if (EXISTS ${TEST_3RDPARTY_DIR})
+    set(MSVC_3RDPARTY_ROOT ${PARENT_DIR} CACHE PATH "Location where the third-party dependencies are extracted")
+  else (EXISTS ${TEST_3RDPARTY_DIR})
+    set(MSVC_3RDPARTY_ROOT NOT_FOUND CACHE PATH "Location where the third-party dependencies are extracted")
+  endif (EXISTS ${TEST_3RDPARTY_DIR})
+else (MSVC)
+  set(MSVC_3RDPARTY_ROOT NOT_FOUND CACHE PATH "Location where the third-party dependencies are extracted")
+endif (MSVC)

-# Setup MSVC 3rd party directories
-include( ConfigureMsvc3rdParty )
+if (MSVC AND MSVC_3RDPARTY_ROOT)
+  message(STATUS "3rdparty files located in ${MSVC_3RDPARTY_ROOT}")
+  set( OSG_MSVC "msvc" )
+  if (${MSVC_VERSION} EQUAL 1600)
+      set( OSG_MSVC ${OSG_MSVC}100 )
+  else (${MSVC_VERSION} EQUAL 1600)
+      set( OSG_MSVC ${OSG_MSVC}90 )
+  endif (${MSVC_VERSION} EQUAL 1600)
+  if (CMAKE_CL_64)
+      set( OSG_MSVC ${OSG_MSVC}-64 )
+      set( MSVC_3RDPARTY_DIR 3rdParty.x64 )
+  else (CMAKE_CL_64)
+      set( MSVC_3RDPARTY_DIR 3rdParty )
+  endif (CMAKE_CL_64)

-if(APPLE)
-  find_library(COCOA_LIBRARY Cocoa)
-endif()
-
-find_package(Threads REQUIRED)
+  set (CMAKE_LIBRARY_PATH ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/lib ${MSVC_3RDPARTY_ROOT}/install/${OSG_MSVC}/OpenScenegraph/lib )
+  set (CMAKE_INCLUDE_PATH ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/include ${MSVC_3RDPARTY_ROOT}/install/${OSG_MSVC}/OpenScenegraph/include)
+  set (BOOST_ROOT ${MSVC_3RDPARTY_ROOT}/boost_1_44_0)
+  message(STATUS "BOOST_ROOT is ${BOOST_ROOT}")
+  set (OPENAL_INCLUDE_DIR ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/include)
+  set (ALUT_INCLUDE_DIR ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/include)
+  set (OPENAL_LIBRARY_DIR ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/lib)
+endif (MSVC AND MSVC_3RDPARTY_ROOT)

 find_package(Boost REQUIRED)
-set (BOOST_CXX_FLAGS "-DBOOST_BIMAP_DISABLE_SERIALIZATION -DBOOST_NO_STDLIB_CONFIG -DBOOST_NO_AUTO_PTR -DBOOST_NO_CXX98_BINDERS")
-include(BoostTestTargets)
-
-set(SG_SOUND_USES_OPENALSOFT OFF) # default to off
+set (BOOST_CXX_FLAGS "-DBOOST_MULTI_INDEX_DISABLE_SERIALIZATION -DBOOST_BIMAP_DISABLE_SERIALIZATION")

 if(SIMGEAR_HEADLESS)
    message(STATUS "SimGear mode: HEADLESS")
-    set(ENABLE_SOUND 0)
 else()
    message(STATUS "SimGear mode: NORMAL")
    find_package(OpenGL REQUIRED)
-
-    if (ENABLE_SOUND)
-        if (USE_AEONWAVE)
-            find_package(AAX)
-        endif()
-
-        if(NOT AAX_FOUND)
-            set(USE_AEONWAVE FALSE)
-            if (USE_OPENALSOFT)
-                message(STATUS "Sound requested to use OpenAL-soft: ensure Config.cmake files are in CMAKE_PREFIX_PATH")
-               find_package(OpenAL REQUIRED CONFIG)
-               if (TARGET OpenAL::OpenAL)
-                set(SG_SOUND_USES_OPENALSOFT ON)
-               endif()
-            else()
-              # regular OpenAL is found via the CMake distro-suppling FindOpenAL
-              find_package(OpenAL REQUIRED)
-            endif()
-
-            message(STATUS "OpenAL: ${OPENAL_LIBRARY}")
-        endif()
-
-        if(AAX_FOUND)
-            message(STATUS "Sound support: AeonWave")
-        elseif (TARGET OpenAL::OpenAL)
-           message(STATUS "Sound support: OpenAL-soft")
-        else()
-            message(STATUS "Sound support: OpenAL (from system)")
-        endif()
-    endif(ENABLE_SOUND)
-
-    find_package(OpenSceneGraph 3.6.0 REQUIRED osgText osgSim osgDB osgParticle osgGA osgViewer osgUtil osgTerrain)
-
-    if (MSVC)
-      set(CMAKE_REQUIRED_INCLUDES ${OPENSCENEGRAPH_INCLUDE_DIRS})
-      # ensure OSG was compiled with OSG_USE_UTF8_FILENAME set
-      check_cxx_source_compiles(
-         "#include <osg/Config>
-         #if !defined(OSG_USE_UTF8_FILENAME)
-          #error OSG UTF8 support not enabled
-         #endif
-         int main() { return 0; }"
-         SIMGEAR_OSG_USE_UTF8_FILENAME)
-      if (NOT SIMGEAR_OSG_USE_UTF8_FILENAME)
-        message(FATAL_ERROR "Please rebuild OSG with OSG_USE_UTF8_FILENAME set to ON")
-      endif()
-    endif()
+    find_package(OpenAL REQUIRED)
+    find_package(ALUT REQUIRED)
+    find_package(OpenSceneGraph 3.0.0 REQUIRED osgText osgSim osgDB osgParticle osgUtil)
 endif(SIMGEAR_HEADLESS)

-if(${CMAKE_SYSTEM_NAME} MATCHES "OpenBSD")
-    # As of 2020-08-01, OpenBSD's system zlib is slightly old, but it's usable
-    # with a workaround in simgear/io/iostreams/gzfstream.cxx.
-    find_package(ZLIB 1.2.3 REQUIRED)
+if(JPEG_FACTORY)
+    message(STATUS "JPEG-factory: ENABLED")
+    find_package(JPEG REQUIRED)
+    include_directories(${JPEG_INCLUDE_DIR})
 else()
-    find_package(ZLIB 1.2.4 REQUIRED)
-endif()
+    message(STATUS "JPEG-factory: DISABLED")
+endif(JPEG_FACTORY)

-find_package(LibLZMA REQUIRED)
-find_package(CURL REQUIRED)
-
-if (SYSTEM_EXPAT)
-    message(STATUS "Requested to use system Expat library, forcing SIMGEAR_SHARED to true")
-    set(SIMGEAR_SHARED ON)
-    find_package(EXPAT REQUIRED)
+if(ENABLE_LIBSVN)
+    find_package(SvnClient)

+    if(LIBSVN_FOUND)
+        message(STATUS "Subversion client support: ENABLED")
+        set(HAVE_SVN_CLIENT_H 1)
+        set(HAVE_LIBSVN_CLIENT_1 1)
+    else()
+        # Oops. ENABLE_LIBSVN is ON, but svn is still missing.
+        # Provide clearly visible warning/hint, so builders know what else they should install (or disable).
+        message(WARNING "Failed to enable subversion client support. Unable to find required subversion client library. Some features may not be available (scenery download).")
+        message(WARNING "Install 'libsvn' library/DLL (libsvn-devel/libsvnclient/...). Otherwise disable subversion support (set 'ENABLE_LIBSVN' to 'OFF').")
+    endif(LIBSVN_FOUND)
 else()
-    message(STATUS "Using built-in expat code")
-endif(SYSTEM_EXPAT)
+    message(STATUS "Subversion client support: DISABLED")
+endif(ENABLE_LIBSVN)
+
+find_package(ZLIB REQUIRED)
+find_package(Threads REQUIRED)
+
+check_include_file(sys/time.h HAVE_SYS_TIME_H)
+check_include_file(sys/timeb.h HAVE_SYS_TIMEB_H)
+check_include_file(unistd.h HAVE_UNISTD_H)
+check_include_file(windows.h HAVE_WINDOWS_H)

 if(ENABLE_RTI)
-    find_package(PkgConfig)
-    if(PKG_CONFIG_FOUND)
-      SET(ENV{PKG_CONFIG_PATH} "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/pkgconfig:$ENV{PKG_CONFIG_PATH}")
-      pkg_check_modules(RTI IMPORTED_TARGET hla-rti13)
-    endif(PKG_CONFIG_FOUND)
-    if(RTI_FOUND)
-      message(STATUS "RTI: ENABLED")
-    else()
-      message(STATUS "RTI: DISABLED")
-    endif(RTI_FOUND)
+    # See if we have any rti library variant installed
+    message(STATUS "RTI: ENABLED")
+    find_package(RTI)
 else()
    message(STATUS "RTI: DISABLED")
 endif(ENABLE_RTI)

-if(ENABLE_CYCLONE)
-    find_package(CycloneDDS QUIET)
-    if (CycloneDDS_FOUND)
-        message(STATUS "Data Distribution Service support: CycloneDDS")
-        set(SG_HAVE_DDS 1)
-    else(CycloneDDS_FOUND)
-        message(STATUS "Data Distribution Service support: DISBLED")
-    endif(CycloneDDS_FOUND)
-endif(ENABLE_CYCLONE)
+check_function_exists(gettimeofday HAVE_GETTIMEOFDAY)
+check_function_exists(ftime HAVE_FTIME)
+check_function_exists(timegm HAVE_TIMEGM)
+check_function_exists(rint HAVE_RINT)
+check_function_exists(mkdtemp HAVE_MKDTEMP)
+check_function_exists(bcopy HAVE_BCOPY)
+check_function_exists(mmap HAVE_MMAP)

-if(ENABLE_GDAL)
-    find_package(GDAL 2.0.0 REQUIRED)
-endif(ENABLE_GDAL)
+if(HAVE_UNISTD_H)
+    set(CMAKE_REQUIRED_INCLUDES ${CMAKE_INCLUDE_PATH})
+    check_cxx_source_compiles(
+       "#include <unistd.h>
+        #if !defined(_POSIX_TIMERS) || (0 >= _POSIX_TIMERS)
+            #error clock_gettime is not supported
+        #endif

+        int main() { return 0; }
+        "
+        HAVE_CLOCK_GETTIME)
+endif(HAVE_UNISTD_H)

-if (ENABLE_VIDEO_RECORD)
-  find_package(FFmpeg COMPONENTS AVCODEC AVFORMAT AVUTIL SWSCALE)
-  if (FFmpeg_FOUND)
-  # set this so it's picked up in simgear_config.h
-    set(SG_FFMPEG 1)
-  else()
-    message(STATUS "Video recording was requested, but required FFmpeg/avcodec libaries not found")
-  endif()
-endif()
-
-include(CheckPOSIXFeatures)
+set(RT_LIBRARY "")
+if(HAVE_CLOCK_GETTIME)
+    check_library_exists(rt clock_gettime "" HAVE_RT)
+    if(HAVE_RT)
+        set(RT_LIBRARY rt)
+    endif(HAVE_RT)
+endif(HAVE_CLOCK_GETTIME)

 SET(CMAKE_DEBUG_POSTFIX "d" CACHE STRING "add a postfix, usually 'd' on windows")
 SET(CMAKE_RELEASE_POSTFIX "" CACHE STRING "add a postfix, usually empty on windows")
 SET(CMAKE_RELWITHDEBINFO_POSTFIX "" CACHE STRING "add a postfix, usually empty on windows")
 SET(CMAKE_MINSIZEREL_POSTFIX "" CACHE STRING "add a postfix, usually empty on windows")

-# Check if the <regex> implementation in the C++ standard library is usable.
-# This is necessary because g++ 4.8 lies about its C++11 compliance: its
-# <regex> is utterly unusable, cf. [1].
-# The big preprocessor test essentially comes from [2], and gcc upstream devs
-# appear to back it (see comments following [2], as well as [3]).
-#
-#   [1] https://stackoverflow.com/a/12665408/4756009
-#   [2] https://stackoverflow.com/a/41186162/4756009
-#   [3] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=78905
+# isnan might not be real symbol, so can't check using function_exists
 check_cxx_source_compiles(
-    "#include <regex>
-
-     int main() {
-       #if __cplusplus >= 201103L &&                             \
-           (!defined(__GLIBCXX__)                         ||     \
-            (__cplusplus >= 201402L)                      ||     \
-            defined(_GLIBCXX_REGEX_DFS_QUANTIFIERS_LIMIT) ||     \
-            defined(_GLIBCXX_REGEX_STATE_LIMIT)           ||     \
-            (defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE > 4))
-       #else
-         nullptr = void; // intentionally trigger a compilation error
-       #endif
-     }"
-    HAVE_WORKING_STD_REGEX)
+    "#include <cmath> 
+    void f() { isnan(0.0);} "
+    HAVE_ISNAN)

 if(CMAKE_COMPILER_IS_GNUCXX)
-    set(WARNING_FLAGS_CXX "-Wall -fPIC")
-    set(WARNING_FLAGS_C   "-Wall -fPIC")
-
-    if (X86 OR X86_64)
-        set(SIMD_COMPILER_FLAGS "-msse2 -mfpmath=sse -ftree-vectorize -ftree-slp-vectorize")
-    endif()
+    set(WARNING_FLAGS_CXX "-Wall")
+    set(WARNING_FLAGS_C   "-Wall")

    # certain GCC versions don't provide the atomic builds, and hence
    # require is to provide them in SGAtomic.cxx
@@ -306,46 +211,11 @@ if(CMAKE_COMPILER_IS_GNUCXX)
    check_cxx_source_compiles(
       "int main() { unsigned mValue; return __sync_add_and_fetch(&mValue, 1); }"
        GCC_ATOMIC_BUILTINS_FOUND)
-
-    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O3 -g -DNDEBUG")
-    set(CMAKE_C_FLAGS_RELWITHDEBINFO  "-O3 -g -DNDEBUG")
 endif(CMAKE_COMPILER_IS_GNUCXX)

-if (CLANG)
-    # Boost redeclares class members
-    set(WARNING_FLAGS_CXX "-Wall -fPIC -Wno-overloaded-virtual -Wno-redeclared-class-member")
-    set(WARNING_FLAGS_C   "-Wall -fPIC")
-    set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++")
-    # fix Boost compilation :(
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
-    # override CMake default RelWithDebInfo flags.
-    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O3 -g -DNDEBUG")
-    set(CMAKE_C_FLAGS_RELWITHDEBINFO  "-O3 -g -DNDEBUG")
-
-    set(SIMD_COMPILER_FLAGS "-msse2 -mfpmath=sse -ftree-vectorize -ftree-slp-vectorize")
-endif()
-
-if (ENABLE_ASAN)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address")
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address")
-  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fsanitize=address")
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address")
-
-  # needed for check_cxx_source_compiles
-  set(CMAKE_REQUIRED_LINK_OPTIONS "-fsanitize=address")
-endif()
-
-if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-# boost goes haywire wrt static asserts
-    check_cxx_compiler_flag(-Wno-unused-local-typedefs HAS_NOWARN_UNUSED_TYPEDEFS)
-    if(HAS_NOWARN_UNUSED_TYPEDEFS)
-        set(WARNING_FLAGS_CXX " ${WARNING_FLAGS_CXX} -Wno-unused-local-typedefs")
-    endif()
-
-    check_cxx_compiler_flag(-Wno-inconsistent-missing-override HAS_NOWARN_MISSING_OVERRIDE)
-    if(HAS_NOWARN_MISSING_OVERRIDE)
-        set(WARNING_FLAGS_CXX " ${WARNING_FLAGS_CXX} -Wno-inconsistent-missing-override")
-    endif()
+if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+   set(WARNING_FLAGS_CXX "-Wall -Wno-overloaded-virtual")
+   set(WARNING_FLAGS_C   "-Wall")
 endif()

 if(WIN32)
@@ -355,48 +225,34 @@ if(WIN32)
    endif()

    if(MSVC)
-        set(MSVC_FLAGS "-D_HAS_STD_BYTE=0 -DWIN32 -DNOMINMAX -D_USE_MATH_DEFINES -D_CRT_SECURE_NO_WARNINGS -D__CRT_NONSTDC_NO_WARNINGS /MP /bigobj")
-        if (X86)
-          set(SIMD_COMPILER_FLAGS "/arch:SSE /arch:SSE2")
-        endif()
-
-        if (NOT OSG_FSTREAM_EXPORT_FIXED)
-          message(STATUS "For better linking performance, use OSG with patched fstream header")
-          # needed to avoid link errors on multiply-defined standard C++
-          # symbols. Suspect this may be an OSG-DB export bug
-            set( MSVC_LD_FLAGS "/FORCE:MULTIPLE" )
-        endif ()
+        # turn off various warnings
+        # foreach(warning 4244 4251 4267 4275 4290 4786 4305 4996)
+        #     SET(WARNING_FLAGS "${WARNING_FLAGS} /wd${warning}")
+        # endforeach(warning)
+        
+        set(MSVC_FLAGS "-DWIN32 -DNOMINMAX -D_USE_MATH_DEFINES -D_CRT_SECURE_NO_WARNINGS -D__CRT_NONSTDC_NO_WARNINGS /wd4996")
    endif(MSVC)
-
+    
    # assumed on Windows
    set(HAVE_GETLOCALTIME 1)
-
+    
    set( WINSOCK_LIBRARY "ws2_32.lib" )
-    set( SHLWAPI_LIBRARY "Shlwapi.lib" )
    set( RT_LIBRARY "winmm" )
 endif(WIN32)

-# append the SIMD flags if requested
-if (ENABLE_SIMD)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${SIMD_COMPILER_FLAGS}")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SIMD_COMPILER_FLAGS}")
-
-  # set for multi-configuration generators
-  set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${SIMD_COMPILER_FLAGS}")
-  set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${SIMD_COMPILER_FLAGS}")
-
-  set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} ${SIMD_COMPILER_FLAGS}")
-  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} ${SIMD_COMPILER_FLAGS}")
-endif()
-
-
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNING_FLAGS_C} ${MSVC_FLAGS}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNING_FLAGS_CXX} ${MSVC_FLAGS} ${BOOST_CXX_FLAGS}")
-set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${MSVC_LD_FLAGS}")

-include(CheckCXXFeatures)
+include_directories(${PROJECT_SOURCE_DIR})
+include_directories(${PROJECT_BINARY_DIR}/simgear)
+include_directories(${PROJECT_BINARY_DIR}/simgear/xml)
+
+include_directories(${OPENSCENEGRAPH_INCLUDE_DIRS} 
+    ${Boost_INCLUDE_DIRS} ${ZLIB_INCLUDE_DIR} 
+    ${ALUT_INCLUDE_DIR} ${OPENAL_INCLUDE_DIR} )

 add_definitions(-DHAVE_CONFIG_H)
+add_definitions(-DHAVE_EXPAT_CONFIG_H)

 # configure a header file to pass some of the CMake settings
 # to the source code
@@ -405,55 +261,24 @@ configure_file (
  "${PROJECT_BINARY_DIR}/simgear/simgear_config.h"
  )

-include (Dart)
-enable_testing()
-include(AddSimGearTest) # helper to setup a test
+configure_file (
+    "${PROJECT_SOURCE_DIR}/simgear/xml/expat_config_cmake.in"
+    "${PROJECT_BINARY_DIR}/simgear/xml/expat_config.h"
+)
+
+if(ENABLE_TESTS)
+    # enable CTest / make test target
+    message(STATUS "Tests: ENABLED")
+
+    include (Dart)
+        enable_testing()
+else()
+    message(STATUS "Tests: DISABLED")
+endif(ENABLE_TESTS)

 install (FILES ${PROJECT_BINARY_DIR}/simgear/simgear_config.h  DESTINATION include/simgear/)
-
-if(SYSTEM_UDNS)
-    message(STATUS "Requested to use system udns library, forcing SIMGEAR_SHARED to true")
-    set(SIMGEAR_SHARED ON)
-    find_package(Udns REQUIRED)
-endif()
-
-add_subdirectory(3rdparty)
 add_subdirectory(simgear)

-#-----------------------------------------------------------------------------
-### Export stuff, see https://cmake.org/cmake/help/v3.2/manual/cmake-packages.7.html#creating-packages
-#-----------------------------------------------------------------------------
-
-generate_export_header(SimGearCore)
-if(NOT SIMGEAR_HEADLESS)
-  generate_export_header(SimGearScene)
-endif()
-
-include(CMakePackageConfigHelpers)
-
-write_basic_package_version_file(
-  "${CMAKE_CURRENT_BINARY_DIR}/SimGear/SimGearConfigVersion.cmake"
-  VERSION ${SIMGEAR_VERSION}
-  COMPATIBILITY AnyNewerVersion
-)
-
-configure_file(SimGearConfig.cmake.in
-  "${CMAKE_CURRENT_BINARY_DIR}/SimGear/SimGearConfig.cmake"
-  @ONLY
-)
-
-set(ConfigPackageLocation ${CMAKE_INSTALL_LIBDIR}/cmake/SimGear)
-install(EXPORT SimGearTargets
-  DESTINATION ${ConfigPackageLocation}
-)
-install(
-  FILES
-    "${CMAKE_CURRENT_BINARY_DIR}/SimGear/SimGearConfig.cmake"
-    "${CMAKE_CURRENT_BINARY_DIR}/SimGear/SimGearConfigVersion.cmake"
-  DESTINATION ${ConfigPackageLocation}
-  COMPONENT Devel
-)
-
 #-----------------------------------------------------------------------------
 ### uninstall target
 #-----------------------------------------------------------------------------
--- a/CMakeModules/AddSimGearTest.cmake
+++ b/CMakeModules/AddSimGearTest.cmake
@@ -1,30 +0,0 @@
-
-function(add_simgear_test _name _sources)
-    add_executable(${_name} ${_sources})
-    target_link_libraries(${_name} SimGearCore Threads::Threads)
-
-    # for simgear_config.h
-    target_include_directories(${_name} PRIVATE ${PROJECT_BINARY_DIR}/simgear)
-endfunction()
-
-
-function(add_simgear_autotest _name _sources)
-    add_executable(${_name} ${_sources})
-    target_link_libraries(${_name} SimGearCore Threads::Threads)
-
-    # for simgear_config.h
-    target_include_directories(${_name} PRIVATE ${PROJECT_BINARY_DIR}/simgear)
-
-    add_test(${_name} ${EXECUTABLE_OUTPUT_PATH}/${_name})
-endfunction()
-
-
-function(add_simgear_scene_autotest _name _sources)
-    add_executable(${_name} ${_sources})
-    target_link_libraries(${_name} SimGearScene Threads::Threads)
-
-    # for simgear_config.h
-    target_include_directories(${_name} PRIVATE ${PROJECT_BINARY_DIR}/simgear)
-
-    add_test(${_name} ${EXECUTABLE_OUTPUT_PATH}/${_name})
-endfunction()
--- a/CMakeModules/BoostTestTargets.cmake
+++ b/CMakeModules/BoostTestTargets.cmake
@@ -1,262 +0,0 @@
-# - Add tests using boost::test
-#
-# Add this line to your test files in place of including a basic boost test header:
-#  #include <BoostTestTargetConfig.h>
-#
-# If you cannot do that and must use the included form for a given test,
-# include the line
-#  // OVERRIDE_BOOST_TEST_INCLUDED_WARNING
-# in the same file with the boost test include.
-#
-#  include(BoostTestTargets)
-#  add_boost_test(<testdriver_name> SOURCES <source1> [<more sources...>]
-#   [FAIL_REGULAR_EXPRESSION <additional fail regex>]
-#   [LAUNCHER <generic launcher script>]
-#   [LIBRARIES <library> [<library>...]]
-#   [RESOURCES <resource> [<resource>...]]
-#   [TESTS <testcasename> [<testcasename>...]])
-#
-#  If for some reason you need access to the executable target created,
-#  it can be found in ${${testdriver_name}_TARGET_NAME} as specified when
-#  you called add_boost_test
-#
-# Requires CMake 2.6 or newer (uses the 'function' command)
-#
-# Requires:
-# 	GetForceIncludeDefinitions
-# 	CopyResourcesToBuildTree
-#
-# Original Author:
-# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
-# http://academic.cleardefinition.com
-# Iowa State University HCI Graduate Program/VRAC
-#
-# Copyright Iowa State University 2009-2010.
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-if(__add_boost_test)
-	return()
-endif()
-set(__add_boost_test YES)
-
-set(BOOST_TEST_TARGET_PREFIX "test")
-
-if(NOT Boost_FOUND)
-	find_package(Boost 1.34.0 QUIET)
-endif()
-
-if (NOT Boost_VERSION_MACRO)
-	# Compatibility with pre CMP0093 (CMake 3.15)
-	set(Boost_VERSION_MACRO ${Boost_VERSION})
-endif()
-
-if("${Boost_VERSION_MACRO}0" LESS "1034000")
-	set(_shared_msg
-		"NOTE: boost::test-based targets and tests cannot "
-		"be added: boost >= 1.34.0 required but not found. "
-		"(found: '${Boost_VERSION_MACRO}'; want >=103400) ")
-	if(ENABLE_TESTS)
-		message(FATAL_ERROR
-			${_shared_msg}
-			"You may disable ENABLE_TESTS to continue without the "
-			"tests.")
-	else()
-		message(STATUS
-			${_shared_msg}
-			"ENABLE_TESTS disabled, so continuing anyway.")
-	endif()
-endif()
-
-include(GetForceIncludeDefinitions)
-include(CopyResourcesToBuildTree)
-
-if(Boost_FOUND AND NOT "${Boost_VERSION_MACRO}0" LESS "1034000")
-	set(_boosttesttargets_libs)
-	set(_boostConfig "BoostTestTargetsIncluded.h")
-	if(NOT Boost_UNIT_TEST_FRAMEWORK_LIBRARY)
-		find_package(Boost 1.34.0 QUIET COMPONENTS unit_test_framework)
-	endif()
-	if(Boost_UNIT_TEST_FRAMEWORK_LIBRARY)
-		set(_boosttesttargets_libs "${Boost_UNIT_TEST_FRAMEWORK_LIBRARY}")
-		if(Boost_USE_STATIC_LIBS)
-			set(_boostConfig "BoostTestTargetsStatic.h")
-		else()
-			set(_boostConfig "BoostTestTargetsDynamic.h")
-		endif()
-	endif()
-	get_filename_component(_moddir ${CMAKE_CURRENT_LIST_FILE} DIRECTORY)
-	configure_file("${_moddir}/${_boostConfig}"
-		"${CMAKE_CURRENT_BINARY_DIR}/BoostTestTargetConfig.h"
-		COPYONLY)
-	include_directories("${CMAKE_CURRENT_BINARY_DIR}")
-endif()
-
-function(add_boost_test _name)
-	if(NOT ENABLE_TESTS)
-		return()
-	endif()
-
-	# parse arguments
-	set(_nowhere)
-	set(_curdest _nowhere)
-	set(_val_args
-		SOURCES
-		FAIL_REGULAR_EXPRESSION
-		LAUNCHER
-		LIBRARIES
-		RESOURCES
-		TESTS)
-	set(_bool_args
-		USE_COMPILED_LIBRARY)
-	foreach(_arg ${_val_args} ${_bool_args})
-		set(${_arg})
-	endforeach()
-	foreach(_element ${ARGN})
-		list(FIND _val_args "${_element}" _val_arg_find)
-		list(FIND _bool_args "${_element}" _bool_arg_find)
-		if("${_val_arg_find}" GREATER "-1")
-			set(_curdest "${_element}")
-		elseif("${_bool_arg_find}" GREATER "-1")
-			set("${_element}" ON)
-			set(_curdest _nowhere)
-		else()
-			list(APPEND ${_curdest} "${_element}")
-		endif()
-	endforeach()
-
-	if(_nowhere)
-		message(FATAL_ERROR "Syntax error in use of add_boost_test!")
-	endif()
-
-	if(NOT SOURCES)
-		message(FATAL_ERROR
-			"Syntax error in use of add_boost_test: at least one source file required!")
-	endif()
-
-	if(Boost_FOUND AND NOT "${Boost_VERSION_MACRO}0" LESS "1034000")
-
-		include_directories(${Boost_INCLUDE_DIRS})
-
-		set(includeType)
-		foreach(src ${SOURCES})
-			file(READ ${src} thefile)
-			if("${thefile}" MATCHES ".*BoostTestTargetConfig.h.*")
-				set(includeType CONFIGURED)
-				set(includeFileLoc ${src})
-				break()
-			elseif("${thefile}" MATCHES ".*boost/test/included/unit_test.hpp.*")
-				set(includeType INCLUDED)
-				set(includeFileLoc ${src})
-				set(_boosttesttargets_libs)	# clear this out - linking would be a bad idea
-				if(NOT
-					"${thefile}"
-					MATCHES
-					".*OVERRIDE_BOOST_TEST_INCLUDED_WARNING.*")
-					message("Please replace the include line in ${src} with this alternate include line instead:")
-					message("  \#include <BoostTestTargetConfig.h>")
-					message("Once you've saved your changes, re-run CMake. (See BoostTestTargets.cmake for more info)")
-				endif()
-				break()
-			endif()
-		endforeach()
-
-		if(NOT _boostTestTargetsNagged${_name} STREQUAL "${includeType}")
-			if("${includeType}" STREQUAL "CONFIGURED")
-				message(STATUS
-					"Test '${_name}' uses the CMake-configurable form of the boost test framework - congrats! (Including File: ${includeFileLoc})")
-			elseif("${includeType}" STREQUAL "INCLUDED")
-				message("In test '${_name}': ${includeFileLoc} uses the 'included' form of the boost unit test framework.")
-			else()
-				message("In test '${_name}': Didn't detect the CMake-configurable boost test include.")
-				message("Please replace your existing boost test include in that test with the following:")
-				message("  \#include <BoostTestTargetConfig.h>")
-				message("Once you've saved your changes, re-run CMake. (See BoostTestTargets.cmake for more info)")
-			endif()
-		endif()
-		set(_boostTestTargetsNagged${_name}
-			"${includeType}"
-			CACHE
-			INTERNAL
-			""
-			FORCE)
-
-
-		if(RESOURCES)
-			list(APPEND SOURCES ${RESOURCES})
-		endif()
-
-		# Generate a unique target name, using the relative binary dir
-		# and provided name. (transform all / into _ and remove all other
-		# non-alphabet characters)
-		file(RELATIVE_PATH
-			targetpath
-			"${CMAKE_BINARY_DIR}"
-			"${CMAKE_CURRENT_BINARY_DIR}")
-		string(REGEX REPLACE "[^A-Za-z/_]" "" targetpath "${targetpath}")
-		string(REPLACE "/" "_" targetpath "${targetpath}")
-
-		set(_target_name ${BOOST_TEST_TARGET_PREFIX}-${targetpath}-${_name})
-		set(${_name}_TARGET_NAME "${_target_name}" PARENT_SCOPE)
-
-		# Build the test.
-		add_executable(${_target_name} ${SOURCES})
-
-		list(APPEND LIBRARIES ${_boosttesttargets_libs})
-
-		if(LIBRARIES)
-			target_link_libraries(${_target_name} ${LIBRARIES})
-		endif()
-
-		if(RESOURCES)
-			set_property(TARGET ${_target_name} PROPERTY RESOURCE ${RESOURCES})
-			copy_resources_to_build_tree(${_target_name})
-		endif()
-
-		if(NOT Boost_TEST_FLAGS)
-#			set(Boost_TEST_FLAGS --catch_system_error=yes --output_format=XML)
-			set(Boost_TEST_FLAGS --catch_system_error=yes)
-		endif()
-
-		# TODO: Figure out why only recent boost handles individual test running properly
-
-		if(LAUNCHER)
-			set(_test_command ${LAUNCHER} "\$<TARGET_FILE:${_target_name}>")
-		else()
-			set(_test_command ${_target_name})
-		endif()
-
-		if(TESTS AND ( "${Boost_VERSION_MACRO}" VERSION_GREATER "103799" ))
-			foreach(_test ${TESTS})
-				add_test(
-					${_name}-${_test}
-					${_test_command} --run_test=${_test} ${Boost_TEST_FLAGS}
-				)
-				if(FAIL_REGULAR_EXPRESSION)
-					set_tests_properties(${_name}-${_test}
-						PROPERTIES
-						FAIL_REGULAR_EXPRESSION
-						"${FAIL_REGULAR_EXPRESSION}")
-				endif()
-			endforeach()
-		else()
-			add_test(
-				${_name}-boost_test
-				${_test_command} ${Boost_TEST_FLAGS}
-			)
-			if(FAIL_REGULAR_EXPRESSION)
-				set_tests_properties(${_name}-boost_test
-					PROPERTIES
-					FAIL_REGULAR_EXPRESSION
-					"${FAIL_REGULAR_EXPRESSION}")
-			endif()
-		endif()
-
-		# CppCheck the test if we can.
-		if(COMMAND add_cppcheck)
-			add_cppcheck(${_target_name} STYLE UNUSED_FUNCTIONS)
-		endif()
-
-	endif()
-endfunction()
--- a/CMakeModules/BoostTestTargetsDynamic.h
+++ b/CMakeModules/BoostTestTargetsDynamic.h
@@ -1,8 +0,0 @@
-// Small header computed by CMake to set up boost test.
-// include AFTER #define BOOST_TEST_MODULE whatever
-// but before any other boost test includes.
-
-// Using the Boost UTF dynamic library
-
-#define BOOST_TEST_DYN_LINK
-#include <boost/test/unit_test.hpp>
--- a/CMakeModules/BoostTestTargetsIncluded.h
+++ b/CMakeModules/BoostTestTargetsIncluded.h
@@ -1,7 +0,0 @@
-// Small header computed by CMake to set up boost test.
-// include AFTER #define BOOST_TEST_MODULE whatever
-// but before any other boost test includes.
-
-// Using the Boost UTF included framework
-
-#include <boost/test/included/unit_test.hpp>
--- a/CMakeModules/BoostTestTargetsStatic.h
+++ b/CMakeModules/BoostTestTargetsStatic.h
@@ -1,7 +0,0 @@
-// Small header computed by CMake to set up boost test.
-// include AFTER #define BOOST_TEST_MODULE whatever
-// but before any other boost test includes.
-
-// Using the Boost UTF static library
-
-#include <boost/test/unit_test.hpp>
--- a/CMakeModules/CheckCXXFeatures.cmake
+++ b/CMakeModules/CheckCXXFeatures.cmake
@@ -1,30 +0,0 @@
-check_cxx_source_compiles("
-  #include <utility>
-  #include <type_traits>
-  std::make_index_sequence<0> t;
-  int main() {}" HAVE_STD_INDEX_SEQUENCE
-)
-
-check_cxx_source_compiles("
-  #include <type_traits>
-  std::remove_cv_t<const int> t;
-  int main() {}" HAVE_STD_REMOVE_CV_T
-)
-
-check_cxx_source_compiles("
-  #include <type_traits>
-  std::remove_cvref_t<const int&> t;
-  int main() {}" HAVE_STD_REMOVE_CVREF_T
-)
-
-check_cxx_source_compiles("
-  #include <type_traits>
-  std::enable_if_t<true, int> t;
-  int main() {}" HAVE_STD_ENABLE_IF_T
-)
-
-check_cxx_source_compiles("
-  #include <type_traits>
-  std::bool_constant<true> t;
-  int main() {}" HAVE_STD_BOOL_CONSTANT
-)
--- a/CMakeModules/CheckPOSIXFeatures.cmake
+++ b/CMakeModules/CheckPOSIXFeatures.cmake
@@ -1,55 +0,0 @@
-check_function_exists(gettimeofday HAVE_GETTIMEOFDAY)
-check_function_exists(rint HAVE_RINT)
-check_function_exists(mkdtemp HAVE_MKDTEMP)
-check_function_exists(bcopy HAVE_BCOPY)
-check_function_exists(mmap HAVE_MMAP)
-
-check_include_file(inttypes.h HAVE_INTTYPES_H)
-check_include_file(sys/time.h HAVE_SYS_TIME_H)
-check_include_file(unistd.h HAVE_UNISTD_H)
-check_include_file(windows.h HAVE_WINDOWS_H)
-
-if (NOT MSVC)
-  check_function_exists(timegm HAVE_TIMEGM)
-  if (NOT HAVE_TIMEGM)
-    message(FATAL_ERROR "Non-Windows platforms must support timegm()")
-  endif()
-endif()
-
-if(HAVE_UNISTD_H)
-    set(CMAKE_REQUIRED_INCLUDES ${CMAKE_INCLUDE_PATH})
-    check_cxx_source_compiles(
-       "#include <unistd.h>
-        #if !defined(_POSIX_TIMERS) || (0 >= _POSIX_TIMERS)
-            #error clock_gettime is not supported
-        #endif
-
-        int main() { return 0; }
-        "
-        HAVE_CLOCK_GETTIME)
-endif(HAVE_UNISTD_H)
-
-set(RT_LIBRARY "")
-if(HAVE_CLOCK_GETTIME)
-    check_library_exists(rt clock_gettime "" HAVE_RT)
-    if(HAVE_RT)
-        set(RT_LIBRARY rt)
-    endif(HAVE_RT)
-endif(HAVE_CLOCK_GETTIME)
-
-set(DL_LIBRARY "")
-check_cxx_source_compiles(
-    "#include <dlfcn.h>
-    int main(void) {
-        return 0;
-    }
-    "
-    HAVE_DLFCN_H)
-
-if(HAVE_DLFCN_H)
-    check_library_exists(dl dlerror "" HAVE_DL)
-    if(HAVE_DL)
-        set(DL_LIBRARY "dl")
-    endif()
-endif()
-
--- a/CMakeModules/ConfigureMsvc3rdParty.cmake
+++ b/CMakeModules/ConfigureMsvc3rdParty.cmake
@@ -1,132 +0,0 @@
-# ConfigureMsvc3rdParty.cmake - Configure 3rd Party Library Paths on Windows
-
-# we want to handle various cases here:
-# fgmeta layout, where windows-3rd-party is a sibling of our flightgear source dir
-#  - this should work with no manual options
-# explicitly specifying MSVC_3RDPARTY_ROOT: we'll select a subdir based on MSVC version
-# and architecture. We want to allow for people specify various paths here:
-# - path to windows-3rd-party
-# - path to an MSVC versioned subdir, eg -DMSVC_3RDPARTY_ROOT=C:\FGFS\windows-3rd-party\msvc140
-# - path to an architecture specific subdir, eg -DMSVC_3RDPARTY_ROOT=C:\FGFS\windows-3rd-party\msvc140\3rdparty.x64
-
-set(_FOUND_3RDPARTY_DIR "NOTFOUND")
-set(_FOUND_BOOST_INCLUDE_DIR "NOTFOUND")
-
-# try various suffixes of a base directory, and
-# set the variables above on success
-function(_check_candidate_msvc_path pathToCheck)
-    unset (_freeTypeHeader CACHE )
-    unset (_zlibDll CACHE )
-    unset (_boostHeaders CACHE )
-
-    find_path(_freeTypeHeader include/ft2build.h
-        PATHS 
-            ${pathToCheck}
-        PATH_SUFFIXES
-            ${ARCH_SUBDIR_NAME}
-            ${MSVC_SUBDIR_NAME}/${ARCH_SUBDIR_NAME}
-            ${COMPAT_SUBDIR_NAME}/${ARCH_SUBDIR_NAME}
-        NO_DEFAULT_PATH
-    )
-
-    find_path(_zlibDll bin/zlib.dll
-        PATHS 
-            ${pathToCheck}
-        PATH_SUFFIXES
-            ${ARCH_SUBDIR_NAME}
-            ${MSVC_SUBDIR_NAME}/${ARCH_SUBDIR_NAME}
-            ${COMPAT_SUBDIR_NAME}/${ARCH_SUBDIR_NAME}
-        NO_DEFAULT_PATH
-    )
-
-    find_path(_boostHeaders boost/atomic.hpp
-        PATHS 
-            ${pathToCheck}
-        NO_DEFAULT_PATH
-    )
-
-    if (_freeTypeHeader AND _zlibDll)
-        set(_FOUND_3RDPARTY_DIR "${_freeTypeHeader}" PARENT_SCOPE)
-
-        if (_boostHeaders) 
-            set(_FOUND_BOOST_INCLUDE_DIR "${_boostHeaders}" PARENT_SCOPE)
-        endif()
-    endif()
-endfunction()
-
-
-if (MSVC)
-    # compute values for the compiler and arch subdirs
-    string(SUBSTRING ${MSVC_VERSION} 0 2 MSVC_VERSION_MAJOR)
-    string(SUBSTRING ${MSVC_VERSION} 2 2 MSVC_VERSION_MINOR)
-
-    if (${MSVC_VERSION_MAJOR} EQUAL "19")
-        if (${MSVC_VERSION_MINOR} EQUAL "00")
-            set( MSVC_SUBDIR_NAME msvc140 )
-        else ()
-            set( MSVC_SUBDIR_NAME msvc141 )
-            set( COMPAT_SUBDIR_NAME msvc140 )
-        endif()
-    else ()
-        message(FATAL_ERROR "Visual Studio 2017 is required")
-    endif ()
-
-    if (CMAKE_CL_64)
-        SET(ARCH_SUBDIR_NAME "3rdParty.x64")
-    else (CMAKE_CL_64)
-        SET(ARCH_SUBDIR_NAME "3rdParty")
-    endif (CMAKE_CL_64)
-
-    
-    # try the explicitly specified value first
-    if (EXISTS ${MSVC_3RDPARTY_ROOT})
-        _check_candidate_msvc_path("${MSVC_3RDPARTY_ROOT}")
-    endif()
-
-    # then try the fgmeta setup: look for a windows-3rdparty sibling of
-    # our source dir
-    get_filename_component(PARENT_SOURCE_DIR ${PROJECT_SOURCE_DIR} DIRECTORY)
-    get_filename_component(PARENT_BINARY_DIR ${PROJECT_BINARY_DIR} DIRECTORY)
-
-
-    if (NOT _FOUND_3RDPARTY_DIR AND EXISTS "${PARENT_SOURCE_DIR}/windows-3rd-party")
-        message(STATUS "Trying src 3rdparty")
-        _check_candidate_msvc_path("${PARENT_SOURCE_DIR}/windows-3rd-party")
-    endif()
-
-    if (NOT _FOUND_3RDPARTY_DIR AND EXISTS "${PARENT_BINARY_DIR}/windows-3rd-party")
-        message(STATUS "Trying bin 3rdparty")
-        _check_candidate_msvc_path("${PARENT_BINARY_DIR}/windows-3rd-party")
-    endif()
-
-    # try the Jenkins setup, whre the arch dir is copied into the WORKSPACE
-    if (NOT _FOUND_3RDPARTY_DIR AND EXISTS "${PARENT_BINARY_DIR}/${ARCH_SUBDIR_NAME}")
-        message(STATUS "Trying arch subdir ${PARENT_BINARY_DIR}/${ARCH_SUBDIR_NAME}")
-        _check_candidate_msvc_path("${PARENT_BINARY_DIR}/${ARCH_SUBDIR_NAME}")
-    endif()
-
-    if (NOT _FOUND_3RDPARTY_DIR)
-        message(WARNING "Failed to find the Windows 3rdparty files at all.")
-        set(MSVC_3RDPARTY_ROOT NOT_FOUND CACHE PATH "Location where the third-party dependencies are extracted")
-    endif()
-
-else (MSVC)
-    set(MSVC_3RDPARTY_ROOT NOT_FOUND CACHE PATH "Location where the third-party dependencies are extracted")
-endif (MSVC)
-
-if (MSVC AND _FOUND_3RDPARTY_DIR)
-    message(STATUS "3rdparty files located in ${_FOUND_3RDPARTY_DIR}")
-    list(APPEND CMAKE_PREFIX_PATH ${_FOUND_3RDPARTY_DIR})
-    set(FINAL_MSVC_3RDPARTY_DIR ${_FOUND_3RDPARTY_DIR})
-
-    if (CMAKE_CL_64)
-		set( BOOST_LIB lib64 )
-    else (CMAKE_CL_64)
-	    set( BOOST_LIB lib )
-    endif (CMAKE_CL_64)
-
-    if(NOT BOOST_INCLUDEDIR AND _FOUND_BOOST_INCLUDE_DIR)
-        set(BOOST_INCLUDEDIR ${_FOUND_BOOST_INCLUDE_DIR})
-        message(STATUS "found Boost headers at ${_FOUND_BOOST_INCLUDE_DIR}")
-      endif()
-endif ()
--- a/CMakeModules/CopyResourcesToBuildTree.cmake
+++ b/CMakeModules/CopyResourcesToBuildTree.cmake
@@ -1,83 +0,0 @@
-# - Copy the resources your app needs to the build tree.
-#
-#  copy_resources_to_build_tree(<target_name>)
-#
-# Requires CMake 2.6 or newer (uses the 'function' command)
-#
-# Original Author:
-# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
-# http://academic.cleardefinition.com
-# Iowa State University HCI Graduate Program/VRAC
-#
-# Copyright Iowa State University 2009-2010.
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-if(__copy_resources_to_build_tree)
-	return()
-endif()
-set(__copy_resources_to_build_tree YES)
-
-function(copy_resources_to_build_tree _target)
-	get_target_property(_resources ${_target} RESOURCE)
-	if(NOT _resources)
-		# Bail if no resources
-		message(STATUS
-			"Told to copy resources for target ${_target}, but "
-			"no resources are set!")
-		return()
-	endif()
-
-	get_target_property(_path ${_target} LOCATION)
-	get_filename_component(_path "${_path}" DIRECTORY)
-
-	if(NOT MSVC AND NOT "${CMAKE_GENERATOR}" MATCHES "Makefiles")
-		foreach(_config ${CMAKE_CONFIGURATION_TYPES})
-			get_target_property(_path${_config} ${_target} LOCATION_${_config})
-			get_filename_component(_path${_config} "${_path${_config}}" DIRECTORY)
-			add_custom_command(TARGET ${_target}
-						POST_BUILD
-						COMMAND
-						${CMAKE_COMMAND}
-						ARGS -E make_directory "${_path${_config}}/"
-						COMMENT "Creating directory ${_path${_config}}/")
-		endforeach()
-	endif()
-
-	foreach(_res ${_resources})
-		if(NOT IS_ABSOLUTE "${_res}")
-			get_filename_component(_res "${_res}" ABSOLUTE)
-		endif()
-		get_filename_component(_name "${_res}" NAME)
-
-		if(MSVC)
-			# Working dir is solution file dir, not exe file dir.
-			add_custom_command(TARGET ${_target}
-				POST_BUILD
-				COMMAND
-				${CMAKE_COMMAND}
-				ARGS -E copy "${_res}" "${CMAKE_BINARY_DIR}/"
-				COMMENT "Copying ${_name} to ${CMAKE_BINARY_DIR}/ for MSVC")
-		else()
-			if("${CMAKE_GENERATOR}" MATCHES "Makefiles")
-				add_custom_command(TARGET ${_target}
-					POST_BUILD
-					COMMAND
-					${CMAKE_COMMAND}
-					ARGS -E copy "${_res}" "${_path}/"
-					COMMENT "Copying ${_name} to ${_path}/")
-			else()
-				foreach(_config ${CMAKE_CONFIGURATION_TYPES})
-					add_custom_command(TARGET ${_target}
-						POST_BUILD
-						COMMAND
-						${CMAKE_COMMAND}
-						ARGS -E copy "${_res}" "${_path${_config}}"
-						COMMENT "Copying ${_name} to ${_path${_config}}")
-				endforeach()
-
-			endif()
-		endif()
-	endforeach()
-endfunction()
--- a/CMakeModules/DetectArch.cmake
+++ b/CMakeModules/DetectArch.cmake
@@ -1,37 +0,0 @@
-IF(CMAKE_SYSTEM_PROCESSOR MATCHES amd64.*|x86_64.* OR CMAKE_GENERATOR MATCHES "Visual Studio.*Win64")
-  IF(CMAKE_C_FLAGS MATCHES -m32 OR CMAKE_CXX_FLAGS MATCHES -m32)
-    SET(X86 1)
-  ELSE(CMAKE_C_FLAGS MATCHES -m32 OR CMAKE_CXX_FLAGS MATCHES -m32)
-    SET(X86_64 1)
-  ENDIF(CMAKE_C_FLAGS MATCHES -m32 OR CMAKE_CXX_FLAGS MATCHES -m32)
-ELSEIF(CMAKE_SYSTEM_PROCESSOR MATCHES i686.*|i386.*|x86.* OR WIN32)
-  IF(CMAKE_C_FLAGS MATCHES -m64 OR CMAKE_CXX_FLAGS MATCHES -m64)
-    SET(X86_64 1)
-  ELSE(CMAKE_C_FLAGS MATCHES -m64 OR CMAKE_CXX_FLAGS MATCHES -m64)
-    SET(X86 1)
-  ENDIF(CMAKE_C_FLAGS MATCHES -m64 OR CMAKE_CXX_FLAGS MATCHES -m64)
-ELSEIF(CMAKE_SYSTEM_PROCESSOR MATCHES arm.* AND CMAKE_SYSTEM_NAME STREQUAL "Linux")
-    SET(ARM 1)
-ELSEIF(CMAKE_SYSTEM_PROCESSOR MATCHES mips)
-    SET(MIPS 1)
-ENDIF()
-
-IF ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang")
-  # using Clang
-  SET(CLANG 1)
-ELSEIF ("${CMAKE_C_COMPILER_ID}" STREQUAL "TinyCC")
-  # using TinyCC
-  SET(TINYCC 1)
-ELSEIF ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU")
-  # using GCC
-  SET(GCC 1)
-ELSEIF ("${CMAKE_C_COMPILER_ID}" STREQUAL "Intel")
-  # using Intel C++
-  SET(INTELCC 1)
-ELSEIF ("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC")
-  # using Visual Studio C++
-  SET(MSVC 1)
-ELSEIF ("${CMAKE_C_COMPILER_ID}" STREQUAL "MIPSpro")
-  # using SGI MIPSpro
-  SET(MIPSPRO 1)
-ENDIF()
--- a/CMakeModules/ExportDebugSymbols.cmake
+++ b/CMakeModules/ExportDebugSymbols.cmake
@@ -1,26 +0,0 @@
-
-
-# placehodler target for other ones to depend upon
-add_custom_target(
-    debug_symbols
-)
-
-function(export_debug_symbols target)
-
-    if (NOT SIMGEAR_SHARED)
-        return()
-    endif()
-
-    if (APPLE)
-        add_custom_target(${target}.dSYM
-            COMMENT "Generating dSYM files for ${target}"
-            COMMAND dsymutil --out=${target}.dSYM $<TARGET_FILE:${target}>
-            DEPENDS $<TARGET_FILE:${target}>
-        ) 
-
-        install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${target}.dSYM DESTINATION symbols OPTIONAL)
-
-        add_dependencies(debug_symbols ${target}.dSYM)
-    endif()
-
-endfunction()
--- a/CMakeModules/FindAAX.cmake
+++ b/CMakeModules/FindAAX.cmake
@@ -1,74 +0,0 @@
-# Try to find AAX (AeonWave)
-# This module defines
-#
-# AAX_FOUND - if false, do not try to link to AAX
-# AAX_INCLUDE_DIR - where to find the headers
-# AAX_LIBRARY - Link these to use AAX
-#
-# Copyright (C) 2016-2018 by Erik Hofman.
-# Copyright (C) 2016-2018 by Adalin B.V.
-#
-# $AAXDIR is an environment variable that would
-# correspond to the ./configure --prefix=$AAXDIR
-# used in building AAX.
-#
-# This file is Public Domain (www.unlicense.org)
-# This is free and unencumbered software released into the public domain.
-
-if (AAX_LIBRARY AND AAX_INCLUDE_DIR)
-  # in cache already
-  set(AAX_FOUND TRUE)
-else()
-  find_path(AAX_INCLUDE_DIR aax/aax.h
-    HINTS
-    $ENV{AAXDIR}
-    $ENV{ProgramFiles}/aax
-    $ENV{ProgramFiles}/AeonWave
-    $ENV{ProgramFiles}/Adalin/AeonWave
-    ${CMAKE_SOURCE_DIR}/aax
-    PATH_SUFFIXES include
-    PATHS
-    ~/Library/Frameworks
-    /Library/Frameworks
-    /usr/local
-    /usr
-    /opt
-  )
-
-  find_library(AAX_LIBRARY 
-    NAMES AAX aax libAAX
-    HINTS
-    $ENV{AAXDIR}
-    $ENV{ProgramFiles}/AAX
-    $ENV{ProgramFiles}/AeonWave
-    $ENV{ProgramFiles}/Adalin/AeonWave
-    ${CMAKE_BUILD_DIR}/aax
-    PATH_SUFFIXES lib64 lib lib/${CMAKE_LIBRARY_ARCHITECTURE} libs64 libs libs/Win32 libs/Win64 bin
-    PATHS
-    ~/Library/Frameworks
-    /Library/Frameworks
-    /usr/local
-    /usr
-    /opt
-  )
-
-  set(AAX_DEFINITIONS "")
-  if (AAX_LIBRARY AND AAX_INCLUDE_DIR)
-    set(AAX_FOUND TRUE)
-  endif()
-
-  if (AAX_FOUND)
-    if (NOT Udns_FIND_QUIETLY)
-      message(STATUS "Found AeonWave: ${AAX_LIBRARY}")
-    endif ()
-  else ()
-    if (Udns_FIND_REQUIRED)
-      message(FATAL_ERROR "Could not find AeonWave")
-    endif ()
-  endif ()
-
-  # show the AAX_INCLUDE_DIR and AAX_LIBRARY variables only in the advanced view
-  mark_as_advanced(AAX_INCLUDE_DIR AAX_LIBRARY)
-
-endif()
-
--- a/CMakeModules/FindALUT.cmake
+++ b/CMakeModules/FindALUT.cmake
@@ -0,0 +1,67 @@
+# Locate ALUT
+# This module defines
+# ALUT_LIBRARY
+# ALUT_FOUND, if false, do not try to link to ALUT 
+# ALUT_INCLUDE_DIR, where to find the headers
+#
+# $ALUTDIR is an environment variable that would
+# correspond to the ./configure --prefix=$ALUTDIR
+# used in building ALUT.
+#
+# Created by James Turner. This was influenced by the FindOpenAL.cmake module.
+
+#=============================================================================
+# Copyright 2005-2009 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distributed this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+# Per my request, CMake should search for frameworks first in
+# the following order:
+# ~/Library/Frameworks/OpenAL.framework/Headers
+# /Library/Frameworks/OpenAL.framework/Headers
+# /System/Library/Frameworks/OpenAL.framework/Headers
+#
+# On OS X, this will prefer the Framework version (if found) over others.
+# People will have to manually change the cache values of 
+# OPENAL_LIBRARY to override this selection or set the CMake environment
+# CMAKE_INCLUDE_PATH to modify the search paths.
+
+FIND_LIBRARY(ALUT_LIBRARY 
+  NAMES ALUT alut
+  HINTS
+  $ENV{ALUTDIR}
+  PATH_SUFFIXES lib64 lib libs64 libs libs/Win32 libs/Win64
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt
+)
+
+FIND_PATH(ALUT_INCLUDE_DIR 
+  NAMES ALUT/alut.h alut.h
+  HINTS
+  $ENV{ALUTDIR}
+  PATH_SUFFIXES include/AL include
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt
+)
+
+include(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(ALUT  DEFAULT_MSG  ALUT_LIBRARY ALUT_INCLUDE_DIR)
+
+MARK_AS_ADVANCED(ALUT_LIBRARY ALUT_INCLUDE_DIR)
+
--- a/CMakeModules/FindCURL.cmake
+++ b/CMakeModules/FindCURL.cmake
@@ -1,203 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#[=======================================================================[.rst:
-FindCURL
--------
-
-Find the native CURL headers and libraries.
-
-This module accept optional COMPONENTS to check supported features and
-protocols::
-
-  PROTOCOLS: ICT FILE FTP FTPS GOPHER HTTP HTTPS IMAP IMAPS LDAP LDAPS POP3
-             POP3S RTMP RTSP SCP SFTP SMB SMBS SMTP SMTPS TELNET TFTP
-  FEATURES:  SSL IPv6 UnixSockets libz AsynchDNS IDN GSS-API PSL SPNEGO
-             Kerberos NTLM NTLM_WB TLS-SRP HTTP2 HTTPS-proxy
-
-IMPORTED Targets
-^^^^^^^^^^^^^^^^
-
-This module defines :prop_tgt:`IMPORTED` target ``CURL::libcurl``, if
-curl has been found.
-
-Result Variables
-^^^^^^^^^^^^^^^^
-
-This module defines the following variables:
-
-``CURL_FOUND``
-  "True" if ``curl`` found.
-
-``CURL_INCLUDE_DIRS``
-  where to find ``curl``/``curl.h``, etc.
-
-``CURL_LIBRARIES``
-  List of libraries when using ``curl``.
-
-``CURL_VERSION_STRING``
-  The version of ``curl`` found.
-
-CURL CMake
-^^^^^^^^^^
-
-If CURL was built using the CMake buildsystem then it provides its own
-``CURLConfig.cmake`` file for use with the :command:`find_package` command's
-config mode. This module looks for this file and, if found,
-returns its results with no further action.
-
-Set ``CURL_NO_CURL_CMAKE`` to ``ON`` to disable this search.
-
-#]=======================================================================]
-
-include(FindPackageHandleStandardArgs)
-
-if(NOT CURL_NO_CURL_CMAKE)
-  # do a find package call to specifically look for the CMake version
-  # of curl
-  find_package(CURL QUIET NO_MODULE)
-  mark_as_advanced(CURL_DIR)
-
-  # if we found the CURL cmake package then we are done, and
-  # can print what we found and return.
-  if(CURL_FOUND)
-    find_package_handle_standard_args(CURL HANDLE_COMPONENTS CONFIG_MODE)
-    return()
-  endif()
-endif()
-
-find_package(PkgConfig QUIET)
-if(PKG_CONFIG_FOUND)
-  pkg_check_modules(PC_CURL QUIET libcurl)
-  if(PC_CURL_FOUND)
-    set(CURL_VERSION_STRING ${PC_CURL_VERSION})
-    pkg_get_variable(CURL_SUPPORTED_PROTOCOLS libcurl supported_protocols)
-    pkg_get_variable(CURL_SUPPORTED_FEATURES libcurl supported_features)
-  endif()
-endif()
-
-# Look for the header file.
-find_path(CURL_INCLUDE_DIR
-          NAMES curl/curl.h
-          HINTS ${PC_CURL_INCLUDE_DIRS})
-mark_as_advanced(CURL_INCLUDE_DIR)
-
-if(NOT CURL_LIBRARY)
-  # Look for the library (sorted from most current/relevant entry to least).
-  find_library(CURL_LIBRARY_RELEASE NAMES
-      curl
-    # Windows MSVC prebuilts:
-      curllib
-      libcurl_imp
-      curllib_static
-    # Windows older "Win32 - MSVC" prebuilts (libcurl.lib, e.g. libcurl-7.15.5-win32-msvc.zip):
-      libcurl
-      HINTS ${PC_CURL_LIBRARY_DIRS}
-  )
-  mark_as_advanced(CURL_LIBRARY_RELEASE)
-
-  find_library(CURL_LIBRARY_DEBUG NAMES
-    # Windows MSVC CMake builds in debug configuration on vcpkg:
-      libcurl-d_imp
-      libcurl-d
-      HINTS ${PC_CURL_LIBRARY_DIRS}
-  )
-  mark_as_advanced(CURL_LIBRARY_DEBUG)
-
-  include(SelectLibraryConfigurations)
-  select_library_configurations(CURL)
-endif()
-
-if(CURL_INCLUDE_DIR AND NOT CURL_VERSION_STRING)
-  foreach(_curl_version_header curlver.h curl.h)
-    if(EXISTS "${CURL_INCLUDE_DIR}/curl/${_curl_version_header}")
-      file(STRINGS "${CURL_INCLUDE_DIR}/curl/${_curl_version_header}" curl_version_str REGEX "^#define[\t ]+LIBCURL_VERSION[\t ]+\".*\"")
-
-      string(REGEX REPLACE "^#define[\t ]+LIBCURL_VERSION[\t ]+\"([^\"]*)\".*" "\\1" CURL_VERSION_STRING "${curl_version_str}")
-      unset(curl_version_str)
-      break()
-    endif()
-  endforeach()
-endif()
-
-if(CURL_FIND_COMPONENTS)
-  set(CURL_KNOWN_PROTOCOLS ICT FILE FTP FTPS GOPHER HTTP HTTPS IMAP IMAPS LDAP LDAPS POP3 POP3S RTMP RTSP SCP SFTP SMB SMBS SMTP SMTPS TELNET TFTP)
-  set(CURL_KNOWN_FEATURES  SSL IPv6 UnixSockets libz AsynchDNS IDN GSS-API PSL SPNEGO Kerberos NTLM NTLM_WB TLS-SRP HTTP2 HTTPS-proxy)
-  foreach(component IN LISTS CURL_KNOWN_PROTOCOLS CURL_KNOWN_FEATURES)
-    set(CURL_${component}_FOUND FALSE)
-  endforeach()
-  if(NOT PC_CURL_FOUND)
-    find_program(CURL_CONFIG_EXECUTABLE NAMES curl-config)
-    if(CURL_CONFIG_EXECUTABLE)
-      execute_process(COMMAND ${CURL_CONFIG_EXECUTABLE} --version
-                      OUTPUT_VARIABLE CURL_CONFIG_VERSION_STRING
-                      ERROR_QUIET
-                      OUTPUT_STRIP_TRAILING_WHITESPACE)
-      execute_process(COMMAND ${CURL_CONFIG_EXECUTABLE} --feature
-                      OUTPUT_VARIABLE CURL_CONFIG_FEATURES_STRING
-                      ERROR_QUIET
-                      OUTPUT_STRIP_TRAILING_WHITESPACE)
-      string(REPLACE "\n" ";" CURL_SUPPORTED_FEATURES "${CURL_CONFIG_FEATURES_STRING}")
-      execute_process(COMMAND ${CURL_CONFIG_EXECUTABLE} --protocols
-                      OUTPUT_VARIABLE CURL_CONFIG_PROTOCOLS_STRING
-                      ERROR_QUIET
-                      OUTPUT_STRIP_TRAILING_WHITESPACE)
-      string(REPLACE "\n" ";" CURL_SUPPORTED_PROTOCOLS "${CURL_CONFIG_PROTOCOLS_STRING}")
-    endif()
-
-  endif()
-  foreach(component IN LISTS CURL_FIND_COMPONENTS)
-    list(FIND CURL_KNOWN_PROTOCOLS ${component} _found)
-    if(_found)
-      list(FIND CURL_SUPPORTED_PROTOCOLS ${component} _found)
-      if(_found)
-        set(CURL_${component}_FOUND TRUE)
-      elseif(CURL_FIND_REQUIRED)
-        message(FATAL_ERROR "CURL: Required protocol ${component} is not found")
-      endif()
-    else()
-      list(FIND CURL_SUPPORTED_FEATURES ${component} _found)
-      if(_found)
-        set(CURL_${component}_FOUND TRUE)
-      elseif(CURL_FIND_REQUIRED)
-        message(FATAL_ERROR "CURL: Required feature ${component} is not found")
-      endif()
-    endif()
-  endforeach()
-endif()
-
-find_package_handle_standard_args(CURL
-                                  REQUIRED_VARS CURL_LIBRARY CURL_INCLUDE_DIR
-                                  VERSION_VAR CURL_VERSION_STRING
-                                  HANDLE_COMPONENTS)
-
-if(CURL_FOUND)
-  set(CURL_LIBRARIES ${CURL_LIBRARY})
-  set(CURL_INCLUDE_DIRS ${CURL_INCLUDE_DIR})
-
-  if(NOT TARGET CURL::libcurl)
-    add_library(CURL::libcurl UNKNOWN IMPORTED)
-    set_target_properties(CURL::libcurl PROPERTIES
-      INTERFACE_INCLUDE_DIRECTORIES "${CURL_INCLUDE_DIRS}")
-
-    if(EXISTS "${CURL_LIBRARY}")
-      set_target_properties(CURL::libcurl PROPERTIES
-        IMPORTED_LINK_INTERFACE_LANGUAGES "C"
-        IMPORTED_LOCATION "${CURL_LIBRARY}")
-    endif()
-    if(CURL_LIBRARY_RELEASE)
-      set_property(TARGET CURL::libcurl APPEND PROPERTY
-        IMPORTED_CONFIGURATIONS RELEASE)
-      set_target_properties(CURL::libcurl PROPERTIES
-        IMPORTED_LINK_INTERFACE_LANGUAGES "C"
-        IMPORTED_LOCATION_RELEASE "${CURL_LIBRARY_RELEASE}")
-    endif()
-    if(CURL_LIBRARY_DEBUG)
-      set_property(TARGET CURL::libcurl APPEND PROPERTY
-        IMPORTED_CONFIGURATIONS DEBUG)
-      set_target_properties(CURL::libcurl PROPERTIES
-        IMPORTED_LINK_INTERFACE_LANGUAGES "C"
-        IMPORTED_LOCATION_DEBUG "${CURL_LIBRARY_DEBUG}")
-    endif()
-  endif()
-endif()
--- a/CMakeModules/FindFFmpeg.cmake
+++ b/CMakeModules/FindFFmpeg.cmake
@@ -1,171 +0,0 @@
-# vim: ts=2 sw=2
-# - Try to find the required ffmpeg components(default: AVFORMAT, AVUTIL, AVCODEC)
-#
-# Once done this will define
-#  FFMPEG_FOUND         - System has the all required components.
-#  FFMPEG_INCLUDE_DIRS  - Include directory necessary for using the required components headers.
-#  FFMPEG_LIBRARIES     - Link these to use the required ffmpeg components.
-#  FFMPEG_DEFINITIONS   - Compiler switches required for using the required ffmpeg components.
-#
-# For each of the components
-#   - AVCODEC
-#   - AVDEVICE
-#   - AVFORMAT
-#   - AVUTIL
-#   - POSTPROCESS
-#   - SWSCALE
-# the following variables will be defined:
-#  <component>_FOUND        - System has <component>
-#  <component>_INCLUDE_DIRS - Include directory necessary for using the <component> headers
-#  <component>_LIBRARIES    - Link these to use <component>
-#  <component>_DEFINITIONS  - Compiler switches required for using <component>
-#  <component>_VERSION      - The components version
-#
-# As the versions of the various FFmpeg components differ for a given release,
-# and CMake supports only one common version for all components, use the
-# following to specify required versions for multiple components:
-#
-# find_package(FFmpeg 57.48 COMPONENTS AVCODEC)
-# find_package(FFmpeg 57.40 COMPONENTS AVFORMAT)
-# find_package(FFmpeg 55.27 COMPONENTS AVUTIL)
-#
-# SPDX-FileCopyrightText: 2006 Matthias Kretz <kretz@kde.org>
-# SPDX-FileCopyrightText: 2008 Alexander Neundorf <neundorf@kde.org>
-# SPDX-FileCopyrightText: 2011 Michael Jansen <kde@michael-jansen.biz>
-# SPDX-FileCopyrightText: 2021 Stefan Brüns <stefan.bruens@rwth-aachen.de>
-# SPDX-License-Identifier: BSD-3-Clause
-
-include(FindPackageHandleStandardArgs)
-
-if (NOT FFmpeg_FIND_COMPONENTS)
-  # The default components were taken from a survey over other FindFFMPEG.cmake files
-  set(FFmpeg_FIND_COMPONENTS AVCODEC AVFORMAT AVUTIL)
-endif ()
-
-list(LENGTH FFmpeg_FIND_COMPONENTS _numComponents)
-if ((${_numComponents} GREATER 1) AND DEFINED ${FFmpeg_FIND_VERSION})
-  message(WARNING "Using a required version in combination with multiple COMPONENTS is not supported")
-  set(_FFmpeg_REQUIRED_VERSION 0)
-elseif (DEFINED FFmpeg_FIND_VERSION)
-  set(_FFmpeg_REQUIRED_VERSION ${FFmpeg_FIND_VERSION})
-else ()
-  set(_FFmpeg_REQUIRED_VERSION 0)
-endif ()
-set(_FFmpeg_ALL_COMPONENTS AVCODEC AVDEVICE AVFORMAT AVUTIL POSTPROCESS SWSCALE)
-
-#
-### Macro: set_component_found
-#
-# Marks the given component as found if both *_LIBRARIES AND *_INCLUDE_DIRS is present.
-#
-macro(set_component_found _component )
-  if (${_component}_LIBRARIES AND ${_component}_INCLUDE_DIRS)
-    set(${_component}_FOUND TRUE)
-    set(FFmpeg_${_component}_FOUND TRUE)
-  endif ()
-endmacro()
-
-#
-### Macro: find_component
-#
-# Checks for the given component by invoking pkgconfig and then looking up the libraries and
-# include directories.
-#
-macro(find_component _component _pkgconfig _library _header)
-
-  if (NOT WIN32)
-     # use pkg-config to get the directories and then use these values
-     # in the FIND_PATH() and FIND_LIBRARY() calls
-     find_package(PkgConfig)
-     if (PKG_CONFIG_FOUND)
-       pkg_check_modules(PC_${_component} QUIET ${_pkgconfig})
-     endif ()
-  endif (NOT WIN32)
-
-  find_path(${_component}_INCLUDE_DIRS ${_header}
-    HINTS
-      ${PC_LIB${_component}_INCLUDEDIR}
-      ${PC_LIB${_component}_INCLUDE_DIRS}
-    PATH_SUFFIXES
-      ffmpeg
-  )
-
-  find_library(${_component}_LIBRARIES NAMES ${_library}
-      HINTS
-      ${PC_LIB${_component}_LIBDIR}
-      ${PC_LIB${_component}_LIBRARY_DIRS}
-  )
-
-  set(${_component}_DEFINITIONS  ${PC_${_component}_CFLAGS_OTHER} CACHE STRING "The ${_component} CFLAGS.")
-  set(${_component}_VERSION      ${PC_${_component}_VERSION}      CACHE STRING "The ${_component} version number.")
-
-  set_component_found(${_component})
-
-  mark_as_advanced(
-    ${_component}_INCLUDE_DIRS
-    ${_component}_LIBRARIES
-    ${_component}_DEFINITIONS
-    ${_component}_VERSION)
-
-endmacro()
-
-# Check for cached results. If there are skip the costly part.
-if (NOT FFMPEG_LIBRARIES)
-
-  # Check for all possible component.
-  find_component(AVCODEC     libavcodec  avcodec  libavcodec/avcodec.h)
-  find_component(AVFORMAT    libavformat avformat libavformat/avformat.h)
-  find_component(AVDEVICE    libavdevice avdevice libavdevice/avdevice.h)
-  find_component(AVUTIL      libavutil   avutil   libavutil/avutil.h)
-  find_component(SWSCALE     libswscale  swscale  libswscale/swscale.h)
-  find_component(POSTPROCESS libpostproc postproc libpostproc/postprocess.h)
-
-  # Check if the required components were found and add their stuff to the FFMPEG_* vars.
-  foreach (_component ${_FFmpeg_ALL_COMPONENTS})
-    if (${_component}_FOUND)
-      set(FFMPEG_LIBRARIES   ${FFMPEG_LIBRARIES}   ${${_component}_LIBRARIES})
-      set(FFMPEG_DEFINITIONS ${FFMPEG_DEFINITIONS} ${${_component}_DEFINITIONS})
-      list(APPEND FFMPEG_INCLUDE_DIRS ${${_component}_INCLUDE_DIRS})
-    endif ()
-  endforeach ()
-
-  # Build the include path with duplicates removed.
-  if (FFMPEG_INCLUDE_DIRS)
-    list(REMOVE_DUPLICATES FFMPEG_INCLUDE_DIRS)
-  endif ()
-
-  # cache the vars.
-  set(FFMPEG_INCLUDE_DIRS ${FFMPEG_INCLUDE_DIRS} CACHE STRING "The FFmpeg include directories." FORCE)
-  set(FFMPEG_LIBRARIES    ${FFMPEG_LIBRARIES}    CACHE STRING "The FFmpeg libraries." FORCE)
-  set(FFMPEG_DEFINITIONS  ${FFMPEG_DEFINITIONS}  CACHE STRING "The FFmpeg cflags." FORCE)
-
-  mark_as_advanced(FFMPEG_INCLUDE_DIRS
-                   FFMPEG_LIBRARIES
-                   FFMPEG_DEFINITIONS)
-
-else ()
-  # Set the noncached _FOUND vars for the components.
-  foreach (_component ${_FFmpeg_ALL_COMPONENTS})
-    set_component_found(${_component})
-  endforeach ()
-endif ()
-
-# Compile the list of required vars
-unset(_FFmpeg_REQUIRED_VARS)
-set(_FFmpeg_FOUND_LIBRARIES "")
-foreach (_component ${FFmpeg_FIND_COMPONENTS})
-  if (${_component}_FOUND)
-    if (${_component}_VERSION VERSION_LESS _FFmpeg_REQUIRED_VERSION)
-      message(STATUS "${_component}: ${${_component}_VERSION} < ${_FFmpeg_REQUIRED_VERSION}")
-      unset(${_component}_FOUND)
-    endif ()
-    list(APPEND _FFmpeg_FOUND_LIBRARIES ${${_component}_LIBRARIES})
-  endif ()
-  list(APPEND _FFmpeg_REQUIRED_VARS ${_component}_LIBRARIES ${_component}_INCLUDE_DIRS ${_component}_FOUND)
-endforeach ()
-list(INSERT _FFmpeg_REQUIRED_VARS 0 _FFmpeg_FOUND_LIBRARIES)
-
-# Give a nice error message if some of the required vars are missing.
-find_package_handle_standard_args(FFmpeg
-    REQUIRED_VARS ${_FFmpeg_REQUIRED_VARS}
-    HANDLE_COMPONENTS)
--- a/CMakeModules/FindGDAL.cmake
+++ b/CMakeModules/FindGDAL.cmake
@@ -1,166 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#[=======================================================================[.rst:
-FindGDAL
--------
-
-Find Geospatial Data Abstraction Library (GDAL).
-
-IMPORTED Targets
-^^^^^^^^^^^^^^^^
-
-This module defines :prop_tgt:`IMPORTED` target ``GDAL::GDAL``
-if GDAL has been found.
-
-Result Variables
-^^^^^^^^^^^^^^^^
-
-This module will set the following variables in your project:
-
-``GDAL_FOUND``
-  True if GDAL is found.
-``GDAL_INCLUDE_DIRS``
-  Include directories for GDAL headers.
-``GDAL_LIBRARIES``
-  Libraries to link to GDAL.
-``GDAL_VERSION``
-  The version of GDAL found.
-
-Cache variables
-^^^^^^^^^^^^^^^
-
-The following cache variables may also be set:
-
-``GDAL_LIBRARY``
-  The libgdal library file.
-``GDAL_INCLUDE_DIR``
-  The directory containing ``gdal.h``.
-
-Hints
-^^^^^
-
-Set ``GDAL_DIR`` or ``GDAL_ROOT`` in the environment to specify the
-GDAL installation prefix.
-#]=======================================================================]
-
-# $GDALDIR is an environment variable that would
-# correspond to the ./configure --prefix=$GDAL_DIR
-# used in building gdal.
-#
-# Created by Eric Wing. I'm not a gdal user, but OpenSceneGraph uses it
-# for osgTerrain so I whipped this module together for completeness.
-# I actually don't know the conventions or where files are typically
-# placed in distros.
-# Any real gdal users are encouraged to correct this (but please don't
-# break the OS X framework stuff when doing so which is what usually seems
-# to happen).
-
-# This makes the presumption that you are include gdal.h like
-#
-#include "gdal.h"
-
-include(FindPackageHandleStandardArgs)
-
-find_path(GDAL_INCLUDE_DIR gdal.h
-  HINTS
-    ENV GDAL_DIR
-    ENV GDAL_ROOT
-  PATH_SUFFIXES
-     include/gdal
-     include/GDAL
-     include
-)
-
-if(UNIX)
-    # Use gdal-config to obtain the library version (this should hopefully
-    # allow us to -lgdal1.x.y where x.y are correct version)
-    # For some reason, libgdal development packages do not contain
-    # libgdal.so...
-    find_program(GDAL_CONFIG gdal-config
-        HINTS
-          ENV GDAL_DIR
-          ENV GDAL_ROOT
-        PATH_SUFFIXES bin
-    )
-
-    if(GDAL_CONFIG)
-        exec_program(${GDAL_CONFIG} ARGS --libs OUTPUT_VARIABLE GDAL_CONFIG_LIBS)
-
-        if(GDAL_CONFIG_LIBS)
-            # treat the output as a command line and split it up
-            separate_arguments(args NATIVE_COMMAND "${GDAL_CONFIG_LIBS}")
-
-            # only consider libraries whose name matches this pattern
-            set(name_pattern "[gG][dD][aA][lL]")
-
-            # consider each entry as a possible library path, name, or parent directory
-            foreach(arg IN LISTS args)
-                # library name
-                if("${arg}" MATCHES "^-l(.*)$")
-                    set(lib "${CMAKE_MATCH_1}")
-
-                    # only consider libraries whose name matches the expected pattern
-                    if("${lib}" MATCHES "${name_pattern}")
-                        list(APPEND _gdal_lib "${lib}")
-                    endif()
-                # library search path
-                elseif("${arg}" MATCHES "^-L(.*)$")
-                    list(APPEND _gdal_libpath "${CMAKE_MATCH_1}")
-                # assume this is a full path to a library
-                elseif(IS_ABSOLUTE "${arg}" AND EXISTS "${arg}")
-                    # extract the file name
-                    get_filename_component(lib "${arg}" NAME)
-
-                    # only consider libraries whose name matches the expected pattern
-                    if(NOT "${lib}" MATCHES "${name_pattern}")
-                        continue()
-                    endif()
-
-                    # extract the file directory
-                    get_filename_component(dir "${arg}" DIRECTORY)
-
-                    # remove library prefixes/suffixes
-                    string(REGEX REPLACE "^(${CMAKE_SHARED_LIBRARY_PREFIX}|${CMAKE_STATIC_LIBRARY_PREFIX})" "" lib "${lib}")
-                    string(REGEX REPLACE "(${CMAKE_SHARED_LIBRARY_SUFFIX}|${CMAKE_STATIC_LIBRARY_SUFFIX})$" "" lib "${lib}")
-
-                    # use the file name and directory as hints
-                    list(APPEND _gdal_libpath "${dir}")
-                    list(APPEND _gdal_lib "${lib}")
-                endif()
-            endforeach()
-        endif()
-    endif()
-endif()
-
-find_library(GDAL_LIBRARY
-  NAMES ${_gdal_lib} gdal gdal_i gdal1.5.0 gdal1.4.0 gdal1.3.2 GDAL
-  HINTS
-     ENV GDAL_DIR
-     ENV GDAL_ROOT
-     ${_gdal_libpath}
-  PATH_SUFFIXES lib
-)
-
-if (EXISTS "${GDAL_INCLUDE_DIR}/gdal_version.h")
-    file(STRINGS "${GDAL_INCLUDE_DIR}/gdal_version.h" _gdal_version
-        REGEX "GDAL_RELEASE_NAME")
-    string(REGEX REPLACE ".*\"\(.*\)\"" "\\1" GDAL_VERSION "${_gdal_version}")
-    unset(_gdal_version)
-else ()
-    set(GDAL_VERSION GDAL_VERSION-NOTFOUND)
-endif ()
-
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(GDAL
-    VERSION_VAR GDAL_VERSION
-    REQUIRED_VARS GDAL_LIBRARY GDAL_INCLUDE_DIR)
-
-if (GDAL_FOUND AND NOT TARGET GDAL::GDAL)
-    add_library(GDAL::GDAL UNKNOWN IMPORTED)
-    set_target_properties(GDAL::GDAL PROPERTIES
-        IMPORTED_LOCATION "${GDAL_LIBRARY}"
-        INTERFACE_INCLUDE_DIRECTORIES "${GDAL_INCLUDE_DIR}")
-endif ()
-
-set(GDAL_LIBRARIES ${GDAL_LIBRARY})
-set(GDAL_INCLUDE_DIRS ${GDAL_INCLUDE_DIR})
--- a/CMakeModules/FindLibLZMA.cmake
+++ b/CMakeModules/FindLibLZMA.cmake
@@ -1,124 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#[=======================================================================[.rst:
-FindLibLZMA
-----------
-
-Find LZMA compression algorithm headers and library.
-
-
-Imported Targets
-^^^^^^^^^^^^^^^^
-
-This module defines :prop_tgt:`IMPORTED` target ``LibLZMA::LibLZMA``, if
-liblzma has been found.
-
-Result variables
-^^^^^^^^^^^^^^^^
-
-This module will set the following variables in your project:
-
-``LIBLZMA_FOUND``
-  True if liblzma headers and library were found.
-``LIBLZMA_INCLUDE_DIRS``
-  Directory where liblzma headers are located.
-``LIBLZMA_LIBRARIES``
-  Lzma libraries to link against.
-``LIBLZMA_HAS_AUTO_DECODER``
-  True if lzma_auto_decoder() is found (required).
-``LIBLZMA_HAS_EASY_ENCODER``
-  True if lzma_easy_encoder() is found (required).
-``LIBLZMA_HAS_LZMA_PRESET``
-  True if lzma_lzma_preset() is found (required).
-``LIBLZMA_VERSION_MAJOR``
-  The major version of lzma
-``LIBLZMA_VERSION_MINOR``
-  The minor version of lzma
-``LIBLZMA_VERSION_PATCH``
-  The patch version of lzma
-``LIBLZMA_VERSION_STRING``
-  version number as a string (ex: "5.0.3")
-#]=======================================================================]
-
-find_path(LIBLZMA_INCLUDE_DIR lzma.h )
-if(NOT LIBLZMA_LIBRARY)
-  find_library(LIBLZMA_LIBRARY_RELEASE NAMES lzma liblzma NAMES_PER_DIR PATH_SUFFIXES lib)
-  find_library(LIBLZMA_LIBRARY_DEBUG NAMES lzmad liblzmad NAMES_PER_DIR PATH_SUFFIXES lib)
-  include(SelectLibraryConfigurations)
-  select_library_configurations(LIBLZMA)
-else()
-  file(TO_CMAKE_PATH "${LIBLZMA_LIBRARY}" LIBLZMA_LIBRARY)
-endif()
-
-if(LIBLZMA_INCLUDE_DIR AND EXISTS "${LIBLZMA_INCLUDE_DIR}/lzma/version.h")
-    file(STRINGS "${LIBLZMA_INCLUDE_DIR}/lzma/version.h" LIBLZMA_HEADER_CONTENTS REGEX "#define LZMA_VERSION_[A-Z]+ [0-9]+")
-
-    string(REGEX REPLACE ".*#define LZMA_VERSION_MAJOR ([0-9]+).*" "\\1" LIBLZMA_VERSION_MAJOR "${LIBLZMA_HEADER_CONTENTS}")
-    string(REGEX REPLACE ".*#define LZMA_VERSION_MINOR ([0-9]+).*" "\\1" LIBLZMA_VERSION_MINOR "${LIBLZMA_HEADER_CONTENTS}")
-    string(REGEX REPLACE ".*#define LZMA_VERSION_PATCH ([0-9]+).*" "\\1" LIBLZMA_VERSION_PATCH "${LIBLZMA_HEADER_CONTENTS}")
-
-    set(LIBLZMA_VERSION_STRING "${LIBLZMA_VERSION_MAJOR}.${LIBLZMA_VERSION_MINOR}.${LIBLZMA_VERSION_PATCH}")
-    unset(LIBLZMA_HEADER_CONTENTS)
-endif()
-
-# We're using new code known now as XZ, even library still been called LZMA
-# it can be found in http://tukaani.org/xz/
-# Avoid using old codebase
-if (LIBLZMA_LIBRARY)
-  include(CheckLibraryExists)
-  set(CMAKE_REQUIRED_QUIET_SAVE ${CMAKE_REQUIRED_QUIET})
-  set(CMAKE_REQUIRED_QUIET ${LibLZMA_FIND_QUIETLY})
-  if(NOT LIBLZMA_LIBRARY_RELEASE AND NOT LIBLZMA_LIBRARY_DEBUG)
-    set(LIBLZMA_LIBRARY_check ${LIBLZMA_LIBRARY})
-  elseif(LIBLZMA_LIBRARY_RELEASE)
-    set(LIBLZMA_LIBRARY_check ${LIBLZMA_LIBRARY_RELEASE})
-  elseif(LIBLZMA_LIBRARY_DEBUG)
-    set(LIBLZMA_LIBRARY_check ${LIBLZMA_LIBRARY_DEBUG})
-  endif()
-  CHECK_LIBRARY_EXISTS(${LIBLZMA_LIBRARY_check} lzma_auto_decoder "" LIBLZMA_HAS_AUTO_DECODER)
-  CHECK_LIBRARY_EXISTS(${LIBLZMA_LIBRARY_check} lzma_easy_encoder "" LIBLZMA_HAS_EASY_ENCODER)
-  CHECK_LIBRARY_EXISTS(${LIBLZMA_LIBRARY_check} lzma_lzma_preset "" LIBLZMA_HAS_LZMA_PRESET)
-  unset(LIBLZMA_LIBRARY_check)
-  set(CMAKE_REQUIRED_QUIET ${CMAKE_REQUIRED_QUIET_SAVE})
-endif ()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(LibLZMA  REQUIRED_VARS  LIBLZMA_LIBRARY
-                                                          LIBLZMA_INCLUDE_DIR
-                                                          LIBLZMA_HAS_AUTO_DECODER
-                                                          LIBLZMA_HAS_EASY_ENCODER
-                                                          LIBLZMA_HAS_LZMA_PRESET
-                                           VERSION_VAR    LIBLZMA_VERSION_STRING
-                                 )
-mark_as_advanced( LIBLZMA_INCLUDE_DIR LIBLZMA_LIBRARY )
-
-if (LIBLZMA_FOUND)
-    set(LIBLZMA_LIBRARIES ${LIBLZMA_LIBRARY})
-    set(LIBLZMA_INCLUDE_DIRS ${LIBLZMA_INCLUDE_DIR})
-    if(NOT TARGET LibLZMA::LibLZMA)
-        add_library(LibLZMA::LibLZMA UNKNOWN IMPORTED)
-        set_target_properties(LibLZMA::LibLZMA PROPERTIES
-                              INTERFACE_INCLUDE_DIRECTORIES ${LIBLZMA_INCLUDE_DIR}
-                              IMPORTED_LINK_INTERFACE_LANGUAGES C)
-
-        if(LIBLZMA_LIBRARY_RELEASE)
-            set_property(TARGET LibLZMA::LibLZMA APPEND PROPERTY
-                IMPORTED_CONFIGURATIONS RELEASE)
-            set_target_properties(LibLZMA::LibLZMA PROPERTIES
-                IMPORTED_LOCATION_RELEASE "${LIBLZMA_LIBRARY_RELEASE}")
-        endif()
-
-        if(LIBLZMA_LIBRARY_DEBUG)
-            set_property(TARGET LibLZMA::LibLZMA APPEND PROPERTY
-                IMPORTED_CONFIGURATIONS DEBUG)
-            set_target_properties(LibLZMA::LibLZMA PROPERTIES
-                IMPORTED_LOCATION_DEBUG "${LIBLZMA_LIBRARY_DEBUG}")
-        endif()
-
-        if(NOT LIBLZMA_LIBRARY_RELEASE AND NOT LIBLZMA_LIBRARY_DEBUG)
-            set_target_properties(LibLZMA::LibLZMA PROPERTIES
-                IMPORTED_LOCATION "${LIBLZMA_LIBRARY}")
-        endif()
-    endif()
-endif ()
--- a/CMakeModules/FindSvnClient.cmake
+++ b/CMakeModules/FindSvnClient.cmake
@@ -0,0 +1,81 @@
+# Find Subversion client libraries, and dependencies
+# including APR (Apache Portable Runtime)
+
+include (CheckFunctionExists)
+include (CheckIncludeFile)
+include (CheckLibraryExists)
+
+macro(find_static_component comp libs)
+    # account for alternative Windows svn distribution naming
+    if(MSVC)
+      set(compLib "lib${comp}")
+    else(MSVC)
+      set(compLib "${comp}")
+    endif(MSVC)
+    
+    string(TOUPPER "${comp}" compLibBase)
+    set( compLibName ${compLibBase}_LIBRARY )
+
+    # NO_DEFAULT_PATH is important on Mac - we need to ensure subversion
+    # libraires in dist/ or Macports are picked over the Apple version 
+    # in /usr, since that's what we will ship.
+    FIND_LIBRARY(${compLibName}
+      NO_DEFAULT_PATH
+      NAMES ${compLib}
+      HINTS $ENV{LIBSVN_DIR} ${CMAKE_INSTALL_PREFIX} 
+      PATH_SUFFIXES lib64 lib libs64 libs libs/Win32 libs/Win64
+      PATHS
+      /opt/local
+      /usr/local
+      /usr
+    )
+
+	list(APPEND ${libs} ${${compLibName}})
+endmacro()
+
+find_program(HAVE_APR_CONFIG apr-1-config)
+if(HAVE_APR_CONFIG) 
+        
+    execute_process(COMMAND apr-1-config --cppflags --includes
+        OUTPUT_VARIABLE APR_CFLAGS
+        OUTPUT_STRIP_TRAILING_WHITESPACE)
+        
+    execute_process(COMMAND apr-1-config --link-ld
+        OUTPUT_VARIABLE RAW_APR_LIBS
+        OUTPUT_STRIP_TRAILING_WHITESPACE)
+    
+# clean up some vars, or other CMake pieces complain
+	string(STRIP "${RAW_APR_LIBS}" APR_LIBS)
+
+else(HAVE_APR_CONFIG)
+    message(STATUS "apr-1-config not found, implement manual search for APR")
+endif(HAVE_APR_CONFIG)
+
+if(HAVE_APR_CONFIG OR MSVC)
+	find_path(LIBSVN_INCLUDE_DIR svn_client.h
+      NO_DEFAULT_PATH
+	  HINTS
+	  $ENV{LIBSVN_DIR} ${CMAKE_INSTALL_PREFIX}
+	  PATH_SUFFIXES include/subversion-1
+	  PATHS
+      /opt/local
+	  /usr/local
+	  /usr
+	)
+	
+	set(LIBSVN_LIBRARIES "")
+	if (MSVC)
+		find_static_component("apr-1" LIBSVN_LIBRARIES)
+	else (MSVC)
+		list(APPEND LIBSVN_LIBRARIES ${APR_LIBS})
+	endif (MSVC)
+	find_static_component("svn_client-1" LIBSVN_LIBRARIES)
+	find_static_component("svn_subr-1" LIBSVN_LIBRARIES)
+	find_static_component("svn_ra-1" LIBSVN_LIBRARIES)
+
+	include(FindPackageHandleStandardArgs)
+	FIND_PACKAGE_HANDLE_STANDARD_ARGS(LIBSVN DEFAULT_MSG LIBSVN_LIBRARIES LIBSVN_INCLUDE_DIR)
+        if(NOT LIBSVN_FOUND)
+		set(LIBSVN_LIBRARIES "")
+        endif(NOT LIBSVN_FOUND)
+endif(HAVE_APR_CONFIG OR MSVC)
--- a/CMakeModules/FindUdns.cmake
+++ b/CMakeModules/FindUdns.cmake
@@ -1,55 +0,0 @@
-# - Try to find UDNS library
-# Once done this will define
-#
-#  UDNS_FOUND - system has UDNS
-#  UDNS_INCLUDE_DIRS - the UDNS include directory
-#  UDNS_LIBRARIES - Link these to use UDNS
-#  UDNS_DEFINITIONS - Compiler switches required for using UDNS
-#
-#  Copyright (c) 2016 Maciej Mrozowski <reavertm@gmail.com>
-#
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-
-if (UDNS_LIBRARIES AND UDNS_INCLUDE_DIRS)
-  # in cache already
-  set(UDNS_FOUND TRUE)
-else ()
-  set(UDNS_DEFINITIONS "")
-
-  find_path(UDNS_INCLUDE_DIRS NAMES udns.h)
-  find_library(UDNS_LIBRARIES NAMES udns)
-
-  if (UDNS_INCLUDE_DIRS AND UDNS_LIBRARIES)
-    set(UDNS_FOUND TRUE)
-  endif ()
-
-  if (UDNS_FOUND)
-    if (NOT Udns_FIND_QUIETLY)
-      message(STATUS "Found UDNS: ${UDNS_LIBRARIES}")
-    endif ()
-  else ()
-    if (Udns_FIND_REQUIRED)
-      message(FATAL_ERROR "Could not find UDNS")
-    endif ()
-  endif ()
-
-  # show the UDNS_INCLUDE_DIRS and UDNS_LIBRARIES variables only in the advanced view
-  mark_as_advanced(UDNS_INCLUDE_DIRS UDNS_LIBRARIES)
-endif ()
-
-if(UDNS_FOUND)
-
-  if(NOT TARGET Udns::Udns)
-    add_library(Udns::Udns UNKNOWN IMPORTED)
-    set_target_properties(Udns::Udns PROPERTIES
-      INTERFACE_INCLUDE_DIRECTORIES "${UDNS_INCLUDE_DIRS}")
-
-      set_target_properties(Udns::Udns PROPERTIES
-        IMPORTED_LINK_INTERFACE_LANGUAGES "C"
-        IMPORTED_LOCATION "${UDNS_LIBRARIES}")
-    
-  endif()
-endif()
--- a/CMakeModules/GetForceIncludeDefinitions.cmake
+++ b/CMakeModules/GetForceIncludeDefinitions.cmake
@@ -1,44 +0,0 @@
-# - Get the platform-appropriate flags to add to force inclusion of a file
-#
-# The most common use of this is to use a generated config.h-type file
-# placed out of the source tree in all files.
-#
-#  get_force_include_definitions(var forcedincludefiles...) -
-#   where var is the name of  your desired output variable, and everything
-#   else is a source file to forcibly include.
-#   a list item to be filtered.
-#
-# Original Author:
-# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
-# http://academic.cleardefinition.com
-# Iowa State University HCI Graduate Program/VRAC
-#
-# Copyright Iowa State University 2009-2010.
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-if(__get_force_include_definitions)
-	return()
-endif()
-set(__get_force_include_definitions YES)
-
-function(get_force_include_definitions var)
-	set(_flagprefix)
-	if(CMAKE_COMPILER_IS_GNUCXX)
-		set(_flag "-include")
-	elseif(MSVC)
-		set(_flag "/FI")
-	else()
-		message(SEND_ERROR "You don't seem to be using MSVC or GCC, but")
-		message(SEND_ERROR "the project called get_force_include_definitions.")
-		message(SEND_ERROR "Contact this project with the name of your")
-		message(FATAL_ERROR "compiler and preferably the flag to force includes")
-	endif()
-
-	set(_out)
-	foreach(_item ${ARGN})
-		list(APPEND _out "${_flag} \"${_item}\"")
-	endforeach()
-	set(${var} "${_out}" PARENT_SCOPE)
-endfunction()
--- a/CMakeModules/OldGNUInstallDirs.cmake
+++ b/CMakeModules/OldGNUInstallDirs.cmake
@@ -0,0 +1,182 @@
+# - Define GNU standard installation directories
+# Provides install directory variables as defined for GNU software:
+#  http://www.gnu.org/prep/standards/html_node/Directory-Variables.html
+# Inclusion of this module defines the following variables:
+#  CMAKE_INSTALL_<dir>      - destination for files of a given type
+#  CMAKE_INSTALL_FULL_<dir> - corresponding absolute path
+# where <dir> is one of:
+#  BINDIR           - user executables (bin)
+#  SBINDIR          - system admin executables (sbin)
+#  LIBEXECDIR       - program executables (libexec)
+#  SYSCONFDIR       - read-only single-machine data (etc)
+#  SHAREDSTATEDIR   - modifiable architecture-independent data (com)
+#  LOCALSTATEDIR    - modifiable single-machine data (var)
+#  LIBDIR           - object code libraries (lib or lib64)
+#  INCLUDEDIR       - C header files (include)
+#  OLDINCLUDEDIR    - C header files for non-gcc (/usr/include)
+#  DATAROOTDIR      - read-only architecture-independent data root (share)
+#  DATADIR          - read-only architecture-independent data (DATAROOTDIR)
+#  INFODIR          - info documentation (DATAROOTDIR/info)
+#  LOCALEDIR        - locale-dependent data (DATAROOTDIR/locale)
+#  MANDIR           - man documentation (DATAROOTDIR/man)
+#  DOCDIR           - documentation root (DATAROOTDIR/doc/PROJECT_NAME)
+# Each CMAKE_INSTALL_<dir> value may be passed to the DESTINATION options of
+# install() commands for the corresponding file type.  If the includer does
+# not define a value the above-shown default will be used and the value will
+# appear in the cache for editing by the user.
+# Each CMAKE_INSTALL_FULL_<dir> value contains an absolute path constructed
+# from the corresponding destination by prepending (if necessary) the value
+# of CMAKE_INSTALL_PREFIX.
+
+#=============================================================================
+# Copyright 2011 Nikita Krupen'ko <krnekit@gmail.com>
+# Copyright 2011 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+# Installation directories
+#
+if(NOT DEFINED CMAKE_INSTALL_BINDIR)
+  set(CMAKE_INSTALL_BINDIR "bin" CACHE PATH "user executables (bin)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_SBINDIR)
+  set(CMAKE_INSTALL_SBINDIR "sbin" CACHE PATH "system admin executables (sbin)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_LIBEXECDIR)
+  set(CMAKE_INSTALL_LIBEXECDIR "libexec" CACHE PATH "program executables (libexec)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_SYSCONFDIR)
+  set(CMAKE_INSTALL_SYSCONFDIR "etc" CACHE PATH "read-only single-machine data (etc)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_SHAREDSTATEDIR)
+  set(CMAKE_INSTALL_SHAREDSTATEDIR "com" CACHE PATH "modifiable architecture-independent data (com)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_LOCALSTATEDIR)
+  set(CMAKE_INSTALL_LOCALSTATEDIR "var" CACHE PATH "modifiable single-machine data (var)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_LIBDIR)
+  set(_LIBDIR_DEFAULT "lib")
+  # Override this default 'lib' with 'lib64' iff:
+  #  - we are on Linux system but NOT cross-compiling
+  #  - we are NOT on debian
+  #  - we are on a 64 bits system
+  # reason is: amd64 ABI: http://www.x86-64.org/documentation/abi.pdf
+  # Note that the future of multi-arch handling may be even
+  # more complicated than that: http://wiki.debian.org/Multiarch
+  if(CMAKE_SYSTEM_NAME MATCHES "Linux"
+      AND NOT CMAKE_CROSSCOMPILING
+      AND NOT EXISTS "/etc/debian_version")
+    if(NOT DEFINED CMAKE_SIZEOF_VOID_P)
+      message(AUTHOR_WARNING
+        "Unable to determine default CMAKE_INSTALL_LIBDIR directory because no target architecture is known. "
+        "Please enable at least one language before including GNUInstallDirs.")
+    else()
+      if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
+        set(_LIBDIR_DEFAULT "lib64")
+      endif()
+    endif()
+  endif()
+  set(CMAKE_INSTALL_LIBDIR "${_LIBDIR_DEFAULT}" CACHE PATH "object code libraries (${_LIBDIR_DEFAULT})")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_INCLUDEDIR)
+  set(CMAKE_INSTALL_INCLUDEDIR "include" CACHE PATH "C header files (include)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_OLDINCLUDEDIR)
+  set(CMAKE_INSTALL_OLDINCLUDEDIR "/usr/include" CACHE PATH "C header files for non-gcc (/usr/include)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_DATAROOTDIR)
+  set(CMAKE_INSTALL_DATAROOTDIR "share" CACHE PATH "read-only architecture-independent data root (share)")
+endif()
+
+#-----------------------------------------------------------------------------
+# Values whose defaults are relative to DATAROOTDIR.  Store empty values in
+# the cache and store the defaults in local variables if the cache values are
+# not set explicitly.  This auto-updates the defaults as DATAROOTDIR changes.
+
+if(NOT CMAKE_INSTALL_DATADIR)
+  set(CMAKE_INSTALL_DATADIR "" CACHE PATH "read-only architecture-independent data (DATAROOTDIR)")
+  set(CMAKE_INSTALL_DATADIR "${CMAKE_INSTALL_DATAROOTDIR}")
+endif()
+
+if(NOT CMAKE_INSTALL_INFODIR)
+  set(CMAKE_INSTALL_INFODIR "" CACHE PATH "info documentation (DATAROOTDIR/info)")
+  set(CMAKE_INSTALL_INFODIR "${CMAKE_INSTALL_DATAROOTDIR}/info")
+endif()
+
+if(NOT CMAKE_INSTALL_LOCALEDIR)
+  set(CMAKE_INSTALL_LOCALEDIR "" CACHE PATH "locale-dependent data (DATAROOTDIR/locale)")
+  set(CMAKE_INSTALL_LOCALEDIR "${CMAKE_INSTALL_DATAROOTDIR}/locale")
+endif()
+
+if(NOT CMAKE_INSTALL_MANDIR)
+  set(CMAKE_INSTALL_MANDIR "" CACHE PATH "man documentation (DATAROOTDIR/man)")
+  set(CMAKE_INSTALL_MANDIR "${CMAKE_INSTALL_DATAROOTDIR}/man")
+endif()
+
+if(NOT CMAKE_INSTALL_DOCDIR)
+  set(CMAKE_INSTALL_DOCDIR "" CACHE PATH "documentation root (DATAROOTDIR/doc/PROJECT_NAME)")
+  set(CMAKE_INSTALL_DOCDIR "${CMAKE_INSTALL_DATAROOTDIR}/doc/${PROJECT_NAME}")
+endif()
+
+#-----------------------------------------------------------------------------
+
+mark_as_advanced(
+  CMAKE_INSTALL_BINDIR
+  CMAKE_INSTALL_SBINDIR
+  CMAKE_INSTALL_LIBEXECDIR
+  CMAKE_INSTALL_SYSCONFDIR
+  CMAKE_INSTALL_SHAREDSTATEDIR
+  CMAKE_INSTALL_LOCALSTATEDIR
+  CMAKE_INSTALL_LIBDIR
+  CMAKE_INSTALL_INCLUDEDIR
+  CMAKE_INSTALL_OLDINCLUDEDIR
+  CMAKE_INSTALL_DATAROOTDIR
+  CMAKE_INSTALL_DATADIR
+  CMAKE_INSTALL_INFODIR
+  CMAKE_INSTALL_LOCALEDIR
+  CMAKE_INSTALL_MANDIR
+  CMAKE_INSTALL_DOCDIR
+  )
+
+# Result directories
+#
+foreach(dir
+    BINDIR
+    SBINDIR
+    LIBEXECDIR
+    SYSCONFDIR
+    SHAREDSTATEDIR
+    LOCALSTATEDIR
+    LIBDIR
+    INCLUDEDIR
+    OLDINCLUDEDIR
+    DATAROOTDIR
+    DATADIR
+    INFODIR
+    LOCALEDIR
+    MANDIR
+    DOCDIR
+    )
+  if(NOT IS_ABSOLUTE ${CMAKE_INSTALL_${dir}})
+    set(CMAKE_INSTALL_FULL_${dir} "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_${dir}}")
+  else()
+    set(CMAKE_INSTALL_FULL_${dir} "${CMAKE_INSTALL_${dir}}")
+  endif()
+endforeach()
--- a/CMakeModules/Packaging.cmake
+++ b/CMakeModules/Packaging.cmake
@@ -1,23 +0,0 @@
-#packaging
-SET(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/COPYING")
-SET(CPACK_RESOURCE_FILE_README "${PROJECT_SOURCE_DIR}/README")
-SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Simulation support libraries for FlightGear and related projects")
-SET(CPACK_PACKAGE_VENDOR "The FlightGear project")
-SET(CPACK_GENERATOR "TBZ2")
-SET(CPACK_INSTALL_CMAKE_PROJECTS  ${CMAKE_CURRENT_BINARY_DIR};SimGear;ALL;/)
-
-
-# split version string into components, note CMAKE_MATCH_0 is the entire regexp match
-string(REGEX MATCH "([0-9]+)\\.([0-9]+)\\.([0-9]+)" CPACK_PACKAGE_VERSION ${SIMGEAR_VERSION} )
-set(CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1})
-set(CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
-set(CPACK_PACKAGE_VERSION_PATCH ${CMAKE_MATCH_3})
-
-message(STATUS "version is ${CPACK_PACKAGE_VERSION_MAJOR} dot ${CPACK_PACKAGE_VERSION_MINOR} dot ${CPACK_PACKAGE_VERSION_PATCH}")
-
-set(CPACK_SOURCE_GENERATOR TBZ2)
-set(CPACK_SOURCE_PACKAGE_FILE_NAME "simgear-${SIMGEAR_VERSION}" CACHE INTERNAL "tarball basename")
-set(CPACK_SOURCE_IGNORE_FILES
-  "^${PROJECT_SOURCE_DIR}/.git;\\\\.gitignore;Makefile.am;~$;${CPACK_SOURCE_IGNORE_FILES}")
-
-include (CPack)
--- a/CMakeModules/SimGearComponent.cmake
+++ b/CMakeModules/SimGearComponent.cmake
@@ -1,26 +1,23 @@

 macro(simgear_component_common name includePath sourcesList sources headers)
-    set(fc${sourcesList} ${name})
-    set(fh${sourcesList} ${name})
-    foreach(s ${sources})
-        set_property(GLOBAL
-            APPEND PROPERTY ${sourcesList} "${CMAKE_CURRENT_SOURCE_DIR}/${s}")
-        set(fc${sourcesList} "${fc${sourcesList}}#${CMAKE_CURRENT_SOURCE_DIR}/${s}")
-    endforeach()
+    if (SIMGEAR_SHARED)

-	foreach(h ${headers})
-		set_property(GLOBAL
-			APPEND PROPERTY PUBLIC_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/${h}")
-        set(fh${sourcesList} "${fh${sourcesList}}#${CMAKE_CURRENT_SOURCE_DIR}/${h}")
+        foreach(s ${sources})
+            set_property(GLOBAL
+                APPEND PROPERTY ${sourcesList} "${CMAKE_CURRENT_SOURCE_DIR}/${s}")
+        endforeach()

-        # also append headers to the sources list, so that IDEs find the files
-        # correctly (otherwise they are not in the project)
-        set_property(GLOBAL
-            APPEND PROPERTY ${sourcesList} "${CMAKE_CURRENT_SOURCE_DIR}/${h}")
-	endforeach()
+		foreach(h ${headers})
+			set_property(GLOBAL
+				APPEND PROPERTY PUBLIC_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/${h}")
+		endforeach()
+        
+    else()
+        set(libName "sg${name}")
+        add_library(${libName} STATIC ${sources} ${headers})

-    set_property(GLOBAL APPEND PROPERTY FG_GROUPS_${sourcesList}_C "${fc${sourcesList}}@")
-    set_property(GLOBAL APPEND PROPERTY FG_GROUPS_${sourcesList}_H "${fh${sourcesList}}@")
+        install (TARGETS ${libName} ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+    endif()
    
    install (FILES ${headers}  DESTINATION include/simgear/${includePath})
 endmacro()
--- a/2645
+++ b/2645
--- a/DoxygenMain.cxx
+++ b/DoxygenMain.cxx
@@ -2,10 +2,6 @@
   documentation.  It has a .cxx extension so that emacs will happily
   autoindent correctly. */

-/**
- * \namespace simgear
- * \brief \ref index "SimGear" main namespace.
- */
 /** \mainpage SimGear
 * Simulation, Visualization, and Game development libraries.

--- a/1
+++ b/1
@@ -31,6 +31,7 @@ SimGear depends on a number of 3rd party libraries, the most notable
 being:

 * OpenSceneGraph (OSG) - see README.OSG
+* Portable Games Library (PLIB) - see README.plib
 * zlib compression library - see README.zlib
 * Open Audio Library (OpenAL) - see README.OpenAL
 * Subversion Client Library (optional dependency)
--- a/README.OpenAL
+++ b/README.OpenAL
@@ -0,0 +1,29 @@
+[This file is mirrored in both the FlightGear and SimGear packages.]
+
+You *must* have the development components of OpenAL installed on your system
+to build FlightGear!"  You can get a copy here:
+
+      http://connect.creativelabs.com/openal/default.aspx
+
+Build notes:
+
+You can download a versioned release of the openal library from 
+http://www.openal.org/downloads.html. Download the openal source,
+release 0.0.8 (dated February 11, 2006) and run:  
+tar xjvf openal-soft-1.5.304.tar.bz2
+cd openal-soft-1.5.304/
+ccmake .
+
+[ While running ccmake: press 'c' to configure, press 'c' once more, and
+  then press 'g' to generate and exit ]
+
+
+The alut library is also required, but comes separately in the package
+freelut-1.1.0.tar.gz. This package can be downloaded from the same page
+(http://connect.creativelabs.com/openal/default.aspx). Download and run:
+tar xzvf freelut-1.1.0.tar.gz
+cd freealut-1.1.0
+./configure
+make
+sudo make install
+
--- a/README.cmake
+++ b/README.cmake
@@ -20,8 +20,8 @@ Probably you want to specify an install prefix:
    cmake ../simgear -DCMAKE_INSTALL_PREFIX=/usr

 Note the install prefix is automatically searched for required libraries
-and header files, so if you install OpenSceneGraph to the same prefix,
-most configuration options are unnecessary.
+and header files, so if you install PLIB, OpenSceneGraph to the
+same prefix, most configuration options are unnecessary.

 If for some reason you have a dependency (or several) at a different prefix,
 you can specify one or more via CMAKE_PREFIX_PATH:
@@ -33,7 +33,7 @@ you can specify one or more via CMAKE_PREFIX_PATH:
 Standard prefixes are searched automatically (/usr, /usr/local, /opt/local)

 Most dependencies also expose an environment variable to specify their
-installation directory explicitly eg OSG_DIR. Any of the methods
+installation directory explicitly eg OSG_DIR or PLIBDIR. Any of the methods
 described above will work, but specifying an INSTALL_PREFIX or PREFIX_PATH is
 usually simpler.

--- a/README.plib
+++ b/README.plib
@@ -0,0 +1,32 @@
+[This file is mirrored in both the FlightGear and SimGear packages.]
+
+You *must* have plib version 1.8.5 or later installed on your system
+to build FlightGear!"  Flight Gear is no longer compatible with the
+earlier versions of the library.
+
+You can get the latest version of plib from:
+
+    http://plib.sourceforge.net
+
+Build notes:
+
+You should be able to just run "./configure" to configure the package
+and use all of plib's defaults.  Then run "make" followed by "make
+install".  By default, plib installs itself into /usr so if you don't
+like this, be sure to specify an alternate prefix such as --prefix=/usr/local
+
+As of this writing (2007-11-18), many linux distributions are shipped with a 
+working version of plib, so chances are that this library is already 
+installed. It should be noted, that currently plib version no longer compiles
+using recent versions of gcc (confirmed on version gcc 4.1.2, as shipped with 
+SuSe 10.2). As a workaround, it is possible to either use plib SVN. Run the 
+following commands: 
+
+
+svn co https://plib.svn.sourceforge.net/svnroot/plib/trunk plib
+cd plib
+./autogen.sh
+./configure
+make
+make install
+
--- a/README.sound
+++ b/README.sound
@@ -1,39 +0,0 @@
-[This file is mirrored in both the FlightGear and SimGear packages.]
-
-For Sound support FlightGear requires one of the two following packages:
- OpenAL
- AeonWave
-
-== OpenAL ===
-
-You *must* have the development components of OpenAL installed on your system
-to build FlightGear!"  You can get a copy here:
-
-      http://connect.creativelabs.com/openal/default.aspx
-
-Build notes:
-
-You can download a versioned release of the openal library from
-http://www.openal.org/downloads.html. Download the openal source,
-release 0.0.8 (dated February 11, 2006) and run:
-tar xjvf openal-soft-1.5.304.tar.bz2
-cd openal-soft-1.5.304/
-ccmake .
-
-[ While running ccmake: press 'c' to configure, press 'c' once more, and
-  then press 'g' to generate and exit ]
-
-
-== AeonWave ===
-
-For FlightGear AeonWave has a number of advantages over OpenAL:
-* Correct Doppler effect behavior
-* Default distance attenuation frequency filtering
-* Native support for 29 types of audio formats.
-* Native support for wav, mp3, vorbis and raw file formats.
-
-The source code of AeonWave can be found on GitHub:
-https://github.com/adalinbv
-
-Optimized binary packages are available at:
-http://www.adalin.com/
--- a/SimGear.spec.in
+++ b/SimGear.spec.in
@@ -0,0 +1,76 @@
+%define ver	@VERSION@
+%define rel	1
+%define prefix	/usr
+
+Summary:	Simulator Construction Gear.
+Name:		@PACKAGE@
+Version:	%ver
+Release:	%rel
+Copyright:	LGPL
+Group:		Libraries/Graphics
+Source:		%{name}-%{version}.tar.gz
+#URL:		
+BuildRoot:	/tmp/%{name}-%{version}-%{rel}-root
+Packager:	Fill In As You Wish
+Docdir:		%{prefix}/doc
+
+%description
+This package contains a tools and libraries useful for constructing 
+simulation and visualization applications such as FlightGear or TerraGear. 
+
+Authors:
+	N/A
+
+%prep
+%setup -n %{name}-%{version}
+
+
+%build
+# Needed for snapshot releases.
+if [ ! -f configure ]; then
+	CFLAGS="$RPM_OPT_FLAGS" ./autogen.sh --prefix=%prefix
+else
+	CFLAGS="$RPM_OPT_FLAGS" ./configure --prefix=%prefix
+fi
+
+if [ "$SMP" != "" ]; then
+	JSMP	= '"MAKE=make -k -j $SMP"'
+fi
+
+make ${JSMP};
+
+
+%install
+[ -d ${RPM_BUILD_ROOT} ] && rm -rf ${RPM_BUILD_ROOT}
+
+make prefix=${RPM_BUILD_ROOT}%{prefix} install
+
+#
+# Generating file lists and store them in file-lists
+# Starting with the directory listings
+#
+find ${RPM_BUILD_ROOT}%{prefix}/{bin,include,lib} -type d | sed "s#^${RPM_BUILD_ROOT}#\%attr (-\,root\,root) \%dir #" > file-lists
+%{?ETCDR:find ${RPM_BUILD_ROOT}%{!?SYSCF:%{prefix}}/etc -type d | sed "s#^${RPM_BUILD_ROOT}#\%attr (-\,root\,root) \%dir #" >> file-lists}
+
+#
+# Then, the file listings
+#
+echo "%defattr (-, root, root)" >> file-lists
+%{?ETCDR:find ${RPM_BUILD_ROOT}%{!?SYSCF:%{prefix}}/etc/%{name}.conf -type f | sed -e "s#^${RPM_BUILD_ROOT}#%config #g" >> file-lists}
+find ${RPM_BUILD_ROOT}%{prefix} -type f | sed -e "s#^${RPM_BUILD_ROOT}##g" >> file-lists
+
+
+%clean
+(cd ..; rm -rf %{name}-%{version} ${RPM_BUILD_ROOT})
+
+
+%files -f file-lists
+%defattr (-, root, root)
+%doc AUTHORS
+%doc COPYING
+%doc ChangeLog
+%doc INSTALL
+%doc NEWS
+%doc README
+%doc %{name}.spec.in
+
--- a/SimGearConfig.cmake.in
+++ b/SimGearConfig.cmake.in
@@ -1,63 +0,0 @@
-include(CMakeFindDependencyMacro)
-
-find_dependency(ZLIB)
-find_dependency(LibLZMA)
-find_dependency(Threads)
-find_dependency(CURL)
-
-# OSG
-
-set(SIMGEAR_HEADLESS @SIMGEAR_HEADLESS@)
-set(SIMGEAR_SOUND @ENABLE_SOUND@)
-set(USE_AEONWAVE @USE_AEONWAVE@)
-set(SG_SOUND_USES_OPENALSOFT @SG_SOUND_USES_OPENALSOFT@)
-
-set(USE_SHADERVG @USE_SHADERVG@)
-if (USE_SHADERVG)
-endif()
-
-set(ENABLE_ASAN @ENABLE_ASAN@)
-set(SIMGEAR_SHARED @SIMGEAR_SHARED@)
-
-# SSE/SSE2 support
-
-set(ENABLE_SIMD @ENABLE_SIMD@)
-
-# SycloneDDS support
-set(SG_HAVE_DDS @SG_HAVE_DDS@)
-if(SG_HAVE_DDS)
-    find_dependency(CycloneDDS)
-endif()
-
-
-if (SIMGEAR_SOUND)
-  # find the sound dependency
-  if (USE_AEONWAVE)
-    find_dependency(AAX)
-  elseif(SG_SOUND_USES_OPENALSOFT)
-    # must force CONFIG mode when using OpenAL soft, to avoid picking
-    # the CMake supplied FindOpenAL and hence defaults to the system
-    # framework on macOS
-    find_dependency(OpenAL CONFIG)
-  else()
-    find_dependency(OpenAL)
-  endif()
-endif()
-
-# OpenRTI support
-set(ENABLE_RTI @ENABLE_RTI@)
-if(ENABLE_RTI)
-    find_dependency(PkgConfig)
-    if(PKG_CONFIG_FOUND)
-      pkg_check_modules(RTI IMPORTED_TARGET hla-rti13)
-    endif(PKG_CONFIG_FOUND)
-endif(ENABLE_RTI)
-
-# Alternative terrain engine based on pagedLOD
-
-set(ENABLE_GDAL @ENABLE_GDAL@)
-if (ENABLE_GDAL)
-  find_dependency(GDAL)
-endif()
-
-include("${CMAKE_CURRENT_LIST_DIR}/SimGearTargets.cmake")
--- a/package/RedHat/README
+++ b/package/RedHat/README
@@ -0,0 +1,13 @@
+Building a SimGear RPM package for Red Hat
+
+Please see the "package/openSUSE" directory for an
+example how to build a SimGear RPM package with
+shared SimGear libraries.
+
+You may need to adapt the names (exact spelling) of some
+of the package dependencies in the openSUSE RPM spec,
+since these may slightly differ for Red Hat.
+
+(If you have a working and tested Red Hat RPM spec,
+you're welcome to contribute it to this project.)
+
--- a/package/openSUSE/README
+++ b/package/openSUSE/README
@@ -0,0 +1,23 @@
+Building a SimGear RPM package for openSUSE
+
+(Last tested with openSUSE 11.4+12.1)
+
+This directory contains the files which, along with
+the source code tar files, can be used to build
+an RPM package targeted at an openSUSE Linux system.
+
+To build SimGear from source do the following:
+
+1. obtain simgear-2.8.0.tar.bz2 (adapt version if
+    necessary) and copy it into ~/rpmbuild/SOURCES
+
+2. look in the BuildRequires section of SimGear.spec
+   and check that all the packages referred to are
+   installed (note, some of these packages may be part
+   of openSUSE's "games" repository).
+
+3. run 'rpmbuild -ba simgear.spec' and find the RPM
+   build result in ~/rpmbuild/RPMS
+
+That's all!
+
--- a/package/openSUSE/SimGear.spec
+++ b/package/openSUSE/SimGear.spec
@@ -0,0 +1,66 @@
+Summary:    Simulator Construction Gear
+Name:       SimGear
+Version:    2.8.0
+Release:    1
+License:    LGPL
+URL:        http://www.flightgear.org
+Group:      Amusements/Games/3D/Simulation
+Source:     http://mirrors.ibiblio.org/pub/mirrors/flightgear/ftp/Source/simgear-%{version}.tar.bz2
+BuildRoot:  %{_tmppath}/%{name}-%{version}-build
+
+BuildRequires: gcc, gcc-c++, cmake
+BuildRequires: freealut, freealut-devel
+BuildRequires: libopenal1-soft, openal-soft
+BuildRequires: plib-devel >= 1.8.5
+BuildRequires: libOpenSceneGraph-devel >= 3.0
+BuildRequires: zlib, zlib-devel
+BuildRequires: libjpeg62, libjpeg62-devel
+BuildRequires: boost-devel >= 1.37
+BuildRequires: subversion-devel, libapr1-devel
+Requires:      OpenSceneGraph-plugins >= 3.0
+
+%description
+This package contains a tools and libraries useful for constructing
+simulation and visualization applications such as FlightGear or TerraGear.
+
+%package devel
+Group:         Development/Libraries/Other
+Summary:       Development header files for SimGear
+Requires:      SimGear = %{version}
+Requires:      plib-devel
+
+%description devel
+Development headers and libraries for building applications against SimGear.
+
+%prep
+%setup -T -q -n simgear-%{version} -b 0
+
+%build
+export CFLAGS="$RPM_OPT_FLAGS"
+export CXXFLAGS="$RPM_OPT_FLAGS"
+# build SHARED simgear libraries
+cmake -DCMAKE_INSTALL_PREFIX=%{_prefix} -DSIMGEAR_SHARED:BOOL=ON -DENABLE_TESTS:BOOL=OFF -DJPEG_FACTORY:BOOL=ON
+make %{?_smp_mflags}
+
+%install
+make DESTDIR=%{buildroot} install
+
+%post -p /sbin/ldconfig
+
+%postun -p /sbin/ldconfig
+
+%files
+%defattr (-, root, root, -)
+%doc AUTHORS COPYING ChangeLog NEWS README
+%{_libdir}/libSimGear*.so.*
+
+%files devel
+%defattr(-,root,root,-)
+%dir %{_includedir}/simgear
+%{_includedir}/simgear/*
+%{_libdir}/libSimGear*.so
+
+%changelog
+* Mon Jul 02 2012 thorstenb@flightgear.org
+- Initial version
+
--- a/1
+++ b/1
@@ -1 +0,0 @@
-2020.4.0
--- a/simgear/CMakeLists.txt
+++ b/simgear/CMakeLists.txt
@@ -1,27 +1,21 @@

 file(WRITE ${PROJECT_BINARY_DIR}/simgear/version.h "#define SIMGEAR_VERSION ${SIMGEAR_VERSION}")

-foreach( mylibfolder
+foreach( mylibfolder 
        bucket
-        bvh
        debug
-        embedded_resources
-        emesary
        ephemeris
        io
        magvar
        math
        misc
        nasal
-        nasal/cppbind
        props
        serial
-        std
        structure
        threads
        timing
        xml
-        package
    )

    add_subdirectory(${mylibfolder})
@@ -29,7 +23,6 @@ foreach( mylibfolder
 endforeach( mylibfolder )

 if(NOT SIMGEAR_HEADLESS)
-    add_subdirectory(canvas)
    add_subdirectory(environment)
    add_subdirectory(screen)
    add_subdirectory(scene)
@@ -45,170 +38,51 @@ endif(ENABLE_RTI)
 set(HEADERS compiler.h constants.h sg_inlines.h ${PROJECT_BINARY_DIR}/simgear/version.h)
 install (FILES ${HEADERS}  DESTINATION include/simgear/)

-get_property(coreSources GLOBAL PROPERTY CORE_SOURCES)
-get_property(sceneSources GLOBAL PROPERTY SCENE_SOURCES)
-get_property(publicHeaders GLOBAL PROPERTY PUBLIC_HEADERS)
-
 if(SIMGEAR_SHARED)
    message(STATUS "Library building mode: SHARED LIBRARIES")
-    add_library(SimGearCore SHARED ${coreSources} ${localExpatSources})
+    get_property(coreSources GLOBAL PROPERTY CORE_SOURCES)
+    get_property(sceneSources GLOBAL PROPERTY SCENE_SOURCES)
+    get_property(publicHeaders GLOBAL PROPERTY PUBLIC_HEADERS)

+    add_library(SimGearCore SHARED ${coreSources})
+
+  # set_property(TARGET SimGearCore PROPERTY FRAMEWORK 1)
+  #  message(STATUS "public header: ${publicHeaders}")
+  #  set_property(TARGET SimGearCore PROPERTY PUBLIC_HEADER "${publicHeaders}")
    set_property(TARGET SimGearCore PROPERTY LINKER_LANGUAGE CXX)
+
    set_property(TARGET SimGearCore PROPERTY VERSION   ${SIMGEAR_VERSION})
    set_property(TARGET SimGearCore PROPERTY SOVERSION ${SIMGEAR_SOVERSION})

+    target_link_libraries(SimGearCore ${ZLIB_LIBRARY} ${RT_LIBRARY})
+    install(TARGETS SimGearCore LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+    if(LIBSVN_FOUND)
+        add_definitions(${APR_CFLAGS})
+        include_directories(${LIBSVN_INCLUDE_DIR})
+        target_link_libraries(SimGearCore ${LIBSVN_LIBRARIES})
+    endif(LIBSVN_FOUND)

    if(NOT SIMGEAR_HEADLESS)
        add_library(SimGearScene SHARED ${sceneSources})
+      # set_property(TARGET SimGearScene PROPERTY FRAMEWORK 1)
+      # set_property(TARGET SimGearScene PROPERTY PUBLIC_HEADER "${publicHeaders}")
        set_property(TARGET SimGearScene PROPERTY LINKER_LANGUAGE CXX)
        set_property(TARGET SimGearScene PROPERTY VERSION   ${SIMGEAR_VERSION})
        set_property(TARGET SimGearScene PROPERTY SOVERSION ${SIMGEAR_SOVERSION})
+
+        target_link_libraries(SimGearScene
+            SimGearCore
+            ${ZLIB_LIBRARY}
+            ${OPENSCENEGRAPH_LIBRARIES}
+            ${OPENAL_LIBRARY} ${ALUT_LIBRARY}
+            ${OPENGL_LIBRARY}
+            ${JPEG_LIBRARY})
+    
+        install(TARGETS SimGearScene LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
    endif()

-    export_debug_symbols(SimGearCore)
-    export_debug_symbols(SimGearScene)
 else()
    message(STATUS "Library building mode: STATIC LIBRARIES")
-
-	get_property(FG_GROUPS_CORE_SOURCES_C GLOBAL PROPERTY FG_GROUPS_CORE_SOURCES_C)
-	string(REPLACE "@" ";" groups ${FG_GROUPS_CORE_SOURCES_C} )
-	foreach(g ${groups})
-		string(REPLACE "#" ";" g2 ${g})
-		list(GET g2 0 name)
-		list(REMOVE_AT g2 0)
-		source_group("${name}\\Sources" FILES ${g2})
-	endforeach()
-
-	get_property(FG_GROUPS_CORE_SOURCES_H GLOBAL PROPERTY FG_GROUPS_CORE_SOURCES_H)
-	string(REPLACE "@" ";" groups ${FG_GROUPS_CORE_SOURCES_H} )
-	foreach(g ${groups})
-		string(REPLACE "#" ";" g2 ${g})
-		list(GET g2 0 name)
-		list(REMOVE_AT g2 0)
-		source_group("${name}\\Headers" FILES ${g2})
-	endforeach()
-
-    add_library(SimGearCore STATIC ${coreSources})
-
-    if(NOT SIMGEAR_HEADLESS)
-		get_property(FG_GROUPS_SCENE_SOURCES_C GLOBAL PROPERTY FG_GROUPS_SCENE_SOURCES_C)
-		string(REPLACE "@" ";" groups ${FG_GROUPS_SCENE_SOURCES_C} )
-		foreach(g ${groups})
-			string(REPLACE "#" ";" g2 ${g})
-			list(GET g2 0 name)
-			list(REMOVE_AT g2 0)
-			source_group("${name}\\Sources" FILES ${g2})
-		endforeach()
-
-		get_property(FG_GROUPS_SCENE_SOURCES_H GLOBAL PROPERTY FG_GROUPS_SCENE_SOURCES_H)
-		string(REPLACE "@" ";" groups ${FG_GROUPS_SCENE_SOURCES_H} )
-		foreach(g ${groups})
-			string(REPLACE "#" ";" g2 ${g})
-			list(GET g2 0 name)
-			list(REMOVE_AT g2 0)
-			source_group("${name}\\Headers" FILES ${g2})
-		endforeach()
-
-        add_library(SimGearScene STATIC ${sceneSources})
-    endif(NOT SIMGEAR_HEADLESS)
 endif(SIMGEAR_SHARED)

-target_include_directories(SimGearCore BEFORE PUBLIC
-    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
-    $<INSTALL_INTERFACE:include>)
-
-# for simgear_config.h
-target_include_directories(SimGearCore PRIVATE ${PROJECT_BINARY_DIR}/simgear)
-
-target_include_directories(SimGearCore PUBLIC
-  ${Boost_INCLUDE_DIRS})
-
-install(TARGETS SimGearCore
-        EXPORT SimGearTargets
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-
-# we expose ZLib in some of our headers
-target_link_libraries(SimGearCore PUBLIC ZLIB::ZLIB)
-
-if (SG_HAVE_DDS)
-    target_link_libraries(SimGearCore PRIVATE CycloneDDS::ddsc)
-endif()
-
-if (ENABLE_RTI)
-    target_sources(SimGearCore PRIVATE $<TARGET_OBJECTS:rti> $<TARGET_OBJECTS:rti13>)
-    target_link_libraries(SimGearCore PRIVATE PkgConfig::RTI)
-endif()
-
-# all of these we keep privately
-target_link_libraries(SimGearCore PRIVATE
-    ${SHLWAPI_LIBRARY}
-    ${RT_LIBRARY}
-    ${DL_LIBRARY}
-    Threads::Threads
-    ${COCOA_LIBRARY}
-    CURL::libcurl
-    EXPAT::EXPAT
-    Udns::Udns
-    LibLZMA::LibLZMA
-    ${WINSOCK_LIBRARY})
-
-if(NOT SIMGEAR_HEADLESS)
-    target_include_directories(SimGearScene PRIVATE ${PROJECT_SOURCE_DIR}/simgear/canvas/${OPENVG}/include)
-
-    target_link_libraries(SimGearScene PUBLIC         
-        SimGearCore
-        ${OPENSCENEGRAPH_LIBRARIES}
-    )
-
-    if(HAVE_INTTYPES_H)
-        # ShivaVG/ShaderVG needs inttypes.h
-        target_compile_definitions(SimGearScene PRIVATE HAVE_INTTYPES_H)
-    endif()
-
-    target_link_libraries(SimGearScene PRIVATE
-        ZLIB::ZLIB
-        ${OPENGL_LIBRARY}
-        ${JPEG_LIBRARY}
-        ${FFMPEG_LIBRARIES}
-        FGTinyGLTF)
-
-    # ToDo: define an ALIAS target for the sound backend, to get
-    # rid of this logic here
-    if (ENABLE_SOUND)
-        if (USE_AEONWAVE)
-            target_link_libraries(SimGearScene PRIVATE ${AAX_LIBRARY})
-        else()
-            target_link_libraries(SimGearScene PRIVATE ${OPENAL_LIBRARY} )
-        endif()
-    endif()
-
-    if(ENABLE_GDAL)
-        # FIXME: should be RIVATE, but we leak GDAL headers
-        # in our own headers :(
-        target_link_libraries(SimGearScene PUBLIC GDAL::GDAL)
-    endif()
-
-    # only actually needed by canvas/KeyboardEvent.cxx
-    target_include_directories(SimGearScene PRIVATE ${PROJECT_SOURCE_DIR}/3rdparty/utf8/source)
-    target_include_directories(SimGearScene PRIVATE ${FFMPEG_INCLUDE_DIRS})
-
-    install(TARGETS SimGearScene
-        EXPORT SimGearTargets
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-
-    target_include_directories(SimGearScene BEFORE PUBLIC
-        $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
-        $<INSTALL_INTERFACE:include>)
-
-    # for simgear_config.h
-    target_include_directories(SimGearScene PRIVATE ${PROJECT_BINARY_DIR}/simgear)
-    target_include_directories(SimGearScene PUBLIC ${OPENSCENEGRAPH_INCLUDE_DIRS})
-
-    if (USE_AEONWAVE)
-        target_include_directories(SimGearScene PRIVATE ${AAX_INCLUDE_DIR} )
-    else()
-        target_include_directories(SimGearScene PRIVATE ${OPENAL_INCLUDE_DIR} )
-    endif()
-endif()
--- a/simgear/bucket/CMakeLists.txt
+++ b/simgear/bucket/CMakeLists.txt
@@ -4,8 +4,4 @@ include (SimGearComponent)
 set(HEADERS newbucket.hxx)
 set(SOURCES newbucket.cxx)

-simgear_component(bucket bucket "${SOURCES}" "${HEADERS}")
-
-if(ENABLE_TESTS)
-    add_simgear_autotest(test_bucket test_bucket.cxx)
-endif(ENABLE_TESTS)
+simgear_component(bucket bucket "${SOURCES}" "${HEADERS}")
--- a/simgear/bucket/newbucket.cxx
+++ b/simgear/bucket/newbucket.cxx
@@ -27,56 +27,36 @@
 #  include <simgear_config.h>
 #endif

-#include <cmath>
-#include <cstdio> // some platforms need this for ::snprintf
-#include <iostream>
+#include <math.h>

 #include <simgear/misc/sg_path.hxx>
-#include <simgear/debug/logstream.hxx>

 #include "newbucket.hxx"


 // default constructor
-SGBucket::SGBucket() :
-    lon(-1000),
-    lat(-1000),
-    x(0),
-    y(0)
-{
+SGBucket::SGBucket() {
 }

-bool SGBucket::isValid() const
-{
-    // The most northerly valid latitude is 89, not 90. There is no tile
-    // whose *bottom* latitude is 90. Similar there is no tile whose left egde
-    // is 180 longitude.
-    return (lon >= -180) &&
-            (lon < 180) &&
-            (lat >= -90) &&
-            (lat < 90) &&
-            (x < 8) && (y < 8);
-}
-
-void SGBucket::make_bad()
-{
-    lon = -1000;
-    lat = -1000;
-}
-
-#ifndef NO_DEPRECATED_API

 // constructor for specified location
 SGBucket::SGBucket(const double dlon, const double dlat) {
    set_bucket(dlon, dlat);
 }
-#endif

 SGBucket::SGBucket(const SGGeod& geod) {
-    innerSet(geod.getLongitudeDeg(),
-             geod.getLatitudeDeg());
+    set_bucket(geod);
 }

+// create an impossible bucket if false
+SGBucket::SGBucket(const bool is_good) {
+    set_bucket(0.0, 0.0);
+    if ( !is_good ) {
+	lon = -1000;
+    }
+}
+
+
 // Parse a unique scenery tile index and find the lon, lat, x, and y
 SGBucket::SGBucket(const long int bindex) {
    long int index = bindex;
@@ -95,59 +75,48 @@ SGBucket::SGBucket(const long int bindex) {
    x = index;
 }

-/* Calculate the greatest integral value less than
- * or equal to the given value (floor(x)),
- * but attribute coordinates close to the boundary to the next
- * (increasing) integral
- */
-static int floorWithEpsilon(double x)
-{
-    return static_cast<int>(floor(x + SG_EPSILON));
-}
-
-#ifndef NO_DEPRECATED_API
-
-void SGBucket::set_bucket(double dlon, double dlat)
-{
-    innerSet(dlon, dlat);
-}
-
-
-void SGBucket::set_bucket(const SGGeod& geod)
-{
-    innerSet(geod.getLongitudeDeg(), geod.getLatitudeDeg());
-}
-
-#endif

 // Set the bucket params for the specified lat and lon
-void SGBucket::innerSet( double dlon, double dlat )
-{
-    if ((dlon < -180.0) || (dlon >= 180.0)) {
-        SG_LOG(SG_TERRAIN, SG_WARN, "SGBucket::set_bucket: passed longitude:" << dlon);
-        dlon = SGMiscd::normalizePeriodic(-180.0, 180.0, dlon);
-    }
-    
-    if ((dlat < -90.0) || (dlat > 90.0)) {
-        SG_LOG(SG_TERRAIN, SG_WARN, "SGBucket::set_bucket: passed latitude" << dlat);
-        dlat = SGMiscd::clip(dlat, -90.0, 90.0);
-    }
-    
+void SGBucket::set_bucket( double *lonlat ) {
+    set_bucket( lonlat[0], lonlat[1] );
+}	
+
+
+// Set the bucket params for the specified lat and lon
+void SGBucket::set_bucket( double dlon, double dlat ) {
    //
-    // longitude first
+    // latitude first
    //
    double span = sg_bucket_span( dlat );
-    // we do NOT need to special case lon=180 here, since
-    // normalizePeriodic will never return 180; it will
-    // return -180, which is what we want.
-    lon = floorWithEpsilon(dlon);
-    
+    double diff = dlon - (double)(int)dlon;
+
+    // cout << "diff = " << diff << "  span = " << span << endl;
+
+    /* Calculate the greatest integral longitude less than
+     * or equal to the given longitude (floor(dlon)),
+     * but attribute coordinates near the east border
+     * to the next tile.
+     */
+    if ( (dlon >= 0) || (fabs(diff) < SG_EPSILON) ) {
+	lon = (int)dlon;
+    } else {
+	lon = (int)dlon - 1;
+    }
+
    // find subdivision or super lon if needed
-    if ( span <= 1.0 ) {
+    if ( span < SG_EPSILON ) {
+        /* sg_bucket_span() never returns 0.0
+         * or anything near it, so this really
+         * should not occur at any time.
+         */
+	// polar cap
+	lon = 0;
+	x = 0;
+    } else if ( span <= 1.0 ) {
        /* We have more than one tile per degree of
         * longitude, so we need an x offset.
         */
-        x = floorWithEpsilon((dlon - lon) / span);
+	x = (int)((dlon - lon) / span);
    } else {
        /* We have one or more degrees per tile,
         * so we need to find the base longitude
@@ -160,123 +129,50 @@ void SGBucket::innerSet( double dlon, double dlat )
         *
         * That way, the Greenwich Meridian is always
         * a tile border.
+         *
+         * This gets us into trouble with the polar caps,
+         * which have width 360 and thus either span
+         * the range from 0 to 360 or from -360 to 0
+         * degrees, depending on whether lon is positive
+         * or negative!
+         *
+         * We also get into trouble with the 8 degree tiles
+         * north of 88N and south of 88S, because the west-
+         * and east-most tiles in that range will cover 184W
+         * to 176W and 176E to 184E respectively, with their
+         * center at 180E/W!
         */
-        lon=static_cast<int>(floor(lon / span) * span);
-        x = 0;
+        lon=(int)floor(floor((lon+SG_EPSILON)/span)*span);
+        /* Correct the polar cap issue */
+        if ( lon < -180 ) {
+            lon = -180;
+        }
+	x = 0;
    }

    //
    // then latitude
    //
-    lat = floorWithEpsilon(dlat);
-    
-    // special case when passing in the north pole point (possibly due to
-    // clipping latitude above). Ensures we generate a valid bucket in this
-    // scenario
-    if (lat == 90) {
-        lat = 89;
-        y = 7;
+    diff = dlat - (double)(int)dlat;
+
+    /* Again, a modified floor() function (see longitude) */
+    if ( (dlat >= 0) || (fabs(diff) < SG_EPSILON) ) {
+	lat = (int)dlat;
    } else {
-        /* Latitude base and offset are easier, as
-         * tiles always are 1/8 degree of latitude wide.
-         */
-        y = floorWithEpsilon((dlat - lat) * 8);
+	lat = (int)dlat - 1;
    }
+    /* Latitude base and offset are easier, as
+     * tiles always are 1/8 degree of latitude wide.
+     */
+    y = (int)((dlat - lat) * 8);
 }

-std::string SGBucket::gen_vpb_base() const {
-    // long int index;
-    int top_lon, top_lat, main_lon, main_lat;
-    char hem, pole;
-    char raw_path[256];

-    top_lon = lon / 10;
-    main_lon = lon;
-    if ( (lon < 0) && (top_lon * 10 != lon) ) {
-	top_lon -= 1;
-    }
-    top_lon *= 10;
-    if ( top_lon >= 0 ) {
-	hem = 'e';
-    } else {
-	hem = 'w';
-	top_lon *= -1;
-    }
-    if ( main_lon < 0 ) {
-	main_lon *= -1;
-    }
-    
-    top_lat = lat / 10;
-    main_lat = lat;
-    if ( (lat < 0) && (top_lat * 10 != lat) ) {
-	top_lat -= 1;
-    }
-    top_lat *= 10;
-    if ( top_lat >= 0 ) {
-	pole = 'n';
-    } else {
-	pole = 's';
-	top_lat *= -1;
-    }
-    if ( main_lat < 0 ) {
-	main_lat *= -1;
-    }
-
-    ::snprintf(raw_path, 256, "%c%03d%c%02d/%c%03d%c%02d/ws_%c%03d%c%02d",
-	    hem, top_lon, pole, top_lat, 
-	    hem, main_lon, pole, main_lat,
-        hem, main_lon, pole, main_lat);
-
-    return raw_path;
+void SGBucket::set_bucket(const SGGeod& geod)
+{
+    set_bucket(geod.getLongitudeDeg(), geod.getLatitudeDeg());
 }

-std::string SGBucket::gen_vpb_subtile(int level, int x, int y) const {
-    // long int index;
-    int top_lon, top_lat, main_lon, main_lat;
-    char hem, pole;
-    char raw_path[256];
-
-    top_lon = lon / 10;
-    main_lon = lon;
-    if ( (lon < 0) && (top_lon * 10 != lon) ) {
-	top_lon -= 1;
-    }
-    top_lon *= 10;
-    if ( top_lon >= 0 ) {
-	hem = 'e';
-    } else {
-	hem = 'w';
-	top_lon *= -1;
-    }
-    if ( main_lon < 0 ) {
-	main_lon *= -1;
-    }
-    
-    top_lat = lat / 10;
-    main_lat = lat;
-    if ( (lat < 0) && (top_lat * 10 != lat) ) {
-	top_lat -= 1;
-    }
-    top_lat *= 10;
-    if ( top_lat >= 0 ) {
-	pole = 'n';
-    } else {
-	pole = 's';
-	top_lat *= -1;
-    }
-    if ( main_lat < 0 ) {
-	main_lat *= -1;
-    }
-
-    ::snprintf(raw_path, 256, "%c%03d%c%02d/%c%03d%c%02d/ws_%c%03d%c%02d_root_L0_X0_Y0/ws_%c%03d%c%02d_L%d_X%d_Y%d_subtile",
-	    hem, top_lon, pole, top_lat, 
-	    hem, main_lon, pole, main_lat,
-        hem, main_lon, pole, main_lat,
-        hem, main_lon, pole, main_lat,
-        level, x, y);
-
-    return raw_path;
-}
 // Build the path name for this bucket
 std::string SGBucket::gen_base_path() const {
    // long int index;
@@ -316,16 +212,29 @@ std::string SGBucket::gen_base_path() const {
 	main_lat *= -1;
    }

-    ::snprintf(raw_path, 256, "%c%03d%c%02d/%c%03d%c%02d",
+    sprintf(raw_path, "%c%03d%c%02d/%c%03d%c%02d", 
 	    hem, top_lon, pole, top_lat, 
 	    hem, main_lon, pole, main_lat);

-    return raw_path;
+    SGPath path( raw_path );
+
+    return path.str();
 }


 // return width of the tile in degrees
 double SGBucket::get_width() const {
+    if (lon==-180 && (lat==-89 || lat==88) ) {
+        /* Normally the tile at 180W in 88N and 89S
+         * would cover 184W to 176W and the next
+         * on the east side starts at 176W.
+         * To correct, make this a special tile
+         * from 180W to 176W with 4 degrees width
+         * instead of the normal 8 degrees at
+         * that latitude.
+         */
+         return 4.0;
+    }
    return sg_bucket_span( get_center_lat() );
 }

@@ -335,32 +244,17 @@ double SGBucket::get_height() const {
    return SG_BUCKET_SPAN;
 }

-double SGBucket::get_highest_lat() const
-{
-    unsigned char adjustedY = y;
-    if (lat >= 0) {
-        // tile is north of the equator, so we want the top edge. Add one
-        // to y to achieve this.
-        ++adjustedY;
+
+// return width of the tile in meters
+double SGBucket::get_width_m() const {
+    double clat = (int)get_center_lat();
+    if ( clat > 0 ) {
+	clat = (int)clat + 0.5;
+    } else {
+	clat = (int)clat - 0.5;
    }
-    
-	return lat + (adjustedY / 8.0);
-}
-
-
-// return width of the tile in meters. This function is used by the
-// tile-manager to estimate how many tiles are in the view distance, so
-// we care about the smallest width, which occurs at the highest latitude.
-double SGBucket::get_width_m() const
-{
-    double clat_rad = get_highest_lat() * SGD_DEGREES_TO_RADIANS;
+    double clat_rad = clat * SGD_DEGREES_TO_RADIANS;
    double cos_lat = cos( clat_rad );
-    if (fabs(cos_lat) < SG_EPSILON) {
-        // happens for polar tiles, since we pass in a latitude of 90
-        // return an arbitrary small value so all tiles are loaded
-        return 10.0;
-    }
-    
    double local_radius = cos_lat * SG_EQUATORIAL_RADIUS_M;
    double local_perimeter = local_radius * SGD_2PI;
    double degree_width = local_perimeter / 360.0;
@@ -377,89 +271,7 @@ double SGBucket::get_height_m() const {
    return SG_BUCKET_SPAN * degree_height;
 }

-unsigned int SGBucket::siblings( int dx, int dy, std::vector<SGBucket>& buckets ) const 
-{
-    if (!isValid()) {
-        SG_LOG(SG_TERRAIN, SG_WARN, "SGBucket::sibling: requesting sibling of invalid bucket");
-        return 0;
-    }
-    
-    double src_span = sg_bucket_span( get_center_lat() );
-   
-    double clat = get_center_lat() + dy * SG_BUCKET_SPAN;
-    // return invalid here instead of clipping, so callers can discard
-    // invalid buckets without having to check if it's an existing one
-    if ((clat < -90.0) || (clat > 90.0)) {
-        return 0;
-    }
-    
-    // find the lon span for the new latitude
-    double trg_span = sg_bucket_span( clat );
-    
-    // if target span < src_span, return multiple buckets...
-    if ( trg_span < src_span ) {
-        // calc center longitude of westernmost sibling
-        double start_lon = get_center_lat() - src_span/2 + trg_span/2;
-        
-        unsigned int num_buckets = src_span/trg_span;
-        for ( unsigned int x = 0; x < num_buckets; x++ ) {
-            double tmp = start_lon + x * trg_span;
-            tmp = SGMiscd::normalizePeriodic(-180.0, 180.0, tmp);
-            
-            SGBucket b;
-            b.innerSet(tmp, clat);
-            
-            buckets.push_back( b );
-        }
-    } else {
-        // just return the single sibling
-        double tmp = get_center_lon() + dx * trg_span;
-        tmp = SGMiscd::normalizePeriodic(-180.0, 180.0, tmp);
-    
-        SGBucket b;
-        b.innerSet(tmp, clat);
-        
-        buckets.push_back( b );
-    }
-    
-    return buckets.size();
-}

-SGBucket SGBucket::sibling(int dx, int dy) const
-{
-    if (!isValid()) {
-        SG_LOG(SG_TERRAIN, SG_WARN, "SGBucket::sibling: requesting sibling of invalid bucket");
-        return SGBucket();
-    }
-    
-    double clat = get_center_lat() + dy * SG_BUCKET_SPAN;
-    // return invalid here instead of clipping, so callers can discard
-    // invalid buckets without having to check if it's an existing one
-    if ((clat < -90.0) || (clat > 90.0)) {
-        return SGBucket();
-    }
-    
-    // find the lon span for the new latitude
-    double span = sg_bucket_span( clat );
-    
-    double tmp = get_center_lon() + dx * span;
-    tmp = SGMiscd::normalizePeriodic(-180.0, 180.0, tmp);
-    
-    SGBucket b;
-    b.innerSet(tmp, clat);
-    return b;
-}
-
-std::string SGBucket::gen_index_str() const
-{
-	char tmp[20];
-	::snprintf(tmp, 20, "%ld",
-                 (((long)lon + 180) << 14) + ((lat + 90) << 6)
-                 + (y << 3) + x);
-	return (std::string)tmp;
-}
-
-#ifndef NO_DEPRECATED_API
 // find the bucket which is offset by the specified tile units in the
 // X & Y direction.  We need the current lon and lat to resolve
 // ambiguities when going from a wider tile to a narrower one above or
@@ -486,7 +298,7 @@ SGBucket sgBucketOffset( double dlon, double dlat, int dx, int dy ) {

    return result;
 }
-#endif
+

 // calculate the offset between two buckets
 void sgBucketDiff( const SGBucket& b1, const SGBucket& b2, int *dx, int *dy ) {
@@ -544,25 +356,4 @@ void sgBucketDiff( const SGBucket& b1, const SGBucket& b2, int *dx, int *dy ) {
 #endif
 }

-void sgGetBuckets( const SGGeod& min, const SGGeod& max, std::vector<SGBucket>& list ) {
-    double lon, lat, span;
-
-    for (lat = min.getLatitudeDeg(); lat < max.getLatitudeDeg()+SG_BUCKET_SPAN; lat += SG_BUCKET_SPAN) {
-        span = sg_bucket_span( lat );
-        for (lon = min.getLongitudeDeg(); lon <= max.getLongitudeDeg(); lon += span)
-        {
-            SGBucket b(SGGeod::fromDeg(lon, lat));
-            if (!b.isValid()) {
-                continue;
-            }
-            
-            list.push_back(b);
-        }
-    }
-}
-
-std::ostream& operator<< ( std::ostream& out, const SGBucket& b )
-{
-    return out << b.lon << ":" << (int)b.x << ", " << b.lat << ":" << (int)b.y;
-}

--- a/simgear/bucket/newbucket.hxx
+++ b/simgear/bucket/newbucket.hxx
@@ -39,11 +39,9 @@
 #include <simgear/math/SGMath.hxx>

 #include <cmath>
+#include <cstdio> // sprintf()
+#include <ostream>
 #include <string>
-#include <iosfwd>
-#include <vector>
-
-// #define NO_DEPRECATED_API

 /**
 * standard size of a bucket in degrees (1/8 of a degree)
@@ -59,7 +57,9 @@
 // return the horizontal tile span factor based on latitude
 static double sg_bucket_span( double l ) {
    if ( l >= 89.0 ) {
-	return 12.0;
+	return 360.0;
+    } else if ( l >= 88.0 ) {
+	return 8.0;
    } else if ( l >= 86.0 ) {
 	return 4.0;
    } else if ( l >= 83.0 ) {
@@ -80,10 +80,12 @@ static double sg_bucket_span( double l ) {
 	return 1.0;
    } else if ( l >= -86.0 ) {
 	return 2.0;
-    } else if ( l >= -89.0 ) {
+    } else if ( l >= -88.0 ) {
 	return 4.0;
+    } else if ( l >= -89.0 ) {
+	return 8.0;
    } else {
-	return 12.0;
+	return 360.0;
    }
 }

@@ -100,69 +102,75 @@ class SGBucket {
 private:
    short lon;        // longitude index (-180 to 179)
    short lat;        // latitude index (-90 to 89)
-    unsigned char x;          // x subdivision (0 to 7)
-    unsigned char y;          // y subdivision (0 to 7)
+    char x;          // x subdivision (0 to 7)
+    char y;          // y subdivision (0 to 7)

-    void innerSet( double dlon, double dlat );
 public:

    /**
-     * Default constructor, creates an invalid SGBucket
+     * Default constructor.
     */
    SGBucket();

-    /**
-     * Check if this bucket refers to a valid tile, or not.
-     */
-    bool isValid() const;
-    
-#ifndef NO_DEPRECATED_API
    /**
     * Construct a bucket given a specific location.
     * @param dlon longitude specified in degrees
     * @param dlat latitude specified in degrees
     */
    SGBucket(const double dlon, const double dlat);
-#endif
-    
+
    /**
     * Construct a bucket given a specific location.
-     *
-     * @param geod Geodetic location
+     * @param dlon longitude specified in degrees
+     * @param dlat latitude specified in degrees
     */
    SGBucket(const SGGeod& geod);

+    /** Construct a bucket.
+     *  @param is_good if false, create an invalid bucket.  This is
+     *  useful * if you are comparing cur_bucket to last_bucket and
+     *  you want to * make sure last_bucket starts out as something
+     *  impossible.
+     */
+    SGBucket(const bool is_good);
+
    /** Construct a bucket given a unique bucket index number.
-     *
     * @param bindex unique bucket index
     */
    SGBucket(const long int bindex);

-#ifndef NO_DEPRECATED_API
-    /**
-     * Reset a bucket to represent a new location.
-     *
-     * @param geod New geodetic location
-     */
-    void set_bucket(const SGGeod& geod);
-
-
    /**
     * Reset a bucket to represent a new lat and lon
     * @param dlon longitude specified in degrees
     * @param dlat latitude specified in degrees
     */
    void set_bucket( double dlon, double dlat );
-#endif
-    
+
+    /**
+     * Reset a bucket to represent a new lat and lon
+     * @param lonlat an array of double[2] holding lon and lat
+     * (specified) in degrees
+     */
+    void set_bucket( double *lonlat );
+
+    /**
+     * Reset a bucket to represent a new lat and lon
+     * @param dlon longitude specified in degrees
+     * @param dlat latitude specified in degrees
+     */
+    void set_bucket(const SGGeod& geod);
+
    /**
     * Create an impossible bucket.
     * This is useful if you are comparing cur_bucket to last_bucket
     * and you want to make sure last_bucket starts out as something
     * impossible.
     */
-    void make_bad();
-    
+    inline void make_bad() {
+	set_bucket(0.0, 0.0);
+	lon = -1000;
+    }
+
    /**
     * Generate the unique scenery tile index for this bucket
     *
@@ -179,21 +187,7 @@ public:
     * @return tile index
     */
    inline long int gen_index() const {
-	    return ((lon + 180) << 14) + ((lat + 90) << 6) + static_cast<unsigned char>(y << 3) + x;
-    }
-
-    /**
-     * Generate a tile index for this bucket shared with all other buckets with the same lat/lon.
-     * Used as an index for VPB tiles, which are 1x1 in size.
-     *
-     * The index is constructed as follows:
-     * 
-     * 9 bits - to represent 360 degrees of longitude (-180 to 179)
-     * 8 bits - to represent 180 degrees of latitude (-90 to 89)
-     * @return tile index
-     */
-    inline long int gen_vpb_index() const {
-	    return ((lon + 180) << 8) + (lat + 90);
+	return ((lon + 180) << 14) + ((lat + 90) << 6) + (y << 3) + x;
    }

    /**
@@ -201,21 +195,19 @@ public:
     * string form.
     * @return tile index in string form
     */
-    std::string gen_index_str() const;
-    
-    /**
-     * Build the base path name for this bucket.
-     * @return base path in string form
-     */
-    std::string gen_base_path() const;
+    inline std::string gen_index_str() const {
+	char tmp[20];
+	std::sprintf(tmp, "%ld", 
+                     (((long)lon + 180) << 14) + ((lat + 90) << 6)
+                     + (y << 3) + x);
+	return (std::string)tmp;
+    }

    /**
     * Build the base path name for this bucket.
     * @return base path in string form
     */
-    std::string gen_vpb_base() const;
-    std::string gen_vpb_base_alt() const;
-    std::string gen_vpb_subtile(int level, int x, int y) const;
+    std::string gen_base_path() const;

    /**
     * @return the center lon of a tile.
@@ -237,13 +229,6 @@ public:
 	return lat + y / 8.0 + SG_HALF_BUCKET_SPAN;
    }

-    /**
-     * @return the highest (furthest from the equator) latitude of this
-     * tile. This is the top edge for tiles north of the equator, and
-     * the bottom edge for tiles south
-     */
-    double get_highest_lat() const;
-    
    /**
     * @return the width of the tile in degrees.
     */
@@ -305,16 +290,6 @@ public:
     */
    inline int get_y() const { return y; }

-    /**
-     * @return bucket offset from this by dx,dy
-     */
-    SGBucket sibling(int dx, int dy) const;
-    
-    /**
-     * @return multiple buckets offset from this by dx,dy
-     */
-    unsigned int siblings(int dz, int dy, std::vector<SGBucket>& buckets) const;
-    
    // friends

    friend std::ostream& operator<< ( std::ostream&, const SGBucket& );
@@ -326,7 +301,7 @@ inline bool operator!= (const SGBucket& lhs, const SGBucket& rhs)
        return !(lhs == rhs);
    }

-#ifndef NO_DEPRECATED_API
+
 /**
 * \relates SGBucket
 * Return the bucket which is offset from the specified dlon, dlat by
@@ -338,7 +313,6 @@ inline bool operator!= (const SGBucket& lhs, const SGBucket& rhs)
 * @return offset bucket
 */
 SGBucket sgBucketOffset( double dlon, double dlat, int x, int y );
-#endif


 /**
@@ -352,21 +326,17 @@ SGBucket sgBucketOffset( double dlon, double dlat, int x, int y );
 void sgBucketDiff( const SGBucket& b1, const SGBucket& b2, int *dx, int *dy );


-/**
- * \relates SGBucket
- * retrieve a list of buckets in the given bounding box
- * @param min min lon,lat of bounding box in degrees
- * @param max max lon,lat of bounding box in degrees
- * @param list standard vector of buckets within the bounding box
- */
-void sgGetBuckets( const SGGeod& min, const SGGeod& max, std::vector<SGBucket>& list );
-
 /**
 * Write the bucket lon, lat, x, and y to the output stream.
 * @param out output stream
 * @param b bucket
 */
-std::ostream& operator<< ( std::ostream& out, const SGBucket& b );
+inline std::ostream&
+operator<< ( std::ostream& out, const SGBucket& b )
+{
+    return out << b.lon << ":" << (int)b.x << ", " << b.lat << ":" << (int)b.y;
+}
+

 /**
 * Compare two bucket structures for equality.
--- a/simgear/bucket/test_bucket.cxx
+++ b/simgear/bucket/test_bucket.cxx
@@ -1,362 +0,0 @@
-/**************************************************************************
- * test_bucket.cxx -- unit-tests for SGBucket class
- *
- * Copyright (C) 2014  James Turner - <zakalawe@mac.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Id$
- **************************************************************************/
-
-#include <simgear/compiler.h>
-
-#include <iostream>
-#include <cstdlib>
-#include <cstring>
-
-using std::cout;
-using std::cerr;
-using std::endl;
-
-#include <simgear/bucket/newbucket.hxx>
-#include <simgear/misc/test_macros.hxx>
-
-void testBucketSpans()
-{
-    SG_CHECK_EQUAL(sg_bucket_span(0.0), 0.125);
-    SG_CHECK_EQUAL(sg_bucket_span(-20), 0.125);
-    SG_CHECK_EQUAL(sg_bucket_span(-40), 0.25);
-    SG_CHECK_EQUAL(sg_bucket_span(89.9), 12.0);
-    SG_CHECK_EQUAL(sg_bucket_span(88.1), 4.0);
-    SG_CHECK_EQUAL(sg_bucket_span(-89.9), 12.0);
-}
-
-void testBasic()
-{
-    SGBucket b1(5.1, 55.05);
-    SG_CHECK_EQUAL(b1.get_chunk_lon(), 5);
-    SG_CHECK_EQUAL(b1.get_chunk_lat(), 55);
-    SG_CHECK_EQUAL(b1.get_x(), 0);
-    SG_CHECK_EQUAL(b1.get_y(), 0);
-    SG_CHECK_EQUAL(b1.gen_index(), 3040320);
-    SG_CHECK_EQUAL(b1.gen_base_path(), "e000n50/e005n55");
-    SG_VERIFY(b1.isValid());
-
-    SGBucket b2(-10.1, -43.8);
-    SG_CHECK_EQUAL(b2.get_chunk_lon(), -11);
-    SG_CHECK_EQUAL(b2.get_chunk_lat(), -44);
-    SG_CHECK_EQUAL(b2.get_x(), 3);
-    // Latitude chunks numbered bottom to top, it seems
-    SG_CHECK_EQUAL(b2.get_y(), 1);
-    SG_CHECK_EQUAL(b2.gen_base_path(), "w020s50/w011s44");
-    SG_VERIFY(b2.isValid());
-
-    SGBucket b3(123.48, 9.01);
-    SG_CHECK_EQUAL(b3.get_chunk_lon(), 123);
-    SG_CHECK_EQUAL(b3.get_chunk_lat(), 9);
-    SG_CHECK_EQUAL(b3.get_x(), 3);
-    SG_CHECK_EQUAL(b3.get_y(), 0);
-    SG_CHECK_EQUAL(b3.gen_base_path(), "e120n00/e123n09");
-    SG_VERIFY(b3.isValid());
-
-    SGBucket defBuck;
-    SG_VERIFY(!defBuck.isValid());
-
-    b3.make_bad();
-    SG_VERIFY(!b3.isValid());
-
-    SGBucket atAntiMeridian(180.0, 12.3);
-    SG_VERIFY(atAntiMeridian.isValid());
-    SG_CHECK_EQUAL(atAntiMeridian.get_chunk_lon(), -180);
-    SG_CHECK_EQUAL(atAntiMeridian.get_x(), 0);
-
-    SGBucket atAntiMeridian2(-180.0, -78.1);
-    SG_VERIFY(atAntiMeridian2.isValid());
-    SG_CHECK_EQUAL(atAntiMeridian2.get_chunk_lon(), -180);
-    SG_CHECK_EQUAL(atAntiMeridian2.get_x(), 0);
-
-    // check comparison operator overload
-    SGBucket b4(5.11, 55.1);
-    SG_VERIFY(b1 == b4); // should be equal
-    SG_VERIFY(b1 == b1);
-    SG_VERIFY(b1 != defBuck);
-    SG_VERIFY(b1 != b2);
-
-    // check wrapping/clipping of inputs
-    SGBucket wrapMeridian(-200.0, 45.0);
-    SG_CHECK_EQUAL(wrapMeridian.get_chunk_lon(), 160);
-
-    SGBucket clipPole(48.9, 91);
-    SG_CHECK_EQUAL(clipPole.get_chunk_lat(), 89);
-
-    // test override of a bucket's geod
-    auto geod = SGGeod::fromDegFt(-86.678, 36.1248, 599.0);
-#ifndef NO_DEPRECATED_API
-    SGBucket bna_airport;
-    bna_airport.set_bucket(geod);
-#else
-    SGBucket bna_airport(geod);
-#endif
-    SG_VERIFY(bna_airport.isValid());
-    SG_CHECK_EQUAL(bna_airport.get_chunk_lon(), -87);           // left origin of the 1-degree chunk
-    SG_CHECK_EQUAL(bna_airport.get_chunk_lat(), 36);            // bottom origin of the 1-degree chunk
-    SG_CHECK_EQUAL(bna_airport.get_x(), 1);                     // buckets are 0.25 deg wide at the W87 parallel
-                                                                //   we're 0.322 deg from the origin (second bucket)
-    SG_CHECK_EQUAL(bna_airport.get_y(), 0);                     // buckets are always 0.125 deg tall
-                                                                //   we're 0.1248 deg from the origin (first bucket)
-    SG_CHECK_EQUAL(bna_airport.gen_base_path(), "w090n30/w087n36");
-    SG_CHECK_EQUAL_EP2(bna_airport.get_width_m(), 22479.1, 0.1);
-    SG_CHECK_EQUAL_EP2(bna_airport.get_height_m(), 13914.9, 0.1);
-    SG_CHECK_EQUAL(bna_airport.gen_index_str(), "1531777");     // 0x175F81 = b01011101|01111110|000|001
-                                                                //          =   93-180 | 126-90 | 0 | 1
-                                                                //          =      -87 |     36 | 0 | 1
-
-    // test stream output
-    cout << "[TEST] BNA Airport: " << bna_airport << endl;
-    auto center = bna_airport.get_center();
-    cout << "[TEST] BNA lon: " << center.getLongitudeDeg() << endl;
-    cout << "[TEST] BNA lat: " << center.getLatitudeDeg() << endl;
-}
-
-void testPolar()
-{
-    SGBucket b1(0.0, 89.92);
-    SGBucket b2(10.0, 89.96);
-    SG_CHECK_EQUAL(b1.get_chunk_lat(), 89);
-    SG_CHECK_EQUAL(b1.get_chunk_lon(), 0);
-    SG_CHECK_EQUAL(b1.get_x(), 0);
-    SG_CHECK_EQUAL(b1.get_y(), 7);
-
-    SG_CHECK_EQUAL_EP(b1.get_highest_lat(), 90.0);
-    SG_CHECK_EQUAL_EP(b1.get_width_m(), 10.0);
-
-    SG_CHECK_EQUAL(b2.get_chunk_lat(), 89);
-    SG_CHECK_EQUAL(b2.get_chunk_lon(), 0);
-    SG_CHECK_EQUAL(b2.get_x(), 0);
-    SG_CHECK_EQUAL(b2.get_y(), 7);
-
-    SG_CHECK_EQUAL(b1.gen_index(), b2.gen_index());
-
-    SGGeod actualNorthPole1 = b1.get_corner(2);
-    SGGeod actualNorthPole2 = b1.get_corner(3);
-    SG_CHECK_EQUAL_EP(actualNorthPole1.getLatitudeDeg(), 90.0);
-    SG_CHECK_EQUAL_EP(actualNorthPole1.getLongitudeDeg(), 12.0);
-    SG_CHECK_EQUAL_EP(actualNorthPole2.getLatitudeDeg(), 90.0);
-    SG_CHECK_EQUAL_EP(actualNorthPole2.getLongitudeDeg(), 0.0);
-
-    SGBucket b3(-2, 89.88);
-    SGBucket b4(-7, 89.88);
-    SG_CHECK_EQUAL(b3.gen_index(), b4.gen_index());
-
-    // south pole
-    SGBucket b5(-170, -89.88);
-    SGBucket b6(-179, -89.88);
-
-    SG_CHECK_EQUAL(b5.get_chunk_lat(), -90);
-    SG_CHECK_EQUAL(b5.get_chunk_lon(), -180);
-    SG_CHECK_EQUAL(b5.get_x(), 0);
-    SG_CHECK_EQUAL(b5.get_y(), 0);
-    SG_CHECK_EQUAL(b5.gen_index(), b6.gen_index());
-    SG_CHECK_EQUAL_EP(b5.get_highest_lat(), -90.0);
-    SG_CHECK_EQUAL_EP(b5.get_width_m(), 10.0);
-
-    SGGeod actualSouthPole1 = b5.get_corner(0);
-    SGGeod actualSouthPole2 = b5.get_corner(1);
-    SG_CHECK_EQUAL_EP(actualSouthPole1.getLatitudeDeg(), -90.0);
-    SG_CHECK_EQUAL_EP(actualSouthPole1.getLongitudeDeg(), -180);
-    SG_CHECK_EQUAL_EP(actualSouthPole2.getLatitudeDeg(), -90.0);
-    SG_CHECK_EQUAL_EP(actualSouthPole2.getLongitudeDeg(), -168);
-
-    SGBucket b7(200, 89.88);
-    SG_CHECK_EQUAL(b7.get_chunk_lon(), -168);
-}
-
-// test the tiles just below the pole (between 86 & 89 degrees N/S)
-void testNearPolar()
-{
-    SGBucket b1(1, 88.5);
-    SGBucket b2(-1, 88.8);
-    SG_CHECK_EQUAL(b1.get_chunk_lon(), 0);
-    SG_CHECK_EQUAL(b1.get_chunk_lat(), 88);
-    SG_VERIFY(b1.gen_index() != b2.gen_index());
-
-    SGBucket b3(176.1, 88.5);
-    SG_CHECK_EQUAL(b3.get_chunk_lon(), 176);
-
-    SGBucket b4(-178, 88.5);
-    SG_CHECK_EQUAL(b4.get_chunk_lon(), -180);
-}
-
-void testOffset()
-{
-    // bucket just below the 22 degree cutoff, so the next tile north
-    // is twice the width
-    SGBucket b1(-59.8, 21.9);
-    SG_CHECK_EQUAL(b1.get_chunk_lat(), 21);
-    SG_CHECK_EQUAL(b1.get_chunk_lon(), -60);
-    SG_CHECK_EQUAL(b1.get_x(), 1);
-    SG_CHECK_EQUAL(b1.get_y(), 7);
-
-    // offset vertically
-    SGBucket b2(b1.sibling(0, 1));
-    SG_CHECK_EQUAL(b2.get_chunk_lat(), 22);
-    SG_CHECK_EQUAL(b2.get_chunk_lon(), -60);
-    SG_CHECK_EQUAL(b2.get_x(), 0);
-    SG_CHECK_EQUAL(b2.get_y(), 0);
-
-    SG_CHECK_EQUAL(b2.gen_index(), sgBucketOffset(-59.8, 21.9, 0, 1));
-
-    // offset vertically and horizontally. We compute horizontal (x)
-    // movement at the target latitude, so this should move 0.25 * -3 degrees,
-    // NOT 0.125 * -3 degrees.
-    SGBucket b3(b1.sibling(-3, 1));
-    SG_CHECK_EQUAL(b3.get_chunk_lat(), 22);
-    SG_CHECK_EQUAL(b3.get_chunk_lon(), -61);
-    SG_CHECK_EQUAL(b3.get_x(), 1);
-    SG_CHECK_EQUAL(b3.get_y(), 0);
-
-    SG_CHECK_EQUAL(b3.gen_index(), sgBucketOffset(-59.8, 21.9, -3, 1));
-}
-
-void testPolarOffset()
-{
-    SGBucket b1(-11.7, -89.6);
-    SG_CHECK_EQUAL(b1.get_chunk_lat(), -90);
-    SG_CHECK_EQUAL(b1.get_chunk_lon(), -12);
-    SG_CHECK_EQUAL(b1.get_x(), 0);
-    SG_CHECK_EQUAL(b1.get_y(), 3);
-
-    // offset horizontally
-    SGBucket b2(b1.sibling(-2, 0));
-    SG_CHECK_EQUAL(b2.get_chunk_lat(), -90);
-    SG_CHECK_EQUAL(b2.get_chunk_lon(), -36);
-    SG_CHECK_EQUAL(b2.get_x(), 0);
-    SG_CHECK_EQUAL(b2.get_y(), 3);
-
-    SG_CHECK_EQUAL(b2.gen_index(), sgBucketOffset(-11.7, -89.6, -2, 0));
-
-    // offset and wrap
-    SGBucket b3(-170, 89.1);
-    SGBucket b4(b3.sibling(-1, 0));
-    SG_CHECK_EQUAL(b4.get_chunk_lat(), 89);
-    SG_CHECK_EQUAL(b4.get_chunk_lon(), 168);
-    SG_CHECK_EQUAL(b4.get_x(), 0);
-    SG_CHECK_EQUAL(b4.get_y(), 0);
-
-    SG_CHECK_EQUAL(b4.gen_index(), sgBucketOffset(-170, 89.1, -1, 0));
-
-
-    SGBucket b5(177, 87.3);
-    SGBucket b6(b5.sibling(1, 1));
-    SG_CHECK_EQUAL(b6.get_chunk_lat(), 87);
-    SG_CHECK_EQUAL(b6.get_chunk_lon(), -180);
-    SG_CHECK_EQUAL(b6.get_x(), 0);
-    SG_CHECK_EQUAL(b6.get_y(), 3);
-
-    SG_CHECK_EQUAL(b6.gen_index(), sgBucketOffset(177, 87.3, 1, 1));
-
-    // offset vertically towards the pole
-    SGBucket b7(b1.sibling(0, -5));
-    SG_VERIFY(!b7.isValid());
-
-    SG_VERIFY(!SGBucket(0, 90).sibling(0, 1).isValid());
-}
-
-// test behaviour of bucket-offset near the anti-meridian (180-meridian)
-void testOffsetWrap()
-{
-    // near the equator
-    SGBucket b1(-179.8, 16.8);
-    SG_CHECK_EQUAL(b1.get_chunk_lat(), 16);
-    SG_CHECK_EQUAL(b1.get_chunk_lon(), -180);
-    SG_CHECK_EQUAL(b1.get_x(), 1);
-    SG_CHECK_EQUAL(b1.get_y(), 6);
-
-    SGBucket b2(b1.sibling(-2, 0));
-    SG_CHECK_EQUAL(b2.get_chunk_lat(), 16);
-    SG_CHECK_EQUAL(b2.get_chunk_lon(), 179);
-    SG_CHECK_EQUAL(b2.get_x(), 7);
-    SG_CHECK_EQUAL(b2.get_y(), 6);
-    SG_CHECK_EQUAL(b2.gen_index(), sgBucketOffset(-179.8, 16.8, -2, 0));
-}
-
-void testSiblings()
-{
-    SGBucket bna_airport(-86.678, 36.1248);
-    SG_VERIFY(bna_airport.isValid());
-
-    // retrieve the sibling two positions north-east of my position
-    auto sib1 = bna_airport.sibling(2, 2);
-    SG_CHECK_EQUAL(sib1.get_chunk_lon(), bna_airport.get_chunk_lon());
-    SG_CHECK_EQUAL(sib1.get_chunk_lat(), bna_airport.get_chunk_lat());
-    SG_CHECK_EQUAL(sib1.get_x(), 3);        // my x-pos (1) + 2 = 3
-    SG_CHECK_EQUAL(sib1.get_y(), 2);        // my y-pos (0) + 2 = 2
-    SG_CHECK_EQUAL(sib1.gen_base_path(), bna_airport.gen_base_path());
-
-    // retrieve the one sibling two positions to the north-east
-    std::vector<SGBucket> siblings;
-    bna_airport.siblings(2, 2, siblings);
-    SG_CHECK_EQUAL(siblings.size(), static_cast<std::vector<SGBucket>::size_type>(1));
-    siblings.clear();
-
-    // retrieve the one sibling at the chunk origin of sib1
-    sib1.siblings(-2, -2, siblings);
-    SG_CHECK_EQUAL(siblings.size(), static_cast<std::vector<SGBucket>::size_type>(1));
-    siblings.clear();
-
-    // calculate delta between two buckets
-    int dx = 0;
-    int dy = 0;
-    sgBucketDiff(bna_airport, sib1, &dx, &dy);
-    SG_CHECK_EQUAL(dx, 2);
-    SG_CHECK_EQUAL(dy, 2);
-
-    // retrieve all siblings between two geodetic locations
-    auto geod_bna = SGGeod::fromDegFt(-86.678, 36.1248, 599.0);
-    auto geod_m54 = SGGeod::fromDegFt(-86.317, 36.1908, 122.0);
-    sgGetBuckets(geod_bna, geod_m54, siblings);
-    SG_CHECK_EQUAL(siblings.size(), static_cast<std::vector<SGBucket>::size_type>(4));
-    siblings.clear();
-
-    // edge cases
-
-    // ensure you cannot retrieve the sibling of an invalid bucket
-    SGBucket bad;
-    auto bad_sib = bad.sibling(1, 1);
-    SG_CHECK_EQUAL(bad_sib.get_chunk_lon(), -1000);
-    SG_CHECK_EQUAL(bad.siblings(2, 2, siblings), 0);
-
-    // if we drop below the 22nd parallel, the bucket widths are half the size
-    // expect this to retrieve two buckets
-    bna_airport.siblings(0, -160, siblings);
-    SG_CHECK_EQUAL(siblings.size(), static_cast<std::vector<SGBucket>::size_type>(2));
-    siblings.clear();
-}
-
-int main(int argc, char* argv[])
-{
-    testBucketSpans();
-
-    testBasic();
-    testPolar();
-    testNearPolar();
-    testOffset();
-    testOffsetWrap();
-    testPolarOffset();
-    testSiblings();
-
-    cout << "all tests passed OK" << endl;
-    return 0; // passed
-}
--- a/simgear/bvh/BVHMaterial.hxx
+++ b/simgear/bvh/BVHMaterial.hxx
@@ -1,90 +0,0 @@
-// Copyright (C) 2008 - 2021  Mathias Froehlich - Mathias.Froehlich@web.de
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Library General Public
-// License as published by the Free Software Foundation; either
-// version 2 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// Library General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-//
-
-#ifndef BVHMaterial_hxx
-#define BVHMaterial_hxx
-
-#include <simgear/structure/SGReferenced.hxx>
-#include <simgear/props/props.hxx>
-
-#include <cstdio>
-
-namespace simgear {
-
-class BVHMaterial : public SGReferenced {
-public:
-    BVHMaterial() = default;
-    virtual ~BVHMaterial() = default;
-
-    /**
-     * Return if the surface material is solid, if it is not solid, a fluid
-     * can be assumed, that is usually water.
-     */
-    bool get_solid () const {
-      return _solid_is_prop ? _solid_property->getBoolValue() : _solid;
-    }
-
-    /**
-     * Return whether the solid factor is a propery.
-     */
-    bool solid_is_prop () const { return _solid_is_prop; }
-    
-    /**
-     * Get the friction factor for that material
-     */
-    double get_friction_factor () const { return _friction_factor; }
-    
-    /**
-     * Get the rolling friction for that material
-     */
-    double get_rolling_friction () const { return _rolling_friction; }
-    
-    /**
-     * Get the bumpines for that material
-     */
-    double get_bumpiness () const { return _bumpiness; }
-    
-    /**
-     * Get the load resistance
-     */
-    double get_load_resistance () const { return _load_resistance; }
-
-protected:    
-    // True if the material is solid, false if it is a fluid
-    bool _solid = true;
-    
-    // the friction factor of that surface material
-    double _friction_factor = 1.0;
-    
-    // the rolling friction of that surface material
-    double _rolling_friction = 0.02;
-    
-    // the bumpiness of that surface material
-    double _bumpiness = 0.0;
-    
-    // the load resistance of that surface material
-    double _load_resistance = 1e30;
-
-    // Placeholder for the solid property, if defined
-    SGPropertyNode_ptr _solid_property;
-    bool _solid_is_prop = false;
-};
-
-
-}
-
-#endif
--- a/simgear/bvh/BVHPageNode.hxx
+++ b/simgear/bvh/BVHPageNode.hxx
@@ -1,66 +0,0 @@
-// Copyright (C) 2008 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Library General Public
-// License as published by the Free Software Foundation; either
-// version 2 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// Library General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-//
-
-#ifndef BVHPageNode_hxx
-#define BVHPageNode_hxx
-
-#include <list>
-
-#include <simgear/structure/SGSharedPtr.hxx>
-
-#include "BVHGroup.hxx"
-#include "BVHVisitor.hxx"
-
-namespace simgear {
-
-class BVHPager;
-class BVHPageRequest;
-
-class BVHPageNode : public BVHGroup {
-public:
-    BVHPageNode();
-    virtual ~BVHPageNode();
-    
-    virtual void accept(BVHVisitor& visitor);
-
-    /// Return the usage stamp of the last access
-    unsigned getUseStamp() const
-    { return _useStamp; }
-
-    virtual SGSphered computeBoundingSphere() const = 0;
-
-    virtual BVHPageRequest* newRequest() = 0;
-
-protected:
-    virtual void invalidateBound() = 0;
-
-    bool getRequested() const
-    { return _requested; }
-    void setRequested(bool requested)
-    { _requested = requested; }
-
-private:
-    friend class BVHPager;
-
-    std::list<SGSharedPtr<BVHPageNode> >::iterator _iterator;
-    unsigned _useStamp;
-    bool _requested;
-};
-
-}
-
-#endif
--- a/simgear/bvh/BVHPageRequest.hxx
+++ b/simgear/bvh/BVHPageRequest.hxx
@@ -1,42 +0,0 @@
-// Copyright (C) 2008 - 2012 Mathias Froehlich - Mathias.Froehlich@web.de
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Library General Public
-// License as published by the Free Software Foundation; either
-// version 2 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// Library General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-//
-
-#ifndef BVHPageRequest_hxx
-#define BVHPageRequest_hxx
-
-#include <simgear/structure/SGReferenced.hxx>
-
-namespace simgear {
-
-class BVHPageNode;
-
-class BVHPageRequest : public SGReferenced {
-public:
-    virtual ~BVHPageRequest();
-
-    /// Happens in the pager thread, do not modify the calling bvh tree
-    virtual void load() = 0;
-    /// Happens in the bvh main thread where the bvh is actually used.
-    /// So inside here it is safe to modify the paged node
-    virtual void insert() = 0;
-    /// The page node this request is for
-    virtual BVHPageNode* getPageNode() = 0;
-};
-
-}
-
-#endif
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
James Turner	2e60af7cc0	Mac changes for Subversion bundling.	2012-08-12 16:59:31 +01:00
James Turner	a7519c9e95	Make dependent template lookups explicit. Clang (in Xcode 4.4) is being strict about dependent lookup rules, so apply the recommended fix-it.	2012-07-31 09:01:42 +01:00