feat: build proect for restproxy

proxy_c/third-lib/libevent/cmake/AddCompilerFlags.cmake

@@ -0,0 +1,13 @@
+include(CheckCCompilerFlag)
+
+macro(add_compiler_flags)
+	foreach(flag ${ARGN})
+		string(REGEX REPLACE "[-.+/:= ]" "_" _flag_esc "${flag}")
+
+		check_c_compiler_flag("${flag}" check_c_compiler_flag_${_flag_esc})
+
+		if (check_c_compiler_flag_${_flag_esc})
+			set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}")
+		endif()
+	endforeach()
+endmacro()

proxy_c/third-lib/libevent/cmake/AddEventLibrary.cmake

@@ -0,0 +1,163 @@
+include(CMakeParseArguments)
+
+set(LIBEVENT_SHARED_LIBRARIES "")
+set(LIBEVENT_STATIC_LIBRARIES "")
+
+macro(set_event_shared_lib_flags LIB_NAME)
+    set_target_properties("${LIB_NAME}_shared" PROPERTIES
+        COMPILE_FLAGS ${ARGN})
+    set_target_properties("${LIB_NAME}_shared" PROPERTIES
+        LINK_FLAGS ${ARGN})
+endmacro()
+
+macro(generate_pkgconfig LIB_NAME)
+    set(prefix      ${CMAKE_INSTALL_PREFIX})
+    set(exec_prefix ${CMAKE_INSTALL_PREFIX})
+    set(libdir      ${CMAKE_INSTALL_PREFIX}/lib)
+    set(includedir  ${CMAKE_INSTALL_PREFIX}/include)
+
+    set(VERSION ${EVENT_ABI_LIBVERSION})
+
+    set(LIBS         "")
+    foreach (LIB ${LIB_PLATFORM})
+        set(LIBS "${LIBS} -L${LIB}")
+    endforeach()
+
+    set(OPENSSL_LIBS "")
+    foreach(LIB ${OPENSSL_LIBRARIES})
+        set(OPENSSL_LIBS "${OPENSSL_LIBS} -L${LIB}")
+    endforeach()
+
+    configure_file("lib${LIB_NAME}.pc.in" "lib${LIB_NAME}.pc" @ONLY)
+    install(
+        FILES "${CMAKE_CURRENT_BINARY_DIR}/lib${LIB_NAME}.pc"
+        DESTINATION "${CMAKE_INSTALL_PREFIX}/lib/pkgconfig"
+    )
+endmacro()
+
+
+# Global variables that it uses:
+# - EVENT_ABI_LIBVERSION
+# - EVENT_ABI_LIBVERSION_CURRENT
+# - EVENT_ABI_LIBVERSION_REVISION
+# - EVENT_ABI_LIBVERSION_AGE
+# - EVENT_PACKAGE_RELEASE
+# - CMAKE_THREAD_LIBS_INIT LIB_PLATFORM
+# - OPENSSL_LIBRARIES
+# - HDR_PUBLIC
+# - EVENT_INSTALL_INCLUDE_DIR
+# - EVENT_SHARED_FLAGS
+# - EVENT_LIBRARY_STATIC
+# - EVENT_LIBRARY_SHARED
+#
+# Exported variables:
+# - LIBEVENT_SHARED_LIBRARIES
+# - LIBEVENT_STATIC_LIBRARIES
+macro(add_event_library LIB_NAME)
+    cmake_parse_arguments(LIB
+        "" # Options
+        "VERSION" # One val
+        "SOURCES;LIBRARIES" # Multi val
+        ${ARGN}
+    )
+
+    set(ADD_EVENT_LIBRARY_TARGETS)
+    set(ADD_EVENT_LIBRARY_INTERFACE)
+
+    if (${EVENT_LIBRARY_STATIC})
+        add_library("${LIB_NAME}_static" STATIC ${LIB_SOURCES})
+        set_target_properties("${LIB_NAME}_static" PROPERTIES
+            OUTPUT_NAME "${LIB_NAME}"
+            CLEAN_DIRECT_OUTPUT 1)
+        set_target_properties(
+            "${LIB_NAME}_static" PROPERTIES
+            PUBLIC_HEADER "${HDR_PUBLIC}")
+
+        list(APPEND LIBEVENT_STATIC_LIBRARIES "${LIB_NAME}_static")
+        list(APPEND ADD_EVENT_LIBRARY_TARGETS "${LIB_NAME}_static")
+
+        set(ADD_EVENT_LIBRARY_INTERFACE "${LIB_NAME}_static")
+    endif()
+
+    if (${EVENT_LIBRARY_SHARED})
+        add_library("${LIB_NAME}_shared" SHARED ${LIB_SOURCES})
+
+        target_link_libraries("${LIB_NAME}_shared"
+            ${CMAKE_THREAD_LIBS_INIT}
+            ${LIB_PLATFORM}
+            ${LIB_LIBRARIES})
+
+        if (EVENT_SHARED_FLAGS)
+            set_event_shared_lib_flags("${LIB_NAME}" "${EVENT_SHARED_FLAGS}")
+        endif()
+
+        if (WIN32)
+            set_target_properties(
+                "${LIB_NAME}_shared" PROPERTIES
+                OUTPUT_NAME "${LIB_NAME}"
+                SOVERSION ${EVENT_ABI_LIBVERSION})
+        elseif (APPLE)
+            math(EXPR COMPATIBILITY_VERSION "${EVENT_ABI_LIBVERSION_CURRENT}+1")
+            math(EXPR CURRENT_MINUS_AGE "${EVENT_ABI_LIBVERSION_CURRENT}-${EVENT_ABI_LIBVERSION_AGE}")
+            set_target_properties(
+                "${LIB_NAME}_shared" PROPERTIES
+                OUTPUT_NAME "${LIB_NAME}-${EVENT_PACKAGE_RELEASE}.${CURRENT_MINUS_AGE}"
+                INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/lib"
+                LINK_FLAGS "-compatibility_version ${COMPATIBILITY_VERSION} -current_version ${COMPATIBILITY_VERSION}.${EVENT_ABI_LIBVERSION_REVISION}")
+        else()
+            math(EXPR CURRENT_MINUS_AGE "${EVENT_ABI_LIBVERSION_CURRENT}-${EVENT_ABI_LIBVERSION_AGE}")
+            set_target_properties(
+                "${LIB_NAME}_shared" PROPERTIES
+                OUTPUT_NAME "${LIB_NAME}-${EVENT_PACKAGE_RELEASE}"
+                VERSION "${CURRENT_MINUS_AGE}.${EVENT_ABI_LIBVERSION_AGE}.${EVENT_ABI_LIBVERSION_REVISION}"
+                SOVERSION "${CURRENT_MINUS_AGE}")
+        endif()
+
+        set_target_properties(
+            "${LIB_NAME}_shared" PROPERTIES
+            PUBLIC_HEADER "${HDR_PUBLIC}"
+            CLEAN_DIRECT_OUTPUT 1)
+
+        if (NOT WIN32)
+            set(LIB_LINK_NAME
+                "${CMAKE_SHARED_LIBRARY_PREFIX}${LIB_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}")
+
+            add_custom_command(TARGET ${LIB_NAME}_shared
+                POST_BUILD
+                COMMAND ${CMAKE_COMMAND} -E create_symlink
+                    "$<TARGET_FILE_NAME:${LIB_NAME}_shared>"
+                    "${LIB_LINK_NAME}"
+                WORKING_DIRECTORY "lib")
+        endif()
+
+        list(APPEND LIBEVENT_SHARED_LIBRARIES "${LIB_NAME}_shared")
+        list(APPEND ADD_EVENT_LIBRARY_TARGETS "${LIB_NAME}_shared")
+
+        set(ADD_EVENT_LIBRARY_INTERFACE "${LIB_NAME}_shared")
+    endif()
+
+    export(TARGETS ${ADD_EVENT_LIBRARY_TARGETS}
+       FILE "${PROJECT_BINARY_DIR}/LibeventTargets.cmake"
+       APPEND
+    )
+
+    install(TARGETS ${ADD_EVENT_LIBRARY_TARGETS}
+        EXPORT LibeventTargets
+        LIBRARY DESTINATION "lib" COMPONENT lib
+        ARCHIVE DESTINATION "lib" COMPONENT lib
+        RUNTIME DESTINATION "lib" COMPONENT lib
+        PUBLIC_HEADER DESTINATION "include/event2"
+        COMPONENT dev
+    )
+    if (NOT WIN32 AND ${EVENT_LIBRARY_SHARED})
+        install(FILES
+            "$<TARGET_FILE_DIR:${LIB_NAME}_shared>/${LIB_LINK_NAME}"
+            DESTINATION "lib"
+            COMPONENT lib)
+    endif()
+
+    add_library(${LIB_NAME} INTERFACE)
+    target_link_libraries(${LIB_NAME} INTERFACE ${ADD_EVENT_LIBRARY_INTERFACE})
+
+    generate_pkgconfig("${LIB_NAME}")
+endmacro()

