projects/lib/src/engineprocess_win.cpp

   1 /*
   2     This file is part of Cute Chess.
   3
   4     Cute Chess is free software: you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation, either version 3 of the License, or
   7     (at your option) any later version.
   8
   9     Cute Chess is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with Cute Chess.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 #include "engineprocess_win.h"
  19 #include <QDir>
  20 #include <QRegExp>
  21 #include <QtDebug>
  22 #include "pipereader_win.h"
  23
  24
  25 EngineProcess::EngineProcess(QObject* parent)
  26         : QIODevice(parent),
  27           m_started(false),
  28           m_finished(false),
  29           m_exitCode(0),
  30           m_exitStatus(EngineProcess::NormalExit),
  31           m_inWrite(INVALID_HANDLE_VALUE),
  32           m_outRead(INVALID_HANDLE_VALUE),
  33           m_reader(0)
  34 {
  35 }
  36
  37 EngineProcess::~EngineProcess()
  38 {
  39         if (m_started)
  40         {
  41                 qWarning("EngineProcess: Destroyed while process is still running.");
  42                 kill();
  43                 waitForFinished();
  44         }
  45         cleanup();
  46 }
  47
  48 int EngineProcess::exitCode() const
  49 {
  50         return (int)m_exitCode;
  51 }
  52
  53 EngineProcess::ExitStatus EngineProcess::exitStatus() const
  54 {
  55         return m_exitStatus;
  56 }
  57
  58 qint64 EngineProcess::bytesAvailable() const
  59 {
  60         qint64 n = QIODevice::bytesAvailable();
  61
  62         if (!m_started)
  63                 return n;
  64         return m_reader->bytesAvailable() + n;
  65 }
  66
  67 bool EngineProcess::canReadLine() const
  68 {
  69         if (!m_started)
  70                 return QIODevice::canReadLine();
  71         return m_reader->canReadLine() || QIODevice::canReadLine();
  72 }
  73
  74 void EngineProcess::killHandle(HANDLE* handle)
  75 {
  76         if (*handle == INVALID_HANDLE_VALUE)
  77                 return;
  78         CloseHandle(*handle);
  79         *handle = INVALID_HANDLE_VALUE;
  80 }
  81
  82 void EngineProcess::cleanup()
  83 {
  84         if (m_reader != 0)
  85         {
  86                 if (m_reader->isRunning())
  87                 {
  88                         qWarning("EngineProcess: pipe reader was terminated");
  89                         m_reader->terminate();
  90                 }
  91                 delete m_reader;
  92                 m_reader = 0;
  93         }
  94
  95         killHandle(&m_inWrite);
  96         killHandle(&m_outRead);
  97
  98         killHandle(&m_processInfo.hProcess);
  99         killHandle(&m_processInfo.hThread);
 100
 101         m_started = false;
 102 }
 103
 104 void EngineProcess::close()
 105 {
 106         if (!m_started)
 107                 return;
 108
 109         emit aboutToClose();
 110         kill();
 111         waitForFinished(-1);
 112         cleanup();
 113         QIODevice::close();
 114 }
 115
 116 bool EngineProcess::isSequential() const
 117 {
 118         return true;
 119 }
 120
 121 void EngineProcess::setWorkingDirectory(const QString& dir)
 122 {
 123         m_workDir = dir;
 124 }
 125
 126 static QString quoteString(QString str)
 127 {
 128         if (!str.contains(' '))
 129                 return str;
 130
 131         if (!str.startsWith('\"'))
 132                 str.prepend('\"');
 133         if (!str.endsWith('\"'))
 134                 str.append('\"');
 135
 136         return str;
 137 }
 138
 139 static QString commandLine(const QString& prog, const QStringList& args)
 140 {
 141         QString cmd = QDir::toNativeSeparators(quoteString(prog));
 142         foreach (const QString& arg, args)
 143                 cmd += ' ' + quoteString(arg);
 144
 145         return cmd;
 146 }
 147
 148 void EngineProcess::start(const QString& program,
 149                           const QStringList& arguments,
 150                           OpenMode mode)
 151 {
 152         if (m_started)
 153                 close();
 154
 155         m_started = false;
 156         m_finished = false;
 157         m_exitCode = 0;
 158         m_exitStatus = NormalExit;
 159
 160         // Temporary handles for the child process' end of the pipes
 161         HANDLE outWrite;
 162         HANDLE inRead;
 163
 164         // Security attributes. Use the same one for both pipes.
 165         SECURITY_ATTRIBUTES saAttr;
 166         saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
 167         saAttr.bInheritHandle = TRUE;
 168         saAttr.lpSecurityDescriptor = NULL;
 169
 170         CreatePipe(&m_outRead, &outWrite, &saAttr, 0);
 171         CreatePipe(&inRead, &m_inWrite, &saAttr, 0);
 172
 173         STARTUPINFO startupInfo;
 174         ZeroMemory(&startupInfo, sizeof(startupInfo));
 175         startupInfo.cb = sizeof(startupInfo);
 176         startupInfo.hStdError = outWrite;
 177         startupInfo.hStdOutput = outWrite;
 178         startupInfo.hStdInput = inRead;
 179         startupInfo.dwFlags |= STARTF_USESTDHANDLES;
 180
 181         // Call DuplicateHandle with a NULL target to get non-inheritable
 182         // handles for the parent process' ends of the pipes
 183         DuplicateHandle(GetCurrentProcess(),
 184                         m_outRead,              // child's stdout read end
 185                         GetCurrentProcess(),
 186                         NULL,                   // no target
 187                         0,                      // flags
 188                         FALSE,                  // not inheritable
 189                         DUPLICATE_SAME_ACCESS); // same handle access
 190         DuplicateHandle(GetCurrentProcess(),
 191                         m_inWrite,              // child's stdin write end
 192                         GetCurrentProcess(),
 193                         NULL,                   // no target
 194                         0,                      // flags
 195                         FALSE,                  // not inheritable
 196                         DUPLICATE_SAME_ACCESS); // same handle access
 197
 198         BOOL ok = FALSE;
 199         QString cmd = commandLine(program, arguments);
 200         QString wdir = QDir::toNativeSeparators(m_workDir);
 201         ZeroMemory(&m_processInfo, sizeof(m_processInfo));
 202
 203 #ifdef UNICODE
 204         ok = CreateProcessW(NULL,
 205                             (WCHAR*)cmd.utf16(),
 206                             NULL,       // process attributes
 207                             NULL,       // thread attributes
 208                             TRUE,       // inherit handles
 209                             CREATE_NEW_PROCESS_GROUP, // creation flags
 210                             NULL,       // environment
 211                             wdir.isEmpty() ? NULL : (WCHAR*)wdir.utf16(),
 212                             &startupInfo,
 213                             &m_processInfo);
 214 #else // not UNICODE
 215         ok = CreateProcessA(NULL,
 216                             cmd.toLocal8Bit().data(),
 217                             NULL,       // process attributes
 218                             NULL,       // thread attributes
 219                             TRUE,       // inherit handles
 220                             CREATE_NEW_PROCESS_GROUP, // creation flags
 221                             NULL,       // environment
 222                             wdir.isEmpty() ? NULL : wdir.toLocal8Bit().data(),
 223                             &startupInfo,
 224                             &m_processInfo);
 225 #endif // not UNICODE
 226
 227         m_started = (bool)ok;
 228         if (ok)
 229         {
 230                 // Close the child process' ends of the pipes to make sure
 231                 // that ReadFile and WriteFile will return when the child
 232                 // terminates and closes its pipes
 233                 killHandle(&outWrite);
 234                 killHandle(&inRead);
 235
 236                 // Start reading input from the child
 237                 m_reader = new PipeReader(m_outRead, this);
 238                 connect(m_reader, SIGNAL(finished()), this, SLOT(onFinished()));
 239                 connect(m_reader, SIGNAL(finished()), this, SIGNAL(readChannelFinished()));
 240                 connect(m_reader, SIGNAL(readyRead()), this, SIGNAL(readyRead()));
 241                 m_reader->start();
 242
 243                 // Make QIODevice aware that the device is now open
 244                 QIODevice::open(mode);
 245         }
 246         else
 247                 cleanup();
 248 }
 249
 250 void EngineProcess::start(const QString& program,
 251                           OpenMode mode)
 252 {
 253         QStringList args;
 254
 255         QRegExp rx("((?:[^\\s\"]+)|(?:\"(?:\\\\\"|[^\"])*\"))");
 256         int pos = 0;
 257         while ((pos = rx.indexIn(program, pos)) != -1)
 258         {
 259                 args << rx.cap();
 260                 pos += rx.matchedLength();
 261         }
 262         if (args.isEmpty())
 263                 return;
 264
 265         QString prog = args.first();
 266         args.removeFirst();
 267         start(prog, args, mode);
 268 }
 269
 270 void EngineProcess::kill()
 271 {
 272         if (m_started)
 273                 TerminateProcess(m_processInfo.hProcess, 0xf291);
 274 }
 275
 276 void EngineProcess::onFinished()
 277 {
 278         if (!m_started || m_finished)
 279                 return;
 280
 281         if (GetExitCodeProcess(m_processInfo.hProcess, &m_exitCode)
 282         &&  m_exitCode != STILL_ACTIVE)
 283         {
 284                 m_finished = true;
 285                 m_exitStatus = NormalExit;
 286                 if (m_exitCode != 0)
 287                         m_exitStatus = CrashExit;
 288
 289                 Q_ASSERT(m_reader == 0 || m_reader->isFinished());
 290                 cleanup();
 291                 emit finished((int)m_exitCode, m_exitStatus);
 292         }
 293 }
 294
 295 bool EngineProcess::waitForFinished(int msecs)
 296 {
 297         if (!m_started)
 298                 return true;
 299
 300         DWORD dwWait;
 301         if (msecs == -1)
 302                 dwWait = INFINITE;
 303         else
 304                 dwWait = msecs;
 305
 306         DWORD ret = WaitForSingleObject(m_processInfo.hProcess, dwWait);
 307         if (ret == WAIT_OBJECT_0)
 308         {
 309                 // The blocking ReadFile call in the pipe reader should
 310                 // return now that the pipes are closed. But if it doesn't
 311                 // happen, the pipe reader will be terminated violently
 312                 // after the timeout.
 313                 m_reader->wait(10000);
 314                 onFinished();
 315
 316                 return true;
 317         }
 318         return false;
 319 }
 320
 321 bool EngineProcess::waitForStarted(int msecs)
 322 {
 323         // Don't wait here because CreateProcess already did the waiting
 324         Q_UNUSED(msecs);
 325         return m_started;
 326 }
 327
 328 QString EngineProcess::workingDirectory() const
 329 {
 330         return m_workDir;
 331 }
 332
 333 qint64 EngineProcess::readData(char* data, qint64 maxSize)
 334 {
 335         if (!m_started)
 336                 return -1;
 337
 338         return m_reader->readData(data, maxSize);
 339 }
 340
 341 qint64 EngineProcess::writeData(const char* data, qint64 maxSize)
 342 {
 343         if (!m_started)
 344                 return -1;
 345
 346         DWORD dwWritten = 0;
 347         if (!WriteFile(m_inWrite, data, (DWORD)maxSize, &dwWritten, 0))
 348                 return -1;
 349         return (qint64)dwWritten;
 350 }