added cmake variable QCA_LIB_SUFFIX

QCA_LIB_SUFFIX intended to replace workaround 3 major version. For building for Qt5 can be used -DQCA_LIB_SUFFIX=qt5 for example. Result will be named libqca2-qt5.so.2.0.3 library for Linux. Also this suffix will be applied for qca2 pkg config file, qcatool2 binary and qcatool2 manpage. I hope that is a good way to resolve the building conflict against qt4 and qt5.
2025-05-10 09:49:33 +00:00 · 2013-08-24 23:24:13 +06:00 · 2013-08-24 23:24:13 +06:00 · 13d0dc5e6d
commit 13d0dc5e6d
parent fc315c5bba
63 changed files with 97 additions and 79 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -30,14 +30,19 @@ endif()
 set(LIB_SUFFIX "" CACHE STRING "Define suffix of directory name (32/64)" )
 set(LIB_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}" CACHE STRING "Directory where lib will install")

-if (Qt5Core_FOUND)
-  set(QCA_LIB_MAJOR_VERSION "3")
-else()
-  set(QCA_LIB_MAJOR_VERSION "2")
-endif()
+set(QCA_LIB_MAJOR_VERSION "2")
 set(QCA_LIB_MINOR_VERSION "0")
 set(QCA_LIB_PATCH_VERSION "3")

+set(QCA_LIB_SUFFIX "" CACHE STRING "Qca library suffix")
+if(QCA_LIB_SUFFIX)
+  set(QCA_LIB_NAME qca-${QCA_LIB_SUFFIX})
+  set(QCA_MANPAGE_NAME qcatool2-${QCA_LIB_SUFFIX}.1)
+else(QCA_LIB_SUFFIX)
+  set(QCA_LIB_NAME qca)
+  set(QCA_MANPAGE_NAME qcatool2.1)
+endif(QCA_LIB_SUFFIX)
+
 set(QCA_LIB_VERSION_STRING "${QCA_LIB_MAJOR_VERSION}.${QCA_LIB_MINOR_VERSION}.${QCA_LIB_PATCH_VERSION}")


