bool ShellSensorModule::isLoggedin(void) {
std::string searchString;
std::string replyString;
std::string lastLine;
this->sendCommand("");
for (int searchCount = 1000; searchCount > 0; searchCount--) {
usleep(1000);
parseOutput(replyString);
searchString.append(replyString);
if (searchString.rfind("\n") != std::string::npos) {
lastLine = searchString.substr(searchString.rfind("\n") + 1);
} else {
lastLine = searchString;
}
if (lastLine.find(optionLoginShell) != std::string::npos) {
return false;
break;
} else if (lastLine.find(optionMonitorShell) != std::string::npos) {
return true;
}
}
throw "Unknown shell state\n";
return false;
}
bool ShellSensorModule::login(std::string username, std::string password) {
info << "Login";
info << "username: "******"password: "******"", string);
string.clear();
this->monitorShell = optionPasswordShell.c_str();
this->parseCommandOutput(username, string);
string.clear();
this->sendCommand(password.c_str());
std::string buffer;
for (int searchCount = 3000; searchCount > 0; searchCount--) {
usleep(1000);
parseOutput(buffer);
string.append(buffer);
if (string.find("Login incorrect") != std::string::npos) {
this->monitorShell = optionLoginShell.c_str();
return false;
} else if (string.find(optionMonitorShell) != std::string::npos) {
this->monitorShell = optionMonitorShell.c_str();
return true;
}
}
this->monitorShell = optionLoginShell.c_str();
throw vmi::ModuleException("Unable to log in to introspection shell");
return false;
}
/*** Parse a statement ***/
Node* Parser::parseStatement()
{
if(hasTokens(2) && peekToken().getType() == T_IDENTIFIER && peekToken(2).getType() == T_ASSIGN)
return parseAssign();
if(hasTokens(2) && peekToken().getType() == T_IDENTIFIER && peekToken(2).getType() == T_LPAREN)
return parseCall();
if(hasTokens() && peekToken().getType() == T_CALL)
return parseCall();
if(hasTokens() && peekToken().getType() == T_CASE)
return parseCase();
if(hasTokens() && peekToken().getType() == T_DO)
return parseDo();
if(hasTokens() && peekToken().getType() == T_END)
return parseEnd();
if(hasTokens() && peekToken().getType() == T_EXIT)
return parseExit();
if(hasTokens() && peekToken().getType() == T_FOR)
return parseFor();
if(hasTokens() && peekToken().getType() == T_IF)
return parseIf();
if(hasTokens() && peekToken().getType() == T_INPUT)
return parseInput();
if(hasTokens() && peekToken().getType() == T_OUTPUT)
return parseOutput();
if(hasTokens() && peekToken().getType() == T_REPEAT)
return parseRepeat();
if(hasTokens() && peekToken().getType() == T_RETURN)
return parseReturn();
if(hasTokens(2) && peekToken(1).getType() == T_IDENTIFIER && peekToken(2).getType() == T_LBRACKET)
return parseSliceSelectAssign();
if(hasTokens() && peekToken().getType() == T_WHILE)
return parseWhile();
throw ParserSyntaxException(getToken(), "Invalid statement!");
return 0;
}
bool
FileIdentifier::identify() {
if (m_fileName.isEmpty())
return false;
QStringList args;
args << "--output-charset" << "utf-8" << "--identify-for-mmg" << m_fileName;
auto process = Process::execute(Settings::get().m_mkvmergeExe, args);
auto exitCode = process->process().exitCode();
m_output = process->output();
if (0 == exitCode)
return parseOutput();
if (3 == exitCode) {
auto pos = m_output.isEmpty() ? -1 : m_output[0].indexOf("container:");
auto container = -1 == pos ? QY("unknown") : m_output[0].mid(pos + 11);
QMessageBox::critical(m_parent, QY("Unsupported file format"), QY("The file is an unsupported container format (%1).").arg(container));
return false;
}
QMessageBox::critical(m_parent, QY("Unrecognized file format"), QY("The file was not recognized as a supported format (exit code: %1).").arg(exitCode));
return false;
}
int TagScanner::scan(QString filepath, QList<Tag> *taglist)
{
if(!m_ctagsExist)
return 0;
QString etagsCmd;
etagsCmd = ETAGS_ARGS;
etagsCmd += " ";
etagsCmd += filepath;
QString name = ETAGS_CMD;
QStringList argList;
argList = etagsCmd.split(' ', QString::SkipEmptyParts);
QByteArray stdoutContent;
QByteArray stderrContent;
int rc = execProgram(ETAGS_CMD, argList,
&stdoutContent,
&stderrContent);
parseOutput(stdoutContent, taglist);
// Display stderr
QString all = stderrContent;
if(!all.isEmpty())
{
QStringList outputList = all.split('\n', QString::SkipEmptyParts);
for(int r = 0;r < outputList.size();r++)
{
errorMsg("%s", stringToCStr(outputList[r]));
}
}
return rc;
}
QVariant CvsLogJob::fetchResults()
{
// Convert job's output into KDevelop::VcsEvent
QList<QVariant> events;
parseOutput(output(), events);
return events;
}
void f3_launcher::on_f3_cui_finished()
{
if (stage == 0)
return;
else if (stage == 1)
{
timer.stop();
if (parseOutput() != 0)
{
stage = 0;
status = f3_launcher_stopped;
emit f3_launcher_status_changed(f3_launcher_stopped);
return;
}
stage = 2;
progress = 0;
QStringList args;
if (showProgress)
args << QString(F3_OPTION_SHOW_PROGRESS);
args << devPath;
f3_cui.start(QString(F3_READ_COMMAND),args);
emit f3_launcher_status_changed(f3_launcher_staged);
if (showProgress)
{
timer.start();
}
}
else
{
timer.stop();
stage = 0;
if (parseOutput() == 0)
{
status = f3_launcher_finished;
emit f3_launcher_status_changed(f3_launcher_finished);
}
else
{
status = f3_launcher_stopped;
emit f3_launcher_status_changed(f3_launcher_stopped);
}
}
}
void StatsVnstat::importIfaceStats()
{
mExternalHours->clear();
mExternalDays->clear();
KProcess vnstatProc;
vnstatProc.setOutputChannelMode( KProcess::OnlyStdoutChannel );
vnstatProc.setEnv( "LANG", "C" );
vnstatProc.setEnv( "LC_ALL", "C" );
vnstatProc << "vnstat" << "--dumpdb" << "-i" << mInterface->ifaceName();
vnstatProc.execute();
parseOutput( vnstatProc.readAllStandardOutput() );
getBtime();
}
ProjectData::ProjectData(BaseLib::ConfigTree const& project_config,
std::string const& path)
{
// geometry
std::string const geometry_file = BaseLib::copyPathToFileName(
project_config.getConfParam<std::string>("geometry"), path
);
detail::readGeometry(geometry_file, *_geoObjects);
// mesh
std::string const mesh_file = BaseLib::copyPathToFileName(
project_config.getConfParam<std::string>("mesh"), path
);
MeshLib::Mesh* const mesh = FileIO::readMeshFromFile(mesh_file);
if (!mesh) {
ERR("Could not read mesh from \'%s\' file. No mesh added.",
mesh_file.c_str());
std::abort();
}
_mesh_vec.push_back(mesh);
// process variables
parseProcessVariables(project_config.getConfSubtree("process_variables"));
// parameters
parseParameters(project_config.getConfSubtree("parameters"));
// processes
parseProcesses(project_config.getConfSubtree("processes"));
// output
parseOutput(project_config.getConfSubtree("output"), path);
// timestepping
parseTimeStepping(project_config.getConfSubtree("time_stepping"));
parseLinearSolvers(project_config.getConfSubtree("linear_solvers"));
parseNonlinearSolvers(project_config.getConfSubtree("nonlinear_solvers"));
}
void VideoConverter::readyReadStandardError()
{
parseOutput(QString::fromLocal8Bit(ffmpegProcess->readAllStandardError()));
}
bool Validator::validate(const QString &file, const QString &schema)
{
m_stderrOutput = QString();
m_validationErrorMessage = QString();
m_returnMessage = QString();
m_inputFile = file;
m_error = Unknown;
m_errorRow = -1;
QStringList args;
args << "--noout"; // Don't print the xml tree
args << "--schema" << schema;
args << m_inputFile;
QProcess p;
p.start("xmllint", args);
int result=0;
if (p.waitForStarted(200)) {
p.waitForFinished(400);
m_stderrOutput = QString(p.readAllStandardError());
result = p.exitCode();
} else {
m_error = ValidatorNotFound;
return false;
}
switch (result) {
case 0: // No error
m_returnMessage = QObject::tr("Success");
m_error = DocumentValid;
return true;
break;
case 1: // Unclassified
m_returnMessage = QObject::tr("Unclassified");
m_error = DocumentValid;
break;
case 2: // Error in DTD
m_returnMessage = QObject::tr("error in DTD");
break;
case 3: // Validation error
case 4: // idem
m_returnMessage = QObject::tr("Validation error");
m_error = DocumentNotValid;
parseOutput();
return false;
case 5: // Error in schema compilation
m_returnMessage = QObject::tr("Error in schema compilation");
break;
case 6: // Error writing output
m_returnMessage = QObject::tr("Error writing output");
break;
case 7: // Error in pattern (generated when [--pattern] option is used)
m_returnMessage = QObject::tr("Error in pattern");
break;
case 8: // Error in Reader registration (generated when [--chkregister] option is used)
m_returnMessage = QObject::tr("Error in Reader registration");
break;
case 9: // Out of memory error
m_returnMessage = QObject::tr("Out of memory error");
break;
case -1: // Starting error
m_returnMessage = QObject::tr("Starting error - no validation performed");
break;
default:
m_returnMessage = QObject::tr("Undocumented error code");
}
return false;
}
bool EPSPlug::convert(QString fn, double x, double y, double b, double h)
{
QStringList args;
QString cmd, cmd1, cmd2, cmd3, tmp, tmp2, tmp3, tmp4;
// import.prolog do not cope with filenames containing blank spaces
// so take care that output filename does not (win32 compatibility)
QString tmpFile = getShortPathName(ScPaths::getTempFileDir())+ "/ps.out";
QString errFile = getShortPathName(ScPaths::getTempFileDir())+ "/ps.err";
QString pfad = ScPaths::instance().libDir();
QString pfad2 = QDir::toNativeSeparators(pfad + "import.prolog");
QFileInfo fi = QFileInfo(fn);
QString ext = fi.suffix().toLower();
if (progressDialog) {
progressDialog->setOverallProgress(1);
qApp->processEvents();
}
/*
// Destill the eps with ghostscript to get a clean eps file
QString cleanFile = getShortPathName(ScPaths::getTempFileDir())+ "/clean.eps";
args.append( "-q" );
args.append( "-dNOPAUSE" );
args.append( "-sDEVICE=epswrite" );
args.append( "-dBATCH" );
args.append( "-dSAFER" );
args.append( "-dDEVICEWIDTH=250000" );
args.append( "-dDEVICEHEIGHT=250000" );
args.append( QString("-sOutputFile=%1").arg(QDir::toNativeSeparators(cleanFile)) );
args.append( QDir::toNativeSeparators(fn) );
System(getShortPathName(PrefsManager::instance()->ghostscriptExecutable()), args, errFile, errFile, &cancel);
args.clear();
*/
args.append( "-q" );
args.append( "-dNOPAUSE" );
args.append( "-dNODISPLAY" );
args.append( "-dBATCH" );
args.append( "-dDELAYBIND" );
// Add any extra font paths being used by Scribus to gs's font search
// path We have to use Scribus's prefs context, not a plugin context, to
// get to the required information.
PrefsContext *pc = PrefsManager::instance()->prefsFile->getContext("Fonts");
PrefsTable *extraFonts = pc->getTable("ExtraFontDirs");
const char sep = ScPaths::envPathSeparator;
if (extraFonts->getRowCount() >= 1)
cmd = QString("-sFONTPATH=%1").arg(extraFonts->get(0,0));
for (int i = 1; i < extraFonts->getRowCount(); ++i)
cmd += QString("%1%2").arg(sep).arg(extraFonts->get(i,0));
if( !cmd.isEmpty() )
args.append( cmd );
// then finish building the command and call gs
args.append( QString("-g%1x%2").arg(tmp2.setNum(qRound((b-x)*4))).arg(tmp3.setNum(qRound((h-y)*4))) );
args.append( "-r288");
args.append( "-dTextAlphaBits=4" );
args.append( "-dGraphicsAlphaBits=4" );
args.append( "-c" );
args.append( tmp.setNum(-x) );
args.append( tmp.setNum(-y) );
args.append( "translate" );
args.append( QString("-sTraceFile=%1").arg(QDir::toNativeSeparators(tmpFile)) );
QString exportPath = m_Doc->DocName + "-" + fi.baseName();
QFileInfo exportFi(exportPath);
if ( !exportFi.isWritable() ) {
PrefsContext* docContext = PrefsManager::instance()->prefsFile->getContext("docdirs", false);
QString docDir = ".";
QString prefsDocDir=PrefsManager::instance()->documentDir();
if (!prefsDocDir.isEmpty())
docDir = docContext->get("docsopen", prefsDocDir);
else
docDir = docContext->get("docsopen", ".");
exportFi.setFile(docDir + "/" + exportFi.baseName());
}
//qDebug() << QString("using export path %1").arg(exportFi.absFilePath());
args.append( QString("-sExportFiles=%1").arg(QDir::toNativeSeparators(exportFi.absoluteFilePath())) );
args.append( pfad2 );
args.append( QDir::toNativeSeparators(fn) );
args.append( "-c" );
args.append( "flush" );
args.append( "cfile" );
args.append( "closefile" );
args.append( "quit" );
QByteArray finalCmd = args.join(" ").toLocal8Bit();
int ret = System(getShortPathName(PrefsManager::instance()->ghostscriptExecutable()), args, errFile, errFile, &cancel);
if (ret != 0 && !cancel)
{
qDebug("PostScript import failed when calling gs as: \n%s\n", finalCmd.data());
qDebug("%s", "Ghostscript diagnostics:\n");
QFile diag(errFile);
if (diag.open(QIODevice::ReadOnly) && !diag.atEnd() ) {
char buf[121];
while (diag.readLine(buf, 120) > 0) {
qDebug("\t%s", buf);
}
diag.close();
}
else {
qDebug("%s", "-- no output --");
}
if (progressDialog)
progressDialog->close();
QString mess = tr("Importing File:\n%1\nfailed!").arg(fn);
ScMessageBox::critical(0, tr("Fatal Error"), mess);
return false;
}
if(progressDialog && !cancel) {
progressDialog->setOverallProgress(2);
progressDialog->setLabel("GI", tr("Generating Items"));
qApp->processEvents();
}
if (!cancel) {
parseOutput(tmpFile, extensionIndicatesEPSorPS(ext));
}
QFile::remove(tmpFile);
// QFile::remove(cleanFile);
if (progressDialog)
progressDialog->close();
return true;
}
void QTestLibArgsParser::parse(bool incremental)
{
if (!incremental)
initDefaults();
QStringList knownFlags;
// Output flag
knownFlags << QLatin1String("o");
// ParserFormat flags
knownFlags << QLatin1String("txt") << QLatin1String("csv") << QLatin1String("xunitxml") << QLatin1String("xml") << QLatin1String("lightxml");
// Verbosity flags
knownFlags << QLatin1String("silent") << QLatin1String("") << QLatin1String("v1") << QLatin1String("v2") << QLatin1String("vs") << QLatin1String("vb");
// Options affecting output
knownFlags << QLatin1String("functions") << QLatin1String("datatags") << QLatin1String("help") << QLatin1String("perfcounterlist");
// Other test flags
knownFlags << QLatin1String("eventdelay") << QLatin1String("keydelay") << QLatin1String("mousedelay") << QLatin1String("maxwarnings") << QLatin1String("nocrashhandler");
// Other benchmark flags
knownFlags << QLatin1String("callgrind") << QLatin1String("perf") << QLatin1String("perfcounter") << QLatin1String("tickcounter") << QLatin1String("eventcounter") << QLatin1String("minimumvalue") << QLatin1String("minimumtotal") << QLatin1String("iterations") << QLatin1String("median");
int currentFlag = -1;
QString token;
while (!(token = nextToken()).isNull()) {
qDebug() << token;
if (currentFlag == -1) {
// Token is not a flag argument
if (token.startsWith(QLatin1Char('-')))
currentFlag = knownFlags.indexOf(token.mid(1));
else
currentFlag = -2;
qDebug() << currentFlag;
switch (currentFlag) {
case -2: // Test case name?
parseSelectedTest(token);
break;
case -1: // Unknown flag
mError = UnknownFlagError;
mErrorString = QCoreApplication::translate("QTestLibPlugin::Internal::QTestLibArgsParser", "Unknown flag \"%1\"").arg(token);
break;
case 7: // Impossible
Q_ASSERT(false);
case 0: // -o
continue;
case 1: // -txt
case 2: // -csv
case 3: // -xunitxml
case 4: // -xml
case 5: // -lightXml
if (!mSeenOutputWithFormat)
mParser = (TestOutputFormat) currentFlag;
break;
case 6: // -silent
case 8: // -v1
case 9: // -v2
case 10: // -vs
case 11: // -vb
mVerbosity = (TestVerbosity) (currentFlag - 7);
break;
case 12: // -functions
if (mOutput == NormalOutput) {
mParser = NoneFormat;
mOutput = FunctionsOutput;
}
break;
case 13: // -datatags
if (mOutput == NormalOutput) {
mParser = NoneFormat;
mOutput = DataTagsOutput;
}
break;
case 14: // -help
if (mOutput == NormalOutput) {
mParser = NoneFormat;
mOutput = HelpOutput;
}
break;
case 15: // -perfcounterlist
if (mOutput == NormalOutput) {
mParser = NoneFormat;
mOutput = PerfCounterNamesOutput;
}
break;
case 16: // -eventdelay
case 17: // -keydelay
case 18: // -mousedelay
case 19: // -maxwarnings
continue;
case 20: // -nocrashhandler
mCrashHandlerEnabled = false;
break;
default:
qWarning() << "Benchmark flags are not supported yet";
break;
}
} else {
// Token is a flag argument
switch(currentFlag) {
case 0: // -o
parseOutput(token);
break;
case 16: // -eventdelay
mEventDelay = parseInteger(token, mEventDelay);
break;
case 17: // -keydelay
mKeyDelay = parseInteger(token, mKeyDelay);
break;
case 18: // -mousedelay
mMouseDelay = parseInteger(token, mMouseDelay);
break;
case 19: // -maxwarnings
mMaxWarnings = parseUnsignedInteger(token, mMaxWarnings);
break;
}
}
currentFlag = -1;
}
if (currentFlag != -1) {
mError = PrematureEndError;
mErrorString = QCoreApplication::translate("QTestLibPlugin::Internal::QTestLibArgsParser", "String of command line arguments ended prematurely");
}
}
