diff --git a/kerfuffle/CMakeLists.txt b/kerfuffle/CMakeLists.txt index 35d41e20..c77a5204 100644 --- a/kerfuffle/CMakeLists.txt +++ b/kerfuffle/CMakeLists.txt @@ -1,40 +1,43 @@ include_directories( ${CMAKE_CURRENT_SOURCE_DIR}/.. ${CMAKE_CURRENT_BINARY_DIR}/.. ) macro_optional_find_package(QJSON) macro_log_feature(QJSON_FOUND "QJSON" "A library for processing and serializing JSON files" "http://qjson.sourceforge.net" FALSE "" "Required for compiling Ark's unit tests") ########### next target ############### set(kerfuffle_SRCS archive.cpp archiveinterface.cpp jobs.cpp archivebase.cpp extractiondialog.cpp adddialog.cpp queries.cpp addtoarchive.cpp cliinterface.cpp ) kde4_add_kcfg_files(kerfuffle_SRCS settings.kcfgc) kde4_add_ui_files(kerfuffle_SRCS extractiondialog.ui adddialog.ui ) kde4_add_library(kerfuffle SHARED ${kerfuffle_SRCS}) target_link_libraries(kerfuffle ${KDE4_KFILE_LIBS} ${KDE4_KPARTS_LIBS}) +if (NOT WIN32) + target_link_libraries(kerfuffle ${KDE4_KPTY_LIBS}) +endif (NOT WIN32) set_target_properties(kerfuffle PROPERTIES VERSION ${GENERIC_LIB_VERSION} SOVERSION ${GENERIC_LIB_SOVERSION}) install(TARGETS kerfuffle ${INSTALL_TARGETS_DEFAULT_ARGS}) install(FILES kerfufflePlugin.desktop DESTINATION ${SERVICETYPES_INSTALL_DIR}) install(FILES ark.kcfg DESTINATION ${KCFG_INSTALL_DIR}) if (QJSON_FOUND) add_subdirectory(tests) endif (QJSON_FOUND) diff --git a/kerfuffle/cliinterface.cpp b/kerfuffle/cliinterface.cpp index 5b085f1d..67b746cc 100644 --- a/kerfuffle/cliinterface.cpp +++ b/kerfuffle/cliinterface.cpp @@ -1,659 +1,690 @@ /* * ark -- archiver for the KDE project * * Copyright (C) 2009 Harald Hvaal * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ( INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION ) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * ( INCLUDING NEGLIGENCE OR OTHERWISE ) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "cliinterface.h" #include "queries.h" -#include +#ifdef Q_OS_WIN +# include +#else +# include +# include +#endif + #include #include #include #include #include #include #include #include +#include #include #include namespace Kerfuffle { CliInterface::CliInterface(QObject *parent, const QVariantList & args) : ReadWriteArchiveInterface(parent, args), m_process(0) { //because this interface uses the event loop setWaitForFinishedSignal(true); if (QMetaType::type("QProcess::ExitStatus") == 0) { qRegisterMetaType("QProcess::ExitStatus"); } } void CliInterface::cacheParameterList() { m_param = parameterList(); Q_ASSERT(m_param.contains(ExtractProgram)); Q_ASSERT(m_param.contains(ListProgram)); Q_ASSERT(m_param.contains(PreservePathSwitch)); Q_ASSERT(m_param.contains(FileExistsExpression)); Q_ASSERT(m_param.contains(FileExistsInput)); } CliInterface::~CliInterface() { Q_ASSERT(!m_process); } bool CliInterface::list() { cacheParameterList(); m_operationMode = List; QStringList args = m_param.value(ListArgs).toStringList(); substituteListVariables(args); if (!runProcess(m_param.value(ListProgram).toString(), args)) { failOperation(); return false; } return true; } bool CliInterface::copyFiles(const QList & files, const QString & destinationDirectory, ExtractionOptions options) { kDebug(); cacheParameterList(); m_operationMode = Copy; //start preparing the argument list QStringList args = m_param.value(ExtractArgs).toStringList(); //now replace the various elements in the list for (int i = 0; i < args.size(); ++i) { QString argument = args.at(i); kDebug() << "Processing argument " << argument; if (argument == QLatin1String( "$Archive" )) { args[i] = filename(); } if (argument == QLatin1String( "$PreservePathSwitch" )) { QStringList replacementFlags = m_param.value(PreservePathSwitch).toStringList(); Q_ASSERT(replacementFlags.size() == 2); bool preservePaths = options.value(QLatin1String( "PreservePaths" )).toBool(); QString theReplacement; if (preservePaths) { theReplacement = replacementFlags.at(0); } else { theReplacement = replacementFlags.at(1); } if (theReplacement.isEmpty()) { args.removeAt(i); --i; //decrement to compensate for the variable we removed } else { //but in this case we don't have to decrement, we just //replace it args[i] = theReplacement; } } if (argument == QLatin1String( "$PasswordSwitch" )) { //if the PasswordSwitch argument has been added, we at least //assume that the format of the switch has been added as well Q_ASSERT(m_param.contains(PasswordSwitch)); //we will decrement i afterwards args.removeAt(i); //if we get a hint about this being a password protected archive, ask about //the password in advance. if ((options.value(QLatin1String("PasswordProtectedHint")).toBool()) && (password().isEmpty())) { kDebug() << "Password hint enabled, querying user"; Kerfuffle::PasswordNeededQuery query(filename()); userQuery(&query); query.waitForResponse(); if (query.responseCancelled()) { failOperation(); return false; } setPassword(query.password()); } QString pass = password(); if (!pass.isEmpty()) { QStringList theSwitch = m_param.value(PasswordSwitch).toStringList(); for (int j = 0; j < theSwitch.size(); ++j) { //get the argument part QString newArg = theSwitch.at(j); //substitute the $Path newArg.replace(QLatin1String( "$Password" ), pass); //put it in the arg list args.insert(i + j, newArg); ++i; } } --i; //decrement to compensate for the variable we replaced } if (argument == QLatin1String( "$RootNodeSwitch" )) { //if the RootNodeSwitch argument has been added, we at least //assume that the format of the switch has been added as well Q_ASSERT(m_param.contains(RootNodeSwitch)); //we will decrement i afterwards args.removeAt(i); QString rootNode; if (options.contains(QLatin1String( "RootNode" ))) { rootNode = options.value(QLatin1String( "RootNode" )).toString(); kDebug() << "Set root node " << rootNode; } if (!rootNode.isEmpty()) { QStringList theSwitch = m_param.value(RootNodeSwitch).toStringList(); for (int j = 0; j < theSwitch.size(); ++j) { //get the argument part QString newArg = theSwitch.at(j); //substitute the $Path newArg.replace(QLatin1String( "$Path" ), rootNode); //put it in the arg list args.insert(i + j, newArg); ++i; } } --i; //decrement to compensate for the variable we replaced } if (argument == QLatin1String( "$Files" )) { args.removeAt(i); for (int j = 0; j < files.count(); ++j) { args.insert(i + j, escapeFileName(files.at(j).toString())); ++i; } --i; } } kDebug() << "Setting current dir to " << destinationDirectory; QDir::setCurrent(destinationDirectory); if (!runProcess(m_param.value(ExtractProgram).toString(), args)) { failOperation(); return false; } return true; } bool CliInterface::addFiles(const QStringList & files, const CompressionOptions& options) { cacheParameterList(); m_operationMode = Add; const QString globalWorkDir = options.value(QLatin1String( "GlobalWorkDir" )).toString(); const QDir workDir = globalWorkDir.isEmpty() ? QDir::current() : QDir(globalWorkDir); if (!globalWorkDir.isEmpty()) { kDebug() << "GlobalWorkDir is set, changing dir to " << globalWorkDir; QDir::setCurrent(globalWorkDir); } //start preparing the argument list QStringList args = m_param.value(AddArgs).toStringList(); //now replace the various elements in the list for (int i = 0; i < args.size(); ++i) { const QString argument = args.at(i); kDebug() << "Processing argument " << argument; if (argument == QLatin1String( "$Archive" )) { args[i] = filename(); } if (argument == QLatin1String( "$Files" )) { args.removeAt(i); for (int j = 0; j < files.count(); ++j) { // #191821: workDir must be used instead of QDir::current() // so that symlinks aren't resolved automatically // TODO: this kind of call should be moved upwards in the // class hierarchy to avoid code duplication const QString relativeName = workDir.relativeFilePath(files.at(j)); args.insert(i + j, relativeName); ++i; } --i; } } if (!runProcess(m_param.value(AddProgram).toString(), args)) { failOperation(); return false; } return true; } bool CliInterface::deleteFiles(const QList & files) { cacheParameterList(); m_operationMode = Delete; //start preparing the argument list QStringList args = m_param.value(DeleteArgs).toStringList(); //now replace the various elements in the list for (int i = 0; i < args.size(); ++i) { QString argument = args.at(i); kDebug() << "Processing argument " << argument; if (argument == QLatin1String( "$Archive" )) { args[i] = filename(); } else if (argument == QLatin1String( "$Files" )) { args.removeAt(i); for (int j = 0; j < files.count(); ++j) { args.insert(i + j, escapeFileName(files.at(j).toString())); ++i; } --i; } } m_removedFiles = files; if (!runProcess(m_param.value(DeleteProgram).toString(), args)) { failOperation(); return false; } return true; } bool CliInterface::runProcess(const QString& programName, const QStringList& arguments) { const QString programPath(KStandardDirs::findExe(programName)); if (programPath.isEmpty()) { error(i18nc("@info", "Failed to locate program %1 in PATH.", programName)); return false; } Q_ASSERT(!m_process); kDebug() << "Executing" << programPath << arguments; +#ifdef Q_OS_WIN m_process = new KProcess(); +#else + m_process = new KPtyProcess(); + m_process->setPtyChannels(KPtyProcess::StdinChannel); +#endif + m_process->setTextModeEnabled(true); m_process->setOutputChannelMode(KProcess::MergedChannels); m_process->setNextOpenMode(QIODevice::ReadWrite | QIODevice::Unbuffered); m_process->setProgram(programPath, arguments); connect(m_process, SIGNAL(started()), SLOT(started()), Qt::DirectConnection); connect(m_process, SIGNAL(readyReadStandardOutput()), SLOT(readStdout()), Qt::DirectConnection); connect(m_process, SIGNAL(finished(int, QProcess::ExitStatus)), SLOT(processFinished(int, QProcess::ExitStatus)), Qt::DirectConnection); m_stdOutData.clear(); m_process->start(); - m_process->waitForFinished(-1); + +#ifdef Q_OS_WIN + bool ret = m_process->waitForFinished(-1); +#else + QEventLoop loop; + bool ret = loop.exec(QEventLoop::WaitForMoreEvents | QEventLoop::ExcludeUserInputEvents); +#endif delete m_process; m_process = 0; - return true; + return ret; } void CliInterface::started() { m_userCancelled = false; } void CliInterface::processFinished(int exitCode, QProcess::ExitStatus exitStatus) { Q_UNUSED(exitCode) Q_UNUSED(exitStatus) kDebug(); //if the m_process pointer is gone, then there is nothing to worry //about here if (!m_process) { return; } if (m_operationMode == Delete) { foreach(const QVariant& v, m_removedFiles) { entryRemoved(v.toString()); } } //handle all the remaining data in the process readStdout(true); progress(1.0); if (m_operationMode == Add) { list(); return; } //and we're finished finished(true); } void CliInterface::failOperation() { kDebug(); doKill(); finished(false); } void CliInterface::readStdout(bool handleAll) { //when hacking this function, please remember the following: //- standard output comes in unpredictable chunks, this is why //you can never know if the last part of the output is a complete line or not //- console applications are not really consistent about what //characters they send out (newline, backspace, carriage return, //etc), so keep in mind that this function is supposed to handle //all those special cases and be the lowest common denominator Q_ASSERT(m_process); if (!m_process->bytesAvailable()) { //if process has no more data, we can just bail out return; } //if the process is still not finished (m_process is appearantly not //set to NULL if here), then the operation should definitely not be in //the main thread as this would freeze everything. assert this. Q_ASSERT(QThread::currentThread() != QApplication::instance()->thread()); QByteArray dd = m_process->readAllStandardOutput(); m_stdOutData += dd; QList lines = m_stdOutData.split('\n'); //The reason for this check is that archivers often do not end //queries (such as file exists, wrong password) on a new line, but //freeze waiting for input. So we check for errors on the last line in //all cases. bool foundErrorMessage = (checkForErrorMessage(QLatin1String( lines.last() ), WrongPasswordPatterns) || checkForErrorMessage(QLatin1String( lines.last() ), ExtractionFailedPatterns) || checkForFileExistsMessage(QLatin1String( lines.last() ))); if (foundErrorMessage) { handleAll = true; } //this is complex, here's an explanation: //if there is no newline, then there is no guaranteed full line to //handle in the output. The exception is that it is supposed to handle //all the data, OR if there's been an error message found in the //partial data. if (lines.size() == 1 && !handleAll) { return; } if (handleAll) { m_stdOutData.clear(); } else { //because the last line might be incomplete we leave it for now //note, this last line may be an empty string if the stdoutdata ends //with a newline m_stdOutData = lines.takeLast(); } foreach(const QByteArray& line, lines) { if (!line.isEmpty()) { handleLine(QString::fromLocal8Bit(line)); } } } void CliInterface::handleLine(const QString& line) { if ((m_operationMode == Copy || m_operationMode == Add) && m_param.contains(CaptureProgress) && m_param.value(CaptureProgress).toBool()) { //read the percentage int pos = line.indexOf(QLatin1Char( '%' )); if (pos != -1 && pos > 1) { int percentage = line.mid(pos - 2, 2).toInt(); progress(float(percentage) / 100); return; } } if (m_operationMode == Copy) { if (checkForErrorMessage(line, WrongPasswordPatterns)) { kDebug() << "Wrong password!"; error(i18n("Incorrect password.")); setPassword(QString()); failOperation(); return; } if (checkForErrorMessage(line, ExtractionFailedPatterns)) { kDebug() << "Error in extraction!!"; error(i18n("Extraction failed because of an unexpected error.")); failOperation(); return; } if (handleFileExistsMessage(line)) { return; } } if (m_operationMode == List) { if (checkForErrorMessage(line, WrongPasswordPatterns)) { kDebug() << "Wrong password!"; error(i18n("Incorrect password.")); setPassword(QString()); failOperation(); return; } if (checkForErrorMessage(line, ExtractionFailedPatterns)) { kDebug() << "Error in extraction!!"; error(i18n("Extraction failed because of an unexpected error.")); failOperation(); return; } if (handleFileExistsMessage(line)) { return; } readListLine(line); return; } } bool CliInterface::checkForFileExistsMessage(const QString& line) { if (m_existsPattern.isEmpty()) { m_existsPattern.setPattern(m_param.value(FileExistsExpression).toString()); } if (m_existsPattern.indexIn(line) != -1) { kDebug() << "Detected file existing!! Filename " << m_existsPattern.cap(1); return true; } return false; } bool CliInterface::handleFileExistsMessage(const QString& line) { if (!checkForFileExistsMessage(line)) { return false; } const QString filename = m_existsPattern.cap(1); Kerfuffle::OverwriteQuery query(QDir::current().path() + QLatin1Char( '/' ) + filename); query.setNoRenameMode(true); userQuery(&query); kDebug() << "Waiting response"; query.waitForResponse(); kDebug() << "Finished response"; QString responseToProcess; const QStringList choices = m_param.value(FileExistsInput).toStringList(); if (query.responseOverwrite()) { responseToProcess = choices.at(0); } else if (query.responseSkip()) { responseToProcess = choices.at(1); } else if (query.responseOverwriteAll()) { responseToProcess = choices.at(2); } else if (query.responseAutoSkip()) { responseToProcess = choices.at(3); } else if (query.responseCancelled()) { responseToProcess = choices.at(4); } Q_ASSERT(!responseToProcess.isEmpty()); responseToProcess += QLatin1Char( '\n' ); - kDebug() << "Writing " << responseToProcess; - - m_process->write(responseToProcess.toLocal8Bit()); + writeToProcess(responseToProcess.toLocal8Bit()); return true; } bool CliInterface::checkForErrorMessage(const QString& line, int parameterIndex) { static QHash > patternCache; QList patterns; if (patternCache.contains(parameterIndex)) { patterns = patternCache.value(parameterIndex); } else { if (!m_param.contains(parameterIndex)) { return false; } foreach(const QString& rawPattern, m_param.value(parameterIndex).toStringList()) { patterns << QRegExp(rawPattern); } patternCache[parameterIndex] = patterns; } foreach(const QRegExp& pattern, patterns) { if (pattern.indexIn(line) != -1) { return true; } } return false; } bool CliInterface::doKill() { if (m_process) { m_process->kill(); return true; } return false; } bool CliInterface::doSuspend() { return false; } bool CliInterface::doResume() { return false; } void CliInterface::substituteListVariables(QStringList& params) { for (int i = 0; i < params.size(); ++i) { const QString parameter = params.at(i); if (parameter == QLatin1String( "$Archive" )) { params[i] = filename(); } } } QString CliInterface::escapedCharacters() { return m_escapedCharacters; } void CliInterface::setEscapedCharacters(const QString& characters) { m_escapedCharacters = characters; } QString CliInterface::escapeFileName(const QString& fileName) { QString quoted; const int len = fileName.length(); const QLatin1Char backslash('\\'); quoted.reserve(len * 2); for (int i = 0; i < len; ++i) { if (m_escapedCharacters.contains(fileName.at(i))) { quoted.append(backslash); } quoted.append(fileName.at(i)); } return quoted; } +void CliInterface::writeToProcess(const QByteArray& data) +{ + Q_ASSERT(m_process); + Q_ASSERT(!data.isNull()); + + kDebug() << "Writing" << data << "to the process"; + +#ifdef Q_OS_WIN + m_process->write(data); +#else + m_process->pty()->write(data); +#endif +} + } #include "cliinterface.moc" diff --git a/kerfuffle/cliinterface.h b/kerfuffle/cliinterface.h index de26d656..fbd73d81 100644 --- a/kerfuffle/cliinterface.h +++ b/kerfuffle/cliinterface.h @@ -1,306 +1,318 @@ /* * ark -- archiver for the KDE project * * Copyright (C) 2009 Harald Hvaal * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ( INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION ) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * ( INCLUDING NEGLIGENCE OR OTHERWISE ) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef CLIINTERFACE_H #define CLIINTERFACE_H #include "archiveinterface.h" #include "kerfuffle_export.h" #include #include class KProcess; +class KPtyProcess; namespace Kerfuffle { enum CliInterfaceParameters { ///////////////[ COMMON ]///////////// /** * Bool (default false) * Will look for the %-sign in the stdout while working, in the form of * (2%, 14%, 35%, etc etc), and report progress based upon this */ CaptureProgress = 0, ///////////////[ LIST ]///////////// /** * QString * The name to the program that will handle listing of this * archive (eg "rar"). Will be searched for in PATH */ ListProgram, /** * QStringList * The arguments that are passed to the program above for * listing the archive. Special strings that will be * substituted: * $Archive - the path of the archive */ ListArgs, ///////////////[ EXTRACT ]///////////// /** * QString * The name to the program that will handle extracting of this * archive (eg "rar"). Will be searched for in PATH */ ExtractProgram, /** * QStringList * The arguments that are passed to the program above for * extracting the archive. Special strings that will be * substituted: * $Archive - the path of the archive * $Files - the files selected to be extracted, if any * $PreservePathSwitch - the flag for extracting with full paths * $RootNodeSwitch - the internal work dir in the archive (for example * when the user has dragged a folder from the archive and wants it * extracted relative to it) * $PasswordSwitch - the switch setting the password. Note that this * will not be inserted unless the listing function has emitted an * entry with the IsPasswordProtected property set to true. */ ExtractArgs, /** * Bool (default false) * When passing directories to the extract program, do not * include trailing slashes * e.g. if the user selected "foo/" and "foo/bar" in the gui, the * paths "foo" and "foo/bar" will be sent to the program. */ NoTrailingSlashes, /** * QStringList * This should be a qstringlist with either two elements. The first * string is what PreservePathSwitch in the ExtractArgs will be replaced * with if PreservePath is True/enabled. The second is for the disabled * case. An empty string means that the argument will not be used in * that case. * Example: for rar, "x" means extract with full paths, and "e" means * extract without full paths. in this case we will use the stringlist * ("x", "e"). Or, for another format that might use the switch * "--extractFull" for preservePaths, and nothing otherwise: we use the * stringlist ("--preservePaths", "") */ PreservePathSwitch, /** * QStringList (default empty) * The format of the root node switch. The variable $Path will be * substituted for the path string. * Example: ("--internalPath=$Path) * or ("--path", "$Path") */ RootNodeSwitch, /** * QStringList (default empty) * The format of the root node switch. The variable $Password will be * substituted for the password string. NOTE: supplying passwords * through a virtual terminal is not supported (yet?), because this * is not cross platform compatible. As of KDE 4.3 there are no plans to * change this. * Example: ("-p$Password) * or ("--password", "$Password") */ PasswordSwitch, /** * QString * This is a regexp, defining how to recognize a "File already exists" * prompt when extracting. It should have one captured string, which is * the filename of the file/folder that already exists. */ FileExistsExpression, /** * int * This sets on what output channel the FileExistsExpression regex * should be applied on, in other words, on what stream the "file * exists" output will appear in. Values accepted: * 0 - Standard error, stderr (default) * 1 - Standard output, stdout */ FileExistsMode, /** * QStringList * The various responses that can be supplied as a response to the * "file exists" prompt. The various items are to be supplied in the * following order: * index 0 - Yes (overwrite) * index 1 - No (skip/do not overwrite) * index 2 - All (overwrite all) * index 3 - Cancel operation * index 4 - Do not overwrite any files (autoskip) */ FileExistsInput, ///////////////[ DELETE ]///////////// /** * QString * The name to the program that will handle deleting of elements in this * archive format (eg "rar"). Will be searched for in PATH */ DeleteProgram, /** * QStringList * The arguments that are passed to the program above for * deleting from the archive. Special strings that will be * substituted: * $Archive - the path of the archive * $Files - the files selected to be deleted */ DeleteArgs, /** * QStringList * Default: empty * A list of regexp patterns that will cause the extraction to exit * with a general fail message */ ExtractionFailedPatterns, /** * QStringList * Default: empty * A list of regexp patterns that will alert the user that the password * was wrong. */ WrongPasswordPatterns, ///////////////[ ADD ]///////////// /** * QString * The name to the program that will handle adding in this * archive format (eg "rar"). Will be searched for in PATH */ AddProgram, /** * QStringList * The arguments that are passed to the program above for * adding to the archive. Special strings that will be * substituted: * $Archive - the path of the archive * $Files - the files selected to be added */ AddArgs }; typedef QHash ParameterList; class KERFUFFLE_EXPORT CliInterface : public ReadWriteArchiveInterface { Q_OBJECT public: enum OperationMode { List, Copy, Add, Delete }; OperationMode m_operationMode; explicit CliInterface(QObject *parent, const QVariantList & args); virtual ~CliInterface(); virtual bool list(); virtual bool copyFiles(const QList & files, const QString & destinationDirectory, ExtractionOptions options); virtual bool addFiles(const QStringList & files, const CompressionOptions& options); virtual bool deleteFiles(const QList & files); virtual ParameterList parameterList() const = 0; virtual bool readListLine(const QString &line) = 0; bool doKill(); bool doSuspend(); bool doResume(); /** * Returns the list of characters which are preceded by a * backslash when a file name in an archive is passed to * a program. * * @see setEscapedCharacters(). */ QString escapedCharacters(); /** * Sets which characters will be preceded by a backslash when * a file name in an archive is passed to a program. * * @see escapedCharacters(). */ void setEscapedCharacters(const QString& characters); private: void substituteListVariables(QStringList& params); void cacheParameterList(); bool checkForFileExistsMessage(const QString& line); bool handleFileExistsMessage(const QString& filename); bool checkForErrorMessage(const QString& line, int parameterIndex); void handleLine(const QString& line); void failOperation(); /** * Run @p programName with the given @p arguments. * The method waits until @p programName is finished to exit. * * @param programName The program that will be run (not the whole path). * @param arguments A list of arguments that will be passed to the program. * * @return @c true if the program was found and the process ran correctly, * @c false otherwise. */ bool runProcess(const QString& programName, const QStringList& arguments); /** * Precedes the characters returned by escapedCharacters() with a * backslash in @p fileName. * * @param fileName String to escape. */ QString escapeFileName(const QString& fileName); + /** + * Wrapper around KProcess::write() or KPtyDevice::write(), depending on + * the platform. + */ + void writeToProcess(const QByteArray& data); + QByteArray m_stdOutData; bool m_userCancelled; QRegExp m_existsPattern; +#ifdef Q_OS_WIN KProcess *m_process; +#else + KPtyProcess *m_process; +#endif + QString m_program; ParameterList m_param; QVariantList m_removedFiles; QString m_escapedCharacters; private slots: void started(); void readStdout(bool handleAll = false); void processFinished(int exitCode, QProcess::ExitStatus exitStatus); }; } #endif /* CLIINTERFACE_H */