Modules/FindOpenSSL.cmake

   1 # Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   2 # file Copyright.txt or https://cmake.org/licensing for details.
   3
   4 #[=======================================================================[.rst:
   5 FindOpenSSL
   6 -----------
   7
   8 Find the OpenSSL encryption library.
   9
  10 This module finds an installed OpenSSL library and determines its version.
  11
  12 .. versionadded:: 3.19
  13   When a version is requested, it can be specified as a simple value or as a
  14   range. For a detailed description of version range usage and capabilities,
  15   refer to the :command:`find_package` command.
  16
  17 .. versionadded:: 3.18
  18   Support for OpenSSL 3.0.
  19
  20 Optional COMPONENTS
  21 ^^^^^^^^^^^^^^^^^^^
  22
  23 .. versionadded:: 3.12
  24
  25 This module supports two optional COMPONENTS: ``Crypto`` and ``SSL``.  Both
  26 components have associated imported targets, as described below.
  27
  28 Imported Targets
  29 ^^^^^^^^^^^^^^^^
  30
  31 .. versionadded:: 3.4
  32
  33 This module defines the following :prop_tgt:`IMPORTED` targets:
  34
  35 ``OpenSSL::SSL``
  36   The OpenSSL ``ssl`` library, if found.
  37 ``OpenSSL::Crypto``
  38   The OpenSSL ``crypto`` library, if found.
  39 ``OpenSSL::applink``
  40   .. versionadded:: 3.18
  41
  42   The OpenSSL ``applink`` components that might be need to be compiled into
  43   projects under MSVC. This target is available only if found OpenSSL version
  44   is not less than 0.9.8. By linking this target the above OpenSSL targets can
  45   be linked even if the project has different MSVC runtime configurations with
  46   the above OpenSSL targets. This target has no effect on platforms other than
  47   MSVC.
  48
  49 NOTE: Due to how ``INTERFACE_SOURCES`` are consumed by the consuming target,
  50 unless you certainly know what you are doing, it is always preferred to link
  51 ``OpenSSL::applink`` target as ``PRIVATE`` and to make sure that this target is
  52 linked at most once for the whole dependency graph of any library or
  53 executable:
  54
  55 .. code-block:: cmake
  56
  57    target_link_libraries(myTarget PRIVATE OpenSSL::applink)
  58
  59 Otherwise you would probably encounter unexpected random problems when building
  60 and linking, as both the ISO C and the ISO C++ standard claims almost nothing
  61 about what a link process should be.
  62
  63 Result Variables
  64 ^^^^^^^^^^^^^^^^
  65
  66 This module will set the following variables in your project:
  67
  68 ``OPENSSL_FOUND``
  69   System has the OpenSSL library. If no components are requested it only
  70   requires the crypto library.
  71 ``OPENSSL_INCLUDE_DIR``
  72   The OpenSSL include directory.
  73 ``OPENSSL_CRYPTO_LIBRARY``
  74   The OpenSSL crypto library.
  75 ``OPENSSL_CRYPTO_LIBRARIES``
  76   The OpenSSL crypto library and its dependencies.
  77 ``OPENSSL_SSL_LIBRARY``
  78   The OpenSSL SSL library.
  79 ``OPENSSL_SSL_LIBRARIES``
  80   The OpenSSL SSL library and its dependencies.
  81 ``OPENSSL_LIBRARIES``
  82   All OpenSSL libraries and their dependencies.
  83 ``OPENSSL_VERSION``
  84   This is set to ``$major.$minor.$revision$patch`` (e.g. ``0.9.8s``).
  85 ``OPENSSL_APPLINK_SOURCE``
  86   The sources in the target ``OpenSSL::applink`` that is mentioned above. This
  87   variable shall always be undefined if found openssl version is less than
  88   0.9.8 or if platform is not MSVC.
  89
  90 Hints
  91 ^^^^^
  92
  93 The following variables may be set to control search behavior:
  94
  95 ``OPENSSL_ROOT_DIR``
  96   Set to the root directory of an OpenSSL installation.
  97
  98 ``OPENSSL_USE_STATIC_LIBS``
  99   .. versionadded:: 3.4
 100
 101   Set to ``TRUE`` to look for static libraries.
 102
 103 ``OPENSSL_MSVC_STATIC_RT``
 104   .. versionadded:: 3.5
 105
 106   Set to ``TRUE`` to choose the MT version of the lib.
 107
 108 ``ENV{PKG_CONFIG_PATH}``
 109   On UNIX-like systems, ``pkg-config`` is used to locate the system OpenSSL.
 110   Set the ``PKG_CONFIG_PATH`` environment variable to look in alternate
 111   locations.  Useful on multi-lib systems.
 112 #]=======================================================================]
 113
 114 cmake_policy(PUSH)
 115 cmake_policy(SET CMP0159 NEW) # file(STRINGS) with REGEX updates CMAKE_MATCH_<n>
 116
 117 macro(_OpenSSL_test_and_find_dependencies ssl_library crypto_library)
 118   unset(_OpenSSL_extra_static_deps)
 119   if(UNIX AND
 120      (("${ssl_library}" MATCHES "\\${CMAKE_STATIC_LIBRARY_SUFFIX}$") OR
 121       ("${crypto_library}" MATCHES "\\${CMAKE_STATIC_LIBRARY_SUFFIX}$")))
 122     set(_OpenSSL_has_dependencies TRUE)
 123     unset(_OpenSSL_has_dependency_zlib)
 124     if(OPENSSL_USE_STATIC_LIBS)
 125       set(_OpenSSL_libs "${_OPENSSL_STATIC_LIBRARIES}")
 126       set(_OpenSSL_ldflags_other "${_OPENSSL_STATIC_LDFLAGS_OTHER}")
 127     else()
 128       set(_OpenSSL_libs "${_OPENSSL_LIBRARIES}")
 129       set(_OpenSSL_ldflags_other "${_OPENSSL_LDFLAGS_OTHER}")
 130     endif()
 131     if(_OpenSSL_libs)
 132       unset(_OpenSSL_has_dependency_dl)
 133       foreach(_OPENSSL_DEP_LIB IN LISTS _OpenSSL_libs)
 134         if (_OPENSSL_DEP_LIB STREQUAL "ssl" OR _OPENSSL_DEP_LIB STREQUAL "crypto")
 135           # ignoring: these are the targets
 136         elseif(_OPENSSL_DEP_LIB STREQUAL CMAKE_DL_LIBS)
 137           set(_OpenSSL_has_dependency_dl TRUE)
 138         elseif(_OPENSSL_DEP_LIB STREQUAL "z")
 139           find_package(ZLIB)
 140           set(_OpenSSL_has_dependency_zlib TRUE)
 141         else()
 142           list(APPEND _OpenSSL_extra_static_deps "${_OPENSSL_DEP_LIB}")
 143         endif()
 144       endforeach()
 145       unset(_OPENSSL_DEP_LIB)
 146     elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
 147       set(_OpenSSL_has_dependency_dl TRUE)
 148     endif()
 149     if(_OpenSSL_ldflags_other)
 150       unset(_OpenSSL_has_dependency_threads)
 151       foreach(_OPENSSL_DEP_LDFLAG IN LISTS _OpenSSL_ldflags_other)
 152         if (_OPENSSL_DEP_LDFLAG STREQUAL "-pthread")
 153           set(_OpenSSL_has_dependency_threads TRUE)
 154           find_package(Threads)
 155         endif()
 156       endforeach()
 157       unset(_OPENSSL_DEP_LDFLAG)
 158     elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
 159       set(_OpenSSL_has_dependency_threads TRUE)
 160       find_package(Threads)
 161     endif()
 162     unset(_OpenSSL_libs)
 163     unset(_OpenSSL_ldflags_other)
 164   else()
 165     set(_OpenSSL_has_dependencies FALSE)
 166   endif()
 167 endmacro()
 168
 169 function(_OpenSSL_add_dependencies libraries_var)
 170   if(_OpenSSL_has_dependency_zlib)
 171     list(APPEND ${libraries_var} ${ZLIB_LIBRARY})
 172   endif()
 173   if(_OpenSSL_has_dependency_threads)
 174     list(APPEND ${libraries_var} ${CMAKE_THREAD_LIBS_INIT})
 175   endif()
 176   if(_OpenSSL_has_dependency_dl)
 177     list(APPEND ${libraries_var} ${CMAKE_DL_LIBS})
 178   endif()
 179   list(APPEND ${libraries_var} ${_OpenSSL_extra_static_deps})
 180   set(${libraries_var} ${${libraries_var}} PARENT_SCOPE)
 181 endfunction()
 182
 183 function(_OpenSSL_target_add_dependencies target)
 184   if(_OpenSSL_has_dependencies)
 185     if(_OpenSSL_has_dependency_zlib)
 186       set_property( TARGET ${target} APPEND PROPERTY INTERFACE_LINK_LIBRARIES ZLIB::ZLIB )
 187     endif()
 188     if(_OpenSSL_has_dependency_threads)
 189       set_property( TARGET ${target} APPEND PROPERTY INTERFACE_LINK_LIBRARIES Threads::Threads)
 190     endif()
 191     if(_OpenSSL_has_dependency_dl)
 192       set_property( TARGET ${target} APPEND PROPERTY INTERFACE_LINK_LIBRARIES ${CMAKE_DL_LIBS} )
 193     endif()
 194     if(_OpenSSL_extra_static_deps)
 195       set_property( TARGET ${target} APPEND PROPERTY INTERFACE_LINK_LIBRARIES ${_OpenSSL_extra_static_deps})
 196     endif()
 197   endif()
 198   if(WIN32 AND OPENSSL_USE_STATIC_LIBS)
 199     if(WINCE)
 200       set_property( TARGET ${target} APPEND PROPERTY INTERFACE_LINK_LIBRARIES ws2 )
 201     else()
 202       set_property( TARGET ${target} APPEND PROPERTY INTERFACE_LINK_LIBRARIES ws2_32 )
 203     endif()
 204     set_property( TARGET ${target} APPEND PROPERTY INTERFACE_LINK_LIBRARIES crypt32 )
 205   endif()
 206 endfunction()
 207
 208 if (UNIX)
 209   find_package(PkgConfig QUIET)
 210   if(PKG_CONFIG_FOUND)
 211     pkg_check_modules(_OPENSSL QUIET openssl)
 212   endif()
 213 endif ()
 214
 215 # Support preference of static libs by adjusting CMAKE_FIND_LIBRARY_SUFFIXES
 216 if(OPENSSL_USE_STATIC_LIBS)
 217   set(_openssl_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
 218   if(MSVC)
 219     set(CMAKE_FIND_LIBRARY_SUFFIXES .lib .a ${CMAKE_FIND_LIBRARY_SUFFIXES})
 220   else()
 221     set(CMAKE_FIND_LIBRARY_SUFFIXES .a )
 222   endif()
 223 endif()
 224
 225 if(CMAKE_SYSTEM_NAME STREQUAL "QNX" AND
 226   CMAKE_SYSTEM_VERSION VERSION_GREATER_EQUAL "7.0" AND CMAKE_SYSTEM_VERSION VERSION_LESS "7.1" AND
 227   OpenSSL_FIND_VERSION VERSION_GREATER_EQUAL "1.1" AND OpenSSL_FIND_VERSION VERSION_LESS "1.2")
 228   # QNX 7.0.x provides openssl 1.0.2 and 1.1.1 in parallel:
 229   # * openssl 1.0.2: libcrypto.so.2 and libssl.so.2, headers under usr/include/openssl
 230   # * openssl 1.1.1: libcrypto1_1.so.2.1 and libssl1_1.so.2.1, header under usr/include/openssl1_1
 231   # See http://www.qnx.com/developers/articles/rel_6726_0.html
 232   set(_OPENSSL_FIND_PATH_SUFFIX "openssl1_1")
 233   set(_OPENSSL_NAME_POSTFIX "1_1")
 234 else()
 235   set(_OPENSSL_FIND_PATH_SUFFIX "include")
 236 endif()
 237
 238 if (OPENSSL_ROOT_DIR OR NOT "$ENV{OPENSSL_ROOT_DIR}" STREQUAL "")
 239   set(_OPENSSL_ROOT_HINTS HINTS ${OPENSSL_ROOT_DIR} ENV OPENSSL_ROOT_DIR)
 240   set(_OPENSSL_ROOT_PATHS NO_DEFAULT_PATH)
 241 elseif (MSVC)
 242   # http://www.slproweb.com/products/Win32OpenSSL.html
 243   set(_OPENSSL_ROOT_HINTS
 244     HINTS
 245     "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\OpenSSL (32-bit)_is1;Inno Setup: App Path]"
 246     "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\OpenSSL (64-bit)_is1;Inno Setup: App Path]"
 247     )
 248
 249   if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "8")
 250     set(_arch "Win64")
 251     file(TO_CMAKE_PATH "$ENV{PROGRAMFILES}" _programfiles)
 252   else()
 253     set(_arch "Win32")
 254     set(_progfiles_x86 "ProgramFiles(x86)")
 255     if(NOT "$ENV{${_progfiles_x86}}" STREQUAL "")
 256       # under windows 64 bit machine
 257       file(TO_CMAKE_PATH "$ENV{${_progfiles_x86}}" _programfiles)
 258     else()
 259       # under windows 32 bit machine
 260       file(TO_CMAKE_PATH "$ENV{ProgramFiles}" _programfiles)
 261     endif()
 262   endif()
 263
 264   set(_OPENSSL_ROOT_PATHS
 265     PATHS
 266     "${_programfiles}/OpenSSL"
 267     "${_programfiles}/OpenSSL-${_arch}"
 268     "C:/OpenSSL/"
 269     "C:/OpenSSL-${_arch}/"
 270     )
 271   unset(_programfiles)
 272   unset(_arch)
 273 endif ()
 274
 275 set(_OPENSSL_ROOT_HINTS_AND_PATHS
 276     ${_OPENSSL_ROOT_HINTS}
 277     ${_OPENSSL_ROOT_PATHS}
 278     )
 279
 280 find_path(OPENSSL_INCLUDE_DIR
 281   NAMES
 282     openssl/ssl.h
 283   ${_OPENSSL_ROOT_HINTS_AND_PATHS}
 284   HINTS
 285     ${_OPENSSL_INCLUDEDIR}
 286     ${_OPENSSL_INCLUDE_DIRS}
 287   PATH_SUFFIXES
 288     ${_OPENSSL_FIND_PATH_SUFFIX}
 289 )
 290
 291 if(WIN32 AND NOT CYGWIN)
 292   if(MSVC)
 293     # /MD and /MDd are the standard values - if someone wants to use
 294     # others, the libnames have to change here too
 295     # use also ssl and ssleay32 in debug as fallback for openssl < 0.9.8b
 296     # enable OPENSSL_MSVC_STATIC_RT to get the libs build /MT (Multithreaded no-DLL)
 297     # In Visual C++ naming convention each of these four kinds of Windows libraries has it's standard suffix:
 298     #   * MD for dynamic-release
 299     #   * MDd for dynamic-debug
 300     #   * MT for static-release
 301     #   * MTd for static-debug
 302
 303     # Implementation details:
 304     # We are using the libraries located in the VC subdir instead of the parent directory even though :
 305     # libeay32MD.lib is identical to ../libeay32.lib, and
 306     # ssleay32MD.lib is identical to ../ssleay32.lib
 307     # enable OPENSSL_USE_STATIC_LIBS to use the static libs located in lib/VC/static
 308
 309     if (OPENSSL_MSVC_STATIC_RT)
 310       set(_OPENSSL_MSVC_RT_MODE "MT")
 311     else ()
 312       set(_OPENSSL_MSVC_RT_MODE "MD")
 313     endif ()
 314
 315     # Since OpenSSL 1.1, lib names are like libcrypto32MTd.lib and libssl32MTd.lib
 316     if( "${CMAKE_SIZEOF_VOID_P}" STREQUAL "8" )
 317         set(_OPENSSL_MSVC_ARCH_SUFFIX "64")
 318         set(_OPENSSL_MSVC_FOLDER_SUFFIX "64")
 319     else()
 320         set(_OPENSSL_MSVC_ARCH_SUFFIX "32")
 321         set(_OPENSSL_MSVC_FOLDER_SUFFIX "86")
 322     endif()
 323
 324     if(OPENSSL_USE_STATIC_LIBS)
 325       set(_OPENSSL_STATIC_SUFFIX
 326         "_static"
 327       )
 328       set(_OPENSSL_PATH_SUFFIXES_DEBUG
 329         "lib/VC/x${_OPENSSL_MSVC_FOLDER_SUFFIX}/${_OPENSSL_MSVC_RT_MODE}d"
 330         "lib/VC/static"
 331         "VC/static"
 332         "lib"
 333         )
 334       set(_OPENSSL_PATH_SUFFIXES_RELEASE
 335         "lib/VC/x${_OPENSSL_MSVC_FOLDER_SUFFIX}/${_OPENSSL_MSVC_RT_MODE}"
 336         "lib/VC/static"
 337         "VC/static"
 338         "lib"
 339         )
 340     else()
 341       set(_OPENSSL_STATIC_SUFFIX
 342         ""
 343       )
 344       set(_OPENSSL_PATH_SUFFIXES_DEBUG
 345         "lib/VC/x${_OPENSSL_MSVC_FOLDER_SUFFIX}/${_OPENSSL_MSVC_RT_MODE}d"
 346         "lib/VC"
 347         "VC"
 348         "lib"
 349         )
 350       set(_OPENSSL_PATH_SUFFIXES_RELEASE
 351         "lib/VC/x${_OPENSSL_MSVC_FOLDER_SUFFIX}/${_OPENSSL_MSVC_RT_MODE}"
 352         "lib/VC"
 353         "VC"
 354         "lib"
 355         )
 356     endif ()
 357
 358     find_library(LIB_EAY_DEBUG
 359       NAMES
 360         # When OpenSSL is built with default options, the static library name is suffixed with "_static".
 361         # Looking the "libcrypto_static.lib" with a higher priority than "libcrypto.lib" which is the
 362         # import library of "libcrypto.dll".
 363         libcrypto${_OPENSSL_STATIC_SUFFIX}${_OPENSSL_MSVC_ARCH_SUFFIX}${_OPENSSL_MSVC_RT_MODE}d
 364         libcrypto${_OPENSSL_STATIC_SUFFIX}${_OPENSSL_MSVC_RT_MODE}d
 365         libcrypto${_OPENSSL_STATIC_SUFFIX}d
 366         libcrypto${_OPENSSL_STATIC_SUFFIX}
 367         libeay32${_OPENSSL_STATIC_SUFFIX}${_OPENSSL_MSVC_RT_MODE}d
 368         libeay32${_OPENSSL_STATIC_SUFFIX}d
 369         crypto${_OPENSSL_STATIC_SUFFIX}d
 370         # When OpenSSL is built with the "-static" option, only the static build is produced,
 371         # and it is not suffixed with "_static".
 372         libcrypto${_OPENSSL_MSVC_ARCH_SUFFIX}${_OPENSSL_MSVC_RT_MODE}d
 373         libcrypto${_OPENSSL_MSVC_RT_MODE}d
 374         libcryptod
 375         libeay32${_OPENSSL_MSVC_RT_MODE}d
 376         libeay32d
 377         cryptod
 378       NAMES_PER_DIR
 379       ${_OPENSSL_ROOT_HINTS_AND_PATHS}
 380       PATH_SUFFIXES
 381         ${_OPENSSL_PATH_SUFFIXES_DEBUG}
 382     )
 383
 384     find_library(LIB_EAY_RELEASE
 385       NAMES
 386         # When OpenSSL is built with default options, the static library name is suffixed with "_static".
 387         # Looking the "libcrypto_static.lib" with a higher priority than "libcrypto.lib" which is the
 388         # import library of "libcrypto.dll".
 389         libcrypto${_OPENSSL_STATIC_SUFFIX}${_OPENSSL_MSVC_ARCH_SUFFIX}${_OPENSSL_MSVC_RT_MODE}
 390         libcrypto${_OPENSSL_STATIC_SUFFIX}${_OPENSSL_MSVC_RT_MODE}
 391         libcrypto${_OPENSSL_STATIC_SUFFIX}
 392         libeay32${_OPENSSL_STATIC_SUFFIX}${_OPENSSL_MSVC_RT_MODE}
 393         libeay32${_OPENSSL_STATIC_SUFFIX}
 394         crypto${_OPENSSL_STATIC_SUFFIX}
 395         # When OpenSSL is built with the "-static" option, only the static build is produced,
 396         # and it is not suffixed with "_static".
 397         libcrypto${_OPENSSL_MSVC_ARCH_SUFFIX}${_OPENSSL_MSVC_RT_MODE}
 398         libcrypto${_OPENSSL_MSVC_RT_MODE}
 399         libcrypto
 400         libeay32${_OPENSSL_MSVC_RT_MODE}
 401         libeay32
 402         crypto
 403       NAMES_PER_DIR
 404       ${_OPENSSL_ROOT_HINTS_AND_PATHS}
 405       PATH_SUFFIXES
 406         ${_OPENSSL_PATH_SUFFIXES_RELEASE}
 407     )
 408
 409     find_library(SSL_EAY_DEBUG
 410       NAMES
 411         # When OpenSSL is built with default options, the static library name is suffixed with "_static".
 412         # Looking the "libssl_static.lib" with a higher priority than "libssl.lib" which is the
 413         # import library of "libssl.dll".
 414         libssl${_OPENSSL_STATIC_SUFFIX}${_OPENSSL_MSVC_ARCH_SUFFIX}${_OPENSSL_MSVC_RT_MODE}d
 415         libssl${_OPENSSL_STATIC_SUFFIX}${_OPENSSL_MSVC_RT_MODE}d
 416         libssl${_OPENSSL_STATIC_SUFFIX}d
 417         libssl${_OPENSSL_STATIC_SUFFIX}
 418         ssleay32${_OPENSSL_STATIC_SUFFIX}${_OPENSSL_MSVC_RT_MODE}d
 419         ssleay32${_OPENSSL_STATIC_SUFFIX}d
 420         ssl${_OPENSSL_STATIC_SUFFIX}d
 421         # When OpenSSL is built with the "-static" option, only the static build is produced,
 422         # and it is not suffixed with "_static".
 423         libssl${_OPENSSL_MSVC_ARCH_SUFFIX}${_OPENSSL_MSVC_RT_MODE}d
 424         libssl${_OPENSSL_MSVC_RT_MODE}d
 425         libssld
 426         ssleay32${_OPENSSL_MSVC_RT_MODE}d
 427         ssleay32d
 428         ssld
 429       NAMES_PER_DIR
 430       ${_OPENSSL_ROOT_HINTS_AND_PATHS}
 431       PATH_SUFFIXES
 432         ${_OPENSSL_PATH_SUFFIXES_DEBUG}
 433     )
 434
 435     find_library(SSL_EAY_RELEASE
 436       NAMES
 437         # When OpenSSL is built with default options, the static library name is suffixed with "_static".
 438         # Looking the "libssl_static.lib" with a higher priority than "libssl.lib" which is the
 439         # import library of "libssl.dll".
 440         libssl${_OPENSSL_STATIC_SUFFIX}${_OPENSSL_MSVC_ARCH_SUFFIX}${_OPENSSL_MSVC_RT_MODE}
 441         libssl${_OPENSSL_STATIC_SUFFIX}${_OPENSSL_MSVC_RT_MODE}
 442         libssl${_OPENSSL_STATIC_SUFFIX}
 443         ssleay32${_OPENSSL_STATIC_SUFFIX}${_OPENSSL_MSVC_RT_MODE}
 444         ssleay32${_OPENSSL_STATIC_SUFFIX}
 445         ssl${_OPENSSL_STATIC_SUFFIX}
 446         # When OpenSSL is built with the "-static" option, only the static build is produced,
 447         # and it is not suffixed with "_static".
 448         libssl${_OPENSSL_MSVC_ARCH_SUFFIX}${_OPENSSL_MSVC_RT_MODE}
 449         libssl${_OPENSSL_MSVC_RT_MODE}
 450         libssl
 451         ssleay32${_OPENSSL_MSVC_RT_MODE}
 452         ssleay32
 453         ssl
 454       NAMES_PER_DIR
 455       ${_OPENSSL_ROOT_HINTS_AND_PATHS}
 456       PATH_SUFFIXES
 457         ${_OPENSSL_PATH_SUFFIXES_RELEASE}
 458     )
 459
 460     set(LIB_EAY_LIBRARY_DEBUG "${LIB_EAY_DEBUG}")
 461     set(LIB_EAY_LIBRARY_RELEASE "${LIB_EAY_RELEASE}")
 462     set(SSL_EAY_LIBRARY_DEBUG "${SSL_EAY_DEBUG}")
 463     set(SSL_EAY_LIBRARY_RELEASE "${SSL_EAY_RELEASE}")
 464
 465     include(${CMAKE_CURRENT_LIST_DIR}/SelectLibraryConfigurations.cmake)
 466     select_library_configurations(LIB_EAY)
 467     select_library_configurations(SSL_EAY)
 468
 469     mark_as_advanced(LIB_EAY_LIBRARY_DEBUG LIB_EAY_LIBRARY_RELEASE
 470                      SSL_EAY_LIBRARY_DEBUG SSL_EAY_LIBRARY_RELEASE)
 471     set(OPENSSL_SSL_LIBRARY ${SSL_EAY_LIBRARY} )
 472     set(OPENSSL_CRYPTO_LIBRARY ${LIB_EAY_LIBRARY} )
 473   elseif(MINGW)
 474     # same player, for MinGW
 475     set(LIB_EAY_NAMES crypto libeay32)
 476     set(SSL_EAY_NAMES ssl ssleay32)
 477     find_library(LIB_EAY
 478       NAMES
 479         ${LIB_EAY_NAMES}
 480       NAMES_PER_DIR
 481       ${_OPENSSL_ROOT_HINTS_AND_PATHS}
 482       PATH_SUFFIXES
 483         "lib/MinGW"
 484         "lib"
 485         "lib64"
 486     )
 487
 488     find_library(SSL_EAY
 489       NAMES
 490         ${SSL_EAY_NAMES}
 491       NAMES_PER_DIR
 492       ${_OPENSSL_ROOT_HINTS_AND_PATHS}
 493       PATH_SUFFIXES
 494         "lib/MinGW"
 495         "lib"
 496         "lib64"
 497     )
 498
 499     mark_as_advanced(SSL_EAY LIB_EAY)
 500     set(OPENSSL_SSL_LIBRARY ${SSL_EAY} )
 501     set(OPENSSL_CRYPTO_LIBRARY ${LIB_EAY} )
 502     unset(LIB_EAY_NAMES)
 503     unset(SSL_EAY_NAMES)
 504   else()
 505     # Not sure what to pick for -say- intel, let's use the toplevel ones and hope someone report issues:
 506     find_library(LIB_EAY
 507       NAMES
 508         libcrypto
 509         libeay32
 510       NAMES_PER_DIR
 511       ${_OPENSSL_ROOT_HINTS_AND_PATHS}
 512       HINTS
 513         ${_OPENSSL_LIBDIR}
 514       PATH_SUFFIXES
 515         lib
 516     )
 517
 518     find_library(SSL_EAY
 519       NAMES
 520         libssl
 521         ssleay32
 522       NAMES_PER_DIR
 523       ${_OPENSSL_ROOT_HINTS_AND_PATHS}
 524       HINTS
 525         ${_OPENSSL_LIBDIR}
 526       PATH_SUFFIXES
 527         lib
 528     )
 529
 530     mark_as_advanced(SSL_EAY LIB_EAY)
 531     set(OPENSSL_SSL_LIBRARY ${SSL_EAY} )
 532     set(OPENSSL_CRYPTO_LIBRARY ${LIB_EAY} )
 533   endif()
 534 else()
 535
 536   find_library(OPENSSL_SSL_LIBRARY
 537     NAMES
 538       ssl${_OPENSSL_NAME_POSTFIX}
 539       ssleay32
 540       ssleay32MD
 541     NAMES_PER_DIR
 542     ${_OPENSSL_ROOT_HINTS_AND_PATHS}
 543     HINTS
 544       ${_OPENSSL_LIBDIR}
 545       ${_OPENSSL_LIBRARY_DIRS}
 546     PATH_SUFFIXES
 547       lib lib64
 548   )
 549
 550   find_library(OPENSSL_CRYPTO_LIBRARY
 551     NAMES
 552       crypto${_OPENSSL_NAME_POSTFIX}
 553     NAMES_PER_DIR
 554     ${_OPENSSL_ROOT_HINTS_AND_PATHS}
 555     HINTS
 556       ${_OPENSSL_LIBDIR}
 557       ${_OPENSSL_LIBRARY_DIRS}
 558     PATH_SUFFIXES
 559       lib lib64
 560   )
 561
 562   mark_as_advanced(OPENSSL_CRYPTO_LIBRARY OPENSSL_SSL_LIBRARY)
 563
 564 endif()
 565
 566 set(OPENSSL_SSL_LIBRARIES ${OPENSSL_SSL_LIBRARY})
 567 set(OPENSSL_CRYPTO_LIBRARIES ${OPENSSL_CRYPTO_LIBRARY})
 568 set(OPENSSL_LIBRARIES ${OPENSSL_SSL_LIBRARIES} ${OPENSSL_CRYPTO_LIBRARIES} )
 569 _OpenSSL_test_and_find_dependencies("${OPENSSL_SSL_LIBRARY}" "${OPENSSL_CRYPTO_LIBRARY}")
 570 if(_OpenSSL_has_dependencies)
 571   _OpenSSL_add_dependencies( OPENSSL_SSL_LIBRARIES )
 572   _OpenSSL_add_dependencies( OPENSSL_CRYPTO_LIBRARIES )
 573   _OpenSSL_add_dependencies( OPENSSL_LIBRARIES )
 574 endif()
 575
 576 if(OPENSSL_INCLUDE_DIR AND EXISTS "${OPENSSL_INCLUDE_DIR}/openssl/opensslv.h")
 577   file(STRINGS "${OPENSSL_INCLUDE_DIR}/openssl/opensslv.h" openssl_version_str
 578        REGEX "^#[\t ]*define[\t ]+OPENSSL_VERSION_NUMBER[\t ]+0x([0-9a-fA-F])+.*")
 579
 580   if(openssl_version_str)
 581     # The version number is encoded as 0xMNNFFPPS: major minor fix patch status
 582     # The status gives if this is a developer or prerelease and is ignored here.
 583     # Major, minor, and fix directly translate into the version numbers shown in
 584     # the string. The patch field translates to the single character suffix that
 585     # indicates the bug fix state, which 00 -> nothing, 01 -> a, 02 -> b and so
 586     # on.
 587
 588     string(REGEX REPLACE "^.*OPENSSL_VERSION_NUMBER[\t ]+0x([0-9a-fA-F])([0-9a-fA-F][0-9a-fA-F])([0-9a-fA-F][0-9a-fA-F])([0-9a-fA-F][0-9a-fA-F])([0-9a-fA-F]).*$"
 589            "\\1;\\2;\\3;\\4;\\5" OPENSSL_VERSION_LIST "${openssl_version_str}")
 590     list(GET OPENSSL_VERSION_LIST 0 OPENSSL_VERSION_MAJOR)
 591     list(GET OPENSSL_VERSION_LIST 1 OPENSSL_VERSION_MINOR)
 592     math(EXPR OPENSSL_VERSION_MINOR "0x${OPENSSL_VERSION_MINOR}")
 593     list(GET OPENSSL_VERSION_LIST 2 OPENSSL_VERSION_FIX)
 594     math(EXPR OPENSSL_VERSION_FIX "0x${OPENSSL_VERSION_FIX}")
 595     list(GET OPENSSL_VERSION_LIST 3 OPENSSL_VERSION_PATCH)
 596
 597     if (NOT OPENSSL_VERSION_PATCH STREQUAL "00")
 598       # 96 is the ASCII code of 'a' minus 1
 599       math(EXPR OPENSSL_VERSION_PATCH_ASCII "0x${OPENSSL_VERSION_PATCH} + 96")
 600       # Once anyone knows how OpenSSL would call the patch versions beyond 'z'
 601       # this should be updated to handle that, too. This has not happened yet
 602       # so it is simply ignored here for now.
 603       string(ASCII "${OPENSSL_VERSION_PATCH_ASCII}" OPENSSL_VERSION_PATCH_STRING)
 604     endif ()
 605
 606     set(OPENSSL_VERSION "${OPENSSL_VERSION_MAJOR}.${OPENSSL_VERSION_MINOR}.${OPENSSL_VERSION_FIX}${OPENSSL_VERSION_PATCH_STRING}")
 607   else ()
 608     # Since OpenSSL 3.0.0, the new version format is MAJOR.MINOR.PATCH and
 609     # a new OPENSSL_VERSION_STR macro contains exactly that
 610     file(STRINGS "${OPENSSL_INCLUDE_DIR}/openssl/opensslv.h" OPENSSL_VERSION_STR
 611          REGEX "^#[\t ]*define[\t ]+OPENSSL_VERSION_STR[\t ]+\"([0-9])+\\.([0-9])+\\.([0-9])+\".*")
 612     string(REGEX REPLACE "^.*OPENSSL_VERSION_STR[\t ]+\"([0-9]+\\.[0-9]+\\.[0-9]+)\".*$"
 613            "\\1" OPENSSL_VERSION_STR "${OPENSSL_VERSION_STR}")
 614
 615     set(OPENSSL_VERSION "${OPENSSL_VERSION_STR}")
 616
 617     # Setting OPENSSL_VERSION_MAJOR OPENSSL_VERSION_MINOR and OPENSSL_VERSION_FIX
 618     string(REGEX MATCHALL "([0-9])+" OPENSSL_VERSION_NUMBER "${OPENSSL_VERSION}")
 619     list(POP_FRONT OPENSSL_VERSION_NUMBER
 620       OPENSSL_VERSION_MAJOR
 621       OPENSSL_VERSION_MINOR
 622       OPENSSL_VERSION_FIX)
 623
 624     unset(OPENSSL_VERSION_NUMBER)
 625     unset(OPENSSL_VERSION_STR)
 626   endif ()
 627 endif ()
 628
 629 foreach(_comp IN LISTS OpenSSL_FIND_COMPONENTS)
 630   if(_comp STREQUAL "Crypto")
 631     if(EXISTS "${OPENSSL_INCLUDE_DIR}" AND
 632         (EXISTS "${OPENSSL_CRYPTO_LIBRARY}" OR
 633         EXISTS "${LIB_EAY_LIBRARY_DEBUG}" OR
 634         EXISTS "${LIB_EAY_LIBRARY_RELEASE}")
 635     )
 636       set(OpenSSL_${_comp}_FOUND TRUE)
 637     else()
 638       set(OpenSSL_${_comp}_FOUND FALSE)
 639     endif()
 640   elseif(_comp STREQUAL "SSL")
 641     if(EXISTS "${OPENSSL_INCLUDE_DIR}" AND
 642         (EXISTS "${OPENSSL_SSL_LIBRARY}" OR
 643         EXISTS "${SSL_EAY_LIBRARY_DEBUG}" OR
 644         EXISTS "${SSL_EAY_LIBRARY_RELEASE}")
 645     )
 646       set(OpenSSL_${_comp}_FOUND TRUE)
 647     else()
 648       set(OpenSSL_${_comp}_FOUND FALSE)
 649     endif()
 650   else()
 651     message(WARNING "${_comp} is not a valid OpenSSL component")
 652     set(OpenSSL_${_comp}_FOUND FALSE)
 653   endif()
 654 endforeach()
 655 unset(_comp)
 656
 657 include(FindPackageHandleStandardArgs)
 658 find_package_handle_standard_args(OpenSSL
 659   REQUIRED_VARS
 660     OPENSSL_CRYPTO_LIBRARY
 661     OPENSSL_INCLUDE_DIR
 662   VERSION_VAR
 663     OPENSSL_VERSION
 664   HANDLE_VERSION_RANGE
 665   HANDLE_COMPONENTS
 666   FAIL_MESSAGE
 667     "Could NOT find OpenSSL, try to set the path to OpenSSL root folder in the system variable OPENSSL_ROOT_DIR"
 668 )
 669
 670 mark_as_advanced(OPENSSL_INCLUDE_DIR)
 671
 672 if(OPENSSL_FOUND)
 673   if(NOT TARGET OpenSSL::Crypto AND
 674       (EXISTS "${OPENSSL_CRYPTO_LIBRARY}" OR
 675         EXISTS "${LIB_EAY_LIBRARY_DEBUG}" OR
 676         EXISTS "${LIB_EAY_LIBRARY_RELEASE}")
 677       )
 678     add_library(OpenSSL::Crypto UNKNOWN IMPORTED)
 679     set_target_properties(OpenSSL::Crypto PROPERTIES
 680       INTERFACE_INCLUDE_DIRECTORIES "${OPENSSL_INCLUDE_DIR}")
 681     if(EXISTS "${OPENSSL_CRYPTO_LIBRARY}")
 682       set_target_properties(OpenSSL::Crypto PROPERTIES
 683         IMPORTED_LINK_INTERFACE_LANGUAGES "C"
 684         IMPORTED_LOCATION "${OPENSSL_CRYPTO_LIBRARY}")
 685     endif()
 686     if(EXISTS "${LIB_EAY_LIBRARY_RELEASE}")
 687       set_property(TARGET OpenSSL::Crypto APPEND PROPERTY
 688         IMPORTED_CONFIGURATIONS RELEASE)
 689       set_target_properties(OpenSSL::Crypto PROPERTIES
 690         IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "C"
 691         IMPORTED_LOCATION_RELEASE "${LIB_EAY_LIBRARY_RELEASE}")
 692     endif()
 693     if(EXISTS "${LIB_EAY_LIBRARY_DEBUG}")
 694       set_property(TARGET OpenSSL::Crypto APPEND PROPERTY
 695         IMPORTED_CONFIGURATIONS DEBUG)
 696       set_target_properties(OpenSSL::Crypto PROPERTIES
 697         IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "C"
 698         IMPORTED_LOCATION_DEBUG "${LIB_EAY_LIBRARY_DEBUG}")
 699     endif()
 700     _OpenSSL_target_add_dependencies(OpenSSL::Crypto)
 701   endif()
 702
 703   if(NOT TARGET OpenSSL::SSL AND
 704       (EXISTS "${OPENSSL_SSL_LIBRARY}" OR
 705         EXISTS "${SSL_EAY_LIBRARY_DEBUG}" OR
 706         EXISTS "${SSL_EAY_LIBRARY_RELEASE}")
 707       )
 708     add_library(OpenSSL::SSL UNKNOWN IMPORTED)
 709     set_target_properties(OpenSSL::SSL PROPERTIES
 710       INTERFACE_INCLUDE_DIRECTORIES "${OPENSSL_INCLUDE_DIR}")
 711     if(EXISTS "${OPENSSL_SSL_LIBRARY}")
 712       set_target_properties(OpenSSL::SSL PROPERTIES
 713         IMPORTED_LINK_INTERFACE_LANGUAGES "C"
 714         IMPORTED_LOCATION "${OPENSSL_SSL_LIBRARY}")
 715     endif()
 716     if(EXISTS "${SSL_EAY_LIBRARY_RELEASE}")
 717       set_property(TARGET OpenSSL::SSL APPEND PROPERTY
 718         IMPORTED_CONFIGURATIONS RELEASE)
 719       set_target_properties(OpenSSL::SSL PROPERTIES
 720         IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "C"
 721         IMPORTED_LOCATION_RELEASE "${SSL_EAY_LIBRARY_RELEASE}")
 722     endif()
 723     if(EXISTS "${SSL_EAY_LIBRARY_DEBUG}")
 724       set_property(TARGET OpenSSL::SSL APPEND PROPERTY
 725         IMPORTED_CONFIGURATIONS DEBUG)
 726       set_target_properties(OpenSSL::SSL PROPERTIES
 727         IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "C"
 728         IMPORTED_LOCATION_DEBUG "${SSL_EAY_LIBRARY_DEBUG}")
 729     endif()
 730     if(TARGET OpenSSL::Crypto)
 731       set_target_properties(OpenSSL::SSL PROPERTIES
 732         INTERFACE_LINK_LIBRARIES OpenSSL::Crypto)
 733     endif()
 734     _OpenSSL_target_add_dependencies(OpenSSL::SSL)
 735   endif()
 736
 737   if("${OPENSSL_VERSION_MAJOR}.${OPENSSL_VERSION_MINOR}.${OPENSSL_VERSION_FIX}" VERSION_GREATER_EQUAL "0.9.8")
 738     if(MSVC)
 739       if(EXISTS "${OPENSSL_INCLUDE_DIR}")
 740         set(_OPENSSL_applink_paths PATHS ${OPENSSL_INCLUDE_DIR})
 741       endif()
 742       find_file(OPENSSL_APPLINK_SOURCE
 743         NAMES
 744           openssl/applink.c
 745         ${_OPENSSL_applink_paths}
 746         NO_DEFAULT_PATH)
 747       if(OPENSSL_APPLINK_SOURCE)
 748         set(_OPENSSL_applink_interface_srcs ${OPENSSL_APPLINK_SOURCE})
 749       endif()
 750     endif()
 751     if(NOT TARGET OpenSSL::applink)
 752       add_library(OpenSSL::applink INTERFACE IMPORTED)
 753       set_property(TARGET OpenSSL::applink APPEND
 754         PROPERTY INTERFACE_SOURCES
 755           ${_OPENSSL_applink_interface_srcs})
 756     endif()
 757   endif()
 758 endif()
 759
 760 # Restore the original find library ordering
 761 if(OPENSSL_USE_STATIC_LIBS)
 762   set(CMAKE_FIND_LIBRARY_SUFFIXES ${_openssl_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES})
 763 endif()
 764
 765 unset(_OPENSSL_FIND_PATH_SUFFIX)
 766 unset(_OPENSSL_NAME_POSTFIX)
 767 unset(_OpenSSL_extra_static_deps)
 768 unset(_OpenSSL_has_dependency_dl)
 769 unset(_OpenSSL_has_dependency_threads)
 770 unset(_OpenSSL_has_dependency_zlib)
 771
 772 cmake_policy(POP)