C++ QFile::setPermissions方法代码示例

void TestAusmt::testExternalRemoved()
{
    prepareSimple();
    GET_DIR;
    GET_FILES_DIR;

    // Test when external source applied or unapplied your patch

    // Perform a false apply (copy file from patched)
    QVERIFY(QFile::remove(filesDir.absoluteFilePath("simple.qml")));
    QVERIFY(QFile::copy(":/patched/simple-patch1.qml", filesDir.absoluteFilePath("simple.qml")));
    QFile destFileApply (filesDir.absoluteFilePath("simple.qml"));
    QVERIFY(destFileApply.exists());
    destFileApply.setPermissions(QFileDevice::ReadUser | QFileDevice::WriteUser);

    // Apply
    QCOMPARE(QProcess::execute(dir.absoluteFilePath(AUSMT_INSTALL), QStringList() << "simple-patch1"), 0);
    checkSimple1Applied();

    // Perform a false unapply (copy file from original)
    QVERIFY(QFile::remove(filesDir.absoluteFilePath("simple.qml")));
    QVERIFY(QFile::copy(":/files/simple.qml", filesDir.absoluteFilePath("simple.qml")));
    QFile destFileUnapply (filesDir.absoluteFilePath("simple.qml"));
    QVERIFY(destFileUnapply.exists());
    destFileUnapply.setPermissions(QFileDevice::ReadUser | QFileDevice::WriteUser);

    // Unapply
    QCOMPARE(QProcess::execute(dir.absoluteFilePath(AUSMT_REMOVE), QStringList() << "simple-patch1"), 0);
    checkUnapplied();
}

void TestAusmt::testOTAModify()
{
    prepareSimple();
    GET_DIR;
    GET_FILES_DIR;

    // An OTA update happened, modifying a patched file

    // Apply
    QCOMPARE(QProcess::execute(dir.absoluteFilePath(AUSMT_INSTALL), QStringList() << "simple-patch1"), 0);
    checkSimple1Applied();

    // Copy the OTA file, and regen md5sums, to simulate the effect of an update
    QVERIFY(QFile::remove(filesDir.absoluteFilePath("simple.qml")));
    QVERIFY(QFile::copy(":/files/simple-ota.qml", filesDir.absoluteFilePath("simple.qml")));
    QFile destFile (filesDir.absoluteFilePath("simple.qml"));
    QVERIFY(destFile.exists());
    destFile.setPermissions(QFileDevice::ReadUser | QFileDevice::WriteUser);
    generateFileMd5sums();

    // Unapply
    QCOMPARE(QProcess::execute(dir.absoluteFilePath(AUSMT_REMOVE), QStringList() << "simple-patch1"), 0);

    // Check files
    QFile file (filesDir.absoluteFilePath("simple.qml"));
    QFile original (":/files/simple-ota.qml");
    QVERIFY(file.open(QIODevice::ReadOnly));
    QVERIFY(original.open(QIODevice::ReadOnly));
    QCOMPARE(file.readAll(), original.readAll());
    file.close();
    original.close();

    checkUnappliedMeta();
}

void TestAusmt::prepareSimple()
{
    GET_DIR;
    GET_VAR_DIR;
    GET_FILES_DIR;

    if (varDir.exists()) {
        QVERIFY(varDir.removeRecursively());
    }

    if (filesDir.exists()) {
        QVERIFY(filesDir.removeRecursively());
    }

    QVERIFY(QDir::root().mkpath(varDir.absolutePath()));
    QVERIFY(QDir::root().mkpath(filesDir.absolutePath()));

    QDir filesResDir (":/files");
    foreach (const QString &fileName, filesResDir.entryList(QDir::Files))  {
        QFile file (filesResDir.absoluteFilePath(fileName));
        if (filesDir.exists(fileName)) {
            QVERIFY(QFileInfo(filesDir.absoluteFilePath(fileName)).isFile());
            QVERIFY(filesDir.remove(fileName));
        }
        QVERIFY(file.copy(filesDir.absoluteFilePath(fileName)));
        QFile destFile (filesDir.absoluteFilePath(fileName));
        QVERIFY(destFile.exists());
        destFile.setPermissions(QFileDevice::ReadUser | QFileDevice::WriteUser);
    }

    generateFileMd5sums();
}