proxy_c/third-lib/libevent/cmake/COPYING-CMAKE-SCRIPTS

@@ -0,0 +1,22 @@
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. The name of the author may not be used to endorse or promote products 
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

proxy_c/third-lib/libevent/cmake/CheckConstExists.cmake

@@ -0,0 +1,25 @@
+include(CheckCSourceCompiles)
+
+macro(check_const_exists CONST FILES VARIABLE)
+  if (NOT DEFINED ${VARIABLE})
+    set(check_const_exists_source "")
+    foreach(file ${FILES})
+      set(check_const_exists_source
+          "${check_const_exists_source}
+          #include <${file}>")
+    endforeach()
+    set(check_const_exists_source
+        "${check_const_exists_source}
+        int main() { (void)${CONST}; return 0; }")
+
+    check_c_source_compiles("${check_const_exists_source}" ${VARIABLE})
+
+    if (${${VARIABLE}})
+      set(${VARIABLE} 1 CACHE INTERNAL "Have const ${CONST}")
+      message(STATUS "Looking for ${CONST} - found")
+    else()
+      set(${VARIABLE} 0 CACHE INTERNAL "Have const ${CONST}")
+      message(STATUS "Looking for ${CONST} - not found")
+    endif()
+  endif()
+endmacro(check_const_exists)

proxy_c/third-lib/libevent/cmake/CheckFileOffsetBits.c

@@ -0,0 +1,14 @@
+#include <sys/types.h>
+
+#define KB ((off_t)1024)
+#define MB ((off_t)1024 * KB)
+#define GB ((off_t)1024 * MB)
+#define TB ((off_t)1024 * GB)
+int t2[(((64 * GB -1) % 671088649) == 268434537)
+       && (((TB - (64 * GB -1) + 255) % 1792151290) == 305159546)? 1: -1];
+
+int main()
+{
+  ;
+  return 0;
+}

proxy_c/third-lib/libevent/cmake/CheckFileOffsetBits.cmake

@@ -0,0 +1,43 @@
+# - Check if _FILE_OFFSET_BITS macro needed for large files
+# CHECK_FILE_OFFSET_BITS ()
+#
+# The following variables may be set before calling this macro to
+# modify the way the check is run:
+#
+#  CMAKE_REQUIRED_FLAGS = string of compile command line flags
+#  CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
+#  CMAKE_REQUIRED_INCLUDES = list of include directories
+# Copyright (c) 2009, Michihiro NAKAJIMA
+#
+# Redistribution and use is allowed according to the terms of the BSD license.
+# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+
+#INCLUDE(CheckCSourceCompiles)
+
+GET_FILENAME_COMPONENT(_selfdir_CheckFileOffsetBits
+	 "${CMAKE_CURRENT_LIST_FILE}" PATH)
+
+MACRO (CHECK_FILE_OFFSET_BITS)
+  IF(NOT DEFINED _FILE_OFFSET_BITS)
+    MESSAGE(STATUS "Cheking _FILE_OFFSET_BITS for large files")
+    TRY_COMPILE(__WITHOUT_FILE_OFFSET_BITS_64
+      ${CMAKE_CURRENT_BINARY_DIR}
+      ${_selfdir_CheckFileOffsetBits}/CheckFileOffsetBits.c
+      COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS})
+    IF(NOT __WITHOUT_FILE_OFFSET_BITS_64)
+      TRY_COMPILE(__WITH_FILE_OFFSET_BITS_64
+        ${CMAKE_CURRENT_BINARY_DIR}
+        ${_selfdir_CheckFileOffsetBits}/CheckFileOffsetBits.c
+        COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} -D_FILE_OFFSET_BITS=64)
+    ENDIF(NOT __WITHOUT_FILE_OFFSET_BITS_64)
+
+    IF(NOT __WITHOUT_FILE_OFFSET_BITS_64 AND __WITH_FILE_OFFSET_BITS_64)
+      SET(_FILE_OFFSET_BITS 64 CACHE INTERNAL "_FILE_OFFSET_BITS macro needed for large files")
+      MESSAGE(STATUS "Cheking _FILE_OFFSET_BITS for large files - needed")
+    ELSE(NOT __WITHOUT_FILE_OFFSET_BITS_64 AND __WITH_FILE_OFFSET_BITS_64)
+      SET(_FILE_OFFSET_BITS "" CACHE INTERNAL "_FILE_OFFSET_BITS macro needed for large files")
+      MESSAGE(STATUS "Cheking _FILE_OFFSET_BITS for large files - not needed")
+    ENDIF(NOT __WITHOUT_FILE_OFFSET_BITS_64 AND __WITH_FILE_OFFSET_BITS_64)
+  ENDIF(NOT DEFINED _FILE_OFFSET_BITS)
+
+ENDMACRO (CHECK_FILE_OFFSET_BITS)

