File indexing completed on 2024-04-28 07:45:45

 /*
     This file is part of the KDE libraries
     SPDX-FileCopyrightText: 2008 Christian Ehrlicher <ch.ehrlicher@gmx.de>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "kmemfile_p.h"
 
 #ifndef QT_NO_SHAREDMEMORY
 
 #include <QCoreApplication>
 #include <QCryptographicHash>
 #include <QDir>
 #include <QFile>
 #include <QSharedMemory>
 
 class KMemFile::Private
 {
 public:
     struct sharedInfoData {
         int shmCounter;
         qint64 shmDataSize;
 
         sharedInfoData()
         {
             memset(this, 0, sizeof(*this));
         }
     };
     Private(KMemFile *_parent)
         : readWritePos(0)
         , shmDataSize(0)
         , parent(_parent)
     {
     }
 
     QString getShmKey(int iCounter = -1);
     static QString getShmKey(const QString &filename, int iCounter = -1);
     bool loadContentsFromFile();
     void close();
 
     QString filename;
     QSharedMemory shmInfo;
     QSharedMemory shmData;
     qint64 readWritePos;
     qint64 shmDataSize;
 
     KMemFile *parent;
 };
 
 QString KMemFile::Private::getShmKey(int iCounter)
 {
     return getShmKey(filename, iCounter);
 }
 
 QString KMemFile::Private::getShmKey(const QString &filename, int iCounter)
 {
     QByteArray tmp = QString(QDir(filename).canonicalPath() + QString::number(iCounter)).toUtf8();
     return QString::fromLatin1(QCryptographicHash::hash(tmp, QCryptographicHash::Sha1));
 }
 
 bool KMemFile::Private::loadContentsFromFile()
 {
     QFile f(filename);
     if (!f.exists()) {
         close();
         parent->setErrorString(QCoreApplication::translate("", "File %1 does not exist").arg(filename));
         return false;
     }
     if (!f.open(QIODevice::ReadOnly)) {
         close();
         parent->setErrorString(QCoreApplication::translate("", "Cannot open %1 for reading").arg(filename));
         return false;
     }
 
     sharedInfoData *infoPtr = static_cast<sharedInfoData *>(shmInfo.data());
 
     infoPtr->shmDataSize = f.size();
     shmData.setKey(getShmKey(infoPtr->shmCounter));
     if (!shmData.create(infoPtr->shmDataSize)) {
         close();
         parent->setErrorString(QCoreApplication::translate("", "Cannot create memory segment for file %1").arg(filename));
         return false;
     }
     shmData.lock();
     qint64 size = 0;
     qint64 bytesRead;
     char *data = static_cast<char *>(shmData.data());
     bytesRead = f.read(data, infoPtr->shmDataSize);
     if (bytesRead != infoPtr->shmDataSize) {
         close();
         parent->setErrorString(QCoreApplication::translate("", "Could not read data from %1 into shm").arg(filename));
         return false;
     }
     shmDataSize = size;
     shmData.unlock();
     return true;
 }
 
 void KMemFile::Private::close()
 {
     shmData.unlock();
     shmData.detach();
     shmInfo.unlock();
     shmInfo.detach();
     readWritePos = 0;
     shmDataSize = 0;
 }
 
 KMemFile::KMemFile(const QString &filename, QObject *parent)
     : QIODevice(parent)
     , d(new Private(this))
 {
     d->filename = filename;
 }
 
 KMemFile::~KMemFile()
 {
     close();
 }
 
 void KMemFile::close()
 {
     QIODevice::close();
     if (!isOpen()) {
         return;
     }
     d->close();
 }
 
 bool KMemFile::isSequential() const
 {
     return false;
 }
 
 bool KMemFile::open(OpenMode mode)
 {
     if (isOpen()) {
         QIODevice::open(mode);
         return false;
     }
 
     if (mode != QIODevice::ReadOnly) {
         setErrorString(QCoreApplication::translate("", "Only 'ReadOnly' allowed"));
         return false;
     }
 
     if (!QFile::exists(d->filename)) {
         setErrorString(QCoreApplication::translate("", "File %1 does not exist").arg(d->filename));
         return false;
     }
 
     QSharedMemory lock(QDir(d->filename).canonicalPath());
     lock.lock();
 
     Private::sharedInfoData *infoPtr;
     d->shmInfo.setKey(d->getShmKey());
     // see if it's already in memory
     if (!d->shmInfo.attach(QSharedMemory::ReadWrite)) {
         if (!d->shmInfo.create(sizeof(Private::sharedInfoData))) {
             lock.unlock();
             setErrorString(QCoreApplication::translate("", "Cannot create memory segment for file %1").arg(d->filename));
             return false;
         }
         d->shmInfo.lock();
         // no -> create it
         infoPtr = static_cast<Private::sharedInfoData *>(d->shmInfo.data());
         memset(infoPtr, 0, sizeof(Private::sharedInfoData));
         infoPtr->shmCounter = 1;
         if (!d->loadContentsFromFile()) {
             d->shmInfo.unlock();
             d->shmInfo.detach();
             lock.unlock();
             return false;
         }
     } else {
         d->shmInfo.lock();
         infoPtr = static_cast<Private::sharedInfoData *>(d->shmInfo.data());
         d->shmData.setKey(d->getShmKey(infoPtr->shmCounter));
         if (!d->shmData.attach(QSharedMemory::ReadOnly)) {
             if (!d->loadContentsFromFile()) {
                 d->shmInfo.unlock();
                 d->shmInfo.detach();
                 lock.unlock();
                 return false;
             }
         }
     }
     d->shmDataSize = infoPtr->shmDataSize;
     d->shmInfo.unlock();
     lock.unlock();
 
     setOpenMode(mode);
     return true;
 }
 
 bool KMemFile::seek(qint64 pos)
 {
     if (d->shmDataSize < pos) {
         setErrorString(QCoreApplication::translate("", "Cannot seek past eof"));
         return false;
     }
     d->readWritePos = pos;
     QIODevice::seek(pos);
     return true;
 }
 
 qint64 KMemFile::size() const
 {
     return d->shmDataSize;
 }
 
 qint64 KMemFile::readData(char *data, qint64 maxSize)
 {
     if ((openMode() & QIODevice::ReadOnly) == 0) {
         return -1;
     }
 
     qint64 maxRead = size() - d->readWritePos;
     qint64 bytesToRead = qMin(maxRead, maxSize);
     const char *src = static_cast<const char *>(d->shmData.data());
     memcpy(data, &src[d->readWritePos], bytesToRead);
     d->readWritePos += bytesToRead;
     return bytesToRead;
 }
 
 qint64 KMemFile::writeData(const char *, qint64)
 {
     return -1;
 }
 
 void KMemFile::fileContentsChanged(const QString &filename)
 {
     QSharedMemory lock(QDir(filename).canonicalPath());
     lock.lock();
 
     QSharedMemory shmData(Private::getShmKey(filename));
     if (!shmData.attach()) {
         return;
     }
     shmData.lock();
     Private::sharedInfoData *infoPtr = static_cast<Private::sharedInfoData *>(shmData.data());
     infoPtr->shmCounter++;
     infoPtr->shmDataSize = 0;
     shmData.unlock();
 }
 
 #endif // QT_NO_SHAREDMEMORY
 
 #include "moc_kmemfile_p.cpp"