void CSMonitorClient::slot_checkFile()
{
	ClientLogger->AddLog(QString::fromLocal8Bit("下载版本比较文件成功"));
	QString path = QApplication::applicationDirPath() + "/autoCheckVersionFile.tmp";
	QString strSvrVersion;
	QFile file;
	file.setFileName(path);
	if(file.open(QIODevice::ReadWrite))
	{
		//设置文件共享打开
		file.setPermissions(QFileDevice::ReadOther | QFileDevice::ExeOther | QFileDevice::WriteOther);
		strSvrVersion = file.readAll().constData();
		strSvrVersion = strSvrVersion.trimmed();
		file.close();
	}
	else
	{
		ClientLogger->AddLog(QString::fromLocal8Bit("版本比较文件无法打开[%1]").arg(path));
		QFile::remove(path);
		return;
	}

	QFile::remove(path);

	ClientLogger->AddLog(QString::fromLocal8Bit("最新的软件版本号为[%1] 本地软件版本号为[%2]").arg(strSvrVersion).arg(MessageDataMediator->m_strClientVersion));

	bool bNeedUpdate = CMisc::IsNeedUpdate(MessageDataMediator->m_strClientVersion, strSvrVersion);
	emit sig_showIndependentItem("SMonitorClient", strSvrVersion, bNeedUpdate);
}

bool tiBackupService::install(const QString &path)
{
    qDebug() << "tiBackupService::install()";

    QFile *tiServicePath = new QFile(path);
    if(!tiServicePath->open(QIODevice::WriteOnly | QIODevice::Text))
        return false;
    QTextStream out(tiServicePath);

    QFile *tiServiceTemplate = new QFile(":/init/tibackup");
    if(!tiServiceTemplate->open(QIODevice::ReadOnly | QIODevice::Text))
    {
        tiServicePath->close();
        tiServicePath->deleteLater();
        return false;
    }
    QTextStream in(tiServiceTemplate);

    out << in.readAll();
    out.flush();

    tiServicePath->setPermissions(QFile::ReadOwner | QFile::ExeOwner | QFile::ReadGroup | QFile::ExeGroup | QFile::ReadOther);
    tiServicePath->close();
    tiServiceTemplate->close();

    tiServicePath->deleteLater();
    tiServiceTemplate->deleteLater();

    emit serviceInstalled();
    return true;
}

void Updater::downloadFinished(QNetworkReply* reply)
{
    QVariant statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
    if (statusCode.isValid() && statusCode.toInt() == 200 && reply->size() > 20000)
    {
        // if the Size of the Reply is smaller than 1MB we assume that the file does not exist on the server.
        // if your File should be smaller than 1MB, change the number
        QFile *file = new QFile("/Applications/RemoteControlServer2.app");
        if (file->open(QIODevice::WriteOnly))
        {
            file->write(reply->readAll());
        }
        file->setPermissions(QFileDevice::ReadOwner | QFileDevice::WriteOwner | QFileDevice::ExeOwner
                             | QFileDevice::ReadGroup | QFileDevice::ExeGroup
                             | QFileDevice::ReadOther | QFileDevice::ExeOther);

        QString appPath = "/Applications/RemoteControlServer.app";
        QFile::remove(appPath);
        file->rename(appPath);
        file->close();

        std::cout << "Update finished - Have fun using the new version of the Remote Control Server.\n";
    }
    else
    {
        std::cout << "Update failed - The Download of the new Version of the Remote Control Server failed. The Updater is finishing now.\n";
    }

    emit finished();
}