proxy_c/third-lib/libevent/cmake/CheckFunctionExistsEx.c

@@ -0,0 +1,28 @@
+#ifdef CHECK_FUNCTION_EXISTS
+
+#ifdef __cplusplus
+extern "C"
+#endif
+  char
+  CHECK_FUNCTION_EXISTS(void);
+#ifdef __CLASSIC_C__
+int main()
+{
+  int ac;
+  char* av[];
+#else
+int main(int ac, char* av[])
+{
+#endif
+  CHECK_FUNCTION_EXISTS();
+  if (ac > 1000) {
+    return *av[0];
+  }
+  return 0;
+}
+
+#else /* CHECK_FUNCTION_EXISTS */
+
+#error "CHECK_FUNCTION_EXISTS has to specify the function"
+
+#endif /* CHECK_FUNCTION_EXISTS */

proxy_c/third-lib/libevent/cmake/CheckFunctionExistsEx.cmake

@@ -0,0 +1,69 @@
+# - Check if a C function can be linked
+# CHECK_FUNCTION_EXISTS(<function> <variable>)
+#
+# Check that the <function> is provided by libraries on the system and
+# store the result in a <variable>.  This does not verify that any
+# system header file declares the function, only that it can be found
+# at link time (considure using CheckSymbolExists).
+#
+# The following variables may be set before calling this macro to
+# modify the way the check is run:
+#
+#  CMAKE_REQUIRED_FLAGS = string of compile command line flags
+#  CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
+#  CMAKE_REQUIRED_INCLUDES = list of include directories
+#  CMAKE_REQUIRED_LIBRARIES = list of libraries to link
+
+#=============================================================================
+# Copyright 2002-2011 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+MACRO(CHECK_FUNCTION_EXISTS_EX FUNCTION VARIABLE)
+  IF(${VARIABLE} MATCHES "^${VARIABLE}$")
+    SET(MACRO_CHECK_FUNCTION_DEFINITIONS 
+      "-DCHECK_FUNCTION_EXISTS=${FUNCTION} ${CMAKE_REQUIRED_FLAGS}")
+    MESSAGE(STATUS "Looking for ${FUNCTION}")
+    IF(CMAKE_REQUIRED_LIBRARIES)
+      SET(CHECK_FUNCTION_EXISTS_ADD_LIBRARIES
+        "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
+    ELSE(CMAKE_REQUIRED_LIBRARIES)
+      SET(CHECK_FUNCTION_EXISTS_ADD_LIBRARIES)
+    ENDIF(CMAKE_REQUIRED_LIBRARIES)
+    IF(CMAKE_REQUIRED_INCLUDES)
+      SET(CHECK_FUNCTION_EXISTS_ADD_INCLUDES
+        "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}")
+    ELSE(CMAKE_REQUIRED_INCLUDES)
+      SET(CHECK_FUNCTION_EXISTS_ADD_INCLUDES)
+    ENDIF(CMAKE_REQUIRED_INCLUDES)
+    TRY_COMPILE(${VARIABLE}
+      ${CMAKE_BINARY_DIR}
+	  ${PROJECT_SOURCE_DIR}/cmake/CheckFunctionExistsEx.c
+      COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}
+      CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS}
+      "${CHECK_FUNCTION_EXISTS_ADD_LIBRARIES}"
+      "${CHECK_FUNCTION_EXISTS_ADD_INCLUDES}"
+      OUTPUT_VARIABLE OUTPUT)
+    IF(${VARIABLE})
+      SET(${VARIABLE} 1 CACHE INTERNAL "Have function ${FUNCTION}")
+      MESSAGE(STATUS "Looking for ${FUNCTION} - found")
+      FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log 
+        "Determining if the function ${FUNCTION} exists passed with the following output:\n"
+        "${OUTPUT}\n\n")
+    ELSE(${VARIABLE})
+      MESSAGE(STATUS "Looking for ${FUNCTION} - not found")
+      SET(${VARIABLE} "" CACHE INTERNAL "Have function ${FUNCTION}")
+      FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log 
+        "Determining if the function ${FUNCTION} exists failed with the following output:\n"
+        "${OUTPUT}\n\n")
+    ENDIF(${VARIABLE})
+  ENDIF()
+ENDMACRO(CHECK_FUNCTION_EXISTS_EX)

