Fix issue #392: mktime takes a localtime as input. Assumption that if HAVE_DAYLIGHT is missing imply that mktime takes a gmt time is wrong (sg_time.cxx, line 482)

Added missing CMake defines for SVN_CLIENT.
Don't detect libsvn without APR.
When installed, enable libsvn support by default (same as for automake).
When enabled, provide libsvn include dir to libtsync.
gitignore temporary CMake files

.gitignore

@@ -1,9 +1,20 @@
-.*
-*~
 Makefile
+Makefile.in
+.deps
+autom4te.cache
+config.guess
+config.log
+config.status
+config.sub
+configure
+depcomp
+install-sh
+missing
+aclocal.m4
+INSTALL
+SimGear.spec
 *.o
 lib*.a
-.*.swp
 cmake_install.cmake
 CMakeFiles
 CMakeCache.txt
@@ -12,9 +23,4 @@ CPackSourceConfig.cmake
 cmake_uninstall.cmake
 CTestTestfile.cmake
 install_manifest.txt
-build*
-Build
-CMakeLists.txt.user
-3rdparty/expat_2.2.6/
-nbproject
-compile_commands.json
+

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)

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()

3rdparty/expat/Expat.COPYING

@@ -1,22 +0,0 @@
-Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
-                               and Clark Cooper
-Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006 Expat maintainers.
-
-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.

3rdparty/expat/ascii.h

@@ -1,123 +0,0 @@
-/*
-                            __  __            _
-                         ___\ \/ /_ __   __ _| |_
-                        / _ \\  /| '_ \ / _` | __|
-                       |  __//  \| |_) | (_| | |_
-                        \___/_/\_\ .__/ \__,_|\__|
-                                 |_| XML parser
-
-   Copyright (c) 1999-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) 2007      Karl Waclawek <karl@waclawek.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.
-*/
-
-#define ASCII_A 0x41
-#define ASCII_B 0x42
-#define ASCII_C 0x43
-#define ASCII_D 0x44
-#define ASCII_E 0x45
-#define ASCII_F 0x46
-#define ASCII_G 0x47
-#define ASCII_H 0x48
-#define ASCII_I 0x49
-#define ASCII_J 0x4A
-#define ASCII_K 0x4B
-#define ASCII_L 0x4C
-#define ASCII_M 0x4D
-#define ASCII_N 0x4E
-#define ASCII_O 0x4F
-#define ASCII_P 0x50
-#define ASCII_Q 0x51
-#define ASCII_R 0x52
-#define ASCII_S 0x53
-#define ASCII_T 0x54
-#define ASCII_U 0x55
-#define ASCII_V 0x56
-#define ASCII_W 0x57
-#define ASCII_X 0x58
-#define ASCII_Y 0x59
-#define ASCII_Z 0x5A
-
-#define ASCII_a 0x61
-#define ASCII_b 0x62
-#define ASCII_c 0x63
-#define ASCII_d 0x64
-#define ASCII_e 0x65
-#define ASCII_f 0x66
-#define ASCII_g 0x67
-#define ASCII_h 0x68
-#define ASCII_i 0x69
-#define ASCII_j 0x6A
-#define ASCII_k 0x6B
-#define ASCII_l 0x6C
-#define ASCII_m 0x6D
-#define ASCII_n 0x6E
-#define ASCII_o 0x6F
-#define ASCII_p 0x70
-#define ASCII_q 0x71
-#define ASCII_r 0x72
-#define ASCII_s 0x73
-#define ASCII_t 0x74
-#define ASCII_u 0x75
-#define ASCII_v 0x76
-#define ASCII_w 0x77
-#define ASCII_x 0x78
-#define ASCII_y 0x79
-#define ASCII_z 0x7A
-
-#define ASCII_0 0x30
-#define ASCII_1 0x31
-#define ASCII_2 0x32
-#define ASCII_3 0x33
-#define ASCII_4 0x34
-#define ASCII_5 0x35
-#define ASCII_6 0x36
-#define ASCII_7 0x37
-#define ASCII_8 0x38
-#define ASCII_9 0x39
-
-#define ASCII_TAB 0x09
-#define ASCII_SPACE 0x20
-#define ASCII_EXCL 0x21
-#define ASCII_QUOT 0x22
-#define ASCII_AMP 0x26
-#define ASCII_APOS 0x27
-#define ASCII_MINUS 0x2D
-#define ASCII_PERIOD 0x2E
-#define ASCII_COLON 0x3A
-#define ASCII_SEMI 0x3B
-#define ASCII_LT 0x3C
-#define ASCII_EQUALS 0x3D
-#define ASCII_GT 0x3E
-#define ASCII_LSQB 0x5B
-#define ASCII_RSQB 0x5D
-#define ASCII_UNDERSCORE 0x5F
-#define ASCII_LPAREN 0x28
-#define ASCII_RPAREN 0x29
-#define ASCII_FF 0x0C
-#define ASCII_SLASH 0x2F
-#define ASCII_HASH 0x23
-#define ASCII_PIPE 0x7C
-#define ASCII_COMMA 0x2C

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,

3rdparty/expat/expat_config_cmake.in

@@ -1,49 +0,0 @@
-
-#ifndef EXPAT_CONFIG_H
-#define EXPAT_CONFIG_H
-
-#cmakedefine HAVE_WINDOWS_H
-
-#ifdef HAVE_WINDOWS_H
-    #define WIN32_LEAN_AND_MEAN
-    #include <windows.h>
-    #undef WIN32_LEAN_AND_MEAN
-#endif
-
-#cmakedefine HAVE_GETRANDOM
-#cmakedefine XML_DEV_URANDOM
-
-// we can assume > 10.7 macOS so always set this
-#ifdef __APPLE__
-    #define HAVE_ARC4RANDOM_BUF
-#endif
-
-/* 1234 = LIL_ENDIAN, 4321 = BIGENDIAN */
-#define BYTEORDER  1234
-
-/* Define to 1 if you have the `bcopy' function. */
-#cmakedefine HAVE_BCOPY
-
-/* Define to 1 if you have the `memmove' function. */
-#define HAVE_MEMMOVE
-
-/* Define to 1 if you have a working `mmap' system call. */
-#cmakedefine HAVE_MMAP
-
-/* Define to 1 if you have the <unistd.h> header file. */
-#cmakedefine HAVE_UNISTD_H
-
-/* whether byteorder is bigendian */
-#undef WORDS_BIGENDIAN
-
-/* Define to specify how much context to retain around the current parse
-   point. */
-#define XML_CONTEXT_BYTES 1024
-
-/* Define to make parameter entity parsing functionality available. */
-#define XML_DTD
-
-/* Define to make XML Namespaces functionality available. */
-#define XML_NS
-
-#endif /* ifndef EXPAT_CONFIG_H */

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,

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

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,

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,
-};

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 */

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 */

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,

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 */

3rdparty/expat/xmlrole.h

