diff --git a/CMakeLists.txt b/CMakeLists.txt
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,262 +1,262 @@
 cmake_minimum_required(VERSION 3.3.0)
 cmake_policy(SET CMP0048 NEW)
 
 if(UNIX AND NOT APPLE)
 	set(LINUX TRUE)
 endif()
-set(CMAKE_OSX_ARCHITECTURES "x86_64;i386")
-set(CMAKE_OSX_DEPLOYMENT_TARGET "10.10" CACHE STRING "Minimum OS X deployment version")
+set(CMAKE_OSX_ARCHITECTURES "x86_64;ARM64")
+set(CMAKE_OSX_DEPLOYMENT_TARGET "10.13" CACHE STRING "Minimum OS X deployment version")
 
 # Specify search path for CMake modules to be loaded by include() 
 # and find_package()
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules")
 
 # Add defaults for cmake
 # Those need to be set before the project() call.
 include(DefineCMakeDefaults)
 include(DefineCompilerFlags)
 
 project(libssh VERSION 0.8.90 LANGUAGES C)
 
 # global needed variable
 set(APPLICATION_NAME ${PROJECT_NAME})
 
 # SOVERSION scheme: CURRENT.AGE.REVISION
 #   If there was an incompatible interface change:
 #     Increment CURRENT. Set AGE and REVISION to 0
 #   If there was a compatible interface change:
 #     Increment AGE. Set REVISION to 0
 #   If the source code was changed, but there were no interface changes:
 #     Increment REVISION.
 set(LIBRARY_VERSION "4.7.2")
 set(LIBRARY_SOVERSION "4")
 
 # where to look first for cmake modules, before ${CMAKE_ROOT}/Modules/ is checked
 
 # add definitions
 include(DefinePlatformDefaults)
 include(DefineInstallationPaths)
 include(DefineOptions.cmake)
 include(CPackConfig.cmake)
 
 include(CompilerChecks.cmake)
 
 # disallow in-source build
 include(MacroEnsureOutOfSourceBuild)
 macro_ensure_out_of_source_build("${PROJECT_NAME} requires an out of source build. Please create a separate build directory and run 'cmake /path/to/${PROJECT_NAME} [options]' there.")
 
 get_filename_component(BUILD ${CMAKE_CURRENT_BINARY_DIR} NAME)
 
 if (MSVC)
 	if ("${BUILD}" STREQUAL "build64")
 		set(OPENSSL_ROOT_DIR "C:/Program\ Files/OpenSSL-Win64")
 	else()
 		set(OPENSSL_ROOT_DIR "C:/Program\ Files\ (x86)/OpenSSL-Win32")
 	endif()
 	if(NOT EXISTS "${OPENSSL_ROOT_DIR}")
 		message(FATAL_ERROR "'${OPENSSL_ROOT_DIR}' not found." )
 	endif()
 	set(OpenSSL_DIR OPENSSL_ROOT_DIR)
 	set(OPENSSL_MSVC_STATIC_RT TRUE)
 elseif (APPLE)
 endif()
 include(FindOpenSSL)
 
 # search for libraries
 if (WITH_ZLIB)
 	if (MSVC)
 		set(ZLIB_LIBRARY "${CMAKE_CURRENT_LIST_DIR}/../zlib/${BUILD}/Release/zlib_static.lib" )
 		set(ZLIB_INCLUDE_DIR "${CMAKE_CURRENT_LIST_DIR}/../zlib" "${CMAKE_CURRENT_LIST_DIR}/../zlib/${BUILD}")		
 		if(NOT EXISTS "${ZLIB_LIBRARY}")
 			message(FATAL_ERROR "'${ZLIB_LIBRARY}' not found." )
 		endif()
 	endif()
     find_package(ZLIB REQUIRED)
 endif (WITH_ZLIB)
 
 if (WITH_GCRYPT)
   find_package(GCrypt 1.5.0 REQUIRED)
   if (NOT GCRYPT_FOUND)
     message(FATAL_ERROR "Could not find GCrypt")
   endif (NOT GCRYPT_FOUND)
 elseif(WITH_MBEDTLS)
     find_package(MbedTLS REQUIRED)
     if (NOT MBEDTLS_FOUND)
       message(FATAL_ERROR "Could not find mbedTLS")
     endif (NOT MBEDTLS_FOUND)
 else (WITH_GCRYPT)
   find_package(OpenSSL HINTS ${OPENSSL_ROOT_DIR})
   if (NOT OPENSSL_FOUND)
     find_package(GCrypt)
     if (NOT GCRYPT_FOUND)
       find_package(MbedTLS)
       if (NOT MBEDTLS_FOUND)
         message(FATAL_ERROR "Could not find OpenSSL, GCrypt or mbedTLS")
       endif (NOT MBEDTLS_FOUND)
     endif (NOT GCRYPT_FOUND)
   endif (NOT OPENSSL_FOUND)
 endif(WITH_GCRYPT)
 
 # Find out if we have threading available
 set(CMAKE_THREAD_PREFER_PTHREADS ON)
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads)
 
 if (WITH_GSSAPI)
     find_package(GSSAPI)
 endif (WITH_GSSAPI)
 
 if (WITH_NACL)
     find_package(NaCl)
     if (NOT NACL_FOUND)
         set(WITH_NACL OFF)
     endif (NOT NACL_FOUND)
 endif (WITH_NACL)
 
 if (BSD OR SOLARIS OR OSX)
     find_package(Argp)
 endif (BSD OR SOLARIS OR OSX)
 
 # Disable symbol versioning in non UNIX platforms
 if (UNIX)
     find_package(ABIMap 0.3.1)
 else (UNIX)
     set(WITH_SYMBOL_VERSIONING OFF)
 endif (UNIX)
 
 # config.h checks
 include(ConfigureChecks.cmake)
 configure_file(config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config.h)
 
 # check subdirectories
 add_subdirectory(doc)
 add_subdirectory(include)
 add_subdirectory(src)
 
 # pkg-config file
 if (UNIX)
 configure_file(libssh.pc.cmake ${CMAKE_CURRENT_BINARY_DIR}/libssh.pc)
 install(
   FILES
     ${CMAKE_CURRENT_BINARY_DIR}/libssh.pc
   DESTINATION
     ${LIB_INSTALL_DIR}/pkgconfig
   COMPONENT
     pkgconfig
 )
 endif (UNIX)
 
 # cmake config files
 set(LIBSSH_LIBRARY_NAME ${CMAKE_SHARED_LIBRARY_PREFIX}ssh${CMAKE_SHARED_LIBRARY_SUFFIX})
 
 configure_file(${PROJECT_NAME}-config.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config.cmake @ONLY)
 configure_file(${PROJECT_NAME}-config-version.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake @ONLY)
 install(
     FILES
         ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config.cmake
         ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake
     DESTINATION
         ${CMAKE_INSTALL_DIR}/${PROJECT_NAME}
     COMPONENT
         devel
 )
 
 
 # in tree build settings
 configure_file(libssh-build-tree-settings.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/libssh-build-tree-settings.cmake @ONLY)
 
 if (WITH_EXAMPLES)
     add_subdirectory(examples)
 endif (WITH_EXAMPLES)
 
 if (UNIT_TESTING)
   find_package(CMocka REQUIRED)
   include(AddCMockaTest)
   add_subdirectory(tests)
 endif (UNIT_TESTING)
 
 ### SOURCE PACKAGE
 if (WITH_SYMBOL_VERSIONING AND ABIMAP_FOUND)
     # Get the current ABI version from source
     get_filename_component(current_abi_path
                            "${CMAKE_SOURCE_DIR}/src/ABI/current"
                            ABSOLUTE)
 
     # Check if the ABI version should be updated
     file(READ ${current_abi_path} CURRENT_ABI_CONTENT)
     string(STRIP "${CURRENT_ABI_CONTENT}" CURRENT_ABI_VERSION)
 
     if (LIBRARY_VERSION VERSION_GREATER CURRENT_ABI_VERSION)
         set(UPDATE_ABI TRUE)
     endif ()
 
     if (UPDATE_ABI)
         message(STATUS "Library version bumped to ${LIBRARY_VERSION}: Updating ABI")
 
         # Get the list of header files
         get_file_list(${PROJECT_NAME}_header_list
                       DIRECTORIES "${CMAKE_SOURCE_DIR}/include/libssh"
                       FILES_PATTERNS "*.h")
 
         # Extract the symbols marked as "LIBSSH_API" from the header files
         extract_symbols(${PROJECT_NAME}.symbols
                         HEADERS_LIST ${PROJECT_NAME}_header_list
                         FILTER_PATTERN "LIBSSH_API"
                         COPY_TO "${CMAKE_SOURCE_DIR}/src/ABI/${PROJECT_NAME}-${LIBRARY_VERSION}.symbols")
 
         if (WITH_ABI_BREAK)
             set(ALLOW_ABI_BREAK "BREAK_ABI")
         endif()
 
         # Target we can depend on in 'make dist'
         set(_SYMBOL_TARGET "${PROJECT_NAME}.map")
 
         # Set the path to the current map file
         set(MAP_PATH "${CMAKE_SOURCE_DIR}/src/${_SYMBOL_TARGET}")
 
         # Generate the symbol version map file
         generate_map_file(${_SYMBOL_TARGET}
                           SYMBOLS ${PROJECT_NAME}.symbols
                           RELEASE_NAME_VERSION ${PROJECT_NAME}_${LIBRARY_VERSION}
                           CURRENT_MAP ${MAP_PATH}
                           COPY_TO ${MAP_PATH}
                           FINAL
                           ${ALLOW_ABI_BREAK})
 
         # Write the current version to the source
         file(WRITE ${current_abi_path} ${LIBRARY_VERSION})
     endif(UPDATE_ABI)
 endif (WITH_SYMBOL_VERSIONING AND ABIMAP_FOUND)
 
 add_custom_target(dist COMMAND ${CMAKE_MAKE_PROGRAM} package_source DEPENDS ${_SYMBOL_TARGET})
 
 message(STATUS "********************************************")
 message(STATUS "********** ${PROJECT_NAME} build options : **********")
 
 message(STATUS "zlib support: ${WITH_ZLIB}")
 message(STATUS "libgcrypt support: ${WITH_GCRYPT}")
 message(STATUS "libmbedTLS support: ${WITH_MBEDTLS}")
 message(STATUS "libnacl support: ${WITH_NACL}")
 message(STATUS "SFTP support: ${WITH_SFTP}")
 message(STATUS "Server support : ${WITH_SERVER}")
 message(STATUS "GSSAPI support : ${WITH_GSSAPI}")
 message(STATUS "Pcap debugging support : ${WITH_PCAP}")
 message(STATUS "With static library: ${WITH_STATIC_LIB}")
 message(STATUS "Unit testing: ${UNIT_TESTING}")
 message(STATUS "Client code testing: ${CLIENT_TESTING}")
 set(_SERVER_TESTING OFF)
 if (WITH_SERVER)
     set(_SERVER_TESTING ${SERVER_TESTING})
 endif()
 message(STATUS "Server code testing: ${_SERVER_TESTING}")
 if (WITH_INTERNAL_DOC)
     message(STATUS "Internal documentation generation")
 else (WITH_INTERNAL_DOC)
     message(STATUS "Public API documentation generation")
 endif (WITH_INTERNAL_DOC)
 message(STATUS "Benchmarks: ${WITH_BENCHMARKS}")
 message(STATUS "Symbol versioning: ${WITH_SYMBOL_VERSIONING}")
 message(STATUS "Allow ABI break: ${WITH_ABI_BREAK}")
 message(STATUS "Release is final: ${WITH_FINAL}")
 message(STATUS "********************************************")
 
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,394 +1,394 @@
-set(CMAKE_OSX_ARCHITECTURES "x86_64;i386")
+set(CMAKE_OSX_ARCHITECTURES "x86_64;ARM64")
 set(CMAKE_OSX_DEPLOYMENT_TARGET "10.10" CACHE STRING "Minimum OS X deployment version")
 
 
 set(LIBSSH_PUBLIC_INCLUDE_DIRS
   ${libssh_SOURCE_DIR}/include
   CACHE INTERNAL "libssh public include directories"
 )
 
 set(LIBSSH_PRIVATE_INCLUDE_DIRS
   ${libssh_BINARY_DIR}
 )
 
 set(LIBSSH_LINK_LIBRARIES
   ${LIBSSH_REQUIRED_LIBRARIES}
 )
 
 if (WIN32)
   set(LIBSSH_LINK_LIBRARIES
     ${LIBSSH_LINK_LIBRARIES}
     ws2_32
   )
 endif (WIN32)
 
 if (HAVE_LIBSOCKET)
   set(LIBSSH_LINK_LIBRARIES
     ${LIBSSH_LINK_LIBRARIES}
     socket
   )
 endif (HAVE_LIBSOCKET)
 
 if (OPENSSL_CRYPTO_LIBRARY)
   set(LIBSSH_PRIVATE_INCLUDE_DIRS
     ${LIBSSH_PRIVATE_INCLUDE_DIRS}
     ${OPENSSL_INCLUDE_DIR}
   )
 
   set(LIBSSH_LINK_LIBRARIES
     ${LIBSSH_LINK_LIBRARIES}
     ${OPENSSL_CRYPTO_LIBRARY}
   )
 endif (OPENSSL_CRYPTO_LIBRARY)
 
 if (MBEDTLS_CRYPTO_LIBRARY)
     set(LIBSSH_PRIVATE_INCLUDE_DIRS
       ${LIBSSH_PRIVATE_INCLUDE_DIRS}
       ${MBEDTLS_INCLUDE_DIR}
     )
   set(LIBSSH_LINK_LIBRARIES
     ${LIBSSH_LINK_LIBRARIES}
     ${MBEDTLS_CRYPTO_LIBRARY}
   )
 endif (MBEDTLS_CRYPTO_LIBRARY)
 
 if (GCRYPT_LIBRARIES)
   set(LIBSSH_PRIVATE_INCLUDE_DIRS
     ${LIBSSH_PRIVATE_INCLUDE_DIRS}
     ${GCRYPT_INCLUDE_DIR}
   )
 
   set(LIBSSH_LINK_LIBRARIES
     ${LIBSSH_LINK_LIBRARIES}
     ${GCRYPT_LIBRARIES})
 endif()
 
 if (WITH_ZLIB)
   set(LIBSSH_PRIVATE_INCLUDE_DIRS
     ${LIBSSH_PRIVATE_INCLUDE_DIRS}
     ${ZLIB_INCLUDE_DIR}
   )
 
   set(LIBSSH_LINK_LIBRARIES
     ${LIBSSH_LINK_LIBRARIES}
     ${ZLIB_LIBRARY}
   )
 endif (WITH_ZLIB)
 
 if (WITH_GSSAPI AND GSSAPI_FOUND)
   set(LIBSSH_PRIVATE_INCLUDE_DIRS
     ${LIBSSH_PRIVATE_INCLUDE_DIRS}
     ${GSSAPI_INCLUDE_DIR}
   )
 
   set(LIBSSH_LINK_LIBRARIES
     ${LIBSSH_LINK_LIBRARIES}
     ${GSSAPI_LIBRARIES}
   )
 endif (WITH_GSSAPI AND GSSAPI_FOUND)
 
 if (WITH_NACL AND NACL_FOUND)
   set(LIBSSH_PRIVATE_INCLUDE_DIRS
     ${LIBSSH_PRIVATE_INCLUDE_DIRS}
     ${NACL_INCLUDE_DIR}
   )
 
   set(LIBSSH_LINK_LIBRARIES
     ${LIBSSH_LINK_LIBRARIES}
     ${NACL_LIBRARY}
   )
 endif (WITH_NACL AND NACL_FOUND)
 
 set(LIBSSH_LINK_LIBRARIES
   ${LIBSSH_LINK_LIBRARIES}
   CACHE INTERNAL "libssh link libraries"
 )
 
 set(LIBSSH_SHARED_LIBRARY
   ssh_shared
   CACHE INTERNAL "libssh shared library"
 )
 
 if (BUILD_STATIC_LIB)
   set(LIBSSH_STATIC_LIBRARY
     ssh_static
     CACHE INTERNAL "libssh static library"
   )
 endif (BUILD_STATIC_LIB)
 
 set(libssh_SRCS
   agent.c
   auth.c
   base64.c
   bignum.c
   buffer.c
   callbacks.c
   channels.c
   client.c
   config.c
   connect.c
   connector.c
   curve25519.c
   dh.c
   ecdh.c
   error.c
   getpass.c
   init.c
   kex.c
   known_hosts.c
   knownhosts.c
   legacy.c
   log.c
   match.c
   messages.c
   misc.c
   options.c
   packet.c
   packet_cb.c
   packet_crypt.c
   pcap.c
   pki.c
   pki_container_openssh.c
   pki_ed25519.c
   poll.c
   session.c
   scp.c
   socket.c
   string.c
   threads.c
   wrapper.c
   external/bcrypt_pbkdf.c
   external/blowfish.c
   external/chacha.c
   external/ed25519.c
   external/fe25519.c
   external/ge25519.c
   external/poly1305.c
   external/sc25519.c
   chachapoly.c
 )
 
 if (DEFAULT_C_NO_DEPRECATION_FLAGS)
     set_source_files_properties(known_hosts.c
                                 PROPERTIES
                                     COMPILE_FLAGS ${DEFAULT_C_NO_DEPRECATION_FLAGS})
 endif()
 
 if (CMAKE_USE_PTHREADS_INIT)
     set(libssh_SRCS
         ${libssh_SRCS}
         threads/noop.c
         threads/pthread.c
     )
 elseif (CMAKE_USE_WIN32_THREADS_INIT)
         set(libssh_SRCS
             ${libssh_SRCS}
             threads/noop.c
             threads/winlocks.c
         )
 else()
     set(libssh_SRCS
         ${libssh_SRCS}
         threads/noop.c
     )
 endif()
 
 if (WITH_GCRYPT)
     set(libssh_SRCS
         ${libssh_SRCS}
         threads/libgcrypt.c
         libgcrypt.c
         gcrypt_missing.c
         pki_gcrypt.c
         ecdh_gcrypt.c
        )
 elseif (WITH_MBEDTLS)
     set(libssh_SRCS
         ${libssh_SRCS}
         threads/mbedtls.c
         libmbedcrypto.c
         mbedcrypto_missing.c
         pki_mbedcrypto.c
         ecdh_mbedcrypto.c
        )
 else (WITH_GCRYPT)
     set(libssh_SRCS
         ${libssh_SRCS}
         threads/libcrypto.c
         pki_crypto.c
         ecdh_crypto.c
         libcrypto.c
        )
     if(OPENSSL_VERSION VERSION_LESS "1.1.0")
         set(libssh_SRCS ${libssh_SRCS} libcrypto-compat.c)
     endif()
 endif (WITH_GCRYPT)
 
 if (WITH_SFTP)
   set(libssh_SRCS
     ${libssh_SRCS}
     sftp.c
   )
 
   if (WITH_SERVER)
     set(libssh_SRCS
       ${libssh_SRCS}
       sftpserver.c
     )
   endif (WITH_SERVER)
 endif (WITH_SFTP)
 
 if (WITH_SERVER)
   set(libssh_SRCS
     ${libssh_SRCS}
     server.c
     bind.c
   )
 endif (WITH_SERVER)
 
 if (WITH_ZLIB)
   set(libssh_SRCS
     ${libssh_SRCS}
     gzip.c
   )
 endif(WITH_ZLIB)
 
 if (WITH_GSSAPI AND GSSAPI_FOUND)
   set(libssh_SRCS
     ${libssh_SRCS}
     gssapi.c
   )
 endif (WITH_GSSAPI AND GSSAPI_FOUND)
 
 if (NOT WITH_NACL)
   set(libssh_SRCS
     ${libssh_SRCS}
     external/curve25519_ref.c
   )
 endif (NOT WITH_NACL)
 
 include_directories(
   ${LIBSSH_PUBLIC_INCLUDE_DIRS}
   ${LIBSSH_PRIVATE_INCLUDE_DIRS}
 )
 
 # Set the path to the default map file
 set(MAP_PATH "${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}.map")
 
 if (WITH_SYMBOL_VERSIONING AND HAVE_LD_VERSION_SCRIPT AND ABIMAP_FOUND)
     # Get the list of header files
     get_file_list(dev_header_list
                   DIRECTORIES "${LIBSSH_PUBLIC_INCLUDE_DIRS}/libssh"
                   FILES_PATTERNS "*.h")
 
     # Extract the symbols marked as "LIBSSH_API" from the header files
     extract_symbols("${PROJECT_NAME}_dev.symbols"
                     HEADERS_LIST dev_header_list
                     FILTER_PATTERN "LIBSSH_API")
 
     if (WITH_ABI_BREAK)
         set(ALLOW_ABI_BREAK "BREAK_ABI")
     endif()
 
     # Generate the symbol version map file
     generate_map_file("${PROJECT_NAME}_dev.map"
                       SYMBOLS "${PROJECT_NAME}_dev.symbols"
                       RELEASE_NAME_VERSION ${PROJECT_NAME}_AFTER_${LIBRARY_VERSION}
                       CURRENT_MAP ${MAP_PATH}
                       ${ALLOW_ABI_BREAK})
 
     set(libssh_SRCS
       ${libssh_SRCS}
       ${PROJECT_NAME}_dev.map
     )
 endif (WITH_SYMBOL_VERSIONING AND HAVE_LD_VERSION_SCRIPT AND ABIMAP_FOUND)
 
 add_library(${LIBSSH_SHARED_LIBRARY} SHARED ${libssh_SRCS})
 target_compile_options(${LIBSSH_SHARED_LIBRARY} PRIVATE ${DEFAULT_C_COMPILE_FLAGS})
 
 target_link_libraries(${LIBSSH_SHARED_LIBRARY} ${LIBSSH_LINK_LIBRARIES})
 
 if (WITH_SYMBOL_VERSIONING AND HAVE_LD_VERSION_SCRIPT AND NOT APPLE)
     if (ABIMAP_FOUND)
         # Change path to devel map file
         set(MAP_PATH "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}_dev.map")
     endif (ABIMAP_FOUND)
 
     set_target_properties(${LIBSSH_SHARED_LIBRARY}
                           PROPERTIES LINK_FLAGS
                           "-Wl,--version-script,\"${MAP_PATH}\"")
 endif (WITH_SYMBOL_VERSIONING AND HAVE_LD_VERSION_SCRIPT)
 
 set_target_properties(
   ${LIBSSH_SHARED_LIBRARY}
     PROPERTIES
       VERSION
         ${LIBRARY_VERSION}
       SOVERSION
         ${LIBRARY_SOVERSION}
       OUTPUT_NAME
         ssh
       DEFINE_SYMBOL
         LIBSSH_EXPORTS
 )
 
 if (WITH_VISIBILITY_HIDDEN)
   set_target_properties(${LIBSSH_SHARED_LIBRARY} PROPERTIES COMPILE_FLAGS "-fvisibility=hidden")
 endif (WITH_VISIBILITY_HIDDEN)
 
 if (MINGW)
     set_target_properties(${LIBSSH_SHARED_LIBRARY} PROPERTIES LINK_FLAGS "-Wl,--enable-stdcall-fixup")
 endif ()
 
 
 install(
   TARGETS
     ${LIBSSH_SHARED_LIBRARY}
   RUNTIME DESTINATION ${BIN_INSTALL_DIR}
   LIBRARY DESTINATION ${LIB_INSTALL_DIR}
   ARCHIVE DESTINATION ${LIB_INSTALL_DIR}
   COMPONENT libraries
 )
 
 if (BUILD_STATIC_LIB)
   add_library(${LIBSSH_STATIC_LIBRARY} STATIC ${libssh_SRCS})
   target_compile_options(${LIBSSH_STATIC_LIBRARY} PRIVATE ${DEFAULT_C_COMPILE_FLAGS})
 
   if (MSVC)
     set(OUTPUT_SUFFIX static)
   else (MSVC)
     set(OUTPUT_SUFFIX )
   endif (MSVC)
   set_target_properties(
     ${LIBSSH_STATIC_LIBRARY}
       PROPERTIES
         VERSION
           ${LIBRARY_VERSION}
         SOVERSION
           ${LIBRARY_SOVERSION}
         OUTPUT_NAME
           ssh
         ARCHIVE_OUTPUT_DIRECTORY
           ${CMAKE_CURRENT_BINARY_DIR}/${OUTPUT_SUFFIX}
   )
 
   if (WIN32)
     set_target_properties(
       ${LIBSSH_STATIC_LIBRARY}
         PROPERTIES
           COMPILE_FLAGS
             "-DLIBSSH_STATIC"
     )
   endif (WIN32)
 
     if (WITH_STATIC_LIB)
       install(TARGETS
                 ${LIBSSH_STATIC_LIBRARY}
               DESTINATION
                 ${LIB_INSTALL_DIR}/${OUTPUT_SUFFIX}
               COMPONENT
                 libraries)
     endif (WITH_STATIC_LIB)
 endif (BUILD_STATIC_LIB)
 
 message(STATUS "Threads_FOUND=${Threads_FOUND}")