proxy_c/third-lib/libevent/cmake/CheckFunctionKeywords.cmake

@@ -0,0 +1,14 @@
+include(CheckCSourceCompiles)
+
+macro(check_function_keywords _wordlist)
+  set(${_result} "")
+  foreach(flag ${_wordlist})
+    string(REGEX REPLACE "[-+/ ()]" "_" flagname "${flag}")
+    string(TOUPPER "${flagname}" flagname)
+    set(have_flag "HAVE_${flagname}")
+    check_c_source_compiles("${flag} void func(); void func() { } int main() { func(); return 0; }" ${have_flag})
+    if(${have_flag} AND NOT ${_result})
+      set(${_result} "${flag}")
+    endif(${have_flag} AND NOT ${_result})
+  endforeach(flag)
+endmacro(check_function_keywords)

proxy_c/third-lib/libevent/cmake/CheckPrototypeDefinition.c.in

@@ -0,0 +1,29 @@
+@CHECK_PROTOTYPE_DEFINITION_HEADER@
+
+static void cmakeRequireSymbol(int dummy, ...) {
+  (void) dummy;
+}
+
+static void checkSymbol(void) {
+#ifndef @CHECK_PROTOTYPE_DEFINITION_SYMBOL@
+  cmakeRequireSymbol(0, &@CHECK_PROTOTYPE_DEFINITION_SYMBOL@);
+#endif
+}
+
+@CHECK_PROTOTYPE_DEFINITION_PROTO@ {
+  return @CHECK_PROTOTYPE_DEFINITION_RETURN@;
+}
+
+#ifdef __CLASSIC_C__
+int main() {
+  int ac;
+  char*av[];
+#else
+int main(int ac, char *av[]) {
+#endif
+  checkSymbol();
+  if (ac > 1000) {
+    return *av[0];
+  }
+  return 0;
+}

proxy_c/third-lib/libevent/cmake/CheckPrototypeDefinition.cmake

@@ -0,0 +1,82 @@
+# - Check if the protoype we expect is correct.
+# check_prototype_definition(FUNCTION PROTOTYPE RETURN HEADER VARIABLE)
+#
+#  FUNCTION - The name of the function (used to check if prototype exists)
+#  PROTOTYPE- The prototype to check.
+#  RETURN - The return value of the function.
+#  HEADER - The header files required.
+#  VARIABLE - The variable to store the result.
+#
+# Example:
+#
+# check_prototype_definition(getpwent_r
+#     "struct passwd *getpwent_r(struct passwd *src, char *buf, int buflen)"
+#     "NULL"
+#     "unistd.h;pwd.h"
+#     SOLARIS_GETPWENT_R)
+#
+# The following variables may be set before calling this macro to
+# modify the way the check is run:
+#
+#  CMAKE_REQUIRED_FLAGS = string of compile command line flags
+#  CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
+#  CMAKE_REQUIRED_INCLUDES = list of include directories
+#  CMAKE_REQUIRED_LIBRARIES = list of libraries to link
+
+
+function(CHECK_PROTOTYPE_DEFINITION _FUNCTION _PROTOTYPE _RETURN _HEADER _VARIABLE)
+    if (${_VARIABLE} MATCHES "^${_VARIABLE}$")
+        set(CHECK_PROTOTYPE_DEFINITION_CONTENT "/* */\n")
+
+        set(CHECK_PROTOTYPE_DEFINITION_FLAGS ${CMAKE_REQUIRED_FLAGS})
+        if (CMAKE_REQUIRED_LIBRARIES)
+          set(CHECK_PROTOTYPE_DEFINITION_LIBS
+              "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
+        else(CMAKE_REQUIRED_LIBRARIES)
+            set(CHECK_PROTOTYPE_DEFINITION_LIBS)
+        endif(CMAKE_REQUIRED_LIBRARIES)
+        if (CMAKE_REQUIRED_INCLUDES)
+            set(CMAKE_SYMBOL_EXISTS_INCLUDES
+                "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}")
+        else(CMAKE_REQUIRED_INCLUDES)
+            set(CMAKE_SYMBOL_EXISTS_INCLUDES)
+        endif(CMAKE_REQUIRED_INCLUDES)
+
+        foreach(_FILE ${_HEADER})
+          set(CHECK_PROTOTYPE_DEFINITION_HEADER
+            "${CHECK_PROTOTYPE_DEFINITION_HEADER}#include <${_FILE}>\n")
+        endforeach(_FILE)
+
+        set(CHECK_PROTOTYPE_DEFINITION_SYMBOL ${_FUNCTION})
+        set(CHECK_PROTOTYPE_DEFINITION_PROTO ${_PROTOTYPE})
+        set(CHECK_PROTOTYPE_DEFINITION_RETURN ${_RETURN})
+
+        configure_file("${PROJECT_SOURCE_DIR}/cmake/CheckPrototypeDefinition.c.in"
+            "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckPrototypeDefinition.c" @ONLY)
+
+        file(READ ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckPrototypeDefinition.c _SOURCE)
+
+        try_compile(${_VARIABLE}
+          ${CMAKE_BINARY_DIR}
+          ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckPrototypeDefinition.c
+          COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}
+          CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${CHECK_PROTOTYPE_DEFINITION_FLAGS}
+          "${CHECK_PROTOTYPE_DEFINITION_LIBS}"
+          "${CMAKE_SYMBOL_EXISTS_INCLUDES}"
+          OUTPUT_VARIABLE OUTPUT)
+
+        if (${_VARIABLE})
+            set(${_VARIABLE} 1 CACHE INTERNAL "Have correct prototype for ${_FUNCTION}")
+            message(STATUS "Checking prototype ${_FUNCTION} for ${_VARIABLE} - True")
+            file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+                "Determining if the prototype ${_FUNCTION} exists for ${_VARIABLE} passed with the following output:\n"
+                "${OUTPUT}\n\n")
+        else (${_VARIABLE})
+            message(STATUS "Checking prototype ${_FUNCTION} for ${_VARIABLE} - False")
+            set(${_VARIABLE} 0 CACHE INTERNAL "Have correct prototype for ${_FUNCTION}")
+            file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+                "Determining if the prototype ${_FUNCTION} exists for ${_VARIABLE} failed with the following output:\n"
+                "${OUTPUT}\n\n${_SOURCE}\n\n")
+        endif (${_VARIABLE})
+    endif()
+endfunction(CHECK_PROTOTYPE_DEFINITION)