@@ -1,142 +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      Karl Waclawek <karl@waclawek.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.
-*/
-
-#ifndef XmlRole_INCLUDED
-#define XmlRole_INCLUDED 1
-
-#ifdef __VMS
-/*      0        1         2         3      0        1         2         3
-        1234567890123456789012345678901     1234567890123456789012345678901 */
-#  define XmlPrologStateInitExternalEntity XmlPrologStateInitExternalEnt
-#endif
-
-#include "xmltok.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-enum {
-  XML_ROLE_ERROR = -1,
-  XML_ROLE_NONE = 0,
-  XML_ROLE_XML_DECL,
-  XML_ROLE_INSTANCE_START,
-  XML_ROLE_DOCTYPE_NONE,
-  XML_ROLE_DOCTYPE_NAME,
-  XML_ROLE_DOCTYPE_SYSTEM_ID,
-  XML_ROLE_DOCTYPE_PUBLIC_ID,
-  XML_ROLE_DOCTYPE_INTERNAL_SUBSET,
-  XML_ROLE_DOCTYPE_CLOSE,
-  XML_ROLE_GENERAL_ENTITY_NAME,
-  XML_ROLE_PARAM_ENTITY_NAME,
-  XML_ROLE_ENTITY_NONE,
-  XML_ROLE_ENTITY_VALUE,
-  XML_ROLE_ENTITY_SYSTEM_ID,
-  XML_ROLE_ENTITY_PUBLIC_ID,
-  XML_ROLE_ENTITY_COMPLETE,
-  XML_ROLE_ENTITY_NOTATION_NAME,
-  XML_ROLE_NOTATION_NONE,
-  XML_ROLE_NOTATION_NAME,
-  XML_ROLE_NOTATION_SYSTEM_ID,
-  XML_ROLE_NOTATION_NO_SYSTEM_ID,
-  XML_ROLE_NOTATION_PUBLIC_ID,
-  XML_ROLE_ATTRIBUTE_NAME,
-  XML_ROLE_ATTRIBUTE_TYPE_CDATA,
-  XML_ROLE_ATTRIBUTE_TYPE_ID,
-  XML_ROLE_ATTRIBUTE_TYPE_IDREF,
-  XML_ROLE_ATTRIBUTE_TYPE_IDREFS,
-  XML_ROLE_ATTRIBUTE_TYPE_ENTITY,
-  XML_ROLE_ATTRIBUTE_TYPE_ENTITIES,
-  XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN,
-  XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS,
-  XML_ROLE_ATTRIBUTE_ENUM_VALUE,
-  XML_ROLE_ATTRIBUTE_NOTATION_VALUE,
-  XML_ROLE_ATTLIST_NONE,
-  XML_ROLE_ATTLIST_ELEMENT_NAME,
-  XML_ROLE_IMPLIED_ATTRIBUTE_VALUE,
-  XML_ROLE_REQUIRED_ATTRIBUTE_VALUE,
-  XML_ROLE_DEFAULT_ATTRIBUTE_VALUE,
-  XML_ROLE_FIXED_ATTRIBUTE_VALUE,
-  XML_ROLE_ELEMENT_NONE,
-  XML_ROLE_ELEMENT_NAME,
-  XML_ROLE_CONTENT_ANY,
-  XML_ROLE_CONTENT_EMPTY,
-  XML_ROLE_CONTENT_PCDATA,
-  XML_ROLE_GROUP_OPEN,
-  XML_ROLE_GROUP_CLOSE,
-  XML_ROLE_GROUP_CLOSE_REP,
-  XML_ROLE_GROUP_CLOSE_OPT,
-  XML_ROLE_GROUP_CLOSE_PLUS,
-  XML_ROLE_GROUP_CHOICE,
-  XML_ROLE_GROUP_SEQUENCE,
-  XML_ROLE_CONTENT_ELEMENT,
-  XML_ROLE_CONTENT_ELEMENT_REP,
-  XML_ROLE_CONTENT_ELEMENT_OPT,
-  XML_ROLE_CONTENT_ELEMENT_PLUS,
-  XML_ROLE_PI,
-  XML_ROLE_COMMENT,
-#ifdef XML_DTD
-  XML_ROLE_TEXT_DECL,
-  XML_ROLE_IGNORE_SECT,
-  XML_ROLE_INNER_PARAM_ENTITY_REF,
-#endif /* XML_DTD */
-  XML_ROLE_PARAM_ENTITY_REF
-};
-
-typedef struct prolog_state {
-  int(PTRCALL *handler)(struct prolog_state *state, int tok, const char *ptr,
-                        const char *end, const ENCODING *enc);
-  unsigned level;
-  int role_none;
-#ifdef XML_DTD
-  unsigned includeLevel;
-  int documentEntity;
-  int inEntityValue;
-#endif /* XML_DTD */
-} PROLOG_STATE;
-
-void XmlPrologStateInit(PROLOG_STATE *);
-#ifdef XML_DTD
-void XmlPrologStateInitExternalEntity(PROLOG_STATE *);
-#endif /* XML_DTD */
-
-#define XmlTokenRole(state, tok, ptr, end, enc)                                \
-  (((state)->handler)(state, tok, ptr, end, enc))
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* not XmlRole_INCLUDED */

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 */

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>

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 */

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()

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()

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!

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)

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.

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.

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?

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

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

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
-}

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).

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;
-}

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;
-}

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

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 */

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.

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;
-}

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 */

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

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));
-}

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);
-}

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 */

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;
-}

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;
-}

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);
-}

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;
-}

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;
-}

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);
-}

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);
-}

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);
-}

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));
-}

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);
-}

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);
-}

CMakeLists.txt

@@ -1,400 +1,139 @@
-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)
 include (CheckFunctionExists)
 include (CheckIncludeFile)
-include (CheckLibraryExists)
 include (CheckCXXSourceCompiles)
-include (CheckCXXCompilerFlag)
-include (GenerateExportHeader)
+include (CPack)
 
-# 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")
 
 # We have some custom .cmake scripts not in the official distribution.
 set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/CMakeModules;${CMAKE_MODULE_PATH}")
 
-include(Packaging)
+option(SIMGEAR_SHARED "Set to ON to build SimGear as a shared library/framework" OFF)
+option(SIMGEAR_HEADLESS "Set to ON to build SimGear with GUI/graphics support" OFF)
+option(JPEG_FACTORY "Enable JPEG-factory support" OFF)
+option(ENABLE_LIBSVN "Set to ON to build SimGear with libsvnclient support" ON)
 
-# Change the default build type to something fast
-if(NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE Release CACHE STRING
-      "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel."
-      FORCE)
-endif(NOT CMAKE_BUILD_TYPE)
+set(MSVC_3RDPARTY_ROOT NOT_FOUND CACHE PATH "Location where the third-party dependencies are extracted")
 
-# 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)
-message(STATUS "Library installation directory: ${CMAKE_INSTALL_LIBDIR}")
+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)
 
-#####################################################################################
-# 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(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 ()
-
-# Setup MSVC 3rd party directories
-include( ConfigureMsvc3rdParty )
-
-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)
+  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 (BOOST_CXX_FLAGS "-DBOOST_MULTI_INDEX_DISABLE_SERIALIZATION -DBOOST_BIMAP_DISABLE_SERIALIZATION")
 
-set(SG_SOUND_USES_OPENALSOFT OFF) # default to off
+find_package(ZLIB REQUIRED)
+find_package(Threads REQUIRED)
 
-if(SIMGEAR_HEADLESS)
-    message(STATUS "SimGear mode: HEADLESS")
-    set(ENABLE_SOUND 0)
+if (${SIMGEAR_HEADLESS})
+    message(STATUS "headlesss mode")
+    set(NO_OPENSCENEGRAPH_INTERFACE 1)
 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()
-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)
-else()
-    find_package(ZLIB 1.2.4 REQUIRED)
+    find_package(OpenAL REQUIRED)
+    find_package(ALUT REQUIRED)
+    find_package(OpenSceneGraph 2.8.1 REQUIRED osgText osgSim osgDB osgParticle osgUtil)
 endif()
 
-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)
-
-else()
-    message(STATUS "Using built-in expat code")
-endif(SYSTEM_EXPAT)
-
-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)
-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)
-
-if(ENABLE_GDAL)
-    find_package(GDAL 2.0.0 REQUIRED)
-endif(ENABLE_GDAL)
-
-
-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()
+if(JPEG_FACTORY)
+    message(STATUS "JPEG-factory enabled")
+    find_package(JPEG REQUIRED)
+    include_directories(${JPEG_INCLUDE_DIR})
 endif()
 