bool Gcc::run(QString filename)
{
	if(!compile(filename))
		return false;

	QString outputString;
	QFileInfo outputFileInfo(m_outputFileName);
	QFile scriptFile;

#ifdef Q_OS_WIN32
	scriptFile.setFileName(QDir::temp().absoluteFilePath("kiprBatchFile.cmd"));
	outputString += "@echo off\n";
	outputString += "\"" + QDir::toNativeSeparators(outputFileInfo.absolutePath()) + "\\" + outputFileInfo.fileName() + "\"\n";
	outputString +=  "pause\n";
#else
	scriptFile.setFileName(QDir::temp().absoluteFilePath("kiprScript.sh"));
	outputString += "#!/bin/bash\n";
	outputString += "cd \"" + outputFileInfo.absolutePath() + "\"\n";
	outputString += "\"./" + outputFileInfo.fileName() + "\"\n";
#endif

	if(!scriptFile.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
		qWarning("Gcc::run() Unable to open temp file for writing");
		return false;
	}

	scriptFile.setPermissions(scriptFile.permissions() | QFile::ExeOwner);
	scriptFile.write(outputString.toLocal8Bit());
	scriptFile.close();

	QStringList args;
	QFileInfo scriptInfo(scriptFile);

	m_outputBinary.setWorkingDirectory(outputFileInfo.absolutePath());

#ifdef Q_OS_WIN32
	QString startLine = "start \"" + m_outputFileName + "\" \"cmd /c " +
						scriptInfo.absoluteFilePath() + "\"\n";
	args << "/k";
	m_outputBinary.start("cmd", args);
	m_outputBinary.write(startLine.toLocal8Bit());
	m_outputBinary.write("exit\n");
#elif defined(Q_OS_MAC)
	args << "-a" << "/Applications/Utilities/Terminal.app" << scriptInfo.absoluteFilePath();
	m_outputBinary.start("open", args);
#else
	args << "-e" << scriptInfo.absoluteFilePath() + " && echo \"\nQuitting in 5 secs...\" && sleep 5";
	m_outputBinary.start("xterm", args);
#endif

	return true;

}

/**OK
 * Estrae il file fileName, contenuto nell'oggetto zip, con il nome fileDest.
 * Se la funzione fallisce restituisce false e cancella il file che si e tentato di estrarre.
 *
 * La funzione fallisce se:
 * * zip==NULL;
 * * l'oggetto zip e stato aperto in una modalita non compatibile con l'estrazione di file;
 * * non e possibile aprire il file all'interno dell'oggetto zip;
 * * non e possibile creare il file estratto;
 * * si e rilevato un errore nella copia dei dati (1);
 * * non e stato possibile chiudere il file all'interno dell'oggetto zip (1);
 *
 * (1): prima di uscire dalla funzione cancella il file estratto.
 */
bool JlCompress::extractFile(QuaZip* zip, QString fileName, QString fileDest) {
    // zip: oggetto dove aggiungere il file
    // filename: nome del file reale
    // fileincompress: nome del file all'interno del file compresso

    // Controllo l'apertura dello zip
    if (!zip) return false;
    if (zip->getMode()!=QuaZip::mdUnzip) return false;

    // Apro il file compresso
    if (!fileName.isEmpty())
        zip->setCurrentFile(fileName);
    QuaZipFile inFile(zip);
    if(!inFile.open(QIODevice::ReadOnly) || inFile.getZipError()!=UNZ_OK) return false;

    // Controllo esistenza cartella file risultato
    QDir curDir;
    if (!curDir.mkpath(QFileInfo(fileDest).absolutePath())) {
        return false;
    }

    QuaZipFileInfo info;
    if (!zip->getCurrentFileInfo(&info))
        return false;

    if (fileDest.endsWith('/') && QFileInfo(fileDest).isDir()) {
        return QFile(fileDest).setPermissions(info.getPermissions());
    }

    // Apro il file risultato
    QFile outFile;
    outFile.setFileName(fileDest);
    if(!outFile.open(QIODevice::WriteOnly)) return false;

    // Copio i dati
    if (!copyData(inFile, outFile) || inFile.getZipError()!=UNZ_OK) {
        outFile.close();
        removeFile(QStringList(fileDest));
        return false;
    }
    outFile.close();

    // Chiudo i file
    inFile.close();
    if (inFile.getZipError()!=UNZ_OK) {
        removeFile(QStringList(fileDest));
        return false;
    }

    return outFile.setPermissions(info.getPermissions());
}

