src/thread_binaries.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Simple x264 Launcher
   3 // Copyright (C) 2004-2018 LoRd_MuldeR <MuldeR2@GMX.de>
   4 //
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 2 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License along
  16 // with this program; if not, write to the Free Software Foundation, Inc.,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19 // http://www.gnu.org/licenses/gpl-2.0.txt
  20 ///////////////////////////////////////////////////////////////////////////////
  21
  22 #include "thread_binaries.h"
  23
  24 #include <QLibrary>
  25 #include <QEventLoop>
  26 #include <QTimer>
  27 #include <QSet>
  28 #include <QMutexLocker>
  29 #include <QApplication>
  30 #include <QProcess>
  31 #include <QDir>
  32
  33 //Internal
  34 #include "global.h"
  35 #include "model_sysinfo.h"
  36 #include "win_updater.h"
  37 #include "encoder_factory.h"
  38 #include "source_factory.h"
  39
  40 //MUtils
  41 #include <MUtils/Global.h>
  42 #include <MUtils/OSSupport.h>
  43
  44 //Static
  45 QMutex BinariesCheckThread::m_binLock;
  46 QScopedPointer<QFile> BinariesCheckThread::m_binPath[MAX_BINARIES];
  47
  48 //Whatever
  49 #define NEXT(X) ((*reinterpret_cast<int*>(&(X)))++)
  50 #define SHFL(X) ((*reinterpret_cast<int*>(&(X))) <<= 1)
  51
  52 //External
  53 QString AVS_CHECK_BINARY(const SysinfoModel *sysinfo, const bool& x64);
  54
  55 //-------------------------------------
  56 // External API
  57 //-------------------------------------
  58
  59 bool BinariesCheckThread::check(SysinfoModel *sysinfo)
  60 {
  61         QMutexLocker lock(&m_binLock);
  62
  63         QEventLoop loop;
  64         BinariesCheckThread thread(sysinfo);
  65
  66         QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
  67
  68         connect(&thread, SIGNAL(finished()), &loop, SLOT(quit()));
  69         connect(&thread, SIGNAL(terminated()), &loop, SLOT(quit()));
  70
  71         thread.start();
  72         QTimer::singleShot(30000, &loop, SLOT(quit()));
  73
  74         qDebug("Binaries checker thread has been created, please wait...");
  75         loop.exec(QEventLoop::ExcludeUserInputEvents);
  76         qDebug("Binaries checker thread finished.");
  77
  78         QApplication::restoreOverrideCursor();
  79
  80         if(!thread.wait(1000))
  81         {
  82                 qWarning("Binaries checker thread encountered timeout -> probably deadlock!");
  83                 thread.terminate();
  84                 thread.wait();
  85                 return false;
  86         }
  87
  88         if(thread.getException())
  89         {
  90                 qWarning("Binaries checker thread encountered an exception !!!");
  91                 return false;
  92         }
  93
  94         return thread.getSuccess();
  95 }
  96
  97 //-------------------------------------
  98 // Thread class
  99 //-------------------------------------
 100
 101 BinariesCheckThread::BinariesCheckThread(const SysinfoModel *const sysinfo)
 102 :
 103         m_sysinfo(sysinfo)
 104 {
 105         m_success = m_exception = false;
 106 }
 107
 108 BinariesCheckThread::~BinariesCheckThread(void)
 109 {
 110 }
 111
 112 void BinariesCheckThread::run(void)
 113 {
 114         m_success = m_exception = false;
 115         checkBinaries1(m_success, m_sysinfo, &m_exception);
 116 }
 117
 118 void BinariesCheckThread::checkBinaries1(volatile bool &success, const SysinfoModel *const sysinfo, volatile bool *exception)
 119 {
 120         __try
 121         {
 122                 checkBinaries2(success, sysinfo, exception);
 123         }
 124         __except(1)
 125         {
 126                 *exception = true;
 127                 qWarning("Unhandled exception error in binaries checker thread !!!");
 128         }
 129 }
 130
 131 void BinariesCheckThread::checkBinaries2(volatile bool &success, const SysinfoModel *const sysinfo, volatile bool *exception)
 132 {
 133         try
 134         {
 135                 return checkBinaries3(success, sysinfo);
 136         }
 137         catch(...)
 138         {
 139                 *exception = true;
 140                 qWarning("Binaries checker initializdation raised an C++ exception!");
 141         }
 142 }
 143
 144 void BinariesCheckThread::checkBinaries3(volatile bool &success, const SysinfoModel *const sysinfo)
 145 {
 146         success = true;
 147
 148         //Create list of all required binary files
 149         typedef QPair<QString, bool> FileEntry;
 150         QList<FileEntry> binFiles;
 151         for(OptionsModel::EncType encdr = OptionsModel::EncType_MIN; encdr <= OptionsModel::EncType_MAX; NEXT(encdr))
 152         {
 153                 const AbstractEncoderInfo &encInfo = EncoderFactory::getEncoderInfo(encdr);
 154                 const quint32 archCount = encInfo.getArchitectures().count();
 155                 QSet<QString> filesSet;
 156                 for (quint32 archIdx = 0; archIdx < archCount; ++archIdx)
 157                 {
 158                         const QStringList variants = encInfo.getVariants();
 159                         for (quint32 varntIdx = 0; varntIdx < quint32(variants.count()); ++varntIdx)
 160                         {
 161                                 const QStringList dependencies = encInfo.getDependencies(sysinfo, archIdx, varntIdx);
 162                                 for (QStringList::ConstIterator iter = dependencies.constBegin(); iter != dependencies.constEnd(); iter++)
 163                                 {
 164                                         if (!filesSet.contains(*iter))
 165                                         {
 166                                                 filesSet << (*iter);
 167                                                 binFiles << qMakePair(*iter, true);
 168                                         }
 169                                 }
 170                                 const QString binary = encInfo.getBinaryPath(sysinfo, archIdx, varntIdx);
 171                                 if (!filesSet.contains(binary))
 172                                 {
 173                                         filesSet << binary;
 174                                         binFiles << qMakePair(binary, false);
 175                                 }
 176                         }
 177                 }
 178         }
 179         for(int i = 0; i < 2; i++)
 180         {
 181                 binFiles << qMakePair(SourceFactory::getSourceInfo(SourceFactory::SourceType_AVS).getBinaryPath(sysinfo, bool(i)), false);
 182                 binFiles << qMakePair(AVS_CHECK_BINARY(sysinfo, bool(i)), false);
 183         }
 184         for(size_t i = 0; UpdaterDialog::BINARIES[i].name; i++)
 185         {
 186                 if(UpdaterDialog::BINARIES[i].exec)
 187                 {
 188                         binFiles << qMakePair(QString("%1/toolset/common/%2").arg(sysinfo->getAppPath(), QString::fromLatin1(UpdaterDialog::BINARIES[i].name)), false);
 189                 }
 190         }
 191
 192         //Actually validate the binaries
 193         size_t currentFile = 0;
 194         for(QList<FileEntry>::ConstIterator iter = binFiles.constBegin(); iter != binFiles.constEnd(); iter++)
 195         {
 196                 QScopedPointer<QFile> file(new QFile(iter->first));
 197                 qDebug("%s", MUTILS_UTF8(file->fileName()));
 198
 199                 if(file->open(QIODevice::ReadOnly))
 200                 {
 201                         if(!iter->second)
 202                         {
 203                                 if (!MUtils::OS::is_executable_file(file->fileName()))
 204                                 {
 205                                         success = false;
 206                                         qWarning("Required tool does NOT look like a valid Win32/Win64 binary:\n%s\n", MUTILS_UTF8(file->fileName()));
 207                                         return;
 208                                 }
 209                         }
 210                         else
 211                         {
 212                                 if (!MUtils::OS::is_library_file(file->fileName()))
 213                                 {
 214                                         success = false;
 215                                         qWarning("Required tool does NOT look like a valid Win32/Win64 library:\n%s\n", MUTILS_UTF8(file->fileName()));
 216                                         return;
 217                                 }
 218                         }
 219                         if(currentFile < MAX_BINARIES)
 220                         {
 221                                 m_binPath[currentFile++].reset(file.take());
 222                                 continue;
 223                         }
 224                         qFatal("Current binary file exceeds max. number of binaries!");
 225                 }
 226                 else
 227                 {
 228                         success = false;
 229                         qWarning("Required tool could not be found or access denied:\n%s\n", MUTILS_UTF8(file->fileName()));
 230                         return;
 231                 }
 232         }
 233 }