-include(CheckPOSIXFeatures)
+if(ENABLE_LIBSVN)
+	find_package(SvnClient)
 
-SET(CMAKE_DEBUG_POSTFIX "d" CACHE STRING "add a postfix, usually 'd' on windows")
+	if(LIBSVN_FOUND)
+		message(STATUS "libsvn found, enabling in SimGear")
+		set(HAVE_SVN_CLIENT_H 1)
+		set(HAVE_LIBSVN_CLIENT_1 1)
+	else()
+		message(STATUS "Missing libsvn, unable to enable SVN in SimGear")
+	endif(LIBSVN_FOUND)
+endif(ENABLE_LIBSVN)
+
+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)
+
+# See if we have any rti library variant installed
+find_package(RTI)
+
+check_function_exists(gettimeofday HAVE_GETTIMEOFDAY)
+check_function_exists(ftime HAVE_FTIME)
+check_function_exists(timegm HAVE_TIMEGM)
+check_function_exists(rint HAVE_RINT)
+
+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")
+SET(CMAKE_RELWITHDEBINFO_POSTFIX "rd" CACHE STRING "add a postfix, usually empty on windows")
+SET(CMAKE_MINSIZEREL_POSTFIX "s" 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()
-
-    # certain GCC versions don't provide the atomic builds, and hence
-    # require is to provide them in SGAtomic.cxx
-    set(CMAKE_REQUIRED_INCLUDES ${CMAKE_INCLUDE_PATH})
-    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")
+    set(WARNING_FLAGS -Wall)
 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()
-endif()
-
 if(WIN32)
 
-    if(MINGW)
-        add_definitions(-D_WIN32_WINNT=0x501)
-    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")
     endif(MSVC)
-
+    
     # assumed on Windows
     set(HAVE_GETLOCALTIME 1)
+endif(WIN32)    
 
-    set( WINSOCK_LIBRARY "ws2_32.lib" )
-    set( SHLWAPI_LIBRARY "Shlwapi.lib" )
-    set( RT_LIBRARY "winmm" )
-endif(WIN32)
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNING_FLAGS} ${MSVC_FLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNING_FLAGS} ${MSVC_FLAGS} ${BOOST_CXX_FLAGS}")
 
-# 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}")
+include_directories(${PROJECT_SOURCE_DIR})
+include_directories(${PROJECT_BINARY_DIR}/simgear)
 
-  # 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}")
+include_directories(${OPENSCENEGRAPH_INCLUDE_DIRS} 
+    ${Boost_INCLUDE_DIRS} ${ZLIB_INCLUDE_DIR} 
+    ${ALUT_INCLUDE_DIR} ${OPENAL_INCLUDE_DIR} )
 
-  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)
 
 add_definitions(-DHAVE_CONFIG_H)
 
@@ -404,56 +143,10 @@ configure_file (
   "${PROJECT_SOURCE_DIR}/simgear/simgear_config_cmake.h.in"
   "${PROJECT_BINARY_DIR}/simgear/simgear_config.h"
   )
-
-include (Dart)
-enable_testing()
-include(AddSimGearTest) # helper to setup a test
-
+  
 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
 #-----------------------------------------------------------------------------
@@ -463,3 +156,5 @@ CONFIGURE_FILE(
   IMMEDIATE @ONLY)
 ADD_CUSTOM_TARGET(uninstall
   "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
+
+

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()

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()

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>

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>

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>

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
-)

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()
-

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 ()

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()

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()

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()

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()
-

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_PATH(ALUT_INCLUDE_DIR alut.h
+  HINTS
+  $ENV{ALUTDIR}
+  PATH_SUFFIXES include/AL include/ALUT include
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt
+)
+
+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
+)
+
+
+SET(ALUT_FOUND "NO")
+IF(ALUT_LIBRARY AND ALUT_INCLUDE_DIR)
+  SET(ALUT_FOUND "YES")
+ENDIF(ALUT_LIBRARY AND ALUT_INCLUDE_DIR)
+

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()

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)

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})

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 ()

CMakeModules/FindSvnClient.cmake

@@ -0,0 +1,51 @@
+# Find Subversion client libraries, and dependencies
+# including APR (Apache Portable Runtime)
+
+include (CheckFunctionExists)
+include (CheckIncludeFile)
+
+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) 
+	find_path(LIBSVN_INCLUDE_DIR svn_client.h
+	  HINTS
+	  $ENV{LIBSVN_DIR}
+	  PATH_SUFFIXES include/subversion-1
+	  PATHS
+	  /usr/local
+	  /usr
+	  /opt
+	)
+
+	check_library_exists(svn_client-1 svn_client_checkout "" HAVE_LIB_SVNCLIENT)
+	check_library_exists(svn_subr-1 svn_cmdline_init "" HAVE_LIB_SVNSUBR)
+	check_library_exists(svn_ra-1 svn_ra_initialize "" HAVE_LIB_SVNRA)
+
+	include(FindPackageHandleStandardArgs)
+	FIND_PACKAGE_HANDLE_STANDARD_ARGS(LIBSVN DEFAULT_MSG 
+		HAVE_LIB_SVNSUBR 
+		HAVE_LIB_SVNCLIENT
+		HAVE_LIB_SVNRA 
+		LIBSVN_INCLUDE_DIR)
+
+	if(LIBSVN_FOUND)
+		set(LIBSVN_LIBRARIES "svn_client-1" "svn_subr-1" "svn_ra-1" ${APR_LIBS})
+	endif(LIBSVN_FOUND)
+endif(HAVE_APR_CONFIG)
+

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()

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()

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)

CMakeModules/SimGearComponent.cmake

@@ -1,34 +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()
+macro(simgear_component name includePath sources headers)
 
-	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}")
+    if (SIMGEAR_SHARED)
+        foreach(s ${sources})
+            set_property(GLOBAL
+                APPEND PROPERTY ALL_SOURCES "${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} )
 
-    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 lib${LIB_SUFFIX})
+        install (FILES ${headers}  DESTINATION include/simgear/${includePath})
+    endif()
     
-    install (FILES ${headers}  DESTINATION include/simgear/${includePath})
 endmacro()
-
-function(simgear_component name includePath sources headers)
-    simgear_component_common(${name} ${includePath} CORE_SOURCES "${sources}" "${headers}")
-endfunction()
-
-function(simgear_scene_component name includePath sources headers)
-    simgear_component_common(${name} ${includePath} SCENE_SOURCES "${sources}" "${headers}")
-endfunction()

COPYING

@@ -2,7 +2,7 @@
                        Version 2, June 1991
 
  Copyright (C) 1991 Free Software Foundation, Inc.
- 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
+                    59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
@@ -464,7 +464,7 @@ convey the exclusion of warranty; and each file should have at least the
 
     You should have received a copy of the GNU Library General Public
     License along with this library; if not, write to the Free
-    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 Also add information on how to contact you by electronic and paper mail.
 

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.
 

INSTALL