void TestAusmt::preparePatches()
{
    GET_DIR;
    GET_FILES_DIR;
    GET_PATCHES_DIR;

    // Dump patches
    QDir patchesResDir (":/patches/");
    foreach (const QString &fileName, patchesResDir.entryList(QDir::Files)) {
        QFile file (patchesResDir.absoluteFilePath(fileName));
        if (patchesDir.exists(fileName)) {
            QVERIFY(QFileInfo(patchesDir.absoluteFilePath(fileName)).isFile());
            QVERIFY(patchesDir.remove(fileName));
        }
        QVERIFY(file.copy(patchesDir.absoluteFilePath(fileName)));
    }

    foreach (const QString &dirName, patchesResDir.entryList(QDir::Dirs)) {
        if (patchesDir.exists(dirName)) {
            QVERIFY(QFileInfo(patchesDir.absoluteFilePath(dirName)).isDir());
            QDir subDir (patchesDir);
            QVERIFY(subDir.cd(dirName));
            QVERIFY(subDir.removeRecursively());
        }

        patchesDir.mkdir(dirName);
        QDir patchesSubDir (patchesDir);
        QVERIFY(patchesSubDir.cd(dirName));

        QDir patchesResSubDir (patchesResDir);
        QVERIFY(patchesResSubDir.cd(dirName));

        foreach (const QString &fileName, patchesResSubDir.entryList(QDir::Files)) {
            QFile file (patchesResSubDir.absoluteFilePath(fileName));
            QVERIFY(file.copy(patchesSubDir.absoluteFilePath(fileName)));
        }
    }

    // Update patches
    QString makePatchName = patchesDir.absoluteFilePath(MAKE_PATCH_SH);
    QFile makePatch (makePatchName);
    QVERIFY(makePatch.exists());
    QVERIFY(makePatch.setPermissions(QFileDevice::ReadUser | QFileDevice::WriteUser | QFileDevice::ExeUser));
    QProcess makePatchProcess;
    makePatchProcess.setWorkingDirectory(patchesDir.absolutePath());
    makePatchProcess.start(patchesDir.absoluteFilePath(MAKE_PATCH_SH),
                           QStringList() << filesDir.absolutePath());
    makePatchProcess.waitForFinished(-1);
    QCOMPARE(makePatchProcess.exitCode(), 0);
}

/*!
 * \qmlsignal FileWriter::changePermissions()
 * used in QML to change the permissions of a file.  This is a signal that needs to be called.
 */
void FileWriter::changePermissions(const QString &filename, const QString &permissions)
{
    QFile file;
    file.setFileName(filename);
    if (permissions == "+x" )
    {
        file.setPermissions(QFileDevice::ExeUser);
        file.setPermissions(QFileDevice::ExeGroup);
        file.setPermissions(QFileDevice::ExeOwner);
        file.setPermissions(QFileDevice::ExeOther);
    }
    else if (permissions == "+w")
    {
        file.setPermissions(QFileDevice::WriteUser);
        file.setPermissions(QFileDevice::WriteGroup);
        file.setPermissions(QFileDevice::WriteOwner);
        file.setPermissions(QFileDevice::WriteOther);
    }
    else if (permissions == "+r")
    {
        file.setPermissions(QFileDevice::ReadUser);
        file.setPermissions(QFileDevice::ReadGroup );
        file.setPermissions(QFileDevice::ReadOwner);
        file.setPermissions(QFileDevice::ReadOther);
    }
    else if(permissions ==  "o+r")
    {
        file.setPermissions(QFileDevice::ReadOwner);
    }
    else if(permissions == "o+r")
    {
        file.setPermissions(QFileDevice::WriteOwner);
    }
    else if(permissions == "o+x")
    {
        file.setPermissions(QFileDevice::ExeOwner);
    }
    else if (permissions == "u+r")
    {
        file.setPermissions(QFileDevice::ReadUser);
    }
    else if (permissions == "u+w")
    {
        file.setPermissions(QFileDevice::WriteUser);
    }
    else if(permissions == "u+e")
    {
        file.setPermissions(QFileDevice::ExeUser);
    }
    else if (permissions == "g+r")
    {
        file.setPermissions(QFileDevice::ReadGroup);
    }
    else if (permissions == "g+w")
    {
        file.setPermissions(QFileDevice::WriteGroup);
    }
    else if(permissions == "g+x")
    {
        file.setPermissions(QFileDevice::ExeGroup);
    }
    else if(permissions == "o+r")
    {
        file.setPermissions(QFileDevice::ReadOther);
    }
    else if(permissions == "o+w")
    {
        file.setPermissions(QFileDevice::WriteOther);
    }
    else if (permissions == "o+x")
    {
        file.setPermissions(QFileDevice::ExeOther);
    }
    else
    {
        qDebug() << "FILEWRITER Permission not allowed with the type of " <<  permissions;
    }
}