@ -186,14 +191,21 @@ install(FILES ${public_HEADERS} DESTINATION "${QCA_INCLUDE_INSTALL_DIR}/QtCrypto
 include_directories(${QT_QTCORE_INCLUDE_DIR} "${qca_INCLUDEDIR}/QtCrypto")

 if(NOT WIN32)
-  configure_file("qca2.pc.cmake" "${CMAKE_BINARY_DIR}/qca2.pc" @ONLY)
-  install(FILES "${CMAKE_BINARY_DIR}/qca2.pc" DESTINATION ${PKGCONFIG_INSTALL_PREFIX})
+  if(QCA_LIB_SUFFIX)
+    set(QCA_PC_NAME "qca2-${QCA_LIB_SUFFIX}.pc")
+  else(QCA_LIB_SUFFIX)
+    set(QCA_PC_NAME "qca2.pc")
+  endif(QCA_LIB_SUFFIX)
+
+  configure_file("qca2.pc.cmake" "${CMAKE_BINARY_DIR}/${QCA_PC_NAME}" @ONLY)
+  install(FILES "${CMAKE_BINARY_DIR}/${QCA_PC_NAME}" DESTINATION ${PKGCONFIG_INSTALL_PREFIX})
 endif(NOT WIN32)

 configure_file("crypto.prf.cmake" "${CMAKE_BINARY_DIR}/crypto.prf" @ONLY)
 install(FILES "${CMAKE_BINARY_DIR}/crypto.prf" DESTINATION "${QCA_FEATURE_INSTALL_DIR}")

-install(FILES man/qcatool2.1 DESTINATION "${QCA_MAN_INSTALL_DIR}/man1")
+configure_file(man/qcatool2.1 "${CMAKE_BINARY_DIR}/${QCA_MANPAGE_NAME}" COPYONLY)
+install(FILES "${CMAKE_BINARY_DIR}/${QCA_MANPAGE_NAME}" DESTINATION "${QCA_MAN_INSTALL_DIR}/man1")

 add_subdirectory(src)
 add_subdirectory(tools)
--- a/crypto.prf.cmake
+++ b/crypto.prf.cmake
@ -5,9 +5,9 @@ CONFIG *= qt
 INCLUDEPATH += $$QCA_INCDIR/QtCrypto
 LIBS += -L$$QCA_LIBDIR

-LINKAGE = -lqca
+LINKAGE = -l@QCA_LIB_NAME@
 CONFIG(debug, debug|release) {
-	windows:LINKAGE = -lqcad
-	mac:LINKAGE = -lqca_debug
+	windows:LINKAGE = -l@QCA_LIB_NAME@d
+	mac:LINKAGE = -l@QCA_LIB_NAME@_debug
 }
 LIBS += $$LINKAGE
--- a/examples/aes-cmac/CMakeLists.txt
+++ b/examples/aes-cmac/CMakeLists.txt
@ -2,5 +2,5 @@ set(aes-cmac_bin_SRCS aes-cmac.cpp)

 add_executable(aes-cmac ${aes-cmac_bin_SRCS})

-target_link_libraries( aes-cmac qca ${QT_QTGUI_LIBRARY})
+target_link_libraries( aes-cmac ${QCA_LIB_NAME} ${QT_QTGUI_LIBRARY})

--- a/examples/base64test/CMakeLists.txt
+++ b/examples/base64test/CMakeLists.txt
@ -2,5 +2,5 @@ set(base64test_bin_SRCS base64test.cpp)

 add_executable(base64test ${base64test_bin_SRCS})

-target_link_libraries( base64test qca ${QT_QTCORE_LIBRARY})
+target_link_libraries( base64test ${QCA_LIB_NAME} ${QT_QTCORE_LIBRARY})

--- a/examples/certtest/CMakeLists.txt
+++ b/examples/certtest/CMakeLists.txt
@ -2,5 +2,5 @@ set(certtest_bin_SRCS certtest.cpp)

 add_executable(certtest ${certtest_bin_SRCS})

-target_link_libraries( certtest qca ${QT_QTGUI_LIBRARY})
+target_link_libraries( certtest ${QCA_LIB_NAME} ${QT_QTGUI_LIBRARY})

--- a/examples/ciphertest/CMakeLists.txt
+++ b/examples/ciphertest/CMakeLists.txt
@ -2,5 +2,5 @@ set(ciphertest_bin_SRCS ciphertest.cpp)

 add_executable(ciphertest ${ciphertest_bin_SRCS})

-target_link_libraries( ciphertest qca ${QT_QTGUI_LIBRARY})
+target_link_libraries( ciphertest ${QCA_LIB_NAME} ${QT_QTGUI_LIBRARY})

--- a/examples/cms/CMakeLists.txt
+++ b/examples/cms/CMakeLists.txt
@ -2,5 +2,5 @@ set(cmsexample_bin_SRCS cmsexample.cpp)

 add_executable(cmsexample ${cmsexample_bin_SRCS})

-target_link_libraries( cmsexample qca ${QT_QTGUI_LIBRARY})
+target_link_libraries( cmsexample ${QCA_LIB_NAME} ${QT_QTGUI_LIBRARY})

--- a/examples/eventhandlerdemo/CMakeLists.txt
+++ b/examples/eventhandlerdemo/CMakeLists.txt
@ -4,5 +4,5 @@ MY_AUTOMOC( eventhandlerdemo_bin_SRCS)

 add_executable(eventhandlerdemo ${eventhandlerdemo_bin_SRCS})

-target_link_libraries( eventhandlerdemo qca ${QT_QTCORE_LIBRARY})
+target_link_libraries( eventhandlerdemo ${QCA_LIB_NAME} ${QT_QTCORE_LIBRARY})

--- a/examples/hashtest/CMakeLists.txt
+++ b/examples/hashtest/CMakeLists.txt
@ -2,5 +2,5 @@ set(hashtest_bin_SRCS hashtest.cpp)

 add_executable(hashtest ${hashtest_bin_SRCS})

-target_link_libraries( hashtest qca ${QT_QTGUI_LIBRARY})
+target_link_libraries( hashtest ${QCA_LIB_NAME} ${QT_QTGUI_LIBRARY})

--- a/examples/hextest/CMakeLists.txt
+++ b/examples/hextest/CMakeLists.txt
@ -2,5 +2,5 @@ set(hextest_bin_SRCS hextest.cpp)

 add_executable(hextest ${hextest_bin_SRCS})

-target_link_libraries( hextest qca ${QT_QTGUI_LIBRARY})
+target_link_libraries( hextest ${QCA_LIB_NAME} ${QT_QTGUI_LIBRARY})

--- a/examples/keyloader/CMakeLists.txt
+++ b/examples/keyloader/CMakeLists.txt
@ -4,5 +4,5 @@ MY_AUTOMOC( keyloader_bin_SRCS )

 add_executable(keyloader ${keyloader_bin_SRCS})

-target_link_libraries( keyloader qca ${QT_QTCORE_LIBRARY})
+target_link_libraries( keyloader ${QCA_LIB_NAME} ${QT_QTCORE_LIBRARY})

--- a/examples/mactest/CMakeLists.txt
+++ b/examples/mactest/CMakeLists.txt
@ -2,5 +2,5 @@ set(mactest_bin_SRCS mactest.cpp)

 add_executable(mactest ${mactest_bin_SRCS})

-target_link_libraries( mactest qca ${QT_QTGUI_LIBRARY})
+target_link_libraries( mactest ${QCA_LIB_NAME} ${QT_QTGUI_LIBRARY})

--- a/examples/md5crypt/CMakeLists.txt
+++ b/examples/md5crypt/CMakeLists.txt
@ -3,5 +3,5 @@ set(md5crypt_bin_SRCS md5crypt.cpp)
 add_executable(md5crypt ${md5crypt_bin_SRCS})

 #add "crypt" to the libs if you are trying the crypt() equivalent
-target_link_libraries( md5crypt qca ${QT_QTGUI_LIBRARY})
+target_link_libraries( md5crypt ${QCA_LIB_NAME} ${QT_QTGUI_LIBRARY})

--- a/examples/providertest/CMakeLists.txt
+++ b/examples/providertest/CMakeLists.txt
@ -2,5 +2,5 @@ set(providertest_bin_SRCS providertest.cpp)

 add_executable(providertest ${providertest_bin_SRCS})

-target_link_libraries( providertest qca ${QT_QTGUI_LIBRARY})
+target_link_libraries( providertest ${QCA_LIB_NAME} ${QT_QTGUI_LIBRARY})

--- a/examples/publickeyexample/CMakeLists.txt
+++ b/examples/publickeyexample/CMakeLists.txt
@ -2,5 +2,5 @@ set(publickeyexample_bin_SRCS publickeyexample.cpp)

 add_executable(publickeyexample ${publickeyexample_bin_SRCS})

-target_link_libraries( publickeyexample qca ${QT_QTGUI_LIBRARY})
+target_link_libraries( publickeyexample ${QCA_LIB_NAME} ${QT_QTGUI_LIBRARY})

--- a/examples/randomtest/CMakeLists.txt
+++ b/examples/randomtest/CMakeLists.txt
@ -2,5 +2,5 @@ set(randomtest_bin_SRCS randomtest.cpp)

 add_executable(randomtest ${randomtest_bin_SRCS})

-target_link_libraries( randomtest qca ${QT_QTGUI_LIBRARY})
+target_link_libraries( randomtest ${QCA_LIB_NAME} ${QT_QTGUI_LIBRARY})

--- a/examples/rsatest/CMakeLists.txt
+++ b/examples/rsatest/CMakeLists.txt
@ -2,5 +2,5 @@ set(rsatest_bin_SRCS rsatest.cpp)

 add_executable(rsatest ${rsatest_bin_SRCS})

-target_link_libraries( rsatest qca ${QT_QTGUI_LIBRARY})
+target_link_libraries( rsatest ${QCA_LIB_NAME} ${QT_QTGUI_LIBRARY})

--- a/examples/saslclient/CMakeLists.txt
+++ b/examples/saslclient/CMakeLists.txt
@ -4,4 +4,4 @@ MY_AUTOMOC( saslclient_bin_SRCS)

 add_executable(saslclient ${saslclient_bin_SRCS})

-target_link_libraries( saslclient qca ${QT_QTGUI_LIBRARY} ${QT_QTNETWORK_LIBRARY})
+target_link_libraries( saslclient ${QCA_LIB_NAME} ${QT_QTGUI_LIBRARY} ${QT_QTNETWORK_LIBRARY})
--- a/examples/saslserver/CMakeLists.txt
+++ b/examples/saslserver/CMakeLists.txt
@ -4,4 +4,4 @@ MY_AUTOMOC( saslserver_bin_SRCS)

 add_executable(saslserver ${saslserver_bin_SRCS})

-target_link_libraries( saslserver qca ${QT_QTGUI_LIBRARY} ${QT_QTNETWORK_LIBRARY})
+target_link_libraries( saslserver ${QCA_LIB_NAME} ${QT_QTGUI_LIBRARY} ${QT_QTNETWORK_LIBRARY})
--- a/examples/sslservtest/CMakeLists.txt
+++ b/examples/sslservtest/CMakeLists.txt
@ -4,5 +4,5 @@ MY_AUTOMOC( sslservtest_bin_SRCS )

 add_executable(sslservtest ${sslservtest_bin_SRCS})

-target_link_libraries( sslservtest qca ${QT_QTGUI_LIBRARY} ${QT_QTNETWORK_LIBRARY})
+target_link_libraries( sslservtest ${QCA_LIB_NAME} ${QT_QTGUI_LIBRARY} ${QT_QTNETWORK_LIBRARY})

--- a/examples/ssltest/CMakeLists.txt
+++ b/examples/ssltest/CMakeLists.txt
@ -5,5 +5,5 @@ MY_AUTOMOC( ssltest_bin_SRCS)

 add_executable(ssltest ${ssltest_bin_SRCS})

-target_link_libraries( ssltest qca ${QT_QTGUI_LIBRARY} ${QT_QTNETWORK_LIBRARY})
+target_link_libraries( ssltest ${QCA_LIB_NAME} ${QT_QTGUI_LIBRARY} ${QT_QTNETWORK_LIBRARY})

--- a/examples/tlssocket/CMakeLists.txt
+++ b/examples/tlssocket/CMakeLists.txt
@ -6,5 +6,5 @@ MY_AUTOMOC( tlssocket_bin_moc_SRCS)

 add_executable(tlssocket ${tlssocket_bin_moc_SRCS} ${tlssocket_bin_nonmoc_SRCS})

-target_link_libraries( tlssocket qca ${QT_QTGUI_LIBRARY} ${QT_QTNETWORK_LIBRARY})
+target_link_libraries( tlssocket ${QCA_LIB_NAME} ${QT_QTGUI_LIBRARY} ${QT_QTNETWORK_LIBRARY})

--- a/plugins/qca-botan/CMakeLists.txt
+++ b/plugins/qca-botan/CMakeLists.txt
@ -6,7 +6,7 @@ MY_AUTOMOC( QCA_BOTAN_SOURCES )

 ADD_LIBRARY(qca-botan MODULE ${QCA_BOTAN_SOURCES})

-TARGET_LINK_LIBRARIES(qca-botan ${QT_QTCORE_LIBRARY} qca ${BOTAN_LIBRARIES})
+TARGET_LINK_LIBRARIES(qca-botan ${QT_QTCORE_LIBRARY} ${QCA_LIB_NAME} ${BOTAN_LIBRARIES})

 INSTALL(TARGETS qca-botan
        LIBRARY DESTINATION "${QCA_PLUGINS_INSTALL_DIR}"
--- a/plugins/qca-cyrus-sasl/CMakeLists.txt
+++ b/plugins/qca-cyrus-sasl/CMakeLists.txt
@ -6,7 +6,7 @@ MY_AUTOMOC( QCA_SASL_SOURCES )

 ADD_LIBRARY(qca-cyrus-sasl MODULE ${QCA_SASL_SOURCES})

-TARGET_LINK_LIBRARIES(qca-cyrus-sasl ${QT_QTCORE_LIBRARY} qca ${SASL2_LIBRARIES})
+TARGET_LINK_LIBRARIES(qca-cyrus-sasl ${QT_QTCORE_LIBRARY} ${QCA_LIB_NAME} ${SASL2_LIBRARIES})

 INSTALL(TARGETS qca-cyrus-sasl 
        LIBRARY DESTINATION "${QCA_PLUGINS_INSTALL_DIR}"
--- a/plugins/qca-gcrypt/CMakeLists.txt
+++ b/plugins/qca-gcrypt/CMakeLists.txt
@ -6,7 +6,7 @@ MY_AUTOMOC( QCA_GCRYPT_SOURCES )

 ADD_LIBRARY(qca-gcrypt MODULE ${QCA_GCRYPT_SOURCES})

-TARGET_LINK_LIBRARIES(qca-gcrypt ${QT_QTCORE_LIBRARY} qca ${LIBGCRYPT_LIBRARIES})
+TARGET_LINK_LIBRARIES(qca-gcrypt ${QT_QTCORE_LIBRARY} ${QCA_LIB_NAME} ${LIBGCRYPT_LIBRARIES})

 INSTALL(TARGETS qca-gcrypt
        LIBRARY DESTINATION "${QCA_PLUGINS_INSTALL_DIR}"
--- a/plugins/qca-gnupg/CMakeLists.txt
+++ b/plugins/qca-gnupg/CMakeLists.txt
@ -11,7 +11,7 @@ QT4_WRAP_CPP( EXTRA_GNUPG_SOURCES gpgproc/sprocess.h )

 ADD_LIBRARY(qca-gnupg MODULE ${QCA_GNUPG_MOC_SOURCES} gpgproc/sprocess.cpp ${EXTRA_GNUPG_SOURCES} )
 INCLUDE_DIRECTORIES(gpgproc)
-TARGET_LINK_LIBRARIES(qca-gnupg ${QT_QTCORE_LIBRARY} qca)
+TARGET_LINK_LIBRARIES(qca-gnupg ${QT_QTCORE_LIBRARY} ${QCA_LIB_NAME})

 IF (WIN32)
  TARGET_LINK_LIBRARIES(qca-gnupg advapi32)
--- a/plugins/qca-logger/CMakeLists.txt
+++ b/plugins/qca-logger/CMakeLists.txt
@ -8,7 +8,7 @@ ADD_LIBRARY(qca-logger MODULE ${QCA_LOGGER_SOURCES})
 ADD_DEFINITIONS(${LOGGERH_DEFINITIONS})
 INCLUDE_DIRECTORIES(${LOGGERH_INCLUDE_DIR})
 TARGET_LINK_LIBRARIES(qca-logger ${QT_QTCORE_LIBRARY})
-TARGET_LINK_LIBRARIES(qca-logger qca)
+TARGET_LINK_LIBRARIES(qca-logger ${QCA_LIB_NAME})

 INSTALL(TARGETS qca-logger
        LIBRARY DESTINATION "${QCA_PLUGINS_INSTALL_DIR}"
--- a/plugins/qca-nss/CMakeLists.txt
+++ b/plugins/qca-nss/CMakeLists.txt
@ -8,7 +8,7 @@ MY_AUTOMOC( QCA_NSS_SOURCES )

 ADD_LIBRARY(qca-nss MODULE ${QCA_NSS_SOURCES})

-TARGET_LINK_LIBRARIES(qca-nss ${QT_QTCORE_LIBRARY} qca ${NSS_LIBRARIES})
+TARGET_LINK_LIBRARIES(qca-nss ${QT_QTCORE_LIBRARY} ${QCA_LIB_NAME} ${NSS_LIBRARIES})

 INSTALL(TARGETS qca-nss
        LIBRARY DESTINATION "${QCA_PLUGINS_INSTALL_DIR}"
--- a/plugins/qca-ossl/CMakeLists.txt
+++ b/plugins/qca-ossl/CMakeLists.txt
@ -23,7 +23,7 @@ MY_AUTOMOC( QCA_OSSL_SOURCES )
 ADD_LIBRARY(qca-ossl MODULE ${QCA_OSSL_SOURCES})
 INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR})
 TARGET_LINK_LIBRARIES(qca-ossl ${QT_QTCORE_LIBRARY})
-TARGET_LINK_LIBRARIES(qca-ossl qca)
+TARGET_LINK_LIBRARIES(qca-ossl ${QCA_LIB_NAME})
 TARGET_LINK_LIBRARIES(qca-ossl ${OPENSSL_LIBRARIES})

 IF (APPLE)
--- a/plugins/qca-pkcs11/CMakeLists.txt
+++ b/plugins/qca-pkcs11/CMakeLists.txt
@ -8,7 +8,7 @@ ADD_LIBRARY(qca-pkcs11 MODULE ${QCA_PKCS11_SOURCES})
 ADD_DEFINITIONS(${PKCS11H_DEFINITIONS})
 INCLUDE_DIRECTORIES(${PKCS11H_INCLUDE_DIR})
 TARGET_LINK_LIBRARIES(qca-pkcs11 ${QT_QTCORE_LIBRARY})
-TARGET_LINK_LIBRARIES(qca-pkcs11 qca)
+TARGET_LINK_LIBRARIES(qca-pkcs11 ${QCA_LIB_NAME})
 TARGET_LINK_LIBRARIES(qca-pkcs11 ${PKCS11H_LIBRARIES})
 IF (WIN32)
  TARGET_LINK_LIBRARIES(qca-pkcs11 pkcs11-helper.dll)
--- a/plugins/qca-softstore/CMakeLists.txt
+++ b/plugins/qca-softstore/CMakeLists.txt
@ -8,7 +8,7 @@ ADD_LIBRARY(qca-softstore MODULE ${QCA_SOFTSTORE_SOURCES})
 ADD_DEFINITIONS(${SOFTSTOREH_DEFINITIONS})
 INCLUDE_DIRECTORIES(${SOFTSTOREH_INCLUDE_DIR})
 TARGET_LINK_LIBRARIES(qca-softstore ${QT_QTCORE_LIBRARY})
-TARGET_LINK_LIBRARIES(qca-softstore qca)
+TARGET_LINK_LIBRARIES(qca-softstore ${QCA_LIB_NAME})

 INSTALL(TARGETS qca-softstore
        LIBRARY DESTINATION "${QCA_PLUGINS_INSTALL_DIR}"
--- a/plugins/qca-wincrypto/CMakeLists.txt
+++ b/plugins/qca-wincrypto/CMakeLists.txt
@ -8,7 +8,7 @@ IF (WIN32)
   ADD_LIBRARY (qca-wincrypto MODULE ${QCA_WINCRYPTO_SOURCES})
   # use win32 includes
   TARGET_LINK_LIBRARIES (qca-wincrypto ${QT_QTCORE_LIBRARY})
-   TARGET_LINK_LIBRARIES (qca-wincrypto qca)
+   TARGET_LINK_LIBRARIES (qca-wincrypto ${QCA_LIB_NAME})
   TARGET_LINK_LIBRARIES (qca-wincrypto advapi32)

   INSTALL (TARGETS qca-wincrypto
--- a/qca2.pc.cmake
+++ b/qca2.pc.cmake
@ -7,5 +7,5 @@ Name: QCA
 Description: Qt Cryptographic Architecture library
 Version: @QCA_LIB_VERSION_STRING@
 Requires: QtCore
-Libs: -L${libdir} -lqca
+Libs: -L${libdir} -l@QCA_LIB_NAME@
 Cflags: -I${includedir}
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@ -129,25 +129,25 @@ qt4_wrap_cpp( SOURCES "${qca_INCLUDEDIR}/QtCrypto/qca_support.h")
 qt4_wrap_cpp( SOURCES "${qca_INCLUDEDIR}/QtCrypto/qpipe.h")
 qt4_wrap_cpp( SOURCES "qca_safeobj.h")

-ADD_LIBRARY(qca SHARED ${SOURCES})
-TARGET_LINK_LIBRARIES(qca ${QT_QTCORE_LIBRARY})
+ADD_LIBRARY(${QCA_LIB_NAME} SHARED ${SOURCES})
+TARGET_LINK_LIBRARIES(${QCA_LIB_NAME} ${QT_QTCORE_LIBRARY})

 if(WIN32)
-	TARGET_LINK_LIBRARIES(qca crypt32 ws2_32)
+	TARGET_LINK_LIBRARIES(${QCA_LIB_NAME} crypt32 ws2_32)
 endif(WIN32)	

 if(APPLE)
   set(CARBON_LIBRARY_SECURITY "-framework Security")
-   TARGET_LINK_LIBRARIES(qca ${CARBON_LIBRARY} ${CARBON_LIBRARY_SECURITY})
+   TARGET_LINK_LIBRARIES(${QCA_LIB_NAME} ${CARBON_LIBRARY} ${CARBON_LIBRARY_SECURITY})
 endif(APPLE)

-set_target_properties(qca PROPERTIES
+set_target_properties(${QCA_LIB_NAME} PROPERTIES
                      VERSION ${QCA_LIB_MAJOR_VERSION}.${QCA_LIB_MINOR_VERSION}.${QCA_LIB_PATCH_VERSION}
                      SOVERSION ${QCA_LIB_MAJOR_VERSION}
                      DEFINE_SYMBOL QCA_MAKEDLL
                      )

-INSTALL(TARGETS qca
+INSTALL(TARGETS ${QCA_LIB_NAME}
   LIBRARY DESTINATION "${QCA_LIBRARY_INSTALL_DIR}"
   RUNTIME DESTINATION bin
   ARCHIVE DESTINATION "${QCA_LIBRARY_INSTALL_DIR}"
--- a/tools/mozcerts/CMakeLists.txt
+++ b/tools/mozcerts/CMakeLists.txt
@ -4,5 +4,5 @@ set(mozcerts_bin_SRCS main.cpp)

 add_executable(mozcerts ${mozcerts_bin_SRCS})

-target_link_libraries( mozcerts qca ${QT_QTGUI_LIBRARY})
+target_link_libraries( mozcerts ${QCA_LIB_NAME} ${QT_QTGUI_LIBRARY})

--- a/tools/qcatool/CMakeLists.txt
+++ b/tools/qcatool/CMakeLists.txt
@ -6,8 +6,14 @@ MY_AUTOMOC( qcatool2_moc_SRCS )

 set(qcatool2_bin_SRCS ${qcatool2_moc_SRCS})  

-add_executable(qcatool2 ${qcatool2_bin_SRCS})
+if(QCA_LIB_SUFFIX)
+  set(QCATOOL_NAME qcatool2-${QCA_LIB_SUFFIX})
+else(QCA_LIB_SUFFIX)
+  set(QCATOOL_NAME qcatool2)
+endif(QCA_LIB_SUFFIX)

-target_link_libraries( qcatool2 qca ${QT_QTCORE_LIBRARY})
+add_executable(${QCATOOL_NAME} ${qcatool2_bin_SRCS})

-install(TARGETS qcatool2 DESTINATION "${QCA_BINARY_INSTALL_DIR}")
+target_link_libraries( ${QCATOOL_NAME} ${QCA_LIB_NAME} ${QT_QTCORE_LIBRARY})
+
+install(TARGETS ${QCATOOL_NAME} DESTINATION "${QCA_BINARY_INSTALL_DIR}")
--- a/unittest/base64unittest/CMakeLists.txt
+++ b/unittest/base64unittest/CMakeLists.txt
@ -6,6 +6,6 @@ MY_AUTOMOC( base64unittest_bin_SRCS )

 add_executable(base64unittest ${base64unittest_bin_SRCS} )

-target_link_libraries( base64unittest qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( base64unittest ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 ADD_TEST(Base64 ${EXECUTABLE_OUTPUT_PATH}/base64unittest)
--- a/unittest/bigintunittest/CMakeLists.txt
+++ b/unittest/bigintunittest/CMakeLists.txt
@ -6,6 +6,6 @@ MY_AUTOMOC( bigintunittest_bin_SRCS )

 add_executable(bigintunittest ${bigintunittest_bin_SRCS} )

-target_link_libraries( bigintunittest qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( bigintunittest ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 ADD_TEST("BigInteger" ${EXECUTABLE_OUTPUT_PATH}/bigintunittest)
--- a/unittest/certunittest/CMakeLists.txt
+++ b/unittest/certunittest/CMakeLists.txt
@ -6,7 +6,7 @@ MY_AUTOMOC( certunittest_bin_SRCS )

 add_executable(certunittest ${certunittest_bin_SRCS} )

-target_link_libraries( certunittest qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( certunittest ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 FOREACH( testFileName RootCAcert.pem 76.pem altname.pem csr1.pem 
 	 GoodCACRL.pem ov-root-ca-cert.crt User.pem QcaTestClientCert.pem xmppcert.pem 
--- a/unittest/cipherunittest/CMakeLists.txt
+++ b/unittest/cipherunittest/CMakeLists.txt
@ -6,6 +6,6 @@ MY_AUTOMOC( cipherunittest_bin_SRCS )

 add_executable(cipherunittest ${cipherunittest_bin_SRCS} )

-target_link_libraries( cipherunittest qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( cipherunittest ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 ADD_TEST( SymmetricCipher ${EXECUTABLE_OUTPUT_PATH}/cipherunittest)
--- a/unittest/clientplugin/CMakeLists.txt
+++ b/unittest/clientplugin/CMakeLists.txt
@ -6,6 +6,6 @@ MY_AUTOMOC( clientplugin_bin_SRCS )

 add_executable(clientplugin ${clientplugin_bin_SRCS} )

-target_link_libraries( clientplugin qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( clientplugin ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 ADD_TEST(ClientSidePlugin ${EXECUTABLE_OUTPUT_PATH}/clientplugin)
--- a/unittest/cms/CMakeLists.txt
+++ b/unittest/cms/CMakeLists.txt
@ -6,7 +6,7 @@ MY_AUTOMOC( cms_bin_SRCS )

 add_executable(cms ${cms_bin_SRCS} )

-target_link_libraries( cms qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( cms ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 FOREACH( testFileName QcaTestRootCert.pem QcaTestClientCert.pem  QcaTestClientKey.pem )
   CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/${testFileName} ${CMAKE_CURRENT_BINARY_DIR}/${testFileName} COPYONLY)
--- a/unittest/dsaunittest/CMakeLists.txt
+++ b/unittest/dsaunittest/CMakeLists.txt
@ -6,7 +6,7 @@ MY_AUTOMOC( dsaunittest_bin_SRCS )

 add_executable( dsaunittest ${dsaunittest_bin_SRCS} )

-target_link_libraries( dsaunittest qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( dsaunittest ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 ADD_TEST(DigitalSignatureAlgorithm ${EXECUTABLE_OUTPUT_PATH}/dsaunittest)

--- a/unittest/hashunittest/CMakeLists.txt
+++ b/unittest/hashunittest/CMakeLists.txt
@ -6,7 +6,7 @@ MY_AUTOMOC( hashunittest_bin_SRCS )

 add_executable( hashunittest ${hashunittest_bin_SRCS} )

-target_link_libraries( hashunittest qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( hashunittest ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/data/empty ${CMAKE_CURRENT_BINARY_DIR}/data/empty COPYONLY)
 CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/data/twobytes ${CMAKE_CURRENT_BINARY_DIR}/data/twobytes COPYONLY)
--- a/unittest/hexunittest/CMakeLists.txt
+++ b/unittest/hexunittest/CMakeLists.txt
@ -6,6 +6,6 @@ MY_AUTOMOC( hexunittest_bin_SRCS )

 add_executable( hexunittest ${hexunittest_bin_SRCS} )

-target_link_libraries( hexunittest qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( hexunittest ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 ADD_TEST(HexadecimalConversion ${EXECUTABLE_OUTPUT_PATH}/hexunittest)
--- a/unittest/kdfunittest/CMakeLists.txt
+++ b/unittest/kdfunittest/CMakeLists.txt
@ -6,6 +6,6 @@ MY_AUTOMOC( kdfunittest_bin_SRCS )

 add_executable( kdfunittest ${kdfunittest_bin_SRCS} )

-target_link_libraries( kdfunittest qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( kdfunittest ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 ADD_TEST(KeyDerivationFunction ${EXECUTABLE_OUTPUT_PATH}/kdfunittest)
--- a/unittest/keybundle/CMakeLists.txt
+++ b/unittest/keybundle/CMakeLists.txt
@ -6,7 +6,7 @@ MY_AUTOMOC( keybundleunittest_bin_SRCS )

 add_executable( keybundle ${keybundleunittest_bin_SRCS} )

-target_link_libraries( keybundle qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( keybundle ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})


 FOREACH( testFileName RootCA2cert.pem  servergood2.p12  
--- a/unittest/keygenunittest/CMakeLists.txt
+++ b/unittest/keygenunittest/CMakeLists.txt
@ -6,6 +6,6 @@ MY_AUTOMOC( keygenunittest_bin_SRCS )

 add_executable( keygenunittest ${keygenunittest_bin_SRCS} )

-target_link_libraries( keygenunittest qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( keygenunittest ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 ADD_TEST(KeyGeneration ${EXECUTABLE_OUTPUT_PATH}/keygenunittest)
--- a/unittest/keylengthunittest/CMakeLists.txt
+++ b/unittest/keylengthunittest/CMakeLists.txt
@ -6,6 +6,6 @@ MY_AUTOMOC( keylengthunittest_bin_SRCS )

 add_executable( keylengthunittest ${keylengthunittest_bin_SRCS} )

-target_link_libraries( keylengthunittest qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( keylengthunittest ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 ADD_TEST(KeyLength ${EXECUTABLE_OUTPUT_PATH}/keylengthunittest)
--- a/unittest/keystore/CMakeLists.txt
+++ b/unittest/keystore/CMakeLists.txt
@ -6,6 +6,6 @@ MY_AUTOMOC( keystoreunittest_bin_SRCS )

 add_executable( keystore ${keystoreunittest_bin_SRCS} )

-target_link_libraries( keystore qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( keystore ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 ADD_TEST(KeyStore ${EXECUTABLE_OUTPUT_PATH}/keystore)
--- a/unittest/logger/CMakeLists.txt
+++ b/unittest/logger/CMakeLists.txt
@ -6,6 +6,6 @@ MY_AUTOMOC( loggerunittest_bin_SRCS )

 add_executable(loggerunittest ${loggerunittest_bin_SRCS} )

-target_link_libraries( loggerunittest qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( loggerunittest ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 ADD_TEST(Logger ${EXECUTABLE_OUTPUT_PATH}/loggerunittest)
--- a/unittest/macunittest/CMakeLists.txt
+++ b/unittest/macunittest/CMakeLists.txt
@ -6,6 +6,6 @@ MY_AUTOMOC( macunittest_bin_SRCS )

 add_executable( macunittest ${macunittest_bin_SRCS} )

-target_link_libraries( macunittest qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( macunittest ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 ADD_TEST(MessageAuthenticationCode ${EXECUTABLE_OUTPUT_PATH}/macunittest)
--- a/unittest/metatype/CMakeLists.txt
+++ b/unittest/metatype/CMakeLists.txt
@ -6,6 +6,6 @@ MY_AUTOMOC( metatype_bin_SRCS )

 add_executable( metatypeunittest ${metatype_bin_SRCS} )

-target_link_libraries( metatypeunittest qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( metatypeunittest ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 ADD_TEST(MetaTypeUnittest ${EXECUTABLE_OUTPUT_PATH}/metatypeunittest)
--- a/unittest/pgpunittest/CMakeLists.txt
+++ b/unittest/pgpunittest/CMakeLists.txt
@ -6,7 +6,7 @@ MY_AUTOMOC( pgpunittest_bin_SRCS )

 add_executable(pgpunittest ${pgpunittest_bin_SRCS} )

-target_link_libraries( pgpunittest qca ${QT_QTTEST_LIBRARY} )
+target_link_libraries( pgpunittest ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY} )

 FOREACH( testFileName pubring.gpg secring.gpg trustdb.gpg )
   CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/keys1/${testFileName} ${CMAKE_CURRENT_BINARY_DIR}/keys1/${testFileName} COPYONLY)
--- a/unittest/pipeunittest/CMakeLists.txt
+++ b/unittest/pipeunittest/CMakeLists.txt
@ -6,6 +6,6 @@ MY_AUTOMOC( pipeunittest_bin_SRCS )

 add_executable( pipeunittest ${pipeunittest_bin_SRCS} )

-target_link_libraries( pipeunittest qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( pipeunittest ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 # ADD_TEST(QPipe ${EXECUTABLE_OUTPUT_PATH}/pipeunittest)
--- a/unittest/pkits/CMakeLists.txt
+++ b/unittest/pkits/CMakeLists.txt
@ -6,7 +6,7 @@ MY_AUTOMOC( pkits_bin_SRCS )

 add_executable(pkits ${pkits_bin_SRCS} )

-target_link_libraries( pkits qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( pkits ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 FOREACH( testFileName BadnotAfterDateCACert.crt RFC3280MandatoryAttributeTypesCACRL.crl BadnotAfterDateCACRL.crl
 	 RFC3280OptionalAttributeTypesCACert.crt BadnotBeforeDateCACert.crt RFC3280OptionalAttributeTypesCACRL.crl
--- a/unittest/randomunittest/CMakeLists.txt
+++ b/unittest/randomunittest/CMakeLists.txt
@ -6,6 +6,6 @@ MY_AUTOMOC( randomunittest_bin_SRCS )

 add_executable( randomunittest ${randomunittest_bin_SRCS} )

-target_link_libraries( randomunittest qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( randomunittest ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 ADD_TEST(RandomNumberGeneration ${EXECUTABLE_OUTPUT_PATH}/randomunittest)
--- a/unittest/rsaunittest/CMakeLists.txt
+++ b/unittest/rsaunittest/CMakeLists.txt
@ -6,6 +6,6 @@ MY_AUTOMOC( rsaunittest_bin_SRCS )

 add_executable(rsaunittest ${rsaunittest_bin_SRCS} )

-target_link_libraries( rsaunittest qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( rsaunittest ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 ADD_TEST(RSA ${EXECUTABLE_OUTPUT_PATH}/rsaunittest)
--- a/unittest/securearrayunittest/CMakeLists.txt
+++ b/unittest/securearrayunittest/CMakeLists.txt
@ -6,6 +6,6 @@ MY_AUTOMOC( securearrayunittest_bin_SRCS )

 add_executable( securearrayunittest ${securearrayunittest_bin_SRCS} )

-target_link_libraries( securearrayunittest qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( securearrayunittest ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 ADD_TEST(SecureArray ${EXECUTABLE_OUTPUT_PATH}/securearrayunittest)
--- a/unittest/staticunittest/CMakeLists.txt
+++ b/unittest/staticunittest/CMakeLists.txt
@ -6,7 +6,7 @@ MY_AUTOMOC( staticunittest_bin_SRCS )

 add_executable( staticunittest ${staticunittest_bin_SRCS} )

-target_link_libraries( staticunittest qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( staticunittest ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 ADD_TEST(StaticFunctions ${EXECUTABLE_OUTPUT_PATH}/staticunittest)

--- a/unittest/symmetrickeyunittest/CMakeLists.txt
+++ b/unittest/symmetrickeyunittest/CMakeLists.txt
@ -6,6 +6,6 @@ MY_AUTOMOC( symmetrickeyunittest_bin_SRCS )

 add_executable( symmetrickeyunittest ${symmetrickeyunittest_bin_SRCS} )

-target_link_libraries( symmetrickeyunittest qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( symmetrickeyunittest ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 ADD_TEST(SymmetricKey ${EXECUTABLE_OUTPUT_PATH}/symmetrickeyunittest)
--- a/unittest/tls/CMakeLists.txt
+++ b/unittest/tls/CMakeLists.txt
@ -6,6 +6,6 @@ MY_AUTOMOC( tlsunittest_bin_SRCS )

 add_executable(tlsunittest ${tlsunittest_bin_SRCS} )

-target_link_libraries( tlsunittest qca ${QT_QTTEST_LIBRARY})
+target_link_libraries( tlsunittest ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY})

 ADD_TEST(TransportLayerSecurity ${EXECUTABLE_OUTPUT_PATH}/tlsunittest)
--- a/unittest/velox/CMakeLists.txt
+++ b/unittest/velox/CMakeLists.txt
@ -6,7 +6,7 @@ MY_AUTOMOC( veloxunittest_bin_SRCS )

 add_executable(veloxunittest ${veloxunittest_bin_SRCS} )

-target_link_libraries( veloxunittest qca ${QT_QTTEST_LIBRARY} ${QT_QTNETWORK_LIBRARY} )
+target_link_libraries( veloxunittest ${QCA_LIB_NAME} ${QT_QTTEST_LIBRARY} ${QT_QTNETWORK_LIBRARY} )

 CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/root.crt ${CMAKE_CURRENT_BINARY_DIR}/root.crt COPYONLY)