@@ -1,56 +0,0 @@
-How to build SimGear
-====================
-
-SimGear uses the CMake build system to generate a platform-specific
-build environment.  CMake reads the CMakeLists.txt files that you'll
-find throughout the source directories, checks for installed
-dependencies and then generates the appropriate build system.
-
-If you don't already have CMake installed on your system you can grab
-it from http://www.cmake.org, use version 2.6.4 or later.
-
-Under unices (i.e. Linux, Solaris, Free-BSD, HP-Ux, OSX) use the cmake
-or ccmake command-line utils. Preferably, create an out-of-source
-build directory and run cmake or ccmake from there. The advantage to
-this approach is that the temporary files created by CMake won't
-clutter the source directory, and also makes it possible to have
-multiple independent build targets by creating multiple build
-directories. In a directory alongside the SimGear source directory
-use:
-
-    mkdir sgbuild
-    cd sgbuild
-    cmake ../simgear -DCMAKE_BUILD_TYPE=Release
-    make
-    sudo make install
-
-
-Build Dependencies
-==================
-SimGear depends on a number of 3rd party libraries, the most notable
-being:
-
-* OpenSceneGraph (OSG) - see README.OSG
-* zlib compression library - see README.zlib
-* Open Audio Library (OpenAL) - see README.OpenAL
-* Subversion Client Library (optional dependency)
-
-
-Further information
-===================
-* README.cmake
-  for more detailed CMake instructions
-
-* README.msvc
-  in the FlightGear source package for more Windows-specific instructions
-
-* FlightGear Wiki
-  http://wiki.flightgear.org/Building_Flightgear
-
-* FlightGear Forums
-  For help on building see: http://www.flightgear.org/forums
-  => Support/Compiling
-
-* FlightGear Mailing lists
-  http://wiki.flightgear.org/index.php/Mailing_list
-

Makefile.am

@@ -0,0 +1,18 @@
+EXTRA_DIST = \
+	acinclude.m4 \
+	autogen.sh \
+	DoxygenMain.cxx \
+	README.zlib \
+	README.plib \
+	README.OpenAL \
+	README.OSG \
+	projects
+
+SUBDIRS	= simgear
+
+#
+# Rule to build RPM distribution package
+#
+rpm: dist
+	rpm -ta $(PACKAGE)-$(VERSION).tar.gz
+

README

@@ -1,15 +1 @@
-SimGear - Simulator Construction Tools
-======================================
-http://www.flightgear.org
-
-SimGear is a set of open-source libraries designed to be used as building
-blocks for quickly assembling 3d simulations, games, and visualization
-applications.
-
-SimGear is developed by the FlightGear project and also provides the base
-for the FlightGear Flight Simulator.
-
-Source code for SimGear is released under the GNU Library General Public
-License (LGPL) - see COPYING for license details.
-
-See INSTALL file for help on building SimGear.
+[ Nothing here at this time. ]

README.OSG

@@ -1,9 +1,10 @@
 [This file is mirrored in both the FlightGear and SimGear packages.]
 
-You *must* have OpenSceneGraph (OSG) installed to build this version of
+You *must* have OpenSceneGraph (OSG) installed to build this version of 
 FlightGear.
 
-Notice that this version of SimGear/FlightGear requires at least OSG 3.0.0.
+Notice that FlightGear 1.9.0 requires at least version 2.7.8. Using earlier 
+versions of OSG will yield serious rendering bugs. 
 
 You can get the latest version of OSG from:
 
@@ -21,6 +22,6 @@ ccmake .
 [ While running ccmake: press 'c' to configure, press 'c' once more, and
   then press 'g' to generate and exit ]
 
-make
+make 
 sudo make install
 

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
+

README.cmake

@@ -1,161 +0,0 @@
-Getting started with CMake
-==========================
-
-(These instructions apply to Unix-like systems, including Cygwin and Mac. To
-build using Visual Studio or some other IDE supported by CMake, most of the
-information below still applies. Otherwise see
-http://wiki.flightgear.org/Building_Flightgear for Windows specific build
-instructions.)
-
-Always compile in a separate directory to the code. For example, if the
-code (eg, from Git) is at /home/curt/projects/simgear, you might create
-/home/curt/projects/sgbuild. Change into the new directory, and run
-
-    cmake ../simgear
-
-To generate standard Unix Makefiles in sgbuild.
-
-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.
-
-If for some reason you have a dependency (or several) at a different prefix,
-you can specify one or more via CMAKE_PREFIX_PATH:
-
-    cmake ../simgear -DCMAKE_PREFIX_PATH="/opt/local;/opt/fgfs"
-
-(note the use of semi-colons to specify multiple prefix paths)
-
-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
-described above will work, but specifying an INSTALL_PREFIX or PREFIX_PATH is
-usually simpler.
-
-By default, we select a release build. To create a debug build, use
-
-    cmake ../simgear -DCMAKE_BUILD_TYPE=Debug
-
-(or MinSizeRel, or RelWithDbg)
-
-Debug builds will automatically use corresponding debug builds of required
-libraries, if they are available. For example you can install debug builds of
-OpenSceneGraph, and a debug SimGear build will use them.
-
-(Debug builds of libraries have the 'd' suffix by default - Release builds
-have no additional suffix)
-
-Note most IDE projects (eg Xcode and Visual Studio) support building all the
-build types from the same project, so you can omit the CMAKE_BUILD_TYPE option
-when running cmake, and simply pick the build configuration as normal in the
-IDE.
-
-It's common to have several build directories with different build
-configurations, eg
-
-    /home/curt/projects/simgear (the git clone)
-    /home/curt/projects/sgdebug
-    /home/curt/projects/sgrelease
-    /home/curt/projects/sg-with-svn-osg
-
-To set an optional feature, do
-
-    cmake ../simgear -DFEATURE_NAME=ON
-
-(or 'OFF' to disable )
-
-To see the variables that can be configured / are currently defined, you can
-run one of the GUI front ends, or the following command:
-
-    cmake ../simgear -L
-
-Add 'A' to see all the options (including advanced options), or 'H' to see
-the help for each option (similar to running configure --help under autoconf):
-
-    cmake ../simgear -LH
-
-
-Build Targets
-=============
-
-For a Unix makefile build, 'make dist', 'make uninstall' and 'make test' are
-all available and should work as expected. 'make clean' is also as normal,
-but there is *no* 'make distclean' target. The equivalent is to completely
-remove your build directory, and start with a fresh one.
-
-Adding new files to the build
-
-Add source files to the SOURCES list, and headers to the HEADERS list. Note
-technically you only need to add source files, but omitting headers confuses
-project generation and distribution / packaging targets.
-
-For target conditional files, you can append to the SOURCES or HEADERS lists
-inside an if() test, for example:
-
-    if(APPLE)
-        list(APPEND SOURCES extraFile1.cxx extraFile2.cxx)
-    endif()
-
-Setting include directories
-
-In any CMakeList.txt, you can do the following:
-
-    include_directories(${PROJECT_SOURCE_DIR}/some/path)
-
-For example, this can be done in particular subdirectory, or at the project
-root, or an intermediate level.
-
-Setting target specific compile flags, includes or defines
-
-Use set_target_property(), for example
-
-    set_target_property(fgfs PROPERTIES
-            COMPILE_DEFINITIONS FOO BAR=1)
-
-You can set a property on an individual source file:
-
-    set_property(SOURCE myfile.cxx PROPERTY COMPILE_FLAGS "-Wno-unsigned-compare")
-
-Detecting Features / Libraries
-
-For most standard libraries (Gtk, wxWidget, Python, GDAL, Qt, libXml, Boost),
-cmake provides a standard helper. To see the available modules, run:
-
-     cmake --help-module-list
-
-In the root CMakeLists file, use a statement like:
-
-    find_package(OpenGL REQUIRED)
-
-Each package helper sets various variables such aaa_FOUND, aaa_INCLUDE_DIR,
-and aaa_LIBRARY. Depending on the complexity of the package, these variables
-might have different names (eg, OPENSCENEGRAPH_LIBRARIES).
-
-If there's no standard helper for a library you need, find a similar one, copy
-it to CMakeModules/FindABC.cmake, and modify the code to fit. Generally this
-is pretty straightforward. The built-in modules reside in the Cmake 'share'
-directory, eg /usr/share/cmake/modules on Unix systems.
-
-Note libraries support by pkg-config can be handled directly, with no need
-to create a custom FindABC helper.
-
-Adding a new executable target
-
-    add_executable(myexecutable ${SOURCES} ${HEADERS})
-    target_link_libraries(myexecutable .... libraries ... )
-    install(TARGETS myexecutable RUNTIME DESTINATION bin)
-
-(If the executable should not be installed, omit the final line above)
-
-If you add an additional line
-
-    add_test(testname ${EXECUTABLE_OUTPUT_PATH}/myexecutable)
-
-Then running 'make test' will run your executable as a unit test. The
-executable should return either a success or failure result code.
-

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
+

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/

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
+

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")