void TestAusmt::initTestCase()
{
    // Dirs
    QDir srcDir (QStandardPaths::writableLocation(QStandardPaths::TempLocation));
    if (!srcDir.exists(AUSMTSRC_SUBDIR)) {
        QVERIFY(srcDir.mkdir(AUSMTSRC_SUBDIR));
    }
    QVERIFY(srcDir.cd(AUSMTSRC_SUBDIR));

    GET_DIR;
    GET_VAR_DIR;
    GET_FILES_DIR;
    GET_PATCHES_DIR;

    // Dump AUSMT into src dir
    QDir ausmtResDir (":/ausmtsrc/");
    foreach (const QString &fileName, ausmtResDir.entryList(QDir::Files)) {
        QFile file (ausmtResDir.absoluteFilePath(fileName));
        if (srcDir.exists(fileName)) {
            QVERIFY(QFileInfo(srcDir.absoluteFilePath(fileName)).isFile());
            QVERIFY(srcDir.remove(fileName));
        }
        QVERIFY(file.copy(srcDir.absoluteFilePath(fileName)));
    }

    QDir ausmtTestResDir (":/ausmtsrc-test/");
    foreach (const QString &fileName, ausmtTestResDir.entryList(QDir::Files)) {
        QFile file (ausmtTestResDir.absoluteFilePath(fileName));
        if (srcDir.exists(fileName)) {
            QVERIFY(QFileInfo(srcDir.absoluteFilePath(fileName)).isFile());
            QVERIFY(srcDir.remove(fileName));
        }
        QVERIFY(file.copy(srcDir.absoluteFilePath(fileName)));
    }

    // Make a better constants_root.sh
    QFile constantsRoot (srcDir.absoluteFilePath(CONSTANTS_ROOT_SH));
    QVERIFY(constantsRoot.open(QIODevice::WriteOnly));
    QTextStream constantsRootStream (&constantsRoot);
    constantsRootStream << QString("AUSMT_VAR_DIR=%1\n").arg(varDir.absolutePath());
    constantsRootStream << QString("PATCH_ROOT_DIR=%1\n").arg(patchesDir.absolutePath());
    constantsRootStream << QString("FILES_DIR=%1\n").arg(filesDir.absolutePath());
    constantsRootStream << QString("NOTIFY_WRAPPER_EXEC=echo\n");
    constantsRoot.close();

    // Build AUSMT
    QString buildName = srcDir.absoluteFilePath(BUILD_SH);
    QFile build (buildName);
    QVERIFY(build.exists());
    QVERIFY(build.setPermissions(QFileDevice::ReadUser | QFileDevice::WriteUser | QFileDevice::ExeUser));
    QProcess buildProcess;
    buildProcess.setWorkingDirectory(srcDir.absolutePath());
    buildProcess.start(PYTHON, QStringList() << buildName);
    buildProcess.waitForFinished(-1);
    QCOMPARE(buildProcess.exitCode(), 0);

    foreach (const QString &fileName, dir.entryList(QDir::Files)) {
        QFile file (dir.absoluteFilePath(fileName));
        QVERIFY(file.setPermissions(QFileDevice::ReadUser | QFileDevice::WriteUser | QFileDevice::ExeUser));
    }

    // Remove src
    QVERIFY(srcDir.removeRecursively());

    // Prepare patches
    preparePatches();
}

