Example #1
0
void tst_QUdpSocket::outOfProcessUnconnectedClientServerTest()
{
#if defined(Q_OS_WINCE)
    QSKIP("This test depends on reading data from QProcess (not supported on Qt/WinCE.", SkipAll);
#endif
#if defined(QT_NO_PROCESS)
    QSKIP("Qt was compiled with QT_NO_PROCESS", SkipAll);
#else

    QProcess serverProcess;
    serverProcess.start(QLatin1String("clientserver/clientserver server 1 1"),
                        QIODevice::ReadWrite | QIODevice::Text);

    // Wait until the server has started and reports success.
    while (!serverProcess.canReadLine())
        QVERIFY(serverProcess.waitForReadyRead(3000));
    QByteArray serverGreeting = serverProcess.readLine();
    QVERIFY(serverGreeting != QByteArray("XXX\n"));
    int serverPort = serverGreeting.trimmed().toInt();
    QVERIFY(serverPort > 0 && serverPort < 65536);

    QProcess clientProcess;
    clientProcess.start(QString::fromLatin1("clientserver/clientserver unconnectedclient %1 %2")
                        .arg(QLatin1String("127.0.0.1")).arg(serverPort),
                        QIODevice::ReadWrite | QIODevice::Text);
    // Wait until the server has started and reports success.
    while (!clientProcess.canReadLine())
        QVERIFY(clientProcess.waitForReadyRead(3000));
    QByteArray clientGreeting = clientProcess.readLine();
    QCOMPARE(clientGreeting, QByteArray("ok\n"));

    // Let the client and server talk for 3 seconds
    QTest::qWait(3000);

    QStringList serverData = QString::fromLocal8Bit(serverProcess.readAll()).split("\n");
    QStringList clientData = QString::fromLocal8Bit(clientProcess.readAll()).split("\n");

    QVERIFY(serverData.size() > 5);
    QVERIFY(clientData.size() > 5);

    for (int i = 0; i < clientData.size() / 2; ++i) {
        QCOMPARE(clientData.at(i * 2), QString("readData()"));
        QCOMPARE(serverData.at(i * 3), QString("readData()"));

        QString cdata = clientData.at(i * 2 + 1);
        QString sdata = serverData.at(i * 3 + 1);
        QVERIFY(cdata.startsWith(QLatin1String("got ")));

        QCOMPARE(cdata.mid(4).trimmed().toInt(), sdata.mid(4).trimmed().toInt() * 2);
        QVERIFY(serverData.at(i * 3 + 2).startsWith(QLatin1String("sending ")));
        QCOMPARE(serverData.at(i * 3 + 2).trimmed().mid(8).toInt(),
                 sdata.mid(4).trimmed().toInt() * 2);
    }

    clientProcess.kill();
    QVERIFY(clientProcess.waitForFinished());
    serverProcess.kill();
    QVERIFY(serverProcess.waitForFinished());
#endif
}
Example #2
0
bool SystemUtils::setUserPassword(const QString &password, const QString &user)
{
	QStringList args;
	if(password.isEmpty()) args << "--delete";
	const QString username = user.isEmpty() ? currentUser() : user;
	args << username;
	QProcess process;
	process.start(PASSWD_PROCESS, args);
	if(!process.waitForStarted(1000)) {
		process.kill();
		return false;
	}
	
	process.write(password.toUtf8());
	process.putChar(NEWLINE_CHAR);
	
	// Confirmation
	process.write(password.toUtf8());
	process.putChar(NEWLINE_CHAR);
	
	if(!process.waitForFinished(1000)) {
		process.kill();
		return false;
	}
	
	return process.exitCode() == 0;
}
Example #3
0
QStringList RunCommand(QString const& command, QStringList const& arguments, 
   unsigned int waitTimeInMilliSeconds) 
{
   QStringList output;
   QFileInfo cmd(command);

   if (cmd.exists()) {
      qDebug() << "Executing command" << command << "with args:" << arguments;
               
      QProcess process;
      process.setWorkingDirectory(cmd.absolutePath());
      process.start(cmd.fileName(), arguments);

      if (process.waitForFinished(waitTimeInMilliSeconds)) {
         QString psOutput(process.readAllStandardOutput());
         output = psOutput.split(QRegExp("\\n"));
      }else {
         // should throw an exception
         process.kill();
      }

   }else {
      QString msg("Could not find command ");
      msg += command;
      QMessageBox::warning(0, "IQmol", msg);
   }

   return output;
}
Example #4
0
QDomDocument UpdateInfoPlugin::update()
{
    if (QThread::currentThread() == QCoreApplication::instance()->thread()) {
        qWarning() << Q_FUNC_INFO << " was not designed to run in main/ gui thread, it is using "
            "QProcess::waitForFinished()";
    }

    // start
    QProcess updater;
    updater.start(d->updaterProgram, QStringList() << d->updaterCheckOnlyArgument);
    while (updater.state() != QProcess::NotRunning) {
        if (!updater.waitForFinished(1000)
                && d->lastCheckUpdateInfoTask.isCanceled()) {
            updater.kill();
            updater.waitForFinished(-1);
            return QDomDocument();
        }
    }

    // process return value
    QDomDocument updates;
    if (updater.exitStatus() != QProcess::CrashExit) {
        d->m_timer.stop();
        updates.setContent(updater.readAllStandardOutput());
        saveSettings(); // force writing out the last update date
    } else {
        qWarning() << "Updater application crashed.";
    }

    d->m_lastDayChecked = QDate::currentDate();
    return updates;
}
QProcessEnvironment PokyRunner::Private::updateEnvironment(const QProcessEnvironment &environment)
{
    QProcessEnvironment env(environment);
    QProcess proc;
    QStringList args;
    args << QLatin1String("-c")
         << QString(QLatin1String(". \"%1\"; env")).arg(envFile);

    proc.start(QLatin1String("sh"), args);
    if (!proc.waitForFinished(5000))
    {
        qWarning() << "[PokyRunner]: Failed to retrieve poky environment from" << envFile;
        proc.kill();
    }
    QByteArray buff;
    buff.reserve(4096);
    qint64 len;

    while ((len = proc.readLine(buff.data(), 4096)) > 0)
    {
        buff.resize(len - 1);
        QString line = QString::fromLatin1(buff);
        int idx = line.indexOf(QLatin1Char('='));
        if (idx < 0)
            qWarning() << "[PokyRunner]: Corrupted output" << line;
        else
            env.insert(line.left(idx), line.mid(idx + 1));
    }
    return env;
}
bool UiCodeModelSupport::runUic(const QString &ui) const
{
    QProcess process;
    const QString uic = uicCommand();
    process.setEnvironment(environment());

    if (debug)
        qDebug() << "UiCodeModelSupport::runUic " << uic << " on " << ui.size() << " bytes";
    process.start(uic, QStringList(), QIODevice::ReadWrite);
    if (!process.waitForStarted())
        return false;
    process.write(ui.toUtf8());
    process.closeWriteChannel();
    if (process.waitForFinished() && process.exitStatus() == QProcess::NormalExit && process.exitCode() == 0) {
        m_contents = process.readAllStandardOutput();
        m_cacheTime = QDateTime::currentDateTime();
        if (debug)
            qDebug() << "ok" << m_contents.size() << "bytes.";
        return true;
    } else {
        if (debug)
            qDebug() << "failed" << process.readAllStandardError();
        process.kill();
    }
    return false;
}
void Exec::run()
{
   QStringList arguments(m_command.split(" ", QString::QString::SkipEmptyParts));

   if (arguments.isEmpty()) {
      m_errorMessage = "Cannot execute null command";
      return;
   }

   // We assume the first token is the command
   QString command(arguments.takeFirst());
   QFileInfo cmd(command);

   if (cmd.exists()) {
      qDebug() << "Executing command" << command << "with args:" << arguments;

      QProcess process;
      process.setWorkingDirectory(cmd.absolutePath());
      process.start(cmd.fileName(), arguments);

      if (process.waitForFinished(m_timeout)) {
         m_outputMessage = process.readAllStandardOutput();
      }else {
         process.kill();
         m_errorMessage = "Process timed out " + m_command;
      }

   }else {
      m_errorMessage = "Command not found " + command;
   }
}
Example #8
0
bool teamStats::fetch(QString tn)
{
	QProcess *proc = new QProcess(this);

	QString wget;
	
	wget = "wget ""http://fah-web.stanford.edu/cgi-bin/main.py?qtype=teampage&teamnum="""+tn+" -O ";
	wget = wget + FW_TEAMSTATS;

	proc->start(wget);
	
	proc->waitForFinished();
	
	if ((!UpdateInProgress())&&(!brokenConnection()))
	{
		MSG(FW_NAME,
        	tr("Your Team Stats have been successfully downloaded!\n\n"
        	   "You may now open the 'Team Stats' window to view the results."));
        	return true;
    	} 
    	else if (UpdateInProgress())
    	{
    		WARN(FW_NAME,
           		tr("Team Stats could not be fetched! Server update is in progress..."));
        	return false;
    	}
    	else if (brokenConnection())
    	{
    		WARN(FW_NAME,
           		tr("Team Stats could not be fetched! This computer doesn't seem to have a working internet connection!"));
        	return false;
   		}
    	proc->kill();
    	return true;
}
Example #9
0
TTSStatus TTSFestival::voice(QString text, QString wavfile, QString* errStr)
{
    qDebug() << "[Festival] Voicing " << text << "->" << wavfile;

    QString path = RbSettings::subValue("festival-client",
            RbSettings::TtsPath).toString();
    QString cmd = QString("%1 --server localhost --otype riff --ttw --withlisp"
            " --output \"%2\" --prolog \"%3\" - ").arg(path).arg(wavfile).arg(prologPath);
    qDebug() << "[Festival] Client cmd: " << cmd;

    QProcess clientProcess;
    clientProcess.start(cmd);
    clientProcess.write(QString("%1.\n").arg(text).toAscii());
    clientProcess.waitForBytesWritten();
    clientProcess.closeWriteChannel();
    clientProcess.waitForReadyRead();
    QString response = clientProcess.readAll();
    response = response.trimmed();
    if(!response.contains("Utterance"))
    {
        qDebug() << "[Festival] Could not voice string: " << response;
        *errStr = tr("engine could not voice string");
        return Warning;
        /* do not stop the voicing process because of a single string
        TODO: needs proper settings */
    }
    clientProcess.closeReadChannel(QProcess::StandardError);
    clientProcess.closeReadChannel(QProcess::StandardOutput);
    clientProcess.terminate();
    clientProcess.kill();

    return NoError;
}
// test connection
void SettingsDialog::on_testBtn_clicked()
{
    QString command = tr("ssh %1@%2 exit").arg(ui->serverUsernameLn->text(),
                                               ui->serverIpLn->text());

    QProcess *process = new QProcess(this);

    process->setProcessEnvironment(MainUtils::mainEnvironment());
    process->start(tr("/bin/bash -c \"%1\"").arg(command));

    if(!process->waitForFinished(3000)){
        ui->testLb->setText("Connection failed");
        qDebug() << "Forcefully killing process";
        process->kill();
        return;
    }

    if(process->exitCode() != 0){
        ui->testLb->setText("Connection failed");
        qDebug() << "Exit code: " << QString::number(process->exitCode());
        return;
    }

    ui->testLb->setText("Connection successful");
}
Example #11
0
bool MountPointInfo::unmount(bool force)
{
    #ifdef Q_OS_UNIX
    if(!this->is_mounted && !force)
    {
        WARN() << "Share" << this->s_host << "is not mounted to" << this->m_mount_point;
        return false;
    }

    QProcess cmd;
    QStringList params;
    params << "umount";
    params << this->m_mount_point;

    cmd.start("sudo", params);

    is_mounted = false;
    if (!cmd.waitForStarted())
    {
        ERROR() << "Cannot unmount point" << s_host << "from" << m_mount_point;
        is_mounted = true;
    }

    cmd.waitForFinished();

    DEBUG() << "unmount result" << cmd.readAllStandardError() << cmd.readAllStandardOutput();

    cmd.close();
    cmd.kill();
    #else
    ONLY_SUPPORTED_ON_UNIX;
    #endif //Q_OS_UNIX

    return true;
}
Example #12
0
void DlvDebugger::stepOut()
{
    QString cmd = LiteApi::getGotools(m_liteApp);
    QProcess process;
    process.setEnvironment(LiteApi::getCurrentEnvironment(m_liteApp).toStringList());
    QFileInfo info(m_lastFileName);
    process.setWorkingDirectory(info.path());
    QStringList args;
    args << "finddecl" << "-file" << info.fileName() << "-line" << QString("%1").arg(m_lastFileLine+1);
    process.start(cmd,args);
    if (!process.waitForFinished(3000)) {
        emit debugLog(LiteApi::DebugErrorLog,"error wait find decl process");
        process.kill();
        return;
    }
    if (process.exitCode() != 0) {
        emit debugLog(LiteApi::DebugErrorLog,"error get find decl result");
        return;
    }
    QByteArray data = process.readAll().trimmed();
    QStringList ar = QString::fromUtf8(data).split(" ");
    if (ar.size() != 4 || ar[0] != "func") {
        emit debugLog(LiteApi::DebugErrorLog,"error find func decl in line");
        return;
    }
    m_funcDecl.fileName = m_lastFileName;
    m_funcDecl.funcName = ar[1];
    m_funcDecl.start = ar[2].toInt()-1;
    m_funcDecl.end = ar[3].toInt()-1;
    m_checkFuncDecl = true;
    command("next");
}
Example #13
0
QString MainWindow::runCmd(QString cmd, QStringList argv, int start, int length){
    QProcess proc;
    proc.start(cmd,argv);

    QString res = "";
    proc.waitForFinished();

    int i=0;
    while(proc.canReadLine()){
        if(i>=start){
            res = res + proc.readLine() + "\n";
        }else{
            proc.readLine();
        }
        if(i>=start+length){
            break;
        }

        i+=1;
    }

    proc.kill();
    res = res.trimmed();
    return res;
}
Example #14
0
int System(const QString exename, const QStringList & args, const QString fileStdErr, const QString fileStdOut, bool* cancel)
{
    QProcess proc;
    if (!fileStdOut.isEmpty())
        proc.setStandardOutputFile(fileStdOut);
    if (!fileStdErr.isEmpty())
        proc.setStandardErrorFile(fileStdErr);
    proc.start(exename, args);
    if (proc.waitForStarted(5000))
    {
        while (!proc.waitForFinished(5000))
        {
            qApp->processEvents();
            if (cancel && (*cancel == true))
            {
                proc.kill();
                break;
            }
        }
    }
    if (cancel && (*cancel == true))
        return -1;
    int ex = proc.exitCode();
    return ex;
}
Example #15
0
bool CameraOutV4L2::sudo(const QString &command,
                         const QStringList &argumments,
                         const QString &password) const
{
    if (password.isEmpty())
        return false;

    QProcess echo;
    QProcess su;

    echo.setStandardOutputProcess(&su);

    switch (this->m_rootMethod) {
        case RootMethodSu: {
            QStringList args;

            for (QString arg: argumments)
                args << arg.replace(" ", "\\ ");

            echo.start("echo", {password});
            su.start("su", {"-c", command + " " + args.join(" ")});

            break;
        }
        case RootMethodSudo: {
            echo.start("echo", {password});
            su.start("sudo", QStringList{"-S", command} << argumments);

            break;
        }
    }

    su.setProcessChannelMode(QProcess::ForwardedChannels);
    echo.waitForStarted();

    if (!su.waitForFinished(this->m_passwordTimeout)) {
        su.kill();
        echo.waitForFinished();

        return false;
    }

    echo.waitForFinished();

    if (su.exitCode()) {
        QByteArray outMsg = su.readAllStandardOutput();

        if (!outMsg.isEmpty())
            qDebug() << outMsg.toStdString().c_str();

        QByteArray errorMsg = su.readAllStandardError();

        if (!errorMsg.isEmpty())
            qDebug() << errorMsg.toStdString().c_str();

        return false;
    }

    return true;
}
void ServerManager::errorDetect(QProcess::ProcessError error)
{
    QProcess *server = qobject_cast<QProcess *>(sender());
    if (server) {
        tSystemError("tfserver error detected(%d). [%s]", error, TFSERVER_CMD);
        //server->close();  // long blocking..
        server->kill();
    }
}
/**
 * This is a test if wget is in PATH environment or not.
 * If the test succeeds true is returned, false otherwise.
 */