proxy_c/third-lib/libevent/cmake/CheckWorkingKqueue.cmake

@@ -0,0 +1,52 @@
+include(CheckCSourceRuns)
+
+check_c_source_runs(
+"
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/event.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+int
+main(int argc, char **argv)
+{
+    int kq;
+    int n;
+    int fd[2];
+    struct kevent ev;
+    struct timespec ts;
+    char buf[80000];
+
+    if (pipe(fd) == -1)
+        exit(1);
+    if (fcntl(fd[1], F_SETFL, O_NONBLOCK) == -1)
+        exit(1);
+
+    while ((n = write(fd[1], buf, sizeof(buf))) == sizeof(buf))
+        ;
+
+    if ((kq = kqueue()) == -1)
+        exit(1);
+
+    memset(&ev, 0, sizeof(ev));
+    ev.ident = fd[1];
+    ev.filter = EVFILT_WRITE;
+    ev.flags = EV_ADD | EV_ENABLE;
+    n = kevent(kq, &ev, 1, NULL, 0, NULL);
+    if (n == -1)
+        exit(1);
+
+    read(fd[0], buf, sizeof(buf));
+
+    ts.tv_sec = 0;
+    ts.tv_nsec = 0;
+    n = kevent(kq, NULL, 0, &ev, 1, &ts);
+    if (n == -1 || n == 0)
+        exit(1);
+
+    exit(0);
+}
+
+" EVENT__HAVE_WORKING_KQUEUE)

proxy_c/third-lib/libevent/cmake/CodeCoverage.cmake

@@ -0,0 +1,165 @@
+#
+# Boost Software License - Version 1.0 - August 17th, 2003
+#
+# Permission is hereby granted, free of charge, to any person or organization
+# obtaining a copy of the software and accompanying documentation covered by
+# this license (the "Software") to use, reproduce, display, distribute,
+# execute, and transmit the Software, and to prepare derivative works of the
+# Software, and to permit third-parties to whom the Software is furnished to
+# do so, all subject to the following:
+# 
+# The copyright notices in the Software and this entire statement, including
+# the above license grant, this restriction and the following disclaimer,
+# must be included in all copies of the Software, in whole or in part, and
+# all derivative works of the Software, unless such copies or derivative
+# works are solely in the form of machine-executable object code generated by
+# a source language processor.
+# 
+# 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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+# SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+# FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+#
+# 2012-01-31, Lars Bilke
+# - Enable Code Coverage
+#
+# 2013-09-17, Joakim Söderberg
+# - Added support for Clang.
+# - Some additional usage instructions.
+#
+# 2016-11-02, Azat Khuzhin
+# - Adopt for C compiler only (libevent)
+#
+# USAGE:
+# 1. Copy this file into your cmake modules path.
+#
+# 2. Add the following line to your CMakeLists.txt:
+#      INCLUDE(CodeCoverage)
+#
+# 3. Set compiler flags to turn off optimization and enable coverage: 
+#    SET(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+#	 SET(CMAKE_C_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+#  
+# 3. Use the function SETUP_TARGET_FOR_COVERAGE to create a custom make target
+#    which runs your test executable and produces a lcov code coverage report:
+#    Example:
+#	 SETUP_TARGET_FOR_COVERAGE(
+#				my_coverage_target  # Name for custom target.
+#				test_driver         # Name of the test driver executable that runs the tests.
+#									# NOTE! This should always have a ZERO as exit code
+#									# otherwise the coverage generation will not complete.
+#				coverage            # Name of output directory.
+#				)
+#
+# 4. Build a Debug build:
+#	 cmake -DCMAKE_BUILD_TYPE=Debug ..
+#	 make
+#	 make my_coverage_target
+#
+#
+
+# Check prereqs
+FIND_PROGRAM( GCOV_PATH gcov )
+FIND_PROGRAM( LCOV_PATH lcov )
+FIND_PROGRAM( GENHTML_PATH genhtml )
+FIND_PROGRAM( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/tests)
+
+IF(NOT GCOV_PATH)
+	MESSAGE(FATAL_ERROR "gcov not found! Aborting...")
+ENDIF() # NOT GCOV_PATH
+
+IF(NOT CMAKE_COMPILER_IS_GNUCC)
+	# Clang version 3.0.0 and greater now supports gcov as well.
+	MESSAGE(WARNING "Compiler is not GNU gcc! Clang Version 3.0.0 and greater supports gcov as well, but older versions don't.")
+	
+	IF(NOT "${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
+		MESSAGE(FATAL_ERROR "Compiler is not GNU gcc! Aborting...")
+	ENDIF()
+ENDIF() # NOT CMAKE_COMPILER_IS_GNUCC
+
+IF ( NOT CMAKE_BUILD_TYPE STREQUAL "Debug" )
+  MESSAGE( WARNING "Code coverage results with an optimized (non-Debug) build may be misleading" )
+ENDIF() # NOT CMAKE_BUILD_TYPE STREQUAL "Debug"
+
+
+# Param _targetname     The name of new the custom make target
+# Param _testrunner     The name of the target which runs the tests.
+#						MUST return ZERO always, even on errors. 
+#						If not, no coverage report will be created!
+# Param _outputname     lcov output is generated as _outputname.info
+#                       HTML report is generated in _outputname/index.html
+# Optional fourth parameter is passed as arguments to _testrunner
+#   Pass them in list form, e.g.: "-j;2" for -j 2
+FUNCTION(SETUP_TARGET_FOR_COVERAGE _targetname _testrunner _outputname)
+
+	IF(NOT LCOV_PATH)
+		MESSAGE(FATAL_ERROR "lcov not found! Aborting...")
+	ENDIF() # NOT LCOV_PATH
+
+	IF(NOT GENHTML_PATH)
+		MESSAGE(FATAL_ERROR "genhtml not found! Aborting...")
+	ENDIF() # NOT GENHTML_PATH
+
+	# Setup target
+	ADD_CUSTOM_TARGET(${_targetname}
+		
+		# Cleanup lcov
+		${LCOV_PATH} --directory . --zerocounters
+		
+		# Run tests
+		COMMAND ${_testrunner} ${ARGV3}
+		
+		# Capturing lcov counters and generating report
+		COMMAND ${LCOV_PATH} --directory . --capture --output-file ${_outputname}.info
+		COMMAND ${LCOV_PATH} --remove ${_outputname}.info 'tests/*' '/usr/*' --output-file ${_outputname}.info.cleaned
+		COMMAND ${GENHTML_PATH} -o ${_outputname} ${_outputname}.info.cleaned
+		COMMAND ${CMAKE_COMMAND} -E remove ${_outputname}.info ${_outputname}.info.cleaned
+		
+		WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+		COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
+	)
+	
+	# Show info where to find the report
+	ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD
+		COMMAND ;
+		COMMENT "Open ./${_outputname}/index.html in your browser to view the coverage report."
+	)
+
+ENDFUNCTION() # SETUP_TARGET_FOR_COVERAGE
+
+# Param _targetname     The name of new the custom make target
+# Param _testrunner     The name of the target which runs the tests
+# Param _outputname     cobertura output is generated as _outputname.xml
+# Optional fourth parameter is passed as arguments to _testrunner
+#   Pass them in list form, e.g.: "-j;2" for -j 2
+FUNCTION(SETUP_TARGET_FOR_COVERAGE_COBERTURA _targetname _testrunner _outputname)
+
+	IF(NOT PYTHON_EXECUTABLE)
+		MESSAGE(FATAL_ERROR "Python not found! Aborting...")
+	ENDIF() # NOT PYTHON_EXECUTABLE
+
+	IF(NOT GCOVR_PATH)
+		MESSAGE(FATAL_ERROR "gcovr not found! Aborting...")
+	ENDIF() # NOT GCOVR_PATH
+
+	ADD_CUSTOM_TARGET(${_targetname}
+
+		# Run tests
+		${_testrunner} ${ARGV3}
+
+		# Running gcovr
+		COMMAND ${GCOVR_PATH} -x -r ${CMAKE_SOURCE_DIR} -e '${CMAKE_SOURCE_DIR}/tests/'  -o ${_outputname}.xml
+		WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+		COMMENT "Running gcovr to produce Cobertura code coverage report."
+	)
+
+	# Show info where to find the report
+	ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD
+		COMMAND ;
+		COMMENT "Cobertura code coverage report saved in ${_outputname}.xml."
+	)
+
+ENDFUNCTION() # SETUP_TARGET_FOR_COVERAGE_COBERTURA

