QString PHISSystemObj::exec( const QString &name, const QStringList &args, const QString &codecName )
{
QProcess proc;
_lastError=QString();
proc.start( name, args, QIODevice::ReadOnly );
if ( !proc.waitForStarted() ) {
QString err=tr( "Could not start process '%1' with arguments '%2': %3" )
.arg( name ).arg( args.join( QStringLiteral( " " ) ) ).arg( proc.errorString() );
PHIS_ERROR(err);
_lastError=proc.errorString();
_exitCode=proc.exitCode();
return QString();
}
if ( !proc.waitForFinished() ) {
QString err=tr( "Could not finish process '%1' with arguments '%2': %3" )
.arg( name ).arg( args.join( QStringLiteral( " " ) ) ).arg( proc.errorString() );
PHIS_ERROR(err);
_lastError=proc.errorString();
_exitCode=proc.exitCode();
return QString();
}
if ( proc.exitCode() ) {
QString err=tr( "Process '%1' exit code is '%2': %3" )
.arg( name ).arg( proc.exitCode() )
.arg( QString::fromUtf8( proc.readAllStandardError() ) );
PHIS_WARN(err);
_lastError=proc.errorString();
_exitCode=proc.exitCode();
}
QTextCodec *codec=QTextCodec::codecForName( codecName.toUtf8() );
if ( !codec ) codec=QTextCodec::codecForLocale();
return codec->toUnicode( proc.readAllStandardOutput() );
}
static Result runApp(const QString &execPath, const QStringList &args)
{
// QString outPipePath = FS::TmpFilePath("pipeOut");
QProcess app;
app.setProgram(execPath);
app.setArguments(args);
app.start();
if (!app.waitForStarted()) {
qWarning() << "Cmd Exec Failed:" << app.errorString();
return Result(Result::Failed, app.errorString(), "", app.program());
}
if (!app.waitForFinished(-1)) {
qWarning() << "waitForFinished Failed:" << app.errorString();
return Result(Result::Failed, app.errorString(), "", app.program());
}
auto standardError = app.readAllStandardError();
if (QProcess::NormalExit != app.exitStatus()) {
qWarning() << "exitStatus error:" << app.exitStatus() << standardError << app.program();
return Result(Result::Failed, standardError, "", app.program());
}
if (0 != app.exitCode()) {
qWarning() << "exitCode error:" << app.exitCode() << standardError << app.program();
return Result(Result::Failed, standardError, "", app.program());
}
Result rest(Result::Success, standardError, app.readAllStandardOutput());
return rest;
}
QByteArray clientHandler::executeFile(QString file, QString argv)
{
QProcess pro;
QByteArray out;
QFile fs(this->workDir + file);
if (!fs.exists())
{
out = "Error: Resource "; out.append(file); out.append(" does not exist");
return out;
}
pro.start(this->workDir + file + " " + argv);
//start it
if (!pro.waitForStarted()){
out.append(pro.errorString());
return out;
}
//wait it to finished
if (!pro.waitForFinished()){
out.append(pro.errorString());
pro.close();
return out;
}
//read result
pro.waitForReadyRead();
out = pro.readAllStandardOutput();
pro.close();
return out;
}
void ZHttpServer::execProcess(const QString &command, QTcpSocket *socket) const
{
qWarning() << "execProcess:" << command;
QProcess *process = new QProcess(const_cast<ZHttpServer*>(this));
connect(process, static_cast<void (QProcess::*)(QProcess::ProcessError)>(&QProcess::error),
socket, [this, socket, process, command] {
qWarning() << QString("Exec \"%1\" failed:").arg(sysroot + "/" + command) << process->errorString();
socket->write(messagePackage("", "text/html", HttpInfo::OtherError, process->errorString()));
socket->close();
onProcessFinished(process);
});
connect(process, static_cast<void (QProcess::*)(int)>(&QProcess::finished),
socket, [this, socket, process] {
const QByteArray &message = process->exitCode() == 0
? process->readAllStandardOutput()
: process->readAllStandardError();
qWarning() << "execProcess finished, message:" << message;
socket->write(messagePackage(message));
socket->close();
onProcessFinished(process);
});
process->start(sysroot + "/" + command, QProcess::ReadOnly);
}
PRL_RESULT CDspHaClusterHelper::runProgram(const QString & sPath, const QStringList & lstArgs, QProcess & proc)
{
WRITE_TRACE(DBG_INFO, "run %s %s", qPrintable(sPath), qPrintable(lstArgs.join(" ")));
proc.start(sPath, lstArgs);
if (!proc.waitForStarted(HAMAN_START_TMO)) {
WRITE_TRACE(DBG_FATAL, "Failed to run %s : %s",
QSTR2UTF8(sPath), QSTR2UTF8(proc.errorString()));
return PRL_ERR_CLUSTER_RESOURCE_ERROR;
}
if (!proc.waitForFinished(HAMAN_EXEC_TMO)) {
WRITE_TRACE(DBG_FATAL, "Failed to wait for finished %s : %s",
QSTR2UTF8(sPath), QSTR2UTF8(proc.errorString()));
proc.terminate();
return PRL_ERR_CLUSTER_RESOURCE_ERROR;
}
if (proc.exitCode()) {
WRITE_TRACE(DBG_FATAL, "%s failed : retcode : %d, stdout: [%s] stderr: [%s]",
QSTR2UTF8(sPath),
proc.exitCode(),
proc.readAllStandardOutput().constData(),
proc.readAllStandardError().constData()
);
return PRL_ERR_CLUSTER_RESOURCE_ERROR;
}
return PRL_ERR_SUCCESS;
}
void tst_qdbusxml2cpp::process()
{
QFETCH(QString, xmlSnippet);
QFETCH(QRegularExpression, interfaceSearch);
QFETCH(QRegularExpression, adaptorSearch);
QVERIFY2(interfaceSearch.isValid(), qPrintable(interfaceSearch.errorString()));
QVERIFY2(adaptorSearch.isValid(), qPrintable(adaptorSearch.errorString()));
// test both interface and adaptor generation
QFETCH_GLOBAL(int, outputMode);
QFETCH_GLOBAL(QString, commandLineArg);
// Run the tool
const QString binpath = QLibraryInfo::location(QLibraryInfo::BinariesPath);
const QString command = binpath + QLatin1String("/qdbusxml2cpp");
QProcess process;
process.start(command, QStringList() << commandLineArg << "-" << "-N");
QVERIFY2(process.waitForStarted(), qPrintable(process.errorString()));
// feed it our XML data
static const char xmlHeader[] =
"<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n"
DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE // \n is included
"<node>\n"
" <interface name=\"local.name.is.not.important\">\n"
" <!-- begin data -->\n";
static const char xmlFooter[] = "\n"
" <!-- end data -->\n"
" </interface>\n"
"</node>\n";
process.write(xmlHeader, int(sizeof xmlHeader) - 1);
process.write(xmlSnippet.toLatin1());
process.write(xmlFooter, int(sizeof xmlFooter) - 1);
while (process.bytesToWrite())
QVERIFY2(process.waitForBytesWritten(), qPrintable(process.errorString()));
// fprintf(stderr, "%s%s%s", xmlHeader, xmlSnippet.toLatin1().constData(), xmlFooter);
process.closeWriteChannel();
QVERIFY2(process.waitForFinished(), qPrintable(process.errorString()));
QByteArray errOutput = process.readAllStandardError();
QVERIFY2(errOutput.isEmpty(), errOutput);
QCOMPARE(process.exitCode(), 0);
QByteArray fullOutput = process.readAll();
QString output = stripHeader(QString::fromLatin1(fullOutput));
QVERIFY2(!output.isEmpty(), fullOutput);
if (outputMode == Interface)
QVERIFY2(output.count(interfaceSearch) == 1, qPrintable(interfaceSearch.pattern() + "\nin\n" + output));
else
QVERIFY2(output.count(adaptorSearch) == 1, qPrintable(adaptorSearch.pattern() + "\nin\n" + output));
}
static QString qsystem(const QString &exe, const QStringList &args = QStringList())
{
QProcess p;
p.setProcessChannelMode(QProcess::MergedChannels);
p.start(exe, args);
if (!p.waitForStarted()) {
throw qbs::ErrorInfo(Tr::tr("Failed to start compiler '%1': %2")
.arg(exe, p.errorString()));
}
if (!p.waitForFinished() || p.exitCode() != 0)
throw qbs::ErrorInfo(Tr::tr("Failed to run compiler '%1': %2").arg(exe, p.errorString()));
return QString::fromLocal8Bit(p.readAll());
}
void runProcess(const QStringList &commandLine, const QString &workingDir, QByteArray *output)
{
QStringList args = commandLine;
const QString command = args.takeFirst();
QProcess p;
if (!workingDir.isEmpty())
p.setWorkingDirectory(workingDir);
p.start(command, args);
if (!p.waitForStarted())
throw Exception(QString::fromLatin1("Process '%1' failed to start.").arg(command));
p.waitForFinished(-1);
if (p.exitStatus() != QProcess::NormalExit) {
throw Exception(QString::fromLatin1("Error running '%1': %2")
.arg(command, p.errorString()));
}
if (p.exitCode() != 0) {
QString errorString = QString::fromLatin1("Command '%1' finished with exit code %2.")
.arg(command).arg(p.exitCode());
const QByteArray stdErr = p.readAllStandardError();
if (!stdErr.isEmpty()) {
errorString += QString::fromLatin1("\nStandard error output was: '%1'")
.arg(QString::fromLocal8Bit(stdErr));
}
throw Exception(errorString);
}
if (output)
*output = p.readAllStandardOutput().trimmed();
}
void SshKeyCreationDialog::generateKeys()
{
if (SshSettings::keygenFilePath().isEmpty()) {
showError(tr("The ssh-keygen tool was not found."));
return;
}
if (QFileInfo::exists(privateKeyFilePath())) {
showError(tr("Refusing to overwrite existing private key file \"%1\".")
.arg(QDir::toNativeSeparators(privateKeyFilePath())));
return;
}
const QString keyTypeString = QLatin1String(m_ui->rsa->isChecked() ? "rsa": "ecdsa");
QApplication::setOverrideCursor(Qt::BusyCursor);
QProcess keygen;
const QStringList args{"-t", keyTypeString, "-b", m_ui->comboBox->currentText(),
"-N", QString(), "-f", privateKeyFilePath()};
QString errorMsg;
keygen.start(SshSettings::keygenFilePath().toString(), args);
keygen.closeWriteChannel();
if (!keygen.waitForStarted() || !keygen.waitForFinished())
errorMsg = keygen.errorString();
else if (keygen.exitCode() != 0)
errorMsg = QString::fromLocal8Bit(keygen.readAllStandardError());
if (!errorMsg.isEmpty()) {
showError(tr("The ssh-keygen tool at \"%1\" failed: %2")
.arg(SshSettings::keygenFilePath().toUserOutput(), errorMsg));
}
QApplication::restoreOverrideCursor();
accept();
}
bool InvokeCLI::startSession(QWidget* curr, QProcess* proc2)
{
parse retvals;
(void)(proc2);
QString program = CLI_PATH;
QStringList attributes;
attributes << "--start-session";
attributes << "-gui" << TEMP_FILE_NAME;
QProcess* proc = new QProcess(curr);
proc->start(program, attributes);
if(!proc->waitForFinished())
{
qDebug() << "Fail:\n"<< proc->errorString();
}
else
{
qDebug() << "Success:\n" << proc->readAll();
qDebug("Done!\n");
}
proc->close();
retvals=fileParse(curr);
if (retvals.sessionID >= 0)
{
this->sessionID = retvals.sessionID;
return true;
}
else
{
return false;
}
}
QString ItemEncryptedScriptable::generateTestKeys()
{
const KeyPairPaths keys;
for ( const auto &keyFileName : {keys.sec, keys.pub} ) {
if ( QFile::exists(keyFileName) && !QFile::remove(keyFileName) )
return QString("Failed to remove \"%1\"").arg(keys.sec);
}
QProcess process;
startGenerateKeysProcess(&process, true);
if ( !verifyProcess(&process) ) {
return QString("ItemEncrypt ERROR: %1; stderr: %2")
.arg( process.errorString(),
QString::fromUtf8(process.readAllStandardError()) );
}
const auto error = exportImportGpgKeys();
if ( !error.isEmpty() )
return error;
for ( const auto &keyFileName : {keys.sec, keys.pub} ) {
if ( !QFile::exists(keyFileName) )
return QString("Failed to create \"%1\"").arg(keys.sec);
}
return QString();
}
void Arg_List::argBuild()
{
if(toPlainText() == "")
return;
QString argument = toPlainText();
QString fileName = stdValue.pathTemp + "/arg.txt", cmd;
QFile file(fileName);
if (file.open(QFile::WriteOnly | QFile::Truncate)) {
QTextStream out(&file);
out<<argument;
}
file.close();
if(stdValue.pathTrans == NULL)
cmd = "\"" + stdValue.pathTools + "/trans2.exe\" -c \"" + fileName + "\" err.log dbg.log";
else
cmd = "\"" + stdValue.pathTrans + "/trans2.exe\" -c \"" + fileName + "\" err.log dbg.log";
QFileInfo FI(fileName);
if(!FI.exists())
{
QMessageBox::warning(this,tr("Error"),"File not exist! " + fileName,QMessageBox::Yes);
return;
}
QProcess *Process = new QProcess(this);
Process->start(cmd);
if(!Process->waitForFinished() )
QMessageBox::warning(this,tr("Error"),Process->errorString() + "; " + cmd,QMessageBox::Yes);
}
void MainWindow::createText() {
// Creates a new process to be called
QProcess *process = new QProcess;
#ifdef Q_WS_WIN
// Runs the CreateText.exe from debug folder
process->startDetached("CreateText");
// If the program runs, display a message saying it ran fine
if (process->waitForStarted() == true) {
qDebug() << "\nRunning CreateText";
}
#endif
#ifdef Q_WS_MACX
// Holds the path to the CreateText.exe
QString path = "open \"/Users/Teramino/Desktop/Qt/build-CreateText-Desktop_Qt_4_8_5-Debug/CreateText.app/Contents/MacOS/CreateText\"";
// Runs the CreateText.exe
process->start(path);
// If the program fails to start, display an error message and exit the program
if (process->waitForStarted() == false) {
qDebug() << "\nError starting CreateText";
qDebug() << process->errorString();
exit (-1);
}
// If the program runs, display a message saying it ran fine
if (process->waitForStarted() == true) {
qDebug() << "\nRunning CreateText";
}
#endif
}
void MainWindow::on_startSim_clicked()
{
QProcess *sim = new QProcess(this);
sim->startDetached("C:\\UDK\\UDK-2013-07\\USARRunMaps\\ExampleMap.bat");
//QThread::sleep(3);
qDebug()<<sim->errorString();
}
bool Packer::zipalign(QString temp) const
{
const QString APK_SRC(temp + "/packed/temp-2.apk");
const QString APK_DST(temp + "/packed/temp-3.apk");
QProcess p;
p.start(QString("zipalign -f 4 \"%1\" \"%2\"").arg(APK_SRC, APK_DST));
if (p.waitForStarted(-1)) {
p.waitForFinished(-1);
if (p.exitCode() == 0) {
QFile::remove(APK_SRC);
return true;
}
else {
qDebug() << "Zipalign exit code:" << p.exitCode();
qDebug() << p.readAllStandardError().replace("\r\n", "\n");
}
}
else {
qDebug() << "Error starting Zipalign";
qDebug() << "Error:" << p.errorString();
}
// Something went wrong:
QFile::rename(APK_SRC, APK_DST);
return false;
}
QStringList MainWindow::exec(const QString &pExe,
const QString &pDir)
{
QProcess lProcess;
lProcess.setProcessChannelMode(QProcess::MergedChannels);
if(!pDir.isEmpty())
{
lProcess.setWorkingDirectory(pDir);
}
lProcess.start(pExe);
if(!lProcess.waitForFinished())
{
return QStringList() << lProcess.errorString();
}
//! TODO: find a better way to do this!
QList<QByteArray> lTempLines = lProcess.readAll().split('\n');
QStringList lStringList;
for(int i=0;i<lTempLines.size();i++)
{
QString lLine(lTempLines[i]);
if(lLine.isEmpty())
continue;
lStringList.append(lLine);
}
return lStringList;
}
bool MountManager::mount()
{
if(!isPasswordCorrect()){
return false;
}
if(mountedDirExists()){
emit errorString(QString(QLatin1String("Already have something mounted in %1 ...continue")).arg(m_mountdir));
return true;
}
if(!QFileInfo(m_imgdir).exists()){
emit errorString(m_imgdir+QLatin1String("file does not exists\n"));
return false;
}
QProcess proc;
proc.setEnvironment(QProcess::systemEnvironment());
proc.start(QString(QLatin1String("sh -c \"echo %1 | sudo -S mount -o loop %2 %3\"")).arg(m_userPassWord).arg(m_imgdir).arg(m_mountdir));
if(!proc.waitForFinished()){
emit errorString(QString(QLatin1String("Can't mount image %1")).arg(QString(proc.errorString())));
return false;
}
if(!mountedDirExists()){
proc.waitForReadyRead();
emit errorString(QLatin1String(proc.readAllStandardError()));
return false;
}
proc.terminate();
messageString(QString(QLatin1String("Image mounted in %1")).arg(m_mountdir));
return true;
}
bool Packer::zip(QString contents, QString temp, QString frameworks) const
{
QProcess p;
p.start(QString("java -jar \"%1/apktool.jar\" b \"%2\" -f -o \"%3/packed/temp.zip\" -p \"%4\"")
.arg(Path::Data::shared(),contents, temp, frameworks));
if (!p.waitForStarted(-1)) {
if (isJavaInstalled()) {
qDebug() << "Error starting Apktool";
qDebug() << "Error:" << p.errorString();
emit error(Apk::ERRORSTART.arg("Apktool"));
return false;
}
else {
emit error(Apk::NOJAVA + "<br>" + Apk::GETJAVA);
return false;
}
}
p.waitForFinished(-1);
if (!p.exitCode()) {
QFile::rename(temp + "/packed/temp.zip", temp + "/packed/temp-1.apk");
return true;
}
else {
qDebug() << p.readAllStandardError().replace("\r\n", "\n");
emit error(Apk::ERROR.arg("Apktool"));
return false;
}
}
QString Kleo::gpgConfListDir( const char * which ) {
if ( !which || !*which )
return QString();
const QString gpgConfPath = Kleo::gpgConfPath();
if ( gpgConfPath.isEmpty() )
return QString();
QProcess gpgConf;
kDebug() << "gpgConfListDir: starting " << qPrintable( gpgConfPath ) << " --list-dirs";
gpgConf.start( gpgConfPath, QStringList() << QLatin1String( "--list-dirs" ) );
if ( !gpgConf.waitForFinished() ) {
kDebug() << "gpgConfListDir(): failed to execute gpgconf: " << qPrintable( gpgConf.errorString() );
kDebug() << "output was:" << endl << gpgConf.readAllStandardError().constData();
return QString();
}
const QList<QByteArray> lines = gpgConf.readAllStandardOutput().split( '\n' );
Q_FOREACH( const QByteArray & line, lines )
if ( line.startsWith( which ) && line[qstrlen(which)] == ':' ) {
const int begin = qstrlen(which) + 1;
int end = line.size();
while ( end && ( line[end-1] == '\n' || line[end-1] == '\r' ) )
--end;
const QString result = QDir::fromNativeSeparators( QFile::decodeName( hexdecode( line.mid( begin, end - begin ) ) ) );
kDebug() << "gpgConfListDir: found " << qPrintable( result )
<< " for '" << which << "'entry";
return result;
}
kDebug() << "gpgConfListDir(): didn't find '" << which << "'"
<< "entry in output:" << endl << gpgConf.readAllStandardError().constData();
return QString();
}
// Find Qt installation by running qmake
static QString findQtInstallPath(const FileName &qmakePath)
{
if (qmakePath.isEmpty())
return QString();
QProcess proc;
QStringList args;
args.append(QLatin1String("-query"));
args.append(QLatin1String("QT_INSTALL_HEADERS"));
proc.start(qmakePath.toString(), args);
if (!proc.waitForStarted()) {
qWarning("%s: Cannot start '%s': %s", Q_FUNC_INFO, qPrintable(qmakePath.toString()),
qPrintable(proc.errorString()));
return QString();
}
proc.closeWriteChannel();
if (!proc.waitForFinished()) {
SynchronousProcess::stopProcess(proc);
qWarning("%s: Timeout running '%s'.", Q_FUNC_INFO, qPrintable(qmakePath.toString()));
return QString();
}
if (proc.exitStatus() != QProcess::NormalExit) {
qWarning("%s: '%s' crashed.", Q_FUNC_INFO, qPrintable(qmakePath.toString()));
return QString();
}
const QByteArray ba = proc.readAllStandardOutput().trimmed();
QDir dir(QString::fromLocal8Bit(ba));
if (dir.exists() && dir.cdUp())
return dir.absolutePath();
return QString();
}
void Oven::cook(QString inputContents, QString scriptContents) {
QTemporaryFile file;
QProcess process;
if (file.open()) {
QString filename = file.fileName();
file.write(scriptContents.toUtf8());
if (!file.error()) {
file.close();
process.setProcessChannelMode(QProcess::ForwardedChannels);
process.start("bash", QStringList() << filename);
QTextStream inputStream(&process);
inputStream << inputContents;
inputStream.flush();
process.closeWriteChannel();
if (process.waitForStarted() && process.waitForFinished()) {
// success!
return;
}
}
}
if (file.error() != QTemporaryFile::NoError) {
emit error(file.errorString());
} else {
emit error(process.errorString());
}
// error.
return;
}
bool Unpacker::unzip(QString filename, QString destination, QString frameworks, bool smali) const
{
QProcess p;
QTime sw;
sw.start();
p.start(QString("java -jar \"%1/apktool.jar\" d \"%2\" -f %3 -o \"%4\" -p \"%5\"")
.arg(Path::Data::shared(), filename, (smali ? "" : "-s"), destination, frameworks));
if (!p.waitForStarted(-1)) {
if (isJavaInstalled()) {
qDebug() << "Error starting Apktool";
qDebug() << "Error:" << p.errorString();
emit error(Apk::ERRORSTART.arg("Apktool"));
return false;
}
else {
emit error(Apk::NOJAVA + "<br>" + Apk::GETJAVA);
return false;
}
}
p.waitForFinished(-1);
qDebug() << qPrintable(QString("Unpacked in %1s").arg(sw.elapsed() / 1000.0));
if (!p.exitCode()) {
return true;
}
else {
qDebug() << p.readAllStandardError().replace("\r\n", "\n");
emit error(Apk::ERROR.arg("Apktool"));
return false;
}
}
QString Unpacker::getManifest(QString filename) const
{
QString manifest;
QProcess p;
p.start(QString("aapt dump badging \"%1\"").arg(filename));
if (!p.waitForStarted(-1)) {
qDebug() << qPrintable("Could not start aapt");
qDebug() << "Error:" << p.errorString();
emit error(Apk::ERRORSTART.arg("aapt"));
return QString();
}
p.waitForFinished(-1);
const int CODE = p.exitCode();
qDebug() << "aapt exit code:" << CODE;
switch (CODE) {
case 1:
qDebug() << "AndroidManifest.xml contains uncritical errors.";
// Continue reading AndroidManifest.xml:
case 0:
manifest = p.readAllStandardOutput().replace("\r\n", "\n");
qDebug() << "\n--- DUMP START ---\n" << qPrintable(manifest) << "--- DUMP END ---\n";
qDebug() << "Application name:" << getApplicationLabel(manifest);
qDebug() << "Application version code:" << getVersionCode(manifest);
qDebug() << "Application version name:" << getVersionName(manifest);
return manifest;
default:
qDebug() << p.readAllStandardError().replace("\r\n", "\n");
emit error(tr("Error reading APK."));
return QString();
}
return QString();
}
QString QProcessProto::errorString() const
{
QProcess *item = qscriptvalue_cast<QProcess*>(thisObject());
if (item)
return item->errorString();
return QString();
}
static const QString msgProcessError(const QProcess &process, const QString &what)
{
QString result;
QTextStream(&result) << what << ": \"" << process.program() << ' '
<< process.arguments().join(QLatin1Char(' ')) << "\": " << process.errorString();
return result;
}
void ProcessSocket::handleProcessError(QProcess::ProcessError err)
{
Q_UNUSED(err);
QProcess *proc = qobject_cast<QProcess *>(d);
Q_ASSERT(proc);
delayedDisconnect->stop();
emit disconnected(tr("Disconnected: %1").arg(proc->errorString()));
}
void MainWindow::on_pushButton_clicked() // process one should be launched (bash launches)
{
QProcess *proc = new QProcess();
proc->setWorkingDirectory("/home/kondo/");
proc->start("/bin/bash", QStringList() << "/home/syed/backup.sh");
qDebug() << "Error in opening the file =" << proc->errorString();
// MainWindow::on_checkBox_2_stateChanged(0);
// MainWindow::pushbutton3(TRUE);
}
/*
* 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;
}
QString getPlatformGenericFont(const char* genericName)
{
#if defined(Q_OS_UNIX) && !defined(QT_NO_FONTCONFIG)
QProcess p;
p.start(QLatin1String("fc-match"), (QStringList() << "-f%{family}" << genericName));
if (!p.waitForStarted())
qWarning("fc-match cannot be started: %s", qPrintable(p.errorString()));
if (p.waitForFinished())
return QString::fromLatin1(p.readAllStandardOutput());
#endif
return QLatin1String(genericName);
}
/*
* 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;
}