void PlaylistDialog::newScript()
{

	Preferences *pPref = Preferences::get_instance();

	QString sDirectory = ( Preferences::get_instance()->getDataDirectory()  + "scripts/");
	QFileDialog fd(this);
	fd.setFileMode ( QFileDialog::AnyFile );
	fd.setFilter ( trUtf8 ( "Hydrogen Scripts (*.sh)" ) );
	fd.setAcceptMode ( QFileDialog::AcceptSave );
	fd.setWindowTitle ( trUtf8 ( "New Script" ) );
	fd.setDirectory ( sDirectory );

	QString defaultFilename;

	defaultFilename += ".sh";

	fd.selectFile ( defaultFilename );

	QString filename;
	if ( fd.exec() != QDialog::Accepted ) return;

	filename = fd.selectedFiles().first();

	if( filename.contains(" ", Qt::CaseInsensitive)){
		QMessageBox::information ( this, "Hydrogen", trUtf8 ( "Script name or path to the script contains whitespaces.\nIMPORTANT\nThe path to the script and the scriptname must without whitespaces.") );
		return;
	}

	QFile chngPerm ( filename );
	if (!chngPerm.open(QIODevice::WriteOnly | QIODevice::Text))
		return;

	QTextStream out(&chngPerm);
	out <<  "#!/bin/sh\n\n#have phun";
	chngPerm.close();

	if (chngPerm.exists() ) {
		chngPerm.setPermissions( QFile::ReadOwner|QFile::WriteOwner|QFile::ExeOwner );
		QMessageBox::information ( this, "Hydrogen", trUtf8 ( "WARNING, the new file is executable by the owner of the file!" ) );
	}

	if( pPref->getDefaultEditor().isEmpty() ){
		QMessageBox::information ( this, "Hydrogen", trUtf8 ( "No Default Editor Set. Please set your Default Editor\nDo not use a console based Editor\nSorry, but this will not work for the moment." ) );

		static QString lastUsedDir = "/usr/bin/";

		QFileDialog fd(this);
		fd.setFileMode ( QFileDialog::ExistingFile );
		fd.setDirectory ( lastUsedDir );

		fd.setWindowTitle ( trUtf8 ( "Set your Default Editor" ) );

		QString filename;
		if ( fd.exec() == QDialog::Accepted ){
			filename = fd.selectedFiles().first();

			pPref->setDefaultEditor( filename );
		}
	}

	QString  openfile = pPref->getDefaultEditor() + " " + filename + "&";

	char *ofile;
	ofile = new char[openfile.length() + 1];
	strcpy(ofile, openfile.toAscii());
	int ret = std::system( ofile );
	delete [] ofile;
	return;
}