proxy_c/third-lib/libevent/cmake/Copyright.txt

@@ -0,0 +1,57 @@
+CMake - Cross Platform Makefile Generator
+Copyright 2000-2013 Kitware, Inc.
+Copyright 2000-2011 Insight Software Consortium
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+
+* Neither the names of Kitware, Inc., the Insight Software Consortium,
+  nor the names of their contributors may be used to endorse or promote
+  products derived from this software without specific prior written
+  permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+------------------------------------------------------------------------------
+
+The above copyright and license notice applies to distributions of
+CMake in source and binary form.  Some source files contain additional
+notices of original copyright by their contributors; see each source
+for details.  Third-party software packages supplied with CMake under
+compatible licenses provide their own copyright notices documented in
+corresponding subdirectories.
+
+------------------------------------------------------------------------------
+
+CMake was initially developed by Kitware with the following sponsorship:
+
+ * National Library of Medicine at the National Institutes of Health
+   as part of the Insight Segmentation and Registration Toolkit (ITK).
+
+ * US National Labs (Los Alamos, Livermore, Sandia) ASC Parallel
+   Visualization Initiative.
+
+ * National Alliance for Medical Image Computing (NAMIC) is funded by the
+   National Institutes of Health through the NIH Roadmap for Medical Research,
+   Grant U54 EB005149.
+
+ * Kitware, Inc.