bool NetworkRetriever::testWget()
{
    QProcess proc;
    proc.start(QString::fromAscii("wget"));
    bool ok = proc.state() == QProcess::Running;
    proc.kill();
    proc.waitForFinished();
    return ok;
}
Example #18
0
    void run()
    {
        QProcess process;
        QString dir = QCoreApplication::applicationDirPath() + "/plugins/hilec";
        process.setWorkingDirectory(dir);
        process.start(dir + "/compile.bat", QStringList(QFileInfo(mFile).canonicalFilePath()) << mBase);
        if(!process.waitForFinished(5000))
        {
            QByteArray standardOutput = process.readAllStandardOutput();
            if(!standardOutput.isEmpty()){
                qDebug() << standardOutput;
            }
            QByteArray standardError = process.readAllStandardError();
            if(!standardError.isEmpty()){
                qDebug() << standardError;
            }
            process.kill();
            return;
        }

        QString str = process.readAllStandardOutput();
        QStringList errors = str.split("\n", QString::SkipEmptyParts);
        ScriptCompileInfo info;
        info.file = mFile;
        QDir baseDir(mBase);
        foreach(QString line, errors)
        {
            ScriptCompileProblem problem;
            QStringList parts = line.split(":");
            if(parts.size() < 3)
                continue;
            QString file = parts.takeFirst();
            if(file.size() == 1) // this is a windows disc
                file += ":" + parts.takeFirst();
            if(QFileInfo(baseDir.absoluteFilePath(file)) != QFileInfo(mFile))
                continue;
            if(parts.size() < 2)
                continue;
            problem.line = parts.takeFirst().toInt();
            QString msg = parts.join(":").trimmed().mid(1);
            int pos = msg.indexOf("]");
            if(pos < 1)
                continue;
            QChar mode = msg[0];
            if(mode == 'E' || mode == 'F')
                problem.mode = ScriptCompileProblem::Error;
            else if(mode == 'W')
                problem.mode = ScriptCompileProblem::Warning;
            else if(mode == 'C')
                problem.mode = ScriptCompileProblem::Info;
            else
                continue;
            problem.msg = msg.mid(pos + 1).trimmed();
            info.problems << problem;
            //qDebug() << mode << msg;
        }
Example #19
0
QString OSInfo::getOSVersion() {
#if defined(Q_WS_WIN)
	OSVERSIONINFOEXW ovi;
	memset(&ovi, 0, sizeof(ovi));

	ovi.dwOSVersionInfoSize=sizeof(ovi);
	GetVersionEx(reinterpret_cast<OSVERSIONINFOW *>(&ovi));

	QString os;
	os.sprintf("%d.%d.%d.%d", ovi.dwMajorVersion, ovi.dwMinorVersion, ovi.dwBuildNumber, (ovi.wProductType == VER_NT_WORKSTATION) ? 1 : 0);
	return os;
#elif defined(Q_OS_MAC)
	SInt32 major, minor, bugfix;
	OSErr err = Gestalt(gestaltSystemVersionMajor, &major);
	if (err == noErr)
		err = Gestalt(gestaltSystemVersionMinor, &minor);
	if (err == noErr)
		err = Gestalt(gestaltSystemVersionBugFix, &bugfix);
	if (err != noErr)
		return QString::number(QSysInfo::MacintoshVersion, 16);

	const NXArchInfo *local = NXGetLocalArchInfo();
	const NXArchInfo *ai = local ? NXGetArchInfoFromCpuType(local->cputype, CPU_SUBTYPE_MULTIPLE) : NULL;
	const char *arch = ai ? ai->name : "unknown";

	QString os;
	os.sprintf("%i.%i.%i (%s)", major, minor, bugfix, arch);
	return os;
#else
#ifdef Q_OS_LINUX
	QProcess qp;
	QStringList args;
	args << QLatin1String("-s");
	args << QLatin1String("-d");
	qp.start(QLatin1String("lsb_release"), args);
	if (qp.waitForFinished(5000)) {
		QString os = QString::fromUtf8(qp.readAll()).simplified();
		if (os.startsWith(QLatin1Char('"')) && os.endsWith(QLatin1Char('"')))
			os = os.mid(1, os.length() - 2).trimmed();
		if (! os.isEmpty())
			return os;
	}
	qWarning("OSInfo: Failed to execute lsb_release");
	qp.terminate();
	if (! qp.waitForFinished(1000))
		qp.kill();
#endif
	struct utsname un;
	if (uname(&un) == 0) {
		QString os;
		os.sprintf("%s %s", un.sysname, un.release);
		return os;
	}
	return QString();
#endif
}
Example #20
0
bool PluginProcessProxy::scanPlugin(const String& pluginPath, RawPluginMetaData& result)
{
    QFileInfo pluginFileInfo(pluginPath);
    if (!pluginFileInfo.exists())
        return false;

    MetaDataResult::Tag metaDataResult = tryReadPluginMetaDataFromCacheFile(pluginFileInfo.canonicalFilePath(), result);
    if (metaDataResult == MetaDataResult::Available)
        return true;
    if (metaDataResult == MetaDataResult::Unloadable)
        return false;

    // Scan the plugin via the plugin process.
    QString commandLine = QString(executablePathOfPluginProcess()) % QLatin1Char(' ')
                          % QStringLiteral("-scanPlugin") % QLatin1Char(' ') % pluginFileInfo.canonicalFilePath();
    QProcess process;
    process.setReadChannel(QProcess::StandardOutput);
    process.start(commandLine);

    bool ranSuccessfully = process.waitForFinished()
                           && process.exitStatus() == QProcess::NormalExit
                           && process.exitCode() == EXIT_SUCCESS;
    if (ranSuccessfully) {
        QByteArray outputBytes = process.readAll();
        ASSERT(!(outputBytes.size() % sizeof(UChar)));

        String output(reinterpret_cast<const UChar*>(outputBytes.constData()), outputBytes.size() / sizeof(UChar));
        Vector<String> lines;
        output.split(UChar('\n'), true, lines);
        ASSERT(lines.size() == 3);

        result.name.swap(lines[0]);
        result.description.swap(lines[1]);
        result.mimeDescription.swap(lines[2]);
    } else
        process.kill();

    QVariantMap map;
    map[QStringLiteral("path")] = QString(pluginFileInfo.canonicalFilePath());
    map[QStringLiteral("timestamp")] = QDateTime::currentDateTime().toString();

    if (!ranSuccessfully || result.mimeDescription.isEmpty()) {
        // We failed getting the meta data in some way. Cache this information, so we don't
        // need to rescan such plugins every time. We will retry it once the plugin is updated.

        map[QStringLiteral("unloadable")] = QStringLiteral("true");
        appendToCacheFile(QJsonObject::fromVariantMap(map));
        return false;
    }

    map[QStringLiteral("name")] = QString(result.name);
    map[QStringLiteral("description")] = QString(result.description);
    map[QStringLiteral("mimeDescription")] = QString(result.mimeDescription);
    appendToCacheFile(QJsonObject::fromVariantMap(map));
    return true;
}
Example #21
0
QString MainWindow::runCmd(QString cmd, QStringList argv){
    QProcess proc;
    proc.start(cmd,argv);
    proc.waitForFinished();
    QString res;
    res.prepend(proc.readAllStandardOutput());
    proc.kill();
    res = res.trimmed();
    return res;
}
bool SynchronousProcess::stopProcess(QProcess &p)
{
    if (p.state() != QProcess::Running)
        return true;
    p.terminate();
    if (p.waitForFinished(300))
        return true;
    p.kill();
    return p.waitForFinished(300);
}
void AndroidDeployStep::stripFiles(const QList<DeployItem> &deployList, Abi::Architecture architecture, const QString &ndkToolchainVersion)
{
    QProcess stripProcess;
    foreach (const DeployItem &item, deployList) {
        stripProcess.start(AndroidConfigurations::instance().stripPath(architecture, ndkToolchainVersion).toString(),
                           QStringList()<<QLatin1String("--strip-unneeded") << item.localFileName);
        stripProcess.waitForStarted();
        if (!stripProcess.waitForFinished())
            stripProcess.kill();
    }
Example #24
0
QString SystemUtils::currentUser()
{
	QProcess process;
	process.start(WHOAMI_PROCESS);
	if(!process.waitForFinished(1000)) {
		process.kill();
		return QString();
	}
	return QString(process.readAllStandardOutput()).trimmed();
}
Example #25
0
// Load image data
QImage ExternalImageLoader::loadImage()
{
	QImage result;

	// Configuration file loading
	QSettings settings("../res/externalimageloader.ini", QSettings::IniFormat);

	// Get external program, redirection and result file names
	QString program = settings.value("program").toString();
	QString redirection = settings.value("redirection").toString();
	QString filename = settings.value("filename").toString();

	if (program.isEmpty() || filename.isEmpty())
		return result;

	// Ensure program has started
	QProcess process;
	if (!redirection.isEmpty())
		process.setStandardOutputFile(redirection);
	process.start(program);
	if (!process.waitForStarted())
		return result;

	// Get timeout value
	int timeout = settings.value("timeout").toInt();
	QTime timer;
	timer.start();

	// Check for program exit or timeout event
	while (process.state() != QProcess::NotRunning)
	{
		if (timeout > 0 && timer.elapsed() > timeout)
		{
			// Stop process
			process.kill();
			// Try to delete file
			QDir dir;
			dir.remove(filename);
			// Return null image
			return result;
		}

		qApp->processEvents();
	}

	// Ensure program has finished correctly
	if (process.exitStatus() != QProcess::NormalExit)
		return result;

	// Try to read and remove the output file
	result = QImage(filename);
	QDir dir;
	dir.remove(filename);
	return result;
}
Example #26
0
/*
 * Initialize and launch process object
 */
bool AbstractTool::startProcess(QProcess &process, const QString &program, const QStringList &args)
{
    static AssignProcessToJobObjectFun AssignProcessToJobObjectPtr = NULL;

    QMutexLocker lock(m_mutex_startProcess);
    emit messageLogged(commandline2string(program, args) + "\n");

    QProcessEnvironment env = process.processEnvironment();
    if(env.isEmpty()) env = QProcessEnvironment::systemEnvironment();
    env.insert("TEMP", QDir::toNativeSeparators(lamexp_temp_folder2()));
    env.insert("TMP", QDir::toNativeSeparators(lamexp_temp_folder2()));
    process.setProcessEnvironment(env);

    if(!AssignProcessToJobObjectPtr)
    {
        QLibrary Kernel32Lib("kernel32.dll");
        AssignProcessToJobObjectPtr = (AssignProcessToJobObjectFun) Kernel32Lib.resolve("AssignProcessToJobObject");
    }

    process.setProcessChannelMode(QProcess::MergedChannels);
    process.setReadChannel(QProcess::StandardOutput);
    process.start(program, args);

    if(process.waitForStarted())
    {

        if(AssignProcessToJobObjectPtr)
        {
            AssignProcessToJobObjectPtr(m_handle_jobObject, process.pid()->hProcess);
        }
        if(!SetPriorityClass(process.pid()->hProcess, BELOW_NORMAL_PRIORITY_CLASS))
        {
            SetPriorityClass(process.pid()->hProcess, IDLE_PRIORITY_CLASS);
        }

        lock.unlock();

        if(m_firstLaunch)
        {
            emit statusUpdated(0);
            m_firstLaunch = false;
        }

        return true;
    }

    emit messageLogged("Process creation has failed :-(");
    QString errorMsg= process.errorString().trimmed();
    if(!errorMsg.isEmpty()) emit messageLogged(errorMsg);

    process.kill();
    process.waitForFinished(-1);
    return false;
}
Example #27
0
/*
 * Initialize and launch process object
 */
bool AbstractTool::startProcess(QProcess &process, const QString &program, const QStringList &args, const QString &workingDir)
{
	QMutexLocker lock(&s_startProcessMutex);
	
	if((!s_startProcessTimer.isNull()) && s_startProcessTimer->isValid())
	{
		qint64 elapsed = s_startProcessTimer->elapsed();
		while(elapsed < START_DELAY)
		{
			lock.unlock();
			MUtils::OS::sleep_ms((size_t)(START_DELAY - elapsed));
			lock.relock();
			elapsed = s_startProcessTimer->elapsed();
		}
	}

	emit messageLogged(commandline2string(program, args) + "\n");
	MUtils::init_process(process, workingDir.isEmpty() ? QFileInfo(program).absolutePath() : workingDir);

	process.start(program, args);
	
	if(process.waitForStarted())
	{
		if(!s_jobObjectInstance.isNull())
		{
			if(!s_jobObjectInstance->addProcessToJob(&process))
			{
				qWarning("Failed to assign process to job object!");
			}
		}

		MUtils::OS::change_process_priority(&process, -1);
		
		if(m_firstLaunch)
		{
			emit statusUpdated(0);
			m_firstLaunch = false;
		}
		
		s_startProcessTimer->start();
		return true;
	}

	emit messageLogged("Process creation has failed :-(");
	QString errorMsg= process.errorString().trimmed();
	if(!errorMsg.isEmpty()) emit messageLogged(errorMsg);

	process.kill();
	process.waitForFinished(-1);

	s_startProcessTimer->start();
	return false;
}
void ProcessSocket::close()
{
    QProcess *proc = qobject_cast<QProcess *>(d);
    Q_ASSERT(proc);
    // Be nice to it, let it die peacefully before using an axe
    // QTBUG-5990, don't call waitForFinished() on a process which hadn't started
    if (proc->state() == QProcess::Running) {
        proc->terminate();
        proc->waitForFinished(200);
        proc->kill();
    }
}
Example #29
0
void makeShader() {
       QStringList files;
       files << "i420_to_rgb_simple.cpp" << "i420_to_rgb_filter.cpp" << "i420_to_rgb_kernel.cpp";
       for (int i=0; i<files.size(); ++i) {
	       qDebug() << "Interpret" << files[i];
	       QProcess proc;
	       proc.setReadChannel(QProcess::StandardOutput);
	       QStringList args;
	       args << "-E" << files[i];
	       proc.start("g++", args, QProcess::ReadOnly);
	       const bool ready = proc.waitForReadyRead();
	       Q_ASSERT(ready);
	       QList<QByteArray> lines = proc.readAllStandardOutput().split('\n');
	       QByteArray output;
	       for (int j=0; j<lines.size(); ++j) {
		       if (!lines[j].startsWith('#')) {
			       output += lines[j];
			       output += '\n';
		       }
	       }

	       if (!proc.waitForFinished())
		       proc.kill();
	       Interpreter interpreter;
	       if (!interpreter.interpret(output))
		       qFatal("Interpreter Error: %s", qPrintable(interpreter.errorMessage()));
	       const QFileInfo info(files[i]);
	       const QString base = info.completeBaseName();
	       QFile fp(base + ".fp");
	       fp.open(QFile::WriteOnly | QFile::Truncate);
	       Q_ASSERT(fp.isOpen());
	       fp.write(interpreter.code());
	       fp.close();
	       args.clear();
	       args << "-i" << (base + ".fp") << ("../" + base + ".hpp");
	       proc.start("xxd", args, QProcess::ReadOnly);
	       if (!proc.waitForFinished())
		       proc.kill();
       }
}
Example #30
0
void MainWindow::on_Send_Eq_clicked()
{
    QString program = Current_Path+"/send_eq";
    QStringList arguments;
    QProcess *myProcess;
    myProcess = new QProcess(this);
    myProcess->start(program,arguments);
    myProcess->waitForStarted();
    myProcess->waitForFinished();
    myProcess->kill();
    myProcess->close();
    ui->textBrowser->setText("!#SUCCESS=Send Equalize!#");
}