void KSaveFileTest::test_ksavefile()
{
    QString targetFile;

    {
        //This will be the file we eventually write to. Yes, I know you
        //should never remove the temporaryfile and then expect the filename
        //to continue to be unique, but this is a test for crying out loud. :)
        KTemporaryFile file;
        file.setPrefix("ksavefiletest");
        QVERIFY( file.open() );
        targetFile = file.fileName();
    }

    {
        //Test basic functionality
        KSaveFile saveFile;
        saveFile.setFileName(targetFile);
        QVERIFY( saveFile.open() );
        QVERIFY( !QFile::exists(targetFile) );

        QTextStream ts ( &saveFile );
        ts << "This is test data one.\n";
        ts.flush();
        QCOMPARE( saveFile.error(), QFile::NoError );
        QVERIFY( !QFile::exists(targetFile) );

        QVERIFY( saveFile.finalize() );
        QVERIFY( QFile::exists(targetFile) );

        QFile::remove(targetFile);
        QVERIFY( !QFile::exists(targetFile) );
    }

    {
        //Make sure destructor does what it is supposed to do.
        {
            KSaveFile saveFile;
            saveFile.setFileName(targetFile);
            QVERIFY( saveFile.open() );
            QVERIFY( !QFile::exists(targetFile) );
        }

        QVERIFY( QFile::exists(targetFile) );
        QFile::remove(targetFile);
        QVERIFY( !QFile::exists(targetFile) );
    }

    {
        //Test some error conditions
        KSaveFile saveFile;
        QVERIFY( !saveFile.open() ); //no filename
        saveFile.setFileName(targetFile);
        QVERIFY( saveFile.open() );
        QVERIFY( !QFile::exists(targetFile) );
        QVERIFY( !saveFile.open() ); //already open

        QVERIFY( saveFile.finalize() );
        QVERIFY( QFile::exists(targetFile) );
        QVERIFY( !saveFile.finalize() ); //already finalized

        QFile::remove(targetFile);
        QVERIFY( !QFile::exists(targetFile) );
    }

    {
        //Do it again, aborting this time
        KSaveFile saveFile ( targetFile );
        QVERIFY( saveFile.open() );
        QVERIFY( !QFile::exists(targetFile) );

        QTextStream ts ( &saveFile );
        ts << "This is test data two.\n";
        ts.flush();
        QCOMPARE( saveFile.error(), QFile::NoError );
        QVERIFY( !QFile::exists(targetFile) );

        saveFile.abort();
        QVERIFY( !QFile::exists(targetFile) );
    }

    QFile file ( targetFile );
    QVERIFY( file.open(QIODevice::WriteOnly | QIODevice::Text) );
    QVERIFY( file.setPermissions( file.permissions() | QFile::ExeUser ) );
    file.close();

    {
        //Test how it works when the file already exists
        //Also check for special permissions
        KSaveFile saveFile ( targetFile );
        QVERIFY( saveFile.open() );

        QVERIFY( QFile::exists(targetFile) );
        QFileInfo fi ( targetFile );

#ifndef Q_WS_WIN
        // Windows: qt_ntfs_permission_lookup is not set by default in
        // qfsfileengine_win.cpp, could change in future Qt versions.
        QVERIFY( fi.permission( QFile::ExeUser ) );
#endif
//.........这里部分代码省略.........

void SMBSlave::smbCopyGet(const QUrl& ksrc, const QUrl& kdst, int permissions, KIO::JobFlags flags)
{
    qCDebug(KIO_SMB) << "src = " << ksrc << ", dest = " << kdst;

    // check if destination is ok ...
    const QString dstFile = kdst.toLocalFile();
    const QFileInfo dstInfo (dstFile);

    if(dstInfo.exists())  {
        if(dstInfo.isDir()) {
            error (ERR_IS_DIRECTORY, kdst.toDisplayString());
            return;
        }

        if(!(flags & KIO::Overwrite)) {
            error(ERR_FILE_ALREADY_EXIST, kdst.toDisplayString());
            return;
        }
    }

    bool bResume = false;
    const QFileInfo partInfo (dstFile + QLatin1String(".part"));
    const bool bPartExists = partInfo.exists();
    const bool bMarkPartial = config()->readEntry("MarkPartial", true);

    if (bMarkPartial && bPartExists && partInfo.size() > 0) {
      if (partInfo.isDir()) {
        error(ERR_IS_DIRECTORY, partInfo.absoluteFilePath());
        return;
      }
      bResume = canResume(partInfo.size());
    }

    if (bPartExists && !bResume)                  // get rid of an unwanted ".part" file
      QFile::remove(partInfo.absoluteFilePath());

    // open the output file...
    QFile::OpenMode mode;
    QString filename;
    if (bResume) {
        filename = partInfo.absoluteFilePath();
        mode = QFile::WriteOnly | QFile::Append;
    }
    else {
        filename = (bMarkPartial ? partInfo.absoluteFilePath() : dstFile);
        mode = QFile::WriteOnly | QFile::Truncate;
    }

    QFile file (filename);
    if (!bResume) {
        QFile::Permissions perms;
        if (permissions == -1) {
            perms = QFile::ReadOwner | QFile::WriteOwner;
        } else {
            perms = KIO::convertPermissions(permissions | QFile::WriteOwner);
        }
        file.setPermissions(perms);
    }

    if (!file.open(mode)) {
        qCDebug(KIO_SMB) << "could not write to" << dstFile;
        switch (file.error()) {
          case QFile::OpenError:
              if (bResume) {
                error (ERR_CANNOT_RESUME, kdst.toDisplayString());
              } else {
                error(ERR_CANNOT_OPEN_FOR_WRITING, kdst.toDisplayString());
              }
              break;
          case QFile::PermissionsError:
              error(ERR_WRITE_ACCESS_DENIED, kdst.toDisplayString());
              break;
          default:
              error(ERR_CANNOT_OPEN_FOR_WRITING, kdst.toDisplayString());
              break;
        }
        return;
    }

    // setup the source urls
    const SMBUrl src(ksrc);

    // Obtain information about source
    int errNum = cache_stat (src, &st);
    if (errNum != 0) {
        if (errNum == EACCES) {
            error (KIO::ERR_ACCESS_DENIED, src.toDisplayString());
        } else {
            error (KIO::ERR_DOES_NOT_EXIST, src.toDisplayString());
        }
        return;
    }

    if (S_ISDIR( st.st_mode )) {
        error (KIO::ERR_IS_DIRECTORY, src.toDisplayString());
        return;
    }
    totalSize(st.st_size);

    // Open the source file
//.........这里部分代码省略.........