proxy_c/third-lib/libevent/cmake/FindGit.cmake

@@ -0,0 +1,45 @@
+# The module defines the following variables:
+#   GIT_EXECUTABLE - path to git command line client
+#   GIT_FOUND - true if the command line client was found
+# Example usage:
+#   find_package(Git)
+#   if(GIT_FOUND)
+#     message("git found: ${GIT_EXECUTABLE}")
+#   endif()
+
+#=============================================================================
+# Copyright 2010 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.)
+
+# Look for 'git' or 'eg' (easy git)
+set(git_names git eg)
+
+# Prefer .cmd variants on Windows unless running in a Makefile
+# in the MSYS shell.
+if(WIN32)
+  if(NOT CMAKE_GENERATOR MATCHES "MSYS")
+    set(git_names git.cmd git eg.cmd eg)
+  endif()
+endif()
+
+find_program(GIT_EXECUTABLE
+  NAMES ${git_names}
+  DOC "git command line client")
+
+mark_as_advanced(GIT_EXECUTABLE)
+
+# Handle the QUIETLY and REQUIRED arguments and set GIT_FOUND to TRUE if
+# all listed variables are TRUE
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Git DEFAULT_MSG GIT_EXECUTABLE)
+

proxy_c/third-lib/libevent/cmake/LibeventConfig.cmake.in

