File indexing completed on 2024-09-29 12:04:15

 /*
   This file is part of the KDE libraries
   Copyright 1999 Waldo Bastian <bastian@kde.org>
   Copyright 2006 Allen Winter <winter@kde.org>
   Copyright 2006 Gregory S. Hayes <syncomm@kde.org>
   Copyright 2006 Jaison Lee <lee.jaison@gmail.com>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License version 2 as published by the Free Software Foundation.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #include "ksavefile.h"
 #include <KLocalizedString>
 #include <QDir>
 #include <QTemporaryFile>
 
 #include <sys/types.h>
 #include <sys/stat.h> // umask, fchmod
 #include <unistd.h> // fchown, fdatasync
 
 #include <stdlib.h>
 #include <errno.h>
 
 #include <config-kdelibs4support.h>
 
 #ifdef Q_OS_WIN
 #include <kde_file_win.h>
 #endif
 
 static int s_umask;
 
 // Read umask before any threads are created to avoid race conditions
 static int kStoreUmask()
 {
     mode_t tmp = 0;
     s_umask = umask(tmp);
     return umask(s_umask);
 }
 
 Q_CONSTRUCTOR_FUNCTION(kStoreUmask)
 
 class Q_DECL_HIDDEN KSaveFile::Private
 {
 public:
     QString realFileName; //The name of the end-result file
     QString tempFileName; //The name of the temp file we are using
 
     QFile::FileError error;
     QString errorString;
     bool needFinalize;
     bool directWriteFallback;
 
     Private()
         : error(QFile::NoError),
           needFinalize(false),
           directWriteFallback(false)
     {
     }
 };
 
 KSaveFile::KSaveFile()
     : d(new Private())
 {
 }
 
 KSaveFile::KSaveFile(const QString &filename)
     : d(new Private())
 {
     KSaveFile::setFileName(filename);
 }
 
 KSaveFile::~KSaveFile()
 {
     finalize();
 
     delete d;
 }
 
 bool KSaveFile::open(OpenMode flags)
 {
     if (isOpen()) {
         return false;
     }
     d->needFinalize = false;
 
     if (d->realFileName.isEmpty()) {
         d->error = QFile::OpenError;
         d->errorString = i18n("No target filename has been given.");
         return false;
     }
 
     if (!d->tempFileName.isNull()) {
 #if 0 // do not set an error here, this open() fails, but the file itself is without errors
         d->error = QFile::OpenError;
         d->errorString = i18n("Already opened.");
 #endif
         return false;
     }
 
     //Create our temporary file
     QTemporaryFile tempFile;
     tempFile.setAutoRemove(false);
     tempFile.setFileTemplate(d->realFileName + QLatin1String("XXXXXX.new"));
     if (!tempFile.open()) {
 #ifdef Q_OS_UNIX
         if (d->directWriteFallback && errno == EACCES) {
             QFile::setFileName(d->realFileName);
             if (QFile::open(flags)) {
                 d->tempFileName.clear();
                 d->error = QFile::NoError;
                 d->needFinalize = true;
                 return true;
             }
         }
 #endif
 
         // we only check here if the directory can be written to
         // the actual filename isn't written to, but replaced later
         // with the contents of our tempfile
         const QFileInfo fileInfo(d->realFileName);
         QDir parentDir = fileInfo.dir();
         if (!QFileInfo(parentDir.absolutePath()).isWritable()) {
             d->error = QFile::PermissionsError;
             d->errorString = i18n("Insufficient permissions in target directory.");
             return false;
         }
         d->error = QFile::OpenError;
         d->errorString = i18n("Unable to open temporary file.");
         return false;
     }
 
     // if we're overwriting an existing file, ensure temp file's
     // permissions are the same as existing file so the existing
     // file's permissions are preserved. this will succeed completely
     // only if we are the same owner and group - or allmighty root.
     QFileInfo fi(d->realFileName);
     if (fi.exists()) {
         //Qt apparently has no way to change owner/group of file :(
         if (fchown(tempFile.handle(), fi.ownerId(), fi.groupId())) {
             // failed to set user and group => try to restore group only.
             fchown(tempFile.handle(), -1, fi.groupId());
         }
 
         tempFile.setPermissions(fi.permissions());
     } else {
         fchmod(tempFile.handle(), 0666 & (~s_umask));
     }
 
     //Open oursleves with the temporary file
     QFile::setFileName(tempFile.fileName());
     if (!QFile::open(flags)) {
         tempFile.setAutoRemove(true);
         return false;
     }
 
     d->tempFileName = tempFile.fileName();
     d->error = QFile::NoError;
     d->errorString.clear();
     d->needFinalize = true;
     return true;
 }
 
 void KSaveFile::setFileName(const QString &filename)
 {
     d->realFileName = filename;
 
     // make absolute if needed
     if (QDir::isRelativePath(filename)) {
         d->realFileName = QDir::current().absoluteFilePath(filename);
     }
 
     const QFileInfo fileInfo(d->realFileName);
     QDir parentDir = fileInfo.dir();
 
     // follow symbolic link, if any
     d->realFileName = parentDir.canonicalPath() + QLatin1Char('/') + fileInfo.fileName();
 }
 
 QFile::FileError KSaveFile::error() const
 {
     if (d->error != QFile::NoError) {
         return d->error;
     } else {
         return QFile::error();
     }
 }
 
 QString KSaveFile::errorString() const
 {
     if (!d->errorString.isEmpty()) {
         return d->errorString;
     } else {
         return QFile::errorString();
     }
 }
 
 QString KSaveFile::fileName() const
 {
     return d->realFileName;
 }
 
 void KSaveFile::abort()
 {
     close();
     if (!d->tempFileName.isEmpty()) {
         QFile::remove(d->tempFileName); //non-static QFile::remove() does not work.
         d->needFinalize = false;
     }
 }
 
 #if HAVE_FDATASYNC
 #  define FDATASYNC fdatasync
 #else
 #  define FDATASYNC fsync
 #endif
 
 bool KSaveFile::finalize()
 {
     if (!d->needFinalize) {
         return false;
     }
     bool success = false;
 #ifdef Q_OS_UNIX
     static int extraSync = -1;
     if (extraSync < 0) {
         extraSync = getenv("KDE_EXTRA_FSYNC") != nullptr ? 1 : 0;
     }
     if (extraSync) {
         if (flush()) {
             Q_FOREVER {
             if (!FDATASYNC(handle()))
                 {
                     break;
                 }
                 if (errno != EINTR)
                 {
                     d->error = QFile::WriteError;
                     d->errorString = i18n("Synchronization to disk failed");
                     break;
                 }
             }
         }
     }
 #endif
 
     close();
 
     if (!d->tempFileName.isEmpty()) {
         if (error() != NoError) {
             QFile::remove(d->tempFileName);
         }
         //Qt does not allow us to atomically overwrite an existing file,
         //so if the target file already exists, there is no way to change it
         //to the temp file without creating a small race condition. So we use
         //the standard rename call instead, which will do the copy without the
         //race condition.
 #ifdef Q_OS_WIN
         else if (0 == kdewin32_rename(QFile::encodeName(d->tempFileName).constData(),
                                       QFile::encodeName(d->realFileName).constData())) {
 #else
         else if (0 == ::rename(QFile::encodeName(d->tempFileName).constData(),
                                QFile::encodeName(d->realFileName).constData())) {
 #endif
             d->error = QFile::NoError;
             d->errorString.clear();
             success = true;
         } else {
             d->error = QFile::OpenError;
             d->errorString = i18n("Error during rename.");
             QFile::remove(d->tempFileName);
         }
     } else { // direct overwrite
         success = true;
     }
     d->needFinalize = false;
 
     return success;
 }
 
 #undef FDATASYNC
 
 void KSaveFile::setDirectWriteFallback(bool enabled)
 {
     d->directWriteFallback = enabled;
 }
 
 bool KSaveFile::directWriteFallback() const
 {
     return d->directWriteFallback;
 }