Support build-tree libowfat and MatrixSSL dependencies

CMakeLists.txt

@@ -0,0 +1,455 @@
+cmake_minimum_required(VERSION 3.16)
+
+project(tinyldap
+  VERSION 0.1.0
+  LANGUAGES C)
+
+include(GNUInstallDirs)
+include(CMakePackageConfigHelpers)
+include(CTest)
+
+option(TINYLDAP_BUILD_STATIC "Build static tinyldap library" OFF)
+option(TINYLDAP_BUILD_SHARED "Build shared tinyldap library" ON)
+option(TINYLDAP_BUILD_TOOLS "Build tinyldap command line tools" ON)
+option(TINYLDAP_BUILD_TESTS "Build tinyldap test programs" ${PROJECT_IS_TOP_LEVEL})
+option(TINYLDAP_RUN_TESTS "Register non-interactive tinyldap tests with CTest" ${PROJECT_IS_TOP_LEVEL})
+option(TINYLDAP_INSTALL "Install tinyldap libraries, headers and tools" ON)
+
+set(TINYLDAP_OUTPUT_NAME "tinyldap" CACHE STRING "Library basename and default server name, e.g. nwdirectory builds libnwdirectory and nwdirectory")
+set(TINYLDAP_SERVER_NAME "" CACHE STRING "Installed server executable name. Defaults to TINYLDAP_OUTPUT_NAME")
+set(TINYLDAP_TOOL_PREFIX "" CACHE STRING "Optional prefix for non-server tool executable names")
+set(TINYLDAP_INCLUDE_SUBDIR "" CACHE STRING "Public include subdirectory below CMAKE_INSTALL_INCLUDEDIR. Defaults to TINYLDAP_OUTPUT_NAME")
+set(TINYLDAP_LIBOWFAT_INCLUDE_SUBDIR "" CACHE STRING "libowfat public include subdirectory. Defaults to LIBOWFAT_INSTALL_INCLUDE_SUBDIR if present, otherwise libowfat")
+set(TINYLDAP_LIBOWFAT_BUILD_DIR "" CACHE PATH "Optional libowfat CMake build directory to consume directly without installation")
+set(TINYLDAP_MATRIXSSL_BUILD_DIR "" CACHE PATH "Optional MatrixSSL CMake build directory to use for OpenSSL::Crypto compatibility")
+set(TINYLDAP_MATRIXSSL_INCLUDE_SUBDIR "" CACHE STRING "MatrixSSL public include subdirectory inside TINYLDAP_MATRIXSSL_BUILD_DIR/include. Auto-detected when empty")
+
+if(NOT TINYLDAP_BUILD_STATIC AND NOT TINYLDAP_BUILD_SHARED)
+  message(FATAL_ERROR "At least one of TINYLDAP_BUILD_STATIC or TINYLDAP_BUILD_SHARED must be ON")
+endif()
+
+if(TINYLDAP_SERVER_NAME STREQUAL "")
+  set(TINYLDAP_SERVER_NAME "${TINYLDAP_OUTPUT_NAME}")
+endif()
+if(TINYLDAP_INCLUDE_SUBDIR STREQUAL "")
+  set(TINYLDAP_INCLUDE_SUBDIR "${TINYLDAP_OUTPUT_NAME}")
+endif()
+
+function(tinyldap_find_library_file out_var search_dir)
+  set(_tinyldap_found "")
+  foreach(_name IN LISTS ARGN)
+    foreach(_suffix IN ITEMS ".so*" ".dylib*" ".a")
+      file(GLOB _tinyldap_candidates LIST_DIRECTORIES false "${search_dir}/lib${_name}${_suffix}")
+      if(_tinyldap_candidates)
+        list(SORT _tinyldap_candidates)
+        list(GET _tinyldap_candidates 0 _tinyldap_found)
+        break()
+      endif()
+    endforeach()
+    if(_tinyldap_found)
+      break()
+    endif()
+  endforeach()
+  set(${out_var} "${_tinyldap_found}" PARENT_SCOPE)
+endfunction()
+
+function(tinyldap_first_existing_dir out_var)
+  set(_tinyldap_found "")
+  foreach(_dir IN LISTS ARGN)
+    if(IS_DIRECTORY "${_dir}")
+      set(_tinyldap_found "${_dir}")
+      break()
+    endif()
+  endforeach()
+  set(${out_var} "${_tinyldap_found}" PARENT_SCOPE)
+endfunction()
+
+function(tinyldap_first_include_root out_var include_subdir)
+  set(_tinyldap_found "")
+  foreach(_dir IN LISTS ARGN)
+    if(IS_DIRECTORY "${_dir}/${include_subdir}")
+      set(_tinyldap_found "${_dir}")
+      break()
+    endif()
+  endforeach()
+  set(${out_var} "${_tinyldap_found}" PARENT_SCOPE)
+endfunction()
+
+# A libowfat build tree exports libowfat-config.cmake before install, but it may
+# not have an adjacent libowfat-targets.cmake.  Detect that layout when callers
+# pass the build directory through CMAKE_PREFIX_PATH and consume the build tree
+# directly instead of letting find_package() fail inside the incomplete config.
+if(TINYLDAP_LIBOWFAT_BUILD_DIR STREQUAL "")
+  foreach(_prefix IN LISTS CMAKE_PREFIX_PATH)
+    if(EXISTS "${_prefix}/libowfat-config.cmake" AND NOT EXISTS "${_prefix}/libowfat-targets.cmake")
+      set(TINYLDAP_LIBOWFAT_BUILD_DIR "${_prefix}")
+      break()
+    endif()
+  endforeach()
+endif()
+
+if(TINYLDAP_LIBOWFAT_INCLUDE_SUBDIR STREQUAL "")
+  if(DEFINED LIBOWFAT_INSTALL_INCLUDE_SUBDIR)
+    set(TINYLDAP_LIBOWFAT_INCLUDE_SUBDIR "${LIBOWFAT_INSTALL_INCLUDE_SUBDIR}")
+  elseif(NOT TINYLDAP_LIBOWFAT_BUILD_DIR STREQUAL "")
+    file(GLOB _tinyldap_libowfat_build_include_dirs LIST_DIRECTORIES true
+      "${TINYLDAP_LIBOWFAT_BUILD_DIR}/include/*libowfat"
+      "${TINYLDAP_LIBOWFAT_BUILD_DIR}/generated/*libowfat")
+    if(_tinyldap_libowfat_build_include_dirs)
+      list(SORT _tinyldap_libowfat_build_include_dirs)
+      list(GET _tinyldap_libowfat_build_include_dirs 0 _tinyldap_libowfat_build_include_dir)
+      get_filename_component(TINYLDAP_LIBOWFAT_INCLUDE_SUBDIR "${_tinyldap_libowfat_build_include_dir}" NAME)
+    else()
+      set(TINYLDAP_LIBOWFAT_INCLUDE_SUBDIR "libowfat")
+    endif()
+  else()
+    set(TINYLDAP_LIBOWFAT_INCLUDE_SUBDIR "libowfat")
+  endif()
+endif()
+
+set(TINYLDAP_BUILD_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/include")
+set(TINYLDAP_PUBLIC_INCLUDE_DIR "${TINYLDAP_BUILD_INCLUDE_DIR}/${TINYLDAP_INCLUDE_SUBDIR}")
+set(TINYLDAP_COMPAT_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/compat-include")
+file(MAKE_DIRECTORY "${TINYLDAP_PUBLIC_INCLUDE_DIR}" "${TINYLDAP_COMPAT_INCLUDE_DIR}")
+
+set(TINYLDAP_PUBLIC_HEADERS
+  acl.h
+  asn1.h
+  auth.h
+  bstr.h
+  ldap.h
+  ldif.h
+  mduptab.h
+  mstorage.h
+  strduptab.h
+  strstorage.h
+  tinytls.h)
+
+foreach(_hdr IN LISTS TINYLDAP_PUBLIC_HEADERS)
+  file(READ "${CMAKE_CURRENT_SOURCE_DIR}/${_hdr}" _tinyldap_public_header)
+  if(NOT TINYLDAP_LIBOWFAT_INCLUDE_SUBDIR STREQUAL "libowfat")
+    string(REPLACE "<libowfat/" "<${TINYLDAP_LIBOWFAT_INCLUDE_SUBDIR}/" _tinyldap_public_header "${_tinyldap_public_header}")
+    string(REPLACE "\"libowfat/" "\"${TINYLDAP_LIBOWFAT_INCLUDE_SUBDIR}/" _tinyldap_public_header "${_tinyldap_public_header}")
+  endif()
+  file(WRITE "${TINYLDAP_PUBLIC_INCLUDE_DIR}/${_hdr}" "${_tinyldap_public_header}")
+endforeach()
+
+# TinyLDAP source code includes libowfat as <libowfat/foo.h>.  When libowfat
+# itself was exported as <nwlibowfat/foo.h>, keep TinyLDAP sources unchanged by
+# providing build-local wrapper headers under compat-include/libowfat/.
+if(NOT TINYLDAP_LIBOWFAT_INCLUDE_SUBDIR STREQUAL "libowfat")
+  file(GLOB _tinyldap_libowfat_refs CONFIGURE_DEPENDS
+    "${CMAKE_CURRENT_SOURCE_DIR}/*.c"
+    "${CMAKE_CURRENT_SOURCE_DIR}/*.h"
+    "${CMAKE_CURRENT_SOURCE_DIR}/test/*.c")
+  set(_tinyldap_libowfat_headers)
+  foreach(_file IN LISTS _tinyldap_libowfat_refs)
+    file(STRINGS "${_file}" _matches REGEX "^[ \t]*#[ \t]*include[ \t]*[<\"]libowfat/[^>\"]+[>\"]")
+    foreach(_line IN LISTS _matches)
+      string(REGEX REPLACE ".*libowfat/([^>\"]+).*" "\\1" _ow_hdr "${_line}")
+      list(APPEND _tinyldap_libowfat_headers "${_ow_hdr}")
+    endforeach()
+  endforeach()
+  list(REMOVE_DUPLICATES _tinyldap_libowfat_headers)
+  file(MAKE_DIRECTORY "${TINYLDAP_COMPAT_INCLUDE_DIR}/libowfat")
+  foreach(_ow_hdr IN LISTS _tinyldap_libowfat_headers)
+    file(WRITE "${TINYLDAP_COMPAT_INCLUDE_DIR}/libowfat/${_ow_hdr}"
+      "#pragma once\n#include <${TINYLDAP_LIBOWFAT_INCLUDE_SUBDIR}/${_ow_hdr}>\n")
+  endforeach()
+endif()
+
+if(TARGET libowfat::libowfat)
+  set(TINYLDAP_LIBOWFAT_TARGET libowfat::libowfat)
+elseif(NOT TINYLDAP_LIBOWFAT_BUILD_DIR STREQUAL "")
+  tinyldap_find_library_file(TINYLDAP_OWFAT_LIBRARY "${TINYLDAP_LIBOWFAT_BUILD_DIR}"
+    "${TINYLDAP_LIBOWFAT_INCLUDE_SUBDIR}" nwowfat owfat)
+  if(NOT TINYLDAP_OWFAT_LIBRARY)
+    message(FATAL_ERROR "Could not find libowfat library in TINYLDAP_LIBOWFAT_BUILD_DIR=${TINYLDAP_LIBOWFAT_BUILD_DIR}")
+  endif()
+  tinyldap_first_include_root(TINYLDAP_OWFAT_INCLUDE_ROOT "${TINYLDAP_LIBOWFAT_INCLUDE_SUBDIR}"
+    "${TINYLDAP_LIBOWFAT_BUILD_DIR}/include"
+    "${TINYLDAP_LIBOWFAT_BUILD_DIR}/generated")
+  if(NOT TINYLDAP_OWFAT_INCLUDE_ROOT)
+    message(FATAL_ERROR "Could not find libowfat build include root containing ${TINYLDAP_LIBOWFAT_INCLUDE_SUBDIR}/ in ${TINYLDAP_LIBOWFAT_BUILD_DIR}")
+  endif()
+  add_library(tinyldap_owfat_external UNKNOWN IMPORTED)
+  set_target_properties(tinyldap_owfat_external PROPERTIES
+    IMPORTED_LOCATION "${TINYLDAP_OWFAT_LIBRARY}"
+    INTERFACE_INCLUDE_DIRECTORIES "${TINYLDAP_OWFAT_INCLUDE_ROOT}")
+  set(TINYLDAP_LIBOWFAT_TARGET tinyldap_owfat_external)
+else()
+  find_package(libowfat CONFIG QUIET)
+  if(TARGET libowfat::libowfat)
+    set(TINYLDAP_LIBOWFAT_TARGET libowfat::libowfat)
+  else()
+    find_library(TINYLDAP_OWFAT_LIBRARY NAMES owfat nwowfat REQUIRED)
+    add_library(tinyldap_owfat_external UNKNOWN IMPORTED)
+    set_target_properties(tinyldap_owfat_external PROPERTIES IMPORTED_LOCATION "${TINYLDAP_OWFAT_LIBRARY}")
+    set(TINYLDAP_LIBOWFAT_TARGET tinyldap_owfat_external)
+  endif()
+endif()
+
+if(TARGET OpenSSL::Crypto)
+  set(TINYLDAP_CRYPTO_TARGET OpenSSL::Crypto)
+elseif(NOT TINYLDAP_MATRIXSSL_BUILD_DIR STREQUAL "")
+  if(TINYLDAP_MATRIXSSL_INCLUDE_SUBDIR STREQUAL "")
+    file(GLOB _tinyldap_matrixssl_include_dirs LIST_DIRECTORIES true
+      "${TINYLDAP_MATRIXSSL_BUILD_DIR}/include/*matrixssl")
+    if(_tinyldap_matrixssl_include_dirs)
+      list(SORT _tinyldap_matrixssl_include_dirs)
+      list(GET _tinyldap_matrixssl_include_dirs 0 _tinyldap_matrixssl_include_dir)
+      get_filename_component(TINYLDAP_MATRIXSSL_INCLUDE_SUBDIR "${_tinyldap_matrixssl_include_dir}" NAME)
+    else()
+      set(TINYLDAP_MATRIXSSL_INCLUDE_SUBDIR "matrixssl")
+    endif()
+  endif()
+  tinyldap_find_library_file(TINYLDAP_MATRIXSSL_CRYPTO_LIBRARY "${TINYLDAP_MATRIXSSL_BUILD_DIR}"
+    "${TINYLDAP_MATRIXSSL_INCLUDE_SUBDIR}" nwmatrixssl matrixssl)
+  if(NOT TINYLDAP_MATRIXSSL_CRYPTO_LIBRARY)
+    message(FATAL_ERROR "Could not find MatrixSSL library in TINYLDAP_MATRIXSSL_BUILD_DIR=${TINYLDAP_MATRIXSSL_BUILD_DIR}")
+  endif()
+  tinyldap_first_include_root(TINYLDAP_MATRIXSSL_OPENSSL_INCLUDE_ROOT "openssl"
+    "${TINYLDAP_MATRIXSSL_BUILD_DIR}/include/${TINYLDAP_MATRIXSSL_INCLUDE_SUBDIR}"
+    "${TINYLDAP_MATRIXSSL_BUILD_DIR}/include")
+  if(NOT TINYLDAP_MATRIXSSL_OPENSSL_INCLUDE_ROOT)
+    message(FATAL_ERROR "Could not find MatrixSSL OpenSSL compatibility include root in ${TINYLDAP_MATRIXSSL_BUILD_DIR}")
+  endif()
+  file(MAKE_DIRECTORY "${TINYLDAP_COMPAT_INCLUDE_DIR}/openssl")
+  if(NOT EXISTS "${TINYLDAP_MATRIXSSL_OPENSSL_INCLUDE_ROOT}/openssl/md5.h")
+    file(WRITE "${TINYLDAP_COMPAT_INCLUDE_DIR}/openssl/md5.h" "#pragma once
+#include <stddef.h>
+#include <crypto/cryptoApi.h>
+typedef psMd5_t MD5_CTX;
+static inline int MD5_Init(MD5_CTX *c) { return psMd5Init(c) >= 0 ? 1 : 0; }
+static inline int MD5_Update(MD5_CTX *c, const void *data, size_t len) { psMd5Update(c, (const unsigned char *)data, (uint32_t)len); return 1; }
+static inline int MD5_Final(unsigned char *md, MD5_CTX *c) { psMd5Final(c, md); return 1; }
+")
+  endif()
+  add_library(tinyldap_matrixssl_crypto_external UNKNOWN IMPORTED)
+  set_target_properties(tinyldap_matrixssl_crypto_external PROPERTIES
+    IMPORTED_LOCATION "${TINYLDAP_MATRIXSSL_CRYPTO_LIBRARY}"
+    INTERFACE_INCLUDE_DIRECTORIES "${TINYLDAP_MATRIXSSL_OPENSSL_INCLUDE_ROOT}")
+  set(TINYLDAP_CRYPTO_TARGET tinyldap_matrixssl_crypto_external)
+else()
+  find_package(OpenSSL REQUIRED COMPONENTS Crypto)
+  set(TINYLDAP_CRYPTO_TARGET OpenSSL::Crypto)
+endif()
+
+find_library(TINYLDAP_CRYPT_LIBRARY crypt)
+
+set(TINYLDAP_LIBRARY_SOURCES
+  fmt_asn1intpayload.c fmt_asn1length.c fmt_asn1tag.c
+  fmt_asn1int.c fmt_asn1string.c fmt_asn1transparent.c scan_asn1tag.c
+  scan_asn1length.c scan_asn1int.c scan_asn1string.c scan_asn1INTEGER.c
+  scan_asn1STRING.c scan_asn1SEQUENCE.c scan_asn1ENUMERATED.c
+  scan_asn1BOOLEAN.c scan_asn1rawint.c scan_asn1SET.c fmt_asn1sint.c
+  fmt_asn1sintpayload.c scan_asn1oid.c scan_asn1BITSTRING.c
+  scan_asn1tagint.c fmt_asn1tagint.c fmt_asn1OID.c scan_asn1generic.c
+  fmt_asn1generic.c scan_asn1rawoid.c fmt_asn1bitstring.c asn1oid.c
+  scan_asn1SEQUENCE_nolengthcheck.c
+
+  scan_ldapmessage.c fmt_ldapmessage.c fmt_ldapbindrequest.c
+  scan_ldapbindrequest.c scan_ldapbindresponse.c scan_ldapresult.c
+  scan_ldapstring.c scan_ldapsearchfilter.c scan_ldapsearchrequest.c
+  freefilter.c freeava.c scan_ldapava.c fmt_ldapsearchresultentry.c
+  fmt_ldapstring.c freepal.c scan_ldapsearchresultentry.c
+  fmt_ldapresult.c fmt_ldappal.c fmt_ldapadl.c fmt_ldapava.c
+  fmt_ldapsearchfilter.c fmt_ldapsearchrequest.c matchstring.c
+  matchprefix.c matchcasestring.c matchcaseprefix.c
+  scan_ldapmodifyrequest.c scan_ldapaddrequest.c bstrlen.c bstrfirst.c
+  bstrstart.c free_ldapadl.c free_ldappal.c free_ldapsearchfilter.c
+  scan_ldapsearchfilterstring.c free_ldapsearchresultentry.c
+  fmt_ldapsearchfilterstring.c
+  fmt_ldapdeleterequest.c scan_ldapdeleterequest.c normalize_dn.c
+  fmt_ldapmodifyrequest.c fmt_ldapaddrequest.c
+  scan_ldapmessage_nolengthcheck.c
+
+  ldif_parse.c
+
+  mstorage_add.c mduptab_add.c bstr_diff.c mduptab_adds.c bstr_diff2.c
+  mstorage_add_bin.c mstorage_init.c mstorage_init_persistent.c
+  mstorage_unmap.c mduptab_init.c mduptab_reset.c
+
+  auth.c
+
+  fmt_tls_clienthello.c init_tls_context.c fmt_tls_serverhello.c
+  fmt_tls_alert.c fmt_tls_packet.c tls_cipherprio.c fmt_tls_alert_pkt.c
+  fmt_tls_handshake_cert.c fmt_tls_handshake_certs_header.c
+  fmt_tls_serverhellodone.c tls_accept.c tls_connect.c tls_doread.c tls_dowrite.c)
+
+add_library(tinyldap_objects OBJECT ${TINYLDAP_LIBRARY_SOURCES})
+target_compile_features(tinyldap_objects PUBLIC c_std_99)
+target_compile_definitions(tinyldap_objects PRIVATE _GNU_SOURCE _FILE_OFFSET_BITS=64)
+target_include_directories(tinyldap_objects
+  PUBLIC
+    "$<BUILD_INTERFACE:${TINYLDAP_BUILD_INCLUDE_DIR}>"
+    "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+  PRIVATE
+    "${TINYLDAP_COMPAT_INCLUDE_DIR}"
+    "${CMAKE_CURRENT_SOURCE_DIR}")
+target_link_libraries(tinyldap_objects PUBLIC ${TINYLDAP_LIBOWFAT_TARGET} ${TINYLDAP_CRYPTO_TARGET})
+if(TINYLDAP_CRYPT_LIBRARY)
+  target_link_libraries(tinyldap_objects PUBLIC "${TINYLDAP_CRYPT_LIBRARY}")
+endif()
+if(TINYLDAP_BUILD_SHARED)
+  set_target_properties(tinyldap_objects PROPERTIES POSITION_INDEPENDENT_CODE ON)
+endif()
+
+set(_tinyldap_export_targets)
+if(TINYLDAP_BUILD_STATIC)
+  add_library(tinyldap_static STATIC $<TARGET_OBJECTS:tinyldap_objects>)
+  add_library(tinyldap::static ALIAS tinyldap_static)
+  set_target_properties(tinyldap_static PROPERTIES
+    OUTPUT_NAME "${TINYLDAP_OUTPUT_NAME}"
+    EXPORT_NAME static)
+  target_link_libraries(tinyldap_static PUBLIC ${TINYLDAP_LIBOWFAT_TARGET} ${TINYLDAP_CRYPTO_TARGET})
+  target_include_directories(tinyldap_static PUBLIC
+    "$<BUILD_INTERFACE:${TINYLDAP_BUILD_INCLUDE_DIR}>"
+    "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
+  if(TINYLDAP_CRYPT_LIBRARY)
+    target_link_libraries(tinyldap_static PUBLIC "${TINYLDAP_CRYPT_LIBRARY}")
+  endif()
+  list(APPEND _tinyldap_export_targets tinyldap_static)
+endif()
+
+if(TINYLDAP_BUILD_SHARED)
+  add_library(tinyldap_shared SHARED $<TARGET_OBJECTS:tinyldap_objects>)
+  add_library(tinyldap::shared ALIAS tinyldap_shared)
+  set_target_properties(tinyldap_shared PROPERTIES
+    OUTPUT_NAME "${TINYLDAP_OUTPUT_NAME}"
+    VERSION "${PROJECT_VERSION}"
+    SOVERSION "${PROJECT_VERSION_MAJOR}"
+    EXPORT_NAME shared)
+  target_link_libraries(tinyldap_shared PUBLIC ${TINYLDAP_LIBOWFAT_TARGET} ${TINYLDAP_CRYPTO_TARGET})
+  target_include_directories(tinyldap_shared PUBLIC
+    "$<BUILD_INTERFACE:${TINYLDAP_BUILD_INCLUDE_DIR}>"
+    "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
+  if(TINYLDAP_CRYPT_LIBRARY)
+    target_link_libraries(tinyldap_shared PUBLIC "${TINYLDAP_CRYPT_LIBRARY}")
+  endif()
+  list(APPEND _tinyldap_export_targets tinyldap_shared)
+endif()
+
+if(TINYLDAP_BUILD_SHARED)
+  add_library(tinyldap::tinyldap ALIAS tinyldap_shared)
+else()
+  add_library(tinyldap::tinyldap ALIAS tinyldap_static)
+endif()
+
+function(tinyldap_add_program target source output_name)
+  add_executable(${target} ${source} ${ARGN})
+  target_compile_features(${target} PRIVATE c_std_99)
+  target_compile_definitions(${target} PRIVATE _GNU_SOURCE _FILE_OFFSET_BITS=64)
+  target_include_directories(${target} PRIVATE
+    "${TINYLDAP_COMPAT_INCLUDE_DIR}"
+    "${CMAKE_CURRENT_SOURCE_DIR}"
+    "${TINYLDAP_BUILD_INCLUDE_DIR}")
+  target_link_libraries(${target} PRIVATE tinyldap::tinyldap)
+  set_target_properties(${target} PROPERTIES OUTPUT_NAME "${output_name}")
+endfunction()
+
+if(TINYLDAP_BUILD_TOOLS)
+  tinyldap_add_program(tinyldap_server tinyldap.c "${TINYLDAP_SERVER_NAME}" ldap_match_mapped.c ldap_match_sre.c)
+  tinyldap_add_program(tinyldap_server_standalone tinyldap.c "${TINYLDAP_SERVER_NAME}_standalone" ldap_match_mapped.c ldap_match_sre.c)
+  target_compile_definitions(tinyldap_server_standalone PRIVATE STANDALONE)
+  tinyldap_add_program(tinyldap_server_debug tinyldap.c "${TINYLDAP_SERVER_NAME}_debug" ldap_match_mapped.c ldap_match_sre.c)
+  target_compile_definitions(tinyldap_server_debug PRIVATE STANDALONE DEBUG)
+
+  tinyldap_add_program(tinyldap_t2 t2.c "${TINYLDAP_TOOL_PREFIX}t2")
+  tinyldap_add_program(tinyldap_parse parse.c "${TINYLDAP_TOOL_PREFIX}parse")
+  tinyldap_add_program(tinyldap_dumpidx dumpidx.c "${TINYLDAP_TOOL_PREFIX}dumpidx")
+  tinyldap_add_program(tinyldap_idx2ldif idx2ldif.c "${TINYLDAP_TOOL_PREFIX}idx2ldif")
+  tinyldap_add_program(tinyldap_addindex addindex.c "${TINYLDAP_TOOL_PREFIX}addindex")
+  tinyldap_add_program(tinyldap_bindrequest bindrequest.c "${TINYLDAP_TOOL_PREFIX}bindrequest")
+  tinyldap_add_program(tinyldap_ldapclient ldapclient.c "${TINYLDAP_TOOL_PREFIX}ldapclient")
+  tinyldap_add_program(tinyldap_ldapclient_str ldapclient_str.c "${TINYLDAP_TOOL_PREFIX}ldapclient_str")
+  tinyldap_add_program(tinyldap_md5password md5password.c "${TINYLDAP_TOOL_PREFIX}md5password")
+  tinyldap_add_program(tinyldap_mysql2ldif mysql2ldif.c "${TINYLDAP_TOOL_PREFIX}mysql2ldif")
+  tinyldap_add_program(tinyldap_acl acl.c "${TINYLDAP_TOOL_PREFIX}acl")
+  tinyldap_add_program(tinyldap_dumpacls dumpacls.c "${TINYLDAP_TOOL_PREFIX}dumpacls")
+  tinyldap_add_program(tinyldap_ldapdelete ldapdelete.c "${TINYLDAP_TOOL_PREFIX}ldapdelete")
+  tinyldap_add_program(tinyldap_asn1dump asn1dump.c "${TINYLDAP_TOOL_PREFIX}asn1dump")
+  tinyldap_add_program(tinyldap_x x.c "${TINYLDAP_TOOL_PREFIX}x")
+endif()
+
+if(TINYLDAP_BUILD_TESTS)
+  tinyldap_add_program(tinyldap_test_bind test/bind.c "${TINYLDAP_TOOL_PREFIX}test-bind")
+  tinyldap_add_program(tinyldap_test_ebind test/ebind.c "${TINYLDAP_TOOL_PREFIX}test-ebind")
+  if(TINYLDAP_RUN_TESTS)
+    # t2 is a simple non-network decoder smoke test.  The other Makefile tests
+    # expect external LDAP data or a running server and are intentionally build-only.
+    add_test(NAME tinyldap_t2 COMMAND tinyldap_t2)
+    set_tests_properties(tinyldap_t2 PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
+  endif()
+
+  file(GLOB _unittest_sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/*.c")
+  foreach(_ut_src IN LISTS _unittest_sources)
+    file(STRINGS "${_ut_src}" _has_unittest REGEX "UNITTEST")
+    if(_has_unittest)
+      get_filename_component(_ut_name "${_ut_src}" NAME_WE)
+      set(_ut_target "tinyldap_unittest_${_ut_name}")
+      add_executable(${_ut_target} "${_ut_src}")
+      target_compile_definitions(${_ut_target} PRIVATE UNITTEST _GNU_SOURCE _FILE_OFFSET_BITS=64)
+      target_include_directories(${_ut_target} PRIVATE
+        "${TINYLDAP_COMPAT_INCLUDE_DIR}"
+        "${CMAKE_CURRENT_SOURCE_DIR}"
+        "${TINYLDAP_BUILD_INCLUDE_DIR}")
+      target_link_libraries(${_ut_target} PRIVATE tinyldap::tinyldap)
+      if(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang")
+        target_compile_options(${_ut_target} PRIVATE -UNDEBUG -O0)
+      endif()
+      if(TINYLDAP_RUN_TESTS)
+        add_test(NAME tinyldap_unittest_${_ut_name} COMMAND ${_ut_target})
+        set_tests_properties(tinyldap_unittest_${_ut_name} PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
+      endif()
+    endif()
+  endforeach()
+endif()
+
+if(TINYLDAP_INSTALL)
+  install(DIRECTORY "${TINYLDAP_PUBLIC_INCLUDE_DIR}/"
+    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${TINYLDAP_INCLUDE_SUBDIR}")
+
+  if(_tinyldap_export_targets)
+    install(TARGETS ${_tinyldap_export_targets}
+      EXPORT tinyldap-targets
+      ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+      LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+      RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
+  endif()
+
+  if(TINYLDAP_BUILD_TOOLS)
+    install(TARGETS
+      tinyldap_server tinyldap_server_standalone tinyldap_server_debug
+      tinyldap_t2 tinyldap_parse tinyldap_dumpidx tinyldap_idx2ldif
+      tinyldap_addindex tinyldap_bindrequest tinyldap_ldapclient
+      tinyldap_ldapclient_str tinyldap_md5password tinyldap_mysql2ldif
+      tinyldap_acl tinyldap_dumpacls tinyldap_ldapdelete tinyldap_asn1dump
+      tinyldap_x
+      RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
+  endif()
+
+  configure_package_config_file(
+    "${CMAKE_CURRENT_SOURCE_DIR}/cmake/tinyldap-config.cmake.in"
+    "${CMAKE_CURRENT_BINARY_DIR}/tinyldap-config.cmake"
+    INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/tinyldap")
+  write_basic_package_version_file(
+    "${CMAKE_CURRENT_BINARY_DIR}/tinyldap-config-version.cmake"
+    VERSION "${PROJECT_VERSION}"
+    COMPATIBILITY SameMajorVersion)
+  install(EXPORT tinyldap-targets
+    NAMESPACE tinyldap::
+    DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/tinyldap")
+  install(FILES
+    "${CMAKE_CURRENT_BINARY_DIR}/tinyldap-config.cmake"
+    "${CMAKE_CURRENT_BINARY_DIR}/tinyldap-config-version.cmake"
+    DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/tinyldap")
+endif()
+
+message(STATUS "tinyldap: building lib${TINYLDAP_OUTPUT_NAME}, server=${TINYLDAP_SERVER_NAME}, include=${TINYLDAP_INCLUDE_SUBDIR}, libowfat include=${TINYLDAP_LIBOWFAT_INCLUDE_SUBDIR}")
+if(NOT TINYLDAP_LIBOWFAT_BUILD_DIR STREQUAL "")
+  message(STATUS "tinyldap: using libowfat build tree ${TINYLDAP_LIBOWFAT_BUILD_DIR}")
+endif()
+if(NOT TINYLDAP_MATRIXSSL_BUILD_DIR STREQUAL "")
+  message(STATUS "tinyldap: using MatrixSSL build tree ${TINYLDAP_MATRIXSSL_BUILD_DIR}")
+endif()

README.md

@@ -0,0 +1,113 @@
+# tinyldap CMake build
+
+This fork can be built with CMake in addition to the original Makefile.
+The CMake build is out-of-tree friendly and can be used either as a top-level
+project or via `add_subdirectory()`.
+
+## Basic build
+
+```sh
+cmake -S . -B build
+cmake --build build
+ctest --test-dir build --output-on-failure
+cmake --install build --prefix /usr/local
+```
+
+By default CMake builds a shared library, the server and the same command-line
+tools that the original Makefile builds.
+
+## Static and shared libraries
+
+```sh
+cmake -S . -B build \
+  -DTINYLDAP_BUILD_STATIC=ON \
+  -DTINYLDAP_BUILD_SHARED=ON
+```
+
+## Custom server and library name
+
+`TINYLDAP_OUTPUT_NAME` controls the library basename and, unless overridden, the
+server executable name:
+
+```sh
+cmake -S . -B build -DTINYLDAP_OUTPUT_NAME=nwdirectory
+```
+
+This builds `libnwdirectory.so` / `libnwdirectory.a` and a server named
+`nwdirectory`.
+
+For a different server name only:
+
+```sh
+cmake -S . -B build \
+  -DTINYLDAP_OUTPUT_NAME=nwdirectory \
+  -DTINYLDAP_SERVER_NAME=my-ldapd
+```
+
+## Include layout
+
+Public headers are exported under an include subdirectory.  By default it matches
+`TINYLDAP_OUTPUT_NAME`:
+
+```c
+#include <tinyldap/ldap.h>
+```
+
+or with `-DTINYLDAP_OUTPUT_NAME=nwdirectory`:
+
+```c
+#include <nwdirectory/ldap.h>
+```
+
+The build tree has the same layout under `${binary_dir}/include`, which makes
+submodule use straightforward.
+
+## libowfat dependency
+
+When libowfat is already present in the parent build, TinyLDAP uses the target
+`libowfat::libowfat`.  Otherwise it tries `find_package(libowfat CONFIG)` and
+then a plain library lookup.
+
+TinyLDAP sources use `#include <libowfat/...>`.  If the libowfat build exports a
+prefixed include directory such as `nwlibowfat`, set:
+
+```sh
+-DTINYLDAP_LIBOWFAT_INCLUDE_SUBDIR=nwlibowfat
+```
+
+When TinyLDAP is added below the CMake libowfat build, this is detected from
+`LIBOWFAT_INSTALL_INCLUDE_SUBDIR` automatically.
+
+If libowfat has been configured in a separate build tree but not installed yet,
+pass that build directory directly:
+
+```sh
+cmake -S . -B build \
+  -DTINYLDAP_LIBOWFAT_BUILD_DIR=/path/to/mars-libowfat-build \
+  -DTINYLDAP_LIBOWFAT_INCLUDE_SUBDIR=nwlibowfat
+```
+
+TinyLDAP also detects this situation when the libowfat build directory is listed
+in `CMAKE_PREFIX_PATH` and contains a build-tree `libowfat-config.cmake` without
+an installed `libowfat-targets.cmake`.
+
+## OpenSSL / MatrixSSL compat
+
+TinyLDAP currently needs OpenSSL-style MD5 APIs for `auth.c` and `md5password.c`.
+If the parent project already provides `OpenSSL::Crypto` via MatrixSSL's
+OpenSSL-compat target, TinyLDAP will use it.  Otherwise CMake falls back to the
+system OpenSSL Crypto library.
+
+For a separate MatrixSSL build tree that has not been installed, pass:
+
+```sh
+cmake -S . -B build \
+  -DTINYLDAP_MATRIXSSL_BUILD_DIR=/path/to/mars-matrixssl-build \
+  -DTINYLDAP_MATRIXSSL_INCLUDE_SUBDIR=nwmatrixssl
+```
+
+The MatrixSSL include subdirectory is auto-detected when possible.  The imported
+build-tree target adds the correct include root so TinyLDAP's
+`#include <openssl/md5.h>` can resolve MatrixSSL's OpenSSL compatibility header.
+If that build tree does not provide `openssl/md5.h`, TinyLDAP generates a small
+build-local MD5 wrapper around MatrixSSL's `psMd5*` API.

cmake/tinyldap-config.cmake.in

@@ -0,0 +1,5 @@
+@PACKAGE_INIT@
+include(CMakeFindDependencyMacro)
+find_dependency(libowfat CONFIG)
+find_dependency(OpenSSL COMPONENTS Crypto)
+include("${CMAKE_CURRENT_LIST_DIR}/tinyldap-targets.cmake")