Ignore symLinks for seacrhing qmake

src/Deploy/src/configparser.cpp

@@ -1135,25 +1135,51 @@ bool ConfigParser::initQmakePrivate(const QString &qmake) {
     QFileInfo info(qmake);
 
     QString basePath = info.absolutePath();
-    if (!setQmake(qmake)) {
-        QDir dir(basePath);
 
-        if (!dir.cdUp()) {
-            QuasarAppUtils::Params::log("Failed to initialize qt directories by qmake.",
+    // Invoke qmake executable only when qmake pathe exclude snapRootFS path.
+    // Because files in snapRootFS is not executable ...
+    if (!qmake.contains(DeployCore::snapRootFS()) && setQmake(qmake)) {
+        return true;
+    }
+
+
+    // try deploy qt using only read FS permisions
+
+    // check debian qt structure
+    if (DeployCore::isDebianQt(info.absoluteFilePath())) {
+        QString neededPlatform = DeployCore::getPlatformLibPrefix(_config.getPlatformOfAll());
+        int qtVersion = DeployCore::qtVersionToString(_config.isNeededQt());
+
+        QString debianQtRoot = QString("/usr/lib/%0/qt%1").
+                               arg(neededPlatform).arg(qtVersion);
+
+
+        if (!setQtDir(debianQtRoot)) {
+            QuasarAppUtils::Params::log("Failed to initialize Qt directories",
                                         QuasarAppUtils::Error);
             return false;
         }
+    }
+
+    QDir dir(basePath);
 
+    if (!dir.cdUp()) {
+        QuasarAppUtils::Params::log("Failed to initialize qt directories by qmake.",
+                                    QuasarAppUtils::Error);
+        return false;
+    }
+
+    // For snap package of cqtdeplyer it is norma behavior
+    if (!DeployCore::isSnap()) {
         QuasarAppUtils::Params::log("Failed to execute the qmake process!"
                                     " Trying to initialize Qt directories from path: " + dir.absolutePath(),
                                     QuasarAppUtils::Warning);
+    }
 
-        if (!setQtDir(dir.absolutePath())){
-            QuasarAppUtils::Params::log("Failed to initialize Qt directories",
-                                        QuasarAppUtils::Error);
-            return false;
-        }
-
+    if (!setQtDir(dir.absolutePath())){
+        QuasarAppUtils::Params::log("Failed to initialize Qt directories",
+                                    QuasarAppUtils::Error);
+        return false;
     }
 
     return true;
@@ -1175,13 +1201,13 @@ bool ConfigParser::initQmake() {
 
     if (!info.isFile() || (info.baseName() != "qmake")) {
 
-        QString qmakeFromRPath = DeployCore::findProcess(getRPathFromTargets(), "qmake");
+        QString qmakeFromRPath = DeployCore::findProcess(getRPathFromTargets(), "qmake", true);
 
         if (qmakeFromRPath.isEmpty()) {
 
             if (!QuasarAppUtils::Params::isEndable("noCheckPATH")) {
                 auto env = QProcessEnvironment::systemEnvironment();
-                auto proc = DeployCore::findProcess(env.value("PATH"), "qmake");
+                auto proc = DeployCore::findProcess(env.value("PATH"), "qmake", true);
                 if (proc.isEmpty()) {
                     QuasarAppUtils::Params::log("The deployment target requires Qt libraries,"
                                                 " but initialize of Qt directories is failed."
@@ -1265,19 +1291,9 @@ bool ConfigParser::setQmake(const QString &value) {
             _config.qtDir.setTranslations(getPathFrmoQmakeLine(value));
         } else if (value.contains("QT_INSTALL_DATA")) {
             _config.qtDir.setResources(getPathFrmoQmakeLine(value) + "/resources");
-        } else if (value.contains("QMAKE_XSPEC")) {
-            auto val = value.split(':').value(1);
-
-            if (val.contains("win32")) {
-                _config.qtDir.setQtPlatform(Platform::Win);
-            } else {
-                _config.qtDir.setQtPlatform(Platform::Unix);
-            }
         }
     }
 
-    _config.qtDir.setQtVersion(_config.isNeededQt());
-
     _config.envirement.addEnv(_config.qtDir.getLibs());
     _config.envirement.addEnv(_config.qtDir.getBins());
 
@@ -1294,11 +1310,16 @@ bool ConfigParser::setQtDir(const QString &value) {
     }
     _config.qtDir.setBins(info.absoluteFilePath() + ("/bin"));
 
-    if (!QFile::exists(info.absoluteFilePath() + ("/lib"))) {
-        QuasarAppUtils::Params::log("get qt lib failed!", QuasarAppUtils::Debug);
-        return false;
+    if (DeployCore::isDebianQt(value)) {
+        _config.qtDir.setLibs(info.absoluteFilePath() + ("/.."));
+    } else {
+        if (!QFile::exists(info.absoluteFilePath() + ("/lib"))) {
+            QuasarAppUtils::Params::log("get qt lib failed!", QuasarAppUtils::Debug);
+            return false;
+        }
+        _config.qtDir.setLibs(info.absoluteFilePath() + ("/lib"));
     }
-    _config.qtDir.setLibs(info.absoluteFilePath() + ("/lib"));
+
 
     if (!QFile::exists(info.absoluteFilePath() + ("/qml"))) {
         QuasarAppUtils::Params::log("get qt qml failed!", QuasarAppUtils::Debug);
@@ -1312,21 +1333,25 @@ bool ConfigParser::setQtDir(const QString &value) {
         _config.qtDir.setPlugins(info.absoluteFilePath() + ("/plugins"));
     }
 
-#ifdef Q_OS_UNIX
-    if (!QFile::exists(info.absoluteFilePath() + ("/libexec"))) {
-        QuasarAppUtils::Params::log("get qt libexec failed!", QuasarAppUtils::Debug);
-    } else {
-        _config.qtDir.setLibexecs(info.absoluteFilePath() + ("/libexec"));
+    if (_config.qtDir.getQtPlatform() & Unix) {
+        if (!QFile::exists(info.absoluteFilePath() + ("/libexec"))) {
+            QuasarAppUtils::Params::log("get qt libexec failed!", QuasarAppUtils::Debug);
+        } else {
+            _config.qtDir.setLibexecs(info.absoluteFilePath() + ("/libexec"));
+        }
+    } else if (_config.qtDir.getQtPlatform() & Win) {
+        _config.qtDir.setLibexecs(info.absoluteFilePath() + ("/bin"));
     }
-#endif
-#ifdef Q_OS_WIN
-    _config.qtDir.setLibexecs(info.absoluteFilePath() + ("/bin"));
-#endif
 
-    if (!QFile::exists(info.absoluteFilePath() + ("/translations"))) {
-        QuasarAppUtils::Params::log("get qt translations failed!", QuasarAppUtils::Debug);
+    if (DeployCore::isDebianQt(value)) {
+        _config.qtDir.setTranslations(QString("/usr/share/qt%0/translations").
+                                      arg(DeployCore::qtVersionToString(_config.isNeededQt())));
     } else {
-        _config.qtDir.setTranslations(info.absoluteFilePath() + ("/translations"));
+        if (!QFile::exists(info.absoluteFilePath() + ("/translations"))) {
+            QuasarAppUtils::Params::log("get qt translations failed!", QuasarAppUtils::Debug);
+        } else {
+            _config.qtDir.setTranslations(info.absoluteFilePath() + ("/translations"));
+        }
     }
 
     if (!QFile::exists(info.absoluteFilePath() + ("/resources"))) {
@@ -1335,15 +1360,6 @@ bool ConfigParser::setQtDir(const QString &value) {
         _config.qtDir.setResources(info.absoluteFilePath() + ("/resources"));
     }
 
-#ifdef Q_OS_UNIX
-    _config.qtDir.setQtPlatform(Platform::Unix);
-#endif
-#ifdef Q_OS_WIN
-    _config.qtDir.setQtPlatform(Platform::Win);
-#endif
-
-    _config.qtDir.setQtVersion(_config.isNeededQt());
-
     _config.envirement.addEnv(_config.qtDir.getLibs());
     _config.envirement.addEnv(_config.qtDir.getBins());
 

src/Deploy/src/deploycore.cpp

@@ -633,11 +633,16 @@ bool DeployCore::isContainsArraySeparators(const QString &val, int lastLvl) {
     return false;
 }
 
-QString DeployCore::findProcess(const QString &env, const QString& proc) {
+QString DeployCore::findProcess(const QString &env, const QString& proc, bool ignoreSymLinks) {
     auto list = env.split(DeployCore::getEnvSeparator());
 
+    auto findEntries = QDir::NoDotAndDotDot | QDir::Files;
+    if (ignoreSymLinks) {
+        findEntries = findEntries | QDir::NoSymLinks;
+    }
+
     for (const auto& path : list) {
-        auto files = QDir(path).entryInfoList(QDir::NoDotAndDotDot | QDir::Files);
+        auto files = QDir(path).entryInfoList(findEntries);
 
         for (const auto& bin : files) {
             if (bin.baseName().compare(proc, DeployCore::getCaseSensitivity()) == 0 && bin.isExecutable()) {
@@ -649,7 +654,7 @@ QString DeployCore::findProcess(const QString &env, const QString& proc) {
     // working only for the snap version of cqtdeployer ...
     if (isSnap()) {
         for (const auto& path : list) {
-            auto files = QDir(transportPathToSnapRoot(path)).entryInfoList(QDir::NoDotAndDotDot | QDir::Files);
+            auto files = QDir(transportPathToSnapRoot(path)).entryInfoList(findEntries);
 
             for (const auto& bin : files) {
                 if (bin.baseName().compare(proc, DeployCore::getCaseSensitivity()) == 0) {
@@ -918,7 +923,7 @@ QString DeployCore::platformToString(Platform platform) {
         {Platform::Win32, "win_x86"},
         {Platform::Win64, "win_x86_64"},
         {Platform::Win_ARM_32, "win_arm"},
-        {Platform::win_ARM_64, "win_arm64"},
+        {Platform::Win_ARM_64, "win_arm64"},
         {Platform::Unix_x86_32, "linux_x86"},
         {Platform::Unix_x86_64, "linux_x86_64"},
         {Platform::Unix_ARM_32, "linux_ARM"},
@@ -952,7 +957,7 @@ Platform DeployCore::getPlatformFromString(const QString &platformName) {
         {"win_x86", Platform::Win32},
         {"win_x86_64", Platform::Win64},
         {"win_arm", Platform::Win_ARM_32},
-        {"win_arm64", Platform::win_ARM_64},
+        {"win_arm64", Platform::Win_ARM_64},
         {"linux_x86", Platform::Unix_x86_32},
         {"linux_x86_64", Platform::Unix_x86_64},
         {"linux_ARM", Platform::Unix_ARM_32},
@@ -1057,7 +1062,49 @@ Qt::CaseSensitivity DeployCore::getCaseSensitivity(const QString &checkedFile) {
     }
 
     return Qt::CaseSensitive;
-};
+}
+
+
+
+QString DeployCore::getPlatformLibPrefix(Platform plarform) {
+
+    if (plarform & Platform::Unix_x86_64) {
+        return "x86_64-linux-gnu";
+    } else if (plarform & Platform::Unix_ARM_64) {
+        return "aarch64-linux-gnu";
+    } else if (plarform & Platform::Unix_x86_32) {
+        return "x86_32-linux-gnu";
+    } else if (plarform & Platform::Unix_ARM_32) {
+        return "arm-linux-gnu";
+    } else if (plarform & Platform::Win64) {
+        return "";
+    } else if (plarform & Platform::Win32) {
+        return "";
+    } else if (plarform & Platform::Win_ARM_64) {
+        return "";
+    } else if (plarform & Platform::Win_ARM_32) {
+        return "";
+    }
+
+    // not supported
+    return "";
+}
+
+int DeployCore::qtVersionToString(QtMajorVersion qtVersion) {
+    if (qtVersion & QtMajorVersion::Qt6) {
+        return 6;
+    } else if (qtVersion & QtMajorVersion::Qt5) {
+        return 5;
+    } else if (qtVersion & QtMajorVersion::Qt4) {
+        return 4;
+    }
+
+    return 0;
+}
+
+bool DeployCore::isDebianQt(const QString &qtRoot) {
+    return qtRoot.contains("/usr/lib/qt");
+}
 
 QString DeployCore::systemLibsFolderName() {
     return "systemLibs";

src/Deploy/src/deploycore.h

@@ -48,7 +48,7 @@ enum Platform {
     Win32           = 0x0001,
     Win64           = 0x0002,
     Win_ARM_32      = 0x0004,
-    win_ARM_64      = 0x0008,
+    Win_ARM_64      = 0x0008,
     Win             = Win32 | Win64,
 
     // Unix
@@ -277,7 +277,7 @@ class DEPLOYSHARED_EXPORT DeployCore
     static bool isExecutable(const QFileInfo &file);
     static bool isContainsArraySeparators(const QString& val,
                                           int lastLvl = 2);
-    static QString findProcess(const QString& env, const QString& proc);
+    static QString findProcess(const QString& env, const QString& proc, bool ignoreSymLinks = false);
 
     static QStringList debugExtensions();
     static bool isDebugFile(const QString& file);
@@ -323,6 +323,27 @@ class DEPLOYSHARED_EXPORT DeployCore
      * @return Qt CaseSensitivity value
      */
     static Qt::CaseSensitivity getCaseSensitivity(const QString& checkedFile = "");
+
+    /**
+     * @brief getPlatformLibPrefix This method return string value of the @a platform
+     * @param plarform This is input platform
+     * @return string value of the @a platfrom. If platform not supported strings implementations the return empty string.
+     */
+    static QString getPlatformLibPrefix(Platform plarform);
+
+    /**
+     * @brief qtVersionToString return integer interpritation of the Qt major version
+     * @return integer implementation of major qt version.
+     * @note return 0 if the @a qtVersion is invalid
+     */
+    static int qtVersionToString(QtMajorVersion qtVersion);
+
+    /**
+     * @brief isDebianQt this method return true if the @a qtRoot is debian system qt.
+     * @param qtRoot path to qt root dir.
+     * @return true if the @a qtRoot is debian system qt else false.
+     */
+    static bool isDebianQt(const QString& qtRoot);
 };
 
 #define internalError() DeployCore::printInternalError(__FUNCTION__, __FILE__, __LINE__)

src/Deploy/src/pe_type.cpp

@@ -128,7 +128,7 @@ bool PE::getLibInfo(const QString &lib, LibInfo &info) const {
             info.setPlatform(Win_ARM_32);
 
         } else {
-            info.setPlatform(win_ARM_64);
+            info.setPlatform(Win_ARM_64);
         }
 
     } else if (parsedPeLib->peHeader.nt.FileHeader.Machine == peparse::IMAGE_FILE_MACHINE_I386 ||

src/Deploy/src/qtdir.cpp

@@ -12,16 +12,24 @@ QtMajorVersion QtDir::getQtVersion() const {
     return _qtVersion;
 }
 
-void QtDir::setQtVersion(const QtMajorVersion &qtVersion) {
-    _qtVersion = qtVersion;
-}
-
 QString QtDir::getLibs() const {
     return libs;
 }
 
 void QtDir::setLibs(const QString &value) {
     libs = PathUtils::fixPath(value);
+
+    auto qtLibs = QDir(libs).entryList(QDir::Files);
+    if (qtLibs.contains("libQt4Core.so")) {
+        _qtVersion = QtMajorVersion::Qt4;
+        _platform = Unix;
+    } else if (qtLibs.contains("libQt5Core.so")) {
+        _qtVersion = QtMajorVersion::Qt5;
+        _platform = Unix;
+    } else if (qtLibs.contains("libQt6Core.so")) {
+        _qtVersion = QtMajorVersion::Qt6;
+        _platform = Unix;
+    }
 }
 
 QString QtDir::getBins() const {
@@ -30,6 +38,18 @@ QString QtDir::getBins() const {
 
 void QtDir::setBins(const QString &value) {
     bins =  PathUtils::fixPath(value);
+
+    auto qtLibs = QDir(bins).entryList(QDir::Files);
+    if (qtLibs.contains("Qt4Core.dll", Qt::CaseInsensitive)) {
+        _qtVersion = QtMajorVersion::Qt4;
+        _platform = Win;
+    } else if (qtLibs.contains("Qt5Core.dll", Qt::CaseInsensitive)) {
+        _qtVersion = QtMajorVersion::Qt5;
+        _platform = Win;
+    } else if (qtLibs.contains("Qt6Core.dll", Qt::CaseInsensitive)) {
+        _qtVersion = QtMajorVersion::Qt6;
+        _platform = Win;
+    }
 }
 
 QString QtDir::getLibexecs() const {
@@ -74,11 +94,7 @@ void QtDir::setResources(const QString &value) {
 }
 
 Platform QtDir::getQtPlatform() const {
-    return qtPlatform;
-}
-
-void QtDir::setQtPlatform(const Platform &value) {
-    qtPlatform = value;
+    return _platform;
 }
 
 bool QtDir::isQt(QString path) const {