TODO

@@ -0,0 +1 @@
+03/25/2001 - Resolve location of Sky dome implimentation documentation.

acinclude.m4

@@ -0,0 +1,706 @@
+dnl
+dnl originally from ncftp 2.3.0
+dnl added wi_EXTRA_PDIR and wi_ANSI_C
+dnl $Id$
+dnl
+AC_DEFUN([wi_EXTRA_IDIR], [
+incdir="$1"
+if test -r $incdir ; then
+    already=""
+    for CPPflag in $CPPFLAGS ; do
+	if test  "_$CPPflag" = "_-I${incdir}" ; then 
+            already=yes
+            break
+        fi
+    done
+    if test -n "$already" ; then
+        echo "   + already had -I$incdir" 1>&AS_MESSAGE_LOG_FD
+    else
+        if test "$CPPFLAGS" = "" ; then
+                CPPFLAGS="-I$incdir"
+        else
+                CPPFLAGS="$CPPFLAGS -I$incdir"
+        fi
+        echo "   + added -I$incdir" 1>&AS_MESSAGE_LOG_FD
+    fi
+else 
+    echo "   + IDIR is not accessible: '$myincdir'" 1>&AS_MESSAGE_LOG_FD
+fi
+])
+dnl
+dnl
+dnl
+dnl
+AC_DEFUN([wi_EXTRA_LDIR], [
+mylibdir="$1"
+if test -r $mylibdir ; then
+    already=""
+    for LDflag in $LDFLAGS ; do
+	if test  "_$LDflag" = "_-L${mylibdir}" ; then 
+            already=yes
+            break
+        fi
+    done
+    if test -n "$already" ; then
+        echo "   + already had -L$mylibdir" 1>&AS_MESSAGE_LOG_FD
+    else
+        if test "$LDFLAGS" = "" ; then
+                LDFLAGS="-L$mylibdir"
+        else
+                LDFLAGS="$LDFLAGS -L$mylibdir"
+        fi
+        echo "   + added -L$mylibdir" 1>&AS_MESSAGE_LOG_FD
+    fi
+else 
+    echo "   + LDIR is not accessible: '$mylibdir'" 1>&AS_MESSAGE_LOG_FD
+fi
+])
+dnl
+dnl __FP__
+dnl
+dnl
+AC_DEFUN([wi_EXTRA_PDIR], [
+progdir="$1"
+if test -r $progdir ; then
+	case ":$PATH:" in
+		*:${progdir}:*)
+			echo "   + already had $progdir in \$PATH" 1>&AS_MESSAGE_LOG_FD
+			;;
+		*)
+			if test "$PATH" = "" ; then
+				PATH="$progdir"
+			else
+				PATH="$PATH:$progdir"
+			fi
+			echo "   + appended $progdir to \$PATH" 1>&AS_MESSAGE_LOG_FD
+			;;
+	esac
+else 
+       echo "   + PDIR is not accessible: '$progdir'" 1>&AS_MESSAGE_LOG_FD
+fi
+])
+dnl
+dnl
+dnl If you want to also look for include and lib subdirectories in the
+dnl $HOME tree, you supply "yes" as the first argument to this macro.
+dnl
+dnl If you want to look for subdirectories in include/lib directories,
+dnl you pass the names in argument 3, otherwise pass a dash.
+dnl
+AC_DEFUN([wi_EXTRA_DIRS], [echo "checking for extra include and lib directories..." 1>&6
+ifelse([$1], yes, [dnl
+b1=`cd .. ; pwd`
+b2=`cd ../.. ; pwd`
+exdirs="$HOME $j $b1 $b2 $prefix $2"
+],[dnl
+exdirs="$prefix $2"
+])
+subexdirs="$3"
+if test "$subexdirs" = "" ; then
+	subexdirs="-"
+fi
+for subexdir in $subexdirs ; do
+    if test "$subexdir" = "-" ; then
+            subexdir=""
+    else
+            subexdir="/$subexdir"
+    fi
+    for exdir in $exdirs ; do
+        if test "$exdir" != "/usr" || test "$subexdir" != ""; then
+            incdir="${exdir}/include${subexdir}"
+            wi_EXTRA_IDIR($incdir)
+
+dnl On 64-bit machines, if lib64/ exists and is not identical to lib/
+dnl then it should be listed here, listed ahead of lib/.
+            mylibdir64="${exdir}/lib64${subexdir}"
+            mylibdir32="${exdir}/lib${subexdir}"
+
+            if test "x86_64" = $(uname -m) \
+              -a ! ${mylibdir64} -ef ${mylibdir32} ; then
+                wi_EXTRA_LDIR($mylibdir64)
+            fi
+
+            wi_EXTRA_LDIR($mylibdir32)
+
+            progdir="${exdir}/bin${subexdir}"
+            wi_EXTRA_PDIR($progdir)
+        fi
+    done
+done
+])
+dnl
+dnl
+dnl
+AC_DEFUN([wi_HPUX_CFLAGS],
+[AC_MSG_CHECKING(if HP-UX ansi C compiler flags are needed)
+AC_REQUIRE([AC_PROG_CC])
+os=`uname -s | tr '[A-Z]' '[a-z]'`
+ac_cv_hpux_flags=no
+if test "$os" = hp-ux ; then
+	if test "$ac_cv_prog_gcc" = yes ; then
+		if test "$CFLAGS" != "" ; then
+			# Shouldn't be in there.
+			CFLAGS=`echo "$CFLAGS" | sed 's/-Aa//g'`
+		fi
+	else
+		# If you're not using gcc, then you better have a cc/c89
+		# that is usable.  If you have the barebones compiler, it
+		# won't work.  The good compiler uses -Aa for the ANSI
+		# compatible stuff.
+		x=`echo $CFLAGS | grep 'Aa' 2>/dev/null`
+		if test "$x" = "" ; then
+			CFLAGS="$CFLAGS -Aa"
+		fi
+		ac_cv_hpux_flags=yes
+	fi
+	# Also add _HPUX_SOURCE to get the extended namespace.
+	x=`echo $CFLAGS | grep '_HPUX_SOURCE' 2>/dev/null`
+	if test "$x" = "" ; then
+		CFLAGS="$CFLAGS -D_HPUX_SOURCE"
+	fi
+fi
+AC_MSG_RESULT($ac_cv_hpux_flags)
+])
+dnl
+dnl
+dnl
+AC_DEFUN([wi_CFLAGS], [AC_REQUIRE([AC_PROG_CC])
+wi_HPUX_CFLAGS
+	if test "$CFLAGS" = "" ; then
+		CFLAGS="-O"
+	elif test "$ac_cv_prog_gcc" = "yes" ; then
+		case "$CFLAGS" in
+			*"-g -O"*)
+				#echo "using -g as default gcc CFLAGS" 1>&6
+				CFLAGS=`echo $CFLAGS | sed 's/-g\ -O/-O/'`
+				;;
+			*"-O -g"*)
+				# Leave the -g, but remove all -O options.
+				#echo "using -g as default gcc CFLAGS" 1>&6
+				CFLAGS=`echo $CFLAGS | sed 's/-O\ -g/-O/'`
+				;;
+		esac
+	fi
+])
+dnl
+dnl
+dnl
+AC_DEFUN([wi_PROTOTYPES], [
+AC_MSG_CHECKING(if the compiler supports function prototypes)
+AC_TRY_COMPILE(,[extern void exit(int status);],[wi_cv_prototypes=yes
+AC_DEFINE(PROTOTYPES)],wi_cv_prototypes=no)
+AC_MSG_RESULT($wi_cv_prototypes)
+])
+dnl
+dnl
+dnl
+AC_DEFUN([wi_ANSI_C], [
+AC_MSG_CHECKING(ANSI-style function definitions)
+AC_TRY_COMPILE(,[int blubb(int x) { return 0; }],[wi_cv_ansi_funcs=yes
+AC_DEFINE(ANSI_FUNCS)],wi_cv_ansi_funcs=no)
+AC_MSG_RESULT($wi_cv_ansi_funcs)
+])
+dnl
+dnl
+dnl
+AC_DEFUN([wi_HEADER_SYS_SELECT_H], [
+# See if <sys/select.h> is includable after <sys/time.h>
+if test "$ac_cv_header_sys_time_h" = no ; then
+AC_CHECK_HEADERS(sys/time.h sys/select.h)
+else
+AC_CHECK_HEADERS(sys/select.h)
+fi
+if test "$ac_cv_header_sys_select_h" = yes ; then
+	AC_MSG_CHECKING([if <sys/select.h> is compatible with <sys/time.h>])
+	selecth=yes
+	if test "$ac_cv_header_sys_time_h" = yes ; then
+		AC_TRY_COMPILE([#include <sys/time.h>
+		#include <sys/select.h>],[
+		fd_set a;
+		struct timeval tmval;
+
+		tmval.tv_sec = 0;],selecth=yes,selecth=no)
+
+		if test "$selecth" = yes ; then
+			AC_DEFINE(CAN_USE_SYS_SELECT_H)
+		fi
+	fi
+	AC_MSG_RESULT($selecth)
+fi
+])
+dnl
+dnl
+dnl
+AC_DEFUN([wi_LIB_RESOLV], [
+# See if we could access two well-known sites without help of any special
+# libraries, like resolv.
+
+AC_TRY_RUN([
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+ 
+main()
+{
+	struct hostent *hp1, *hp2;
+	int result;
+
+	hp1 = gethostbyname("gatekeeper.dec.com");
+	hp2 = gethostbyname("ftp.ncsa.uiuc.edu");
+	result = ((hp1 != (struct hostent *) 0) && (hp2 != (struct hostent *) 0));
+	exit(! result);
+}],look_for_resolv=no,look_for_resolv=yes,look_for_resolv=yes)
+
+AC_MSG_CHECKING([if we need to look for -lresolv])
+AC_MSG_RESULT($look_for_resolv)
+if test "$look_for_resolv" = yes ; then
+AC_CHECK_LIB(resolv,main)
+else
+	ac_cv_lib_resolv=no
+fi
+])
+dnl
+dnl
+dnl
+
+AC_DEFUN([wi_LIB_NSL], [
+AC_MSG_CHECKING(if we can use -lnsl)
+ac_save_LIBS="$LIBS";
+LIBS="$LIBS -lnsl";
+AC_CACHE_VAL(r_cv_use_libnsl, [
+AC_TRY_RUN(
+main() { if (getpwuid(getuid())) exit(0); exit(-1); },
+nc_cv_use_libnsl=yes, nc_cv_use_libnsl=no, nc_cv_use_libnsl=no)
+])
+if test "$nc_cv_use_libnsl" = "no"; then LIBS="$ac_save_LIBS"; fi
+AC_MSG_RESULT($nc_cv_use_libnsl)
+])dnl
+
+dnl
+dnl
+dnl
+
+AC_DEFUN([nc_PATH_PROG_ZCAT], [
+AC_PATH_PROG(GZCAT,gzcat)
+AC_PATH_PROG(ZCAT,zcat)
+if test "x$GZCAT" = x ; then
+	if test "x$ZCAT" != x ; then
+		# See if zcat is really gzcat.  gzcat has a --version option, regular
+		# zcat does not.
+		AC_MSG_CHECKING(if zcat is really gzcat in disguise)
+		if $ZCAT --version 2> /dev/null ; then
+			AC_DEFINE_UNQUOTED(GZCAT, "$ZCAT")
+			AC_MSG_RESULT(yes)
+		else
+			AC_MSG_RESULT(no)
+		fi
+	fi
+else
+	AC_DEFINE_UNQUOTED(GZCAT, "$GZCAT")
+fi
+
+if test "x$ZCAT" != x ; then
+	AC_DEFINE_UNQUOTED(ZCAT, "$ZCAT")
+fi
+])
+dnl
+dnl
+dnl
+AC_DEFUN([wi_SYSV_EXTRA_DIRS], [
+# Use System V because their curses extensions are required.  This must
+# be done early so we use the -I and -L in the library checks also.
+# This is mostly a Solaris/SunOS hack.  Note that doing this will also
+# use all of the other System V libraries and headers.
+
+AC_MSG_CHECKING(for alternative System V libraries)
+if test -f /usr/5include/curses.h ; then
+	CPPFLAGS="$CPPFLAGS -I/usr/5include"
+	LDFLAGS="$LDFLAGS -L/usr/5lib"
+	AC_MSG_RESULT(yes)
+else
+	AC_MSG_RESULT(no)
+fi
+])
+dnl
+dnl
+dnl
+AC_DEFUN([wi_DEFINE_UNAME], [
+# Get first 127 chars of all uname information.  Some folks have
+# way too much stuff there, so grab only the first 127.
+unam=`uname -a 2>/dev/null | cut -c1-127`
+if test "$unam" != "" ; then
+	AC_DEFINE_UNQUOTED(UNAME, "$unam")
+fi
+])
+dnl
+dnl
+dnl
+AC_DEFUN([wi_READLINE_WITH_NCURSES], [
+# Readline and Ncurses could both define "backspace".
+# Warn about this if we have both things in our definitions list.
+
+if test "$ac_cv_lib_readline" = yes && test "$ac_cv_lib_ncurses" = yes ; then
+
+AC_MSG_CHECKING(if readline and ncurses will link together)
+j="$LIBS"
+LIBS="-lreadline -lncurses"
+AC_TRY_LINK(,[
+readline("prompt");
+endwin();
+],k=yes,k=no)
+if test "$k" = no ; then
+	AC_MSG_RESULT(no)
+	# Remove '-lreadline' from LIBS.
+	LIBS=`echo $j | sed s/-lreadline//g`
+	ac_cv_lib_readline=no
+	AC_WARN([The versions of GNU readline and ncurses you have installed on this system
+can't be used together, because they use the same symbol, backspace. If
+possible, recompile one of the libraries with -Dbackspace=back_space, then
+re-run configure.])
+
+else
+	AC_MSG_RESULT(yes)
+	LIBS="$j"
+fi
+
+fi
+])
+dnl
+dnl
+dnl
+
+dnl AC_EXT_DAYLIGHT
+dnl Check for an external variable daylight. Stolen from w3c-libwww.
+AC_DEFUN([AC_EXT_DAYLIGHT],
+[ AC_MSG_CHECKING(int daylight variable)
+AC_TRY_COMPILE([#include <time.h>], [return daylight;],
+  have_daylight=yes,
+  have_daylight=no)
+AC_MSG_RESULT($have_daylight)
+])dnl
+
+dnl AC_EXT_TIMEZONE
+dnl Check for an external variable timezone. Stolen from tcl-8.0.
+AC_DEFUN([AC_EXT_TIMEZONE],
+[
+#
+# Its important to include time.h in this check, as some systems (like convex)
+# have timezone functions, etc.
+#
+have_timezone=no
+AC_MSG_CHECKING([long timezone variable])
+AC_TRY_COMPILE([#include <time.h>],
+        [extern long timezone;
+         timezone += 1;
+         exit (0);],
+        [have_timezone=yes
+         AC_MSG_RESULT(yes)],
+         AC_MSG_RESULT(no))
+
+#
+# On some systems (eg IRIX 6.2), timezone is a time_t and not a long.
+#
+if test "$have_timezone" = no; then
+   AC_MSG_CHECKING([time_t timezone variable])
+   AC_TRY_COMPILE([#include <time.h>],
+        [extern time_t timezone;
+         timezone += 1;
+         exit (0);],
+        [have_timezone=yes
+         AC_MSG_RESULT(yes)],
+         AC_MSG_RESULT(no))
+fi
+])dnl
+
+## AC_BZ_SET_COMPILER: Addition by Theodore Papadopoulo
+## Patch by Jim McKelvey: change sed -e 's/ /@/g' to sed -e 's/ /@/'
+AC_DEFUN([AC_SG_SET_COMPILER],
+  [cxxwith=`echo $1 | sed -e 's/ /@/'`
+   case "$cxxwith" in
+     *:*@*)                 # Full initialization syntax
+       CXX=`echo "$cxxwith" | sed  -n -e 's/.*:\(.*\)@.*/\1/p'`
+       CXXFLAGS=`echo "$cxxwith" | sed  -n -e 's/.*:.*@\(.*\)/\1/p'`
+     ;;
+     *:*)                   # Simple initialization syntax
+       CXX=`echo "$cxxwith" | sed  -n -e 's/.*:\(.*\)/\1/p'`
+       CXXFLAGS=$3
+     ;;
+     *)                     # Default values
+       CXX=$2
+       CXXFLAGS=$3
+       CC="$2 --c"
+##       CFLAGS=
+     ;;
+   esac])
+
+pushdef([AC_PROG_INSTALL],
+[
+  dnl our own version, testing for a -p flag
+  popdef([AC_PROG_INSTALL])
+  dnl as AC_PROG_INSTALL works as it works we first have
+  dnl to save if the user didn't specify INSTALL, as the
+  dnl autoconf one overwrites INSTALL and we have no chance to find
+  dnl out afterwards
+  AC_PROG_INSTALL
+
+    # OK, user hasn't given any INSTALL, autoconf found one for us
+    # now we test, if it supports the -p flag
+    AC_MSG_CHECKING(for -p flag to install)
+    rm -f confinst.$$.* > /dev/null 2>&1
+    echo "Testtest" > confinst.$$.orig
+    ac_res=no
+    if ${INSTALL} -p confinst.$$.orig confinst.$$.new > /dev/null 2>&1 ; then
+      if test -f confinst.$$.new ; then
+        # OK, -p seems to do no harm to install
+        INSTALL="${INSTALL} -p"
+        ac_res=yes
+      fi
+    fi
+    rm -f confinst.$$.*
+    AC_MSG_RESULT($ac_res)
+  dnl the following tries to resolve some signs and wonders coming up
+  dnl with different autoconf/automake versions
+  dnl e.g.:
+  dnl  *automake 1.4 install-strip sets A_M_INSTALL_PROGRAM_FLAGS to -s
+  dnl   and has INSTALL_PROGRAM = @INSTALL_PROGRAM@ $(A_M_INSTALL_PROGRAM_FLAGS)
+  dnl   it header-vars.am, so there the actual INSTALL_PROGRAM gets the -s
+  dnl  *automake 1.4a (and above) use INSTALL_STRIP_FLAG and only has
+  dnl   INSTALL_PROGRAM = @INSTALL_PROGRAM@ there, but changes the
+  dnl   install-@DIR@PROGRAMS targets to explicitly use that flag
+  dnl  *autoconf 2.13 is dumb, and thinks it can use INSTALL_PROGRAM as
+  dnl   INSTALL_SCRIPT, which breaks with automake <= 1.4
+  dnl  *autoconf >2.13 (since 10.Apr 1999) has not that failure
+  dnl to clean up that mess we:
+  dnl  +set INSTALL_PROGRAM to use INSTALL_STRIP_FLAG
+  dnl   which cleans KDE's program with automake > 1.4;
+  dnl  +set INSTALL_SCRIPT to only use INSTALL, to clean up autoconf's problems
+  dnl   with automake<=1.4
+  dnl  note that dues to this sometimes two '-s' flags are used
+    INSTALL_PROGRAM='${INSTALL} $(INSTALL_STRIP_FLAG)'
+    INSTALL_SCRIPT='${INSTALL}'
+])dnl
+
+# ===========================================================================
+#             http://autoconf-archive.cryp.to/ax_boost_base.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_BOOST_BASE([MINIMUM-VERSION])
+#
+# DESCRIPTION
+#
+#   Test for the Boost C++ libraries of a particular version (or newer)
+#
+#   If no path to the installed boost library is given the macro searchs
+#   under /usr, /usr/local, /opt and /opt/local and evaluates the
+#   $BOOST_ROOT environment variable. Further documentation is available at
+#   <http://randspringer.de/boost/index.html>.
+#
+#   This macro calls:
+#
+#     AC_SUBST(BOOST_CPPFLAGS) / AC_SUBST(BOOST_LDFLAGS)
+#
+#   And sets:
+#
+#     HAVE_BOOST
+#
+# LAST MODIFICATION
+#
+#   2008-04-12
+#
+# COPYLEFT
+#
+#   Copyright (c) 2008 Thomas Porschberg <thomas@randspringer.de>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved.
+
+AC_DEFUN([AX_BOOST_BASE],
+[
+AC_ARG_WITH([boost],
+	AS_HELP_STRING([--with-boost@<:@=DIR@:>@], [use boost (default is yes) - it is possible to specify the root directory for boost (optional)]),
+	[
+    if test "$withval" = "no"; then
+		want_boost="no"
+    elif test "$withval" = "yes"; then
+        want_boost="yes"
+        ac_boost_path=""
+    else
+	    want_boost="yes"
+        ac_boost_path="$withval"
+	fi
+    ],
+    [want_boost="yes"])
+
+
+AC_ARG_WITH([boost-libdir],
+        AS_HELP_STRING([--with-boost-libdir=LIB_DIR],
+        [Force given directory for boost libraries. Note that this will overwrite library path detection, so use this parameter only if default library detection fails and you know exactly where your boost libraries are located.]),
+        [
+        if test -d $withval
+        then
+                ac_boost_lib_path="$withval"
+        else
+                AC_MSG_ERROR(--with-boost-libdir expected directory name)
+        fi
+        ],
+        [ac_boost_lib_path=""]
+)
+
+if test "x$want_boost" = "xyes"; then
+	boost_lib_version_req=ifelse([$1], ,1.20.0,$1)
+	boost_lib_version_req_shorten=`expr $boost_lib_version_req : '\([[0-9]]*\.[[0-9]]*\)'`
+	boost_lib_version_req_major=`expr $boost_lib_version_req : '\([[0-9]]*\)'`
+	boost_lib_version_req_minor=`expr $boost_lib_version_req : '[[0-9]]*\.\([[0-9]]*\)'`
+	boost_lib_version_req_sub_minor=`expr $boost_lib_version_req : '[[0-9]]*\.[[0-9]]*\.\([[0-9]]*\)'`
+	if test "x$boost_lib_version_req_sub_minor" = "x" ; then
+		boost_lib_version_req_sub_minor="0"
+    	fi
+	WANT_BOOST_VERSION=`expr $boost_lib_version_req_major \* 100000 \+  $boost_lib_version_req_minor \* 100 \+ $boost_lib_version_req_sub_minor`
+	AC_MSG_CHECKING(for boostlib >= $boost_lib_version_req)
+	succeeded=no
+
+	dnl first we check the system location for boost libraries
+	dnl this location ist chosen if boost libraries are installed with the --layout=system option
+	dnl or if you install boost with RPM
+	if test "$ac_boost_path" != ""; then
+		BOOST_LDFLAGS="-L$ac_boost_path/lib"
+		BOOST_CPPFLAGS="-I$ac_boost_path/include"
+	else
+		for ac_boost_path_tmp in /usr /usr/local /opt /opt/local ; do
+			if test -d "$ac_boost_path_tmp/include/boost" && test -r "$ac_boost_path_tmp/include/boost"; then
+				BOOST_LDFLAGS="-L$ac_boost_path_tmp/lib"
+				BOOST_CPPFLAGS="-I$ac_boost_path_tmp/include"
+				break;
+			fi
+		done
+	fi
+
+    dnl overwrite ld flags if we have required special directory with
+    dnl --with-boost-libdir parameter
+    if test "$ac_boost_lib_path" != ""; then
+       BOOST_LDFLAGS="-L$ac_boost_lib_path"
+    fi
+
+	CPPFLAGS_SAVED="$CPPFLAGS"
+	CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
+	export CPPFLAGS
+
+	LDFLAGS_SAVED="$LDFLAGS"
+	LDFLAGS="$LDFLAGS $BOOST_LDFLAGS"
+	export LDFLAGS
+
+	AC_LANG_PUSH(C++)
+     	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+	@%:@include <boost/version.hpp>
+	]], [[
+	#if BOOST_VERSION >= $WANT_BOOST_VERSION
+	// Everything is okay
+	#else
+	#  error Boost version is too old
+	#endif
+	]])],[
+        AC_MSG_RESULT(yes)
+	succeeded=yes
+	found_system=yes
+       	],[
+       	])
+	AC_LANG_POP([C++])
+
+
+
+	dnl if we found no boost with system layout we search for boost libraries
+	dnl built and installed without the --layout=system option or for a staged(not installed) version
+	if test "x$succeeded" != "xyes"; then
+		_version=0
+		if test "$ac_boost_path" != ""; then
+			if test -d "$ac_boost_path" && test -r "$ac_boost_path"; then
+				for i in `ls -d $ac_boost_path/include/boost-* 2>/dev/null`; do
+					_version_tmp=`echo $i | sed "s#$ac_boost_path##" | sed 's/\/include\/boost-//' | sed 's/_/./'`
+					V_CHECK=`expr $_version_tmp \> $_version`
+					if test "$V_CHECK" = "1" ; then
+						_version=$_version_tmp
+					fi
+					VERSION_UNDERSCORE=`echo $_version | sed 's/\./_/'`
+					BOOST_CPPFLAGS="-I$ac_boost_path/include/boost-$VERSION_UNDERSCORE"
+				done
+			fi
+		else
+			for ac_boost_path in /usr /usr/local /opt /opt/local ; do
+				if test -d "$ac_boost_path" && test -r "$ac_boost_path"; then
+					for i in `ls -d $ac_boost_path/include/boost-* 2>/dev/null`; do
+						_version_tmp=`echo $i | sed "s#$ac_boost_path##" | sed 's/\/include\/boost-//' | sed 's/_/./'`
+						V_CHECK=`expr $_version_tmp \> $_version`
+						if test "$V_CHECK" = "1" ; then
+							_version=$_version_tmp
+	               					best_path=$ac_boost_path
+						fi
+					done
+				fi
+			done
+
+			VERSION_UNDERSCORE=`echo $_version | sed 's/\./_/'`
+			BOOST_CPPFLAGS="-I$best_path/include/boost-$VERSION_UNDERSCORE"
+            if test "$ac_boost_lib_path" = ""
+            then
+               BOOST_LDFLAGS="-L$best_path/lib"
+            fi
+
+	    		if test "x$BOOST_ROOT" != "x"; then
+				if test -d "$BOOST_ROOT" && test -r "$BOOST_ROOT" && test -d "$BOOST_ROOT/stage/lib" && test -r "$BOOST_ROOT/stage/lib"; then
+					version_dir=`expr //$BOOST_ROOT : '.*/\(.*\)'`
+					stage_version=`echo $version_dir | sed 's/boost_//' | sed 's/_/./g'`
+			        	stage_version_shorten=`expr $stage_version : '\([[0-9]]*\.[[0-9]]*\)'`
+					V_CHECK=`expr $stage_version_shorten \>\= $_version`
+                    if test "$V_CHECK" = "1" -a "$ac_boost_lib_path" = "" ; then
+						AC_MSG_NOTICE(We will use a staged boost library from $BOOST_ROOT)
+						BOOST_CPPFLAGS="-I$BOOST_ROOT"
+						BOOST_LDFLAGS="-L$BOOST_ROOT/stage/lib"
+					fi
+				fi
+	    		fi
+		fi
+
+		CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
+		export CPPFLAGS
+		LDFLAGS="$LDFLAGS $BOOST_LDFLAGS"
+		export LDFLAGS
+
+		AC_LANG_PUSH(C++)
+	     	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+		@%:@include <boost/version.hpp>
+		]], [[
+		#if BOOST_VERSION >= $WANT_BOOST_VERSION
+		// Everything is okay
+		#else
+		#  error Boost version is too old
+		#endif
+		]])],[
+        	AC_MSG_RESULT(yes)
+		succeeded=yes
+		found_system=yes
+       		],[
+	       	])
+		AC_LANG_POP([C++])
+	fi
+
+	if test "$succeeded" != "yes" ; then
+		if test "$_version" = "0" ; then
+			AC_MSG_ERROR([[We could not detect the boost libraries (version $boost_lib_version_req_shorten or higher). If you have a staged boost library (still not installed) please specify \$BOOST_ROOT in your environment and do not give a PATH to --with-boost option.  If you are sure you have boost installed, then check your version number looking in <boost/version.hpp>. See http://randspringer.de/boost for more documentation.]])
+		else
+			AC_MSG_ERROR([Your boost libraries seems to old (version $_version).])
+		fi
+	else
+		AC_SUBST(BOOST_CPPFLAGS)
+		AC_SUBST(BOOST_LDFLAGS)
+		AC_DEFINE(HAVE_BOOST,,[define if the Boost library is available])
+	fi
+
+        CPPFLAGS="$CPPFLAGS_SAVED"
+       	LDFLAGS="$LDFLAGS_SAVED"
+fi
+
+])

am2dsp.cfg

@@ -0,0 +1,38 @@
+type = StaticLibrary,Multithreaded,
+exclude_dir = threads
+
+include_path = .
+include_path = ..
+include_path = .\SimGear
+include_path = ..\zlib-1.2.3
+include_path = "..\OpenAL 1.0 Software Development Kit\include"
+
+define = _USE_MATH_DEFINES
+define = _CRT_SECURE_NO_DEPRECATE
+define = HAVE_CONFIG_H
+
+# Rule to create simgear_config.h
+add_source_file = SOURCE=.\simgear\simgear_config.h.vc5\
+\
+!IF  "$(CFG)" == "SimGear - Win32 Release"\
+\
+# Begin Custom Build - Creating config.h\
+InputPath=.\simgear\simgear_config.h.vc5\
+\
+".\simgear\simgear_config.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"\
+        copy .\simgear\simgear_config.h.vc5 .\simgear\simgear_config.h\
+\
+# End Custom Build\
+\
+!ELSEIF  "$(CFG)" == "SimGear - Win32 Debug"\
+\
+# Begin Custom Build - Creating config.h\
+InputPath=.\simgear\simgear_config.h.vc5\
+\
+".\simgear\simgear_config.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"\
+        copy .\simgear\simgear_config.h.vc5 .\simgear\simgear_config.h\
+\
+# End Custom Build\
+\
+!ENDIF\
+