src/LockedFile.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // LameXP - Audio Encoder Front-End
   3 // Copyright (C) 2004-2015 LoRd_MuldeR <MuldeR2@GMX.de>
   4 //
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 2 of the License, or
   8 // (at your option) any later version, but always including the *additional*
   9 // restrictions defined in the "License.txt" file.
  10 //
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License along
  17 // with this program; if not, write to the Free Software Foundation, Inc.,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20 // http://www.gnu.org/licenses/gpl-2.0.txt
  21 ///////////////////////////////////////////////////////////////////////////////
  22
  23 #include "LockedFile.h"
  24
  25 //Internal
  26 #include "Global.h"
  27 #include "FileHash.h"
  28
  29 //MUtils
  30 #include <MUtils/OSSupport.h>
  31 #include <MUtils/Exception.h>
  32
  33 //Qt
  34 #include <QResource>
  35 #include <QFile>
  36 #include <QFileInfo>
  37 #include <QDir>
  38 #include <QCryptographicHash>
  39
  40 //CRT
  41 #include <stdio.h>
  42 #include <io.h>
  43 #include <fcntl.h>
  44 #include <stdexcept>
  45
  46 //Windows includes
  47 #define NOMINMAX
  48 #define WIN32_LEAN_AND_MEAN
  49 #include <Windows.h>
  50
  51 ///////////////////////////////////////////////////////////////////////////////
  52
  53 // WARNING: Passing file descriptors into Qt does NOT work with dynamically linked CRT!
  54 #ifdef QT_NODLL
  55         static const bool g_useFileDescrForQFile = true;
  56 #else
  57         static const bool g_useFileDescrForQFile = false;
  58 #endif
  59
  60 #define VALID_HANDLE(H) (((H) != NULL) && ((H) != INVALID_HANDLE_VALUE))
  61
  62 static void CLOSE_HANDLE(HANDLE &h)
  63 {
  64         if(VALID_HANDLE(h))
  65         {
  66                 CloseHandle(h);
  67                 h = NULL;
  68         }
  69 }
  70
  71 ///////////////////////////////////////////////////////////////////////////////
  72
  73 static __forceinline void doWriteOutput(QFile &outFile, const QResource *const resource)
  74 {
  75         for(int i = 0; i < 64; i++)
  76         {
  77                 if(outFile.open(QIODevice::WriteOnly))
  78                 {
  79                         break;
  80                 }
  81                 if(i == 0)
  82                 {
  83                         qWarning("Failed to open file on first attemp, retrying...");
  84                 }
  85                 Sleep(25);
  86         }
  87
  88         //Write data to file
  89         if(outFile.isOpen() && outFile.isWritable())
  90         {
  91                 if(outFile.write(reinterpret_cast<const char*>(resource->data()), resource->size()) != resource->size())
  92                 {
  93                         QFile::remove(QFileInfo(outFile).canonicalFilePath());
  94                         MUTILS_THROW_FMT("File '%s' could not be written!", MUTILS_UTF8(QFileInfo(outFile).fileName()));
  95                 }
  96         }
  97         else
  98         {
  99                 MUTILS_THROW_FMT("File '%s' could not be created!", MUTILS_UTF8(QFileInfo(outFile).fileName()));
 100         }
 101
 102         //Close file after it has been written
 103         outFile.close();
 104 }
 105
 106 static __forceinline void doValidateFileExists(const QString &filePath)
 107 {
 108         QFileInfo existingFileInfo(filePath);
 109         existingFileInfo.setCaching(false);
 110
 111         //Make sure the file exists, before we try to lock it
 112         if((!existingFileInfo.exists()) || (!existingFileInfo.isFile()) || filePath.isEmpty())
 113         {
 114                 MUTILS_THROW_FMT("File '%s' does not exist!", MUTILS_UTF8(filePath));
 115         }
 116 }
 117
 118 static __forceinline void doLockFile(HANDLE &fileHandle, const QString &filePath, QFile *const outFile)
 119 {
 120         for(int i = 0; i < 64; i++)
 121         {
 122                 fileHandle = CreateFileW(MUTILS_WCHR(QDir::toNativeSeparators(filePath)), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
 123                 if(VALID_HANDLE(fileHandle))
 124                 {
 125                         break;
 126                 }
 127                 if(i == 0)
 128                 {
 129                         qWarning("Failed to lock file on first attemp, retrying...");
 130                 }
 131                 Sleep(25);
 132         }
 133
 134         //Locked successfully?
 135         if(!VALID_HANDLE(fileHandle))
 136         {
 137                 if(outFile)
 138                 {
 139                         QFile::remove(QFileInfo(*outFile).canonicalFilePath());
 140                 }
 141                 MUTILS_THROW_FMT("File '%s' could not be locked!", MUTILS_UTF8(QFileInfo(filePath).fileName()));
 142         }
 143 }
 144
 145 static __forceinline void doInitFileDescriptor(const HANDLE &fileHandle, int &fileDescriptor)
 146 {
 147         fileDescriptor = _open_osfhandle(reinterpret_cast<intptr_t>(fileHandle), _O_RDONLY | _O_BINARY);
 148         if(fileDescriptor < 0)
 149         {
 150                 MUTILS_THROW_FMT("Failed to obtain C Runtime file descriptor!");
 151         }
 152 }
 153
 154 static __forceinline void doValidateHash(HANDLE &fileHandle, const int &fileDescriptor, const QByteArray &expectedHash, const QString &filePath)
 155 {
 156         QFile checkFile;
 157
 158         //Now re-open the file for reading
 159         if(g_useFileDescrForQFile)
 160         {
 161                 checkFile.open(fileDescriptor, QIODevice::ReadOnly);
 162         }
 163         else
 164         {
 165                 checkFile.setFileName(filePath);
 166                 for(int i = 0; i < 64; i++)
 167                 {
 168                         if(checkFile.open(QIODevice::ReadOnly)) break;
 169                         if(!i) qWarning("Failed to re-open file on first attemp, retrying...");
 170                         Sleep(100);
 171                 }
 172         }
 173
 174         //Opened successfully
 175         if(!checkFile.isOpen())
 176         {
 177                 QFile::remove(filePath);
 178                 MUTILS_THROW_FMT("File '%s' could not be read!", MUTILS_UTF8(QFileInfo(filePath).fileName()));
 179         }
 180
 181         //Verify file contents
 182         const QByteArray hash = FileHash::computeHash(checkFile);
 183         checkFile.close();
 184
 185         //Compare hashes
 186         if(hash.isNull() || _stricmp(hash.constData(), expectedHash.constData()))
 187         {
 188                 qWarning("\nFile checksum error:\n A = %s\n B = %s\n", expectedHash.constData(), hash.constData());
 189                 CLOSE_HANDLE(fileHandle);
 190                 QFile::remove(filePath);
 191                 MUTILS_THROW_FMT("File '%s' is corruputed, take care!", MUTILS_UTF8(QFileInfo(filePath).fileName()));
 192         }
 193 }
 194
 195 static __forceinline bool doRemoveFile(const QString &filePath)
 196 {
 197         for(int i = 0; i < 32; i++)
 198         {
 199                 if(MUtils::remove_file(filePath))
 200                 {
 201                         return true;
 202                 }
 203                 MUtils::OS::sleep_ms(1);
 204         }
 205         return false;
 206 }
 207
 208 ///////////////////////////////////////////////////////////////////////////////
 209
 210 LockedFile::LockedFile(QResource *const resource, const QString &outPath, const QByteArray &expectedHash, const bool bOwnsFile)
 211 :
 212         m_bOwnsFile(bOwnsFile),
 213         m_filePath(QFileInfo(outPath).absoluteFilePath())
 214 {
 215         m_fileDescriptor = -1;
 216         HANDLE fileHandle = NULL;
 217
 218         //Make sure the resource is valid
 219         if(!(resource->isValid() && resource->data()))
 220         {
 221                 MUTILS_THROW_FMT("The resource at %p is invalid!", resource);
 222         }
 223
 224         //Write data to output file
 225         QFile outFile(m_filePath);
 226         doWriteOutput(outFile, resource);
 227
 228         //Now lock the file!
 229         doLockFile(fileHandle, m_filePath, &outFile);
 230
 231         //Get file descriptor
 232         doInitFileDescriptor(fileHandle, m_fileDescriptor);
 233
 234         //Validate file hash
 235         doValidateHash(fileHandle, m_fileDescriptor, expectedHash, m_filePath);
 236 }
 237
 238 LockedFile::LockedFile(const QString &filePath, const QByteArray &expectedHash, const bool bOwnsFile)
 239 :
 240         m_bOwnsFile(bOwnsFile),
 241         m_filePath(QFileInfo(filePath).absoluteFilePath())
 242 {
 243         m_fileDescriptor = -1;
 244         HANDLE fileHandle = NULL;
 245
 246         //Make sure the file exists, before we try to lock it
 247         doValidateFileExists(m_filePath);
 248
 249         //Now lock the file!
 250         doLockFile(fileHandle, m_filePath, NULL);
 251
 252         //Get file descriptor
 253         doInitFileDescriptor(fileHandle, m_fileDescriptor);
 254
 255         //Validate file hash
 256         doValidateHash(fileHandle, m_fileDescriptor, expectedHash, m_filePath);
 257 }
 258
 259 LockedFile::LockedFile(const QString &filePath, const bool bOwnsFile)
 260 :
 261         m_bOwnsFile(bOwnsFile),
 262         m_filePath(QFileInfo(filePath).canonicalFilePath())
 263 {
 264         m_fileDescriptor = -1;
 265         HANDLE fileHandle = NULL;
 266
 267         //Make sure the file exists, before we try to lock it
 268         doValidateFileExists(m_filePath);
 269
 270         //Now lock the file!
 271         doLockFile(fileHandle, m_filePath, NULL);
 272
 273         //Get file descriptor
 274         doInitFileDescriptor(fileHandle, m_fileDescriptor);
 275 }
 276
 277 LockedFile::~LockedFile(void)
 278 {
 279         if(m_fileDescriptor >= 0)
 280         {
 281                 _close(m_fileDescriptor);
 282                 m_fileDescriptor = -1;
 283         }
 284         if(m_bOwnsFile)
 285         {
 286                 doRemoveFile(m_filePath);
 287         }
 288 }
 289
 290 const QString &LockedFile::filePath()
 291 {
 292         return m_filePath;
 293 }