QString unquoteWord(const QString &word)
{
if (word.isEmpty()) {
return QString();
}
KProcess echo;
echo.setShellCommand(QString(QLatin1String("echo -n %1")).arg(word));
echo.setOutputChannelMode(KProcess::OnlyStdoutChannel);
if (echo.execute() == 0) {
return QString::fromLocal8Bit(echo.readAllStandardOutput().constData());
}
QChar ch;
QString quotedWord = word, unquotedWord;
QTextStream stream("edWord, QIODevice::ReadOnly | QIODevice::Text);
while (!stream.atEnd()) {
stream >> ch;
if (ch == QLatin1Char('\'')) {
Q_FOREVER {
if (stream.atEnd()) {
return QString();
}
stream >> ch;
if (ch == QLatin1Char('\'')) {
return unquotedWord;
} else {
unquotedWord.append(ch);
}
}
} else if (ch == QLatin1Char('"')) {
QString OcrGocrDialog::version()
{
kDebug() << "of" << m_ocrCmd;
QString vers;
KProcess proc;
proc.setOutputChannelMode(KProcess::MergedChannels);
proc << m_ocrCmd << "-h";
int status = proc.execute(5000);
if (status==0)
{
QByteArray output = proc.readAllStandardOutput();
QRegExp rx("-- gocr ([\\d\\.\\s]+)");
if (rx.indexIn(output)>-1) vers = rx.cap(1);
else vers = i18n("Unknown");
}
else
{
kDebug() << "failed with status" << status;
vers = i18n("Error");
}
return (vers);
}
const QString EncoderAssistant::version(const EncoderAssistant::Encoder encoder) {
KProcess process;
process.setOutputChannelMode(KProcess::SeparateChannels);
process.setReadChannel(KProcess::StandardError);
switch (encoder) {
case EncoderAssistant::LAME : process.setShellCommand(QString(ENCODER_LAME_BIN)+" "+QString(ENCODER_LAME_VERSION_PARA)); break;
case EncoderAssistant::OGGENC : process.setShellCommand(QString(ENCODER_OGGENC_BIN)+" "+QString(ENCODER_OGGENC_VERSION_PARA)); break;
case EncoderAssistant::FLAC : process.setShellCommand(QString(ENCODER_FLAC_BIN)+" "+QString(ENCODER_FLAC_VERSION_PARA)); break;
case EncoderAssistant::FAAC : process.setShellCommand(QString(ENCODER_FAAC_BIN)+" "+QString(ENCODER_FAAC_VERSION_PARA)); break;
case EncoderAssistant::WAVE : return "";
case EncoderAssistant::CUSTOM : return "";
default : return "";
}
process.start();
if (!process.waitForFinished()) return "";
QByteArray rawoutput = process.readAllStandardError();
if (rawoutput.size() == 0) rawoutput = process.readAllStandardOutput();
QString output(rawoutput);
QStringList list = output.trimmed().split("\n");
if (list.count()==0) return "";
QStringList words = list[0].split(" ");
if (words.count()==0) return "";
switch (encoder) {
case EncoderAssistant::LAME :
if ((words.contains("version")) && (words.indexOf("version")+1<words.count())) return words[words.indexOf("version")+1];
if (words.count()<2) return "";
return words[words.count()-2];
case EncoderAssistant::OGGENC :
case EncoderAssistant::FLAC :
return words.last();
case EncoderAssistant::FAAC :
if (list.count()<2) return "";
words = list[1].split(" ");
if (words.count()<2) return "";
if ((words.contains("FAAC")) && (words.indexOf("FAAC")+1<words.count())) return words[words.indexOf("FAAC")+1];
return words[1];
case EncoderAssistant::WAVE :
case EncoderAssistant::CUSTOM :
default : ;
}
return "";
}
void IndexBuilder::slotProcessExited( int exitCode, QProcess::ExitStatus exitStatus )
{
KProcess *proc = static_cast<KProcess *>(sender());
if ( exitStatus != QProcess::NormalExit ) {
kError(1402) << "Process failed" << endl;
kError(1402) << "stdout output:" << proc->readAllStandardOutput();
kError(1402) << "stderr output:" << proc->readAllStandardError();
}
else if (exitCode != 0 ) {
kError(1402) << "running" << proc->program() << "failed with exitCode" << exitCode;
kError(1402) << "stdout output:" << proc->readAllStandardOutput();
kError(1402) << "stderr output:" << proc->readAllStandardError();
}
delete proc;
sendProgressSignal();
processCmdQueue();
}
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();
}
void QtHelpQtDoc::lookupDone(int code)
{
if(code==0) {
KProcess* p = qobject_cast<KProcess*>(sender());
QString path = QDir::fromNativeSeparators(QString::fromLatin1(p->readAllStandardOutput().trimmed()));
qCDebug(QTHELP) << "Detected doc path:" << path;
if (!path.isEmpty()) {
loadDirectory(path);
loadDirectory(path+"/qch/");
}
}
sender()->deleteLater();
}
static void recursor(char **argv)
{
if (argv[1]) {
KProcess p;
p.setShellCommand("echo " EOUT "; echo " EERR " >&2");
p.setOutputChannelMode((KProcess::OutputChannelMode)atoi(argv[1]));
fputs(POUT, stdout);
fflush(stdout);
p.execute();
fputs(ROUT, stdout);
fputs(p.readAllStandardOutput(), stdout);
fputs(RERR, stdout);
fputs(p.readAllStandardError(), stdout);
exit(0);
}
gargv = argv;
}
//Copied from CMakeManager
QString executeProcess(const QString& execName, const QStringList& args=QStringList())
{
KProcess p;
p.setOutputChannelMode(KProcess::MergedChannels);
p.setProgram(execName, args);
p.start();
if(!p.waitForFinished())
{
qCDebug(CMAKE) << "failed to execute:" << execName;
}
QByteArray b = p.readAllStandardOutput();
QString t;
t.prepend(b.trimmed());
return t;
}
void SystemInformation::lsbReleaseFinished()
{
KProcess *process = qobject_cast<KProcess*>(sender());
Q_ASSERT(process);
m_lsbRelease = QString::fromLocal8Bit(process->readAllStandardOutput().trimmed());
process->deleteLater();
//Guess distro string
QString platform = guessBugzillaPlatform(m_lsbRelease);
// if lsb_release doesn't work well, turn to the /etc/os-release file
if (platform == PLATFORM_UNSPECIFIED) {
const QString& osReleaseInfo = fetchOSReleaseInformation();
platform = guessBugzillaPlatform(osReleaseInfo);
}
setBugzillaPlatform(platform);
}
QString CMakeBuildDirCreator::executeProcess(const QString& execName, const QStringList& args)
{
kDebug(9042) << "Executing:" << execName << "::" << args /*<< "into" << *m_vars*/;
KProcess p;
p.setOutputChannelMode(KProcess::MergedChannels);
p.setProgram(execName, args);
p.start();
if(!p.waitForFinished())
{
kDebug(9042) << "failed to execute:" << execName;
}
QByteArray b = p.readAllStandardOutput();
QString t;
t.prepend(b.trimmed());
kDebug(9042) << "executed" << execName << "<" << t;
return t;
}
QMap<QString, QString> MANProtocol::buildIndexMap(const QString §ion)
{
QMap<QString, QString> i;
QStringList man_dirs = manDirectories();
// Supplementary places for whatis databases
man_dirs += m_mandbpath;
if (!man_dirs.contains("/var/cache/man"))
man_dirs << "/var/cache/man";
if (!man_dirs.contains("/var/catman"))
man_dirs << "/var/catman";
QStringList names;
names << "whatis.db" << "whatis";
QString mark = "\\s+\\(" + section + "[a-z]*\\)\\s+-\\s+";
for ( QStringList::ConstIterator it_dir = man_dirs.constBegin();
it_dir != man_dirs.constEnd();
++it_dir )
{
if ( QFile::exists( *it_dir ) ) {
QStringList::ConstIterator it_name;
for ( it_name = names.constBegin();
it_name != names.constEnd();
it_name++ )
{
if (addWhatIs(i, (*it_dir) + '/' + (*it_name), mark))
break;
}
if ( it_name == names.constEnd() ) {
KProcess proc;
proc << "whatis" << "-M" << (*it_dir) << "-w" << "*";
proc.setOutputChannelMode( KProcess::OnlyStdoutChannel );
proc.execute();
QTextStream t( proc.readAllStandardOutput(), QIODevice::ReadOnly );
parseWhatIs( i, t, mark );
}
}
}
return i;
}
void CameraController::slotCheckRename(const QString& folder, const QString& file,
const QString& destination, const QString& temp,
const QString& script)
{
// this is the direct continuation of executeCommand, case CameraCommand::cam_download
bool skip = false;
bool cancel = false;
bool overwrite = d->overwriteAll;
QString dest = destination;
// Check if dest file already exist, unless we overwrite anyway
QFileInfo info(dest);
if (!d->overwriteAll)
{
while (info.exists())
{
if (d->skipAll)
{
skip = true;
break;
}
QPointer<KIO::RenameDialog> dlg = new KIO::RenameDialog(d->parent, i18nc("@title:window", "Rename File"),
QString(folder + QLatin1String("/") + file), dest,
KIO::RenameDialog_Mode(KIO::M_MULTI |
KIO::M_OVERWRITE |
KIO::M_SKIP));
int result = dlg->exec();
dest = dlg->newDestUrl().toLocalFile();
info = QFileInfo(dest);
delete dlg;
switch (result)
{
case KIO::R_CANCEL:
{
cancel = true;
break;
}
case KIO::R_SKIP:
{
skip = true;
break;
}
case KIO::R_AUTO_SKIP:
{
d->skipAll = true;
skip = true;
break;
}
case KIO::R_OVERWRITE:
{
overwrite = true;
break;
}
case KIO::R_OVERWRITE_ALL:
{
d->overwriteAll = true;
overwrite = true;
break;
}
default:
break;
}
if (cancel || skip || overwrite)
{
break;
}
}
}
if (cancel)
{
unlink(QFile::encodeName(temp));
slotCancel();
emit signalSkipped(folder, file);
return;
}
else if (skip)
{
unlink(QFile::encodeName(temp));
sendLogMsg(i18n("Skipped file <filename>%1</filename>", file), DHistoryView::WarningEntry, folder, file);
emit signalSkipped(folder, file);
return;
}
kDebug() << "Checking whether (" << temp << ") has a sidecar";
// move the file to the destination file
if (DMetadata::hasSidecar(temp))
{
kDebug() << " Yes, renaming it to " << dest;
if (KDE::rename(DMetadata::sidecarPath(temp), DMetadata::sidecarPath(dest)) != 0)
{
sendLogMsg(i18n("Failed to save sidecar file for <filename>%1</filename>", file), DHistoryView::ErrorEntry, folder, file);
}
}
if (KDE::rename(temp, dest) != 0)
{
kDebug() << "Renaming " << temp << " to " << dest << " failed";
// rename failed. delete the temp file
unlink(QFile::encodeName(temp));
emit signalDownloaded(folder, file, CamItemInfo::DownloadFailed);
sendLogMsg(i18n("Failed to download <filename>%1</filename>", file), DHistoryView::ErrorEntry, folder, file);
}
else
{
kDebug() << "Rename done, emiting downloaded signals:" << file << " info.filename: " << info.fileName();
// TODO why two signals??
emit signalDownloaded(folder, file, CamItemInfo::DownloadedYes);
emit signalDownloadComplete(folder, file, info.path(), info.fileName());
// Run script
if (!script.isEmpty())
{
kDebug() << "Got a script, processing: " << script;
KProcess process;
process.setOutputChannelMode(KProcess::SeparateChannels);
QString s;
if (script.indexOf('%') > -1)
{
QHash<QString, QString> map;
map.insert("file", dest);
map.insert("filename", info.fileName());
map.insert("path", info.path());
map.insert("orgfilename", file);
map.insert("orgpath", folder);
s = KMacroExpander::expandMacros(script, map);
}
else
{
s = script + " \"" + dest + "\"";
}
process.setShellCommand(s);
kDebug() << "Running: " << s;
int ret = process.execute();
if (ret != 0)
{
sendLogMsg(i18n("Failed to run script for <filename>%1</filename>", file), DHistoryView::ErrorEntry, folder, file);
}
kDebug() << "stdout" << process.readAllStandardOutput();
kDebug() << "stderr" << process.readAllStandardError();
}
}
}
char *MANProtocol::readManPage(const char *_filename)
{
QByteArray filename = _filename;
QByteArray array;
/* Determine type of man page file by checking its path. Determination by
* MIME type with KMimeType doesn't work reliablely. E.g., Solaris 7:
* /usr/man/sman7fs/pcfs.7fs -> text/x-csrc : WRONG
* If the path name constains the string sman, assume that it's SGML and
* convert it to roff format (used on Solaris). */
//QString file_mimetype = KMimeType::findByPath(QString(filename), 0, false)->name();
if (QString(filename).contains("sman", Qt::CaseInsensitive)) //file_mimetype == "text/html" || )
{
KProcess proc;
// Determine path to sgml2roff, if not already done.
getProgramPath();
proc << mySgml2RoffPath << filename;
proc.setOutputChannelMode( KProcess::OnlyStdoutChannel );
proc.execute();
array = proc.readAllStandardOutput();
}
else
{
if (QDir::isRelativePath(filename))
{
qCDebug(KIO_MAN_LOG) << "relative " << filename;
filename = QDir::cleanPath(lastdir + '/' + filename).toUtf8();
qCDebug(KIO_MAN_LOG) << "resolved to " << filename;
}
lastdir = filename.left(filename.lastIndexOf('/'));
if ( !QFile::exists(QFile::decodeName(filename)) ) // if given file does not exist, find with suffix
{
qCDebug(KIO_MAN_LOG) << "not existing " << filename;
QDir mandir(lastdir);
mandir.setNameFilters(QStringList() << (filename.mid(filename.lastIndexOf('/') + 1) + ".*"));
filename = lastdir + '/' + QFile::encodeName(mandir.entryList().first());
qCDebug(KIO_MAN_LOG) << "resolved to " << filename;
}
QIODevice *fd = KFilterDev::deviceForFile(filename);
if ( !fd || !fd->open(QIODevice::ReadOnly))
{
delete fd;
return 0;
}
array = fd->readAll();
qCDebug(KIO_MAN_LOG) << "read " << array.size();
fd->close();
delete fd;
}
if (array.isEmpty())
return 0;
// as we do not know in which encoding the man source is, try to automatically
// detect it and always return it as UTF-8
KEncodingProber encodingProber;
encodingProber.feed(array);
qCDebug(KIO_MAN_LOG) << "auto-detect encoding for" << filename << "guess=" << encodingProber.encoding()
<< "confidence=" << encodingProber.confidence();
QString out = QTextCodec::codecForName(encodingProber.encoding())->toUnicode(array);
array = out.toUtf8();
const int len = array.size();
char *buf = new char[len + 4];
memmove(buf + 1, array.data(), len);
buf[0] = buf[len+1] = '\n'; // Start and end with an end of line
buf[len+2] = buf[len+3] = '\0'; // Two NUL characters at end
return buf;
}