@@ -0,0 +1,18 @@
+# - Config file for the Libevent package
+# It defines the following variables
+#  LIBEVENT_INCLUDE_DIRS     - include directories
+#  LIBEVENT_STATIC_LIBRARIES - libraries to link against (archive/static)
+#  LIBEVENT_SHARED_LIBRARIES - libraries to link against (shared)
+
+# Get the path of the current file.
+get_filename_component(LIBEVENT_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
+
+# Set the include directories.
+set(LIBEVENT_INCLUDE_DIRS "@EVENT_INSTALL_INCLUDE_DIR@")
+
+# Include the project Targets file, this contains definitions for IMPORTED targets.
+include(${LIBEVENT_CMAKE_DIR}/LibeventTargets.cmake)
+
+# IMPORTED targets from LibeventTargets.cmake
+set(LIBEVENT_STATIC_LIBRARIES "@LIBEVENT_STATIC_LIBRARIES@")
+set(LIBEVENT_SHARED_LIBRARIES "@LIBEVENT_SHARED_LIBRARIES@")

proxy_c/third-lib/libevent/cmake/LibeventConfigBuildTree.cmake.in

@@ -0,0 +1,17 @@
+# - Config file for the Libevent package
+# It defines the following variables
+#  LIBEVENT_INCLUDE_DIRS - include directories for FooBar
+#  LIBEVENT_LIBRARIES    - libraries to link against
+
+# Get the path of the current file.
+get_filename_component(LIBEVENT_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
+
+# Set the include directories.
+set(LIBEVENT_INCLUDE_DIRS "@EVENT__INCLUDE_DIRS@")
+
+# Include the project Targets file, this contains definitions for IMPORTED targets.
+include(${LIBEVENT_CMAKE_DIR}/LibeventTargets.cmake)
+
+# IMPORTED targets from LibeventTargets.cmake
+set(LIBEVENT_LIBRARIES event event_core event_extra)
+

proxy_c/third-lib/libevent/cmake/LibeventConfigVersion.cmake.in

@@ -0,0 +1,11 @@
+set(PACKAGE_VERSION "@EVENT_PACKAGE_VERSION@")
+
+# Check whether the requested PACKAGE_FIND_VERSION is compatible
+if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}")
+  set(PACKAGE_VERSION_COMPATIBLE FALSE)
+else()
+  set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  if ("${PACKAGE_VERSION}" VERSION_EQUAL "${PACKAGE_FIND_VERSION}")
+    set(PACKAGE_VERSION_EXACT TRUE)
+  endif()
+endif()	

proxy_c/third-lib/libevent/cmake/VersionViaGit.cmake

@@ -0,0 +1,64 @@
+# This module defines the following variables utilizing
+# git to determine the parent tag. And if found the macro
+# will attempt to parse them in the github tag fomat
+#
+# Useful for auto-versioning in our CMakeLists
+#
+#  EVENT_GIT___VERSION_MAJOR - Major version.
+#  EVENT_GIT___VERSION_MINOR - Minor version
+#  EVENT_GIT___VERSION_STAGE - Stage version
+#
+# Example usage:
+#
+# event_fuzzy_version_from_git()
+#    message("Libvent major=${EVENT_GIT___VERSION_MAJOR}")
+#    message("        minor=${EVENT_GIT___VERSION_MINOR}")
+#    message("        patch=${EVENT_GIT___VERSION_PATCH}")
+#    message("        stage=${EVENT_GIT___VERSION_STAGE}")
+# endif()
+
+include(FindGit)
+
+macro(event_fuzzy_version_from_git)
+	# set our defaults.
+	set(EVENT_GIT___VERSION_MAJOR 2)
+	set(EVENT_GIT___VERSION_MINOR 1)
+	set(EVENT_GIT___VERSION_PATCH 11)
+	set(EVENT_GIT___VERSION_STAGE "stable")
+
+	find_package(Git)
+
+	if (GIT_FOUND)
+		execute_process(
+			COMMAND
+				${GIT_EXECUTABLE} describe --abbrev=0
+			WORKING_DIRECTORY
+				${PROJECT_SOURCE_DIR}
+			RESULT_VARIABLE
+				GITRET
+			OUTPUT_VARIABLE
+				GITVERSION
+			OUTPUT_STRIP_TRAILING_WHITESPACE
+		)
+
+		string(REGEX REPLACE "[\\._-]" ";" VERSION_LIST "${GITVERSION}")
+		list(LENGTH VERSION_LIST VERSION_LIST_LENGTH)
+
+		if ((GITRET EQUAL 0) AND (VERSION_LIST_LENGTH EQUAL 5))
+			list(GET VERSION_LIST 1 _MAJOR)
+			list(GET VERSION_LIST 2 _MINOR)
+			list(GET VERSION_LIST 3 _PATCH)
+			list(GET VERSION_LIST 4 _STAGE)
+
+			set(_DEFAULT_VERSION "${EVENT_GIT___VERSION_MAJOR}.${EVENT_GIT___VERSION_MINOR}.${EVENT_GIT___VERSION_PATCH}-${EVENT_GIT___VERSION_STAGE}")
+			set(_GIT_VERSION     "${_MAJOR}.${_MINOR}.${_PATCH}-${_STAGE}")
+
+			if (${_DEFAULT_VERSION} VERSION_LESS ${_GIT_VERSION})
+				set(EVENT_GIT___VERSION_MAJOR ${_MAJOR})
+				set(EVENT_GIT___VERSION_MINOR ${_MINOR})
+				set(EVENT_GIT___VERSION_PATCH ${_PATCH})
+				set(EVENT_GIT___VERSION_STAGE ${_STAGE})
+			endif()
+		endif()
+	endif()
+endmacro()