src/LockedFile.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // LameXP - Audio Encoder Front-End
   3 // Copyright (C) 2004-2014 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 #include "Global.h"
  25
  26 #include <QResource>
  27 #include <QFile>
  28 #include <QFileInfo>
  29 #include <QDir>
  30 #include <QCryptographicHash>
  31 #include <QKeccakHash>
  32
  33 #include <stdio.h>
  34 #include <io.h>
  35 #include <fcntl.h>
  36 #include <stdexcept>
  37
  38 //Windows includes
  39 #define NOMINMAX
  40 #define WIN32_LEAN_AND_MEAN
  41 #include <Windows.h>
  42
  43 ///////////////////////////////////////////////////////////////////////////////
  44
  45 // WARNING: Passing file descriptors into Qt does NOT work with dynamically linked CRT!
  46 #ifdef QT_NODLL
  47         static const bool g_useFileDescrForQFile = true;
  48 #else
  49         static const bool g_useFileDescrForQFile = false;
  50 #endif
  51
  52 ///////////////////////////////////////////////////////////////////////////////
  53
  54 static const char *g_blnk = "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef";
  55 static const char *g_seed = "c375d83b4388329408dfcbb4d9a065b6e06d28272f25ef299c70b506e26600af79fd2f866ae24602daf38f25c9d4b7e1";
  56 static const char *g_salt = "ee9f7bdabc170763d2200a7e3030045aafe380011aefc1730e547e9244c62308aac42a976feeca224ba553de0c4bb883";
  57
  58 QByteArray LockedFile::fileHash(QFile &file)
  59 {
  60         QByteArray hash = QByteArray::fromHex(g_blnk);
  61
  62         if(file.isOpen() && file.reset())
  63         {
  64                 QKeccakHash keccak;
  65
  66                 const QByteArray data = file.readAll();
  67                 const QByteArray seed = QByteArray::fromHex(g_seed);
  68                 const QByteArray salt = QByteArray::fromHex(g_salt);
  69
  70                 if(keccak.init(QKeccakHash::hb384))
  71                 {
  72                         bool ok = true;
  73                         ok = ok && keccak.addData(seed);
  74                         ok = ok && keccak.addData(data);
  75                         ok = ok && keccak.addData(salt);
  76                         if(ok)
  77                         {
  78                                 const QByteArray digest = keccak.finalize();
  79                                 if(!digest.isEmpty()) hash = digest.toHex();
  80                         }
  81                 }
  82         }
  83
  84         return hash;
  85 }
  86
  87 ///////////////////////////////////////////////////////////////////////////////
  88
  89 LockedFile::LockedFile(QResource *const resource, const QString &outPath, const QByteArray &expectedHash, const bool bOwnsFile)
  90 :
  91         m_bOwnsFile(bOwnsFile),
  92         m_filePath(QFileInfo(outPath).absoluteFilePath())
  93 {
  94         m_fileDescriptor = -1;
  95         HANDLE fileHandle = NULL;
  96
  97         //Make sure the resource is valid
  98         if(!(resource->isValid() && resource->data()))
  99         {
 100                 THROW_FMT("The resource at %p is invalid!", resource);
 101         }
 102
 103         QFile outFile(m_filePath);
 104
 105         //Open output file
 106         for(int i = 0; i < 64; i++)
 107         {
 108                 if(outFile.open(QIODevice::WriteOnly)) break;
 109                 if(!i) qWarning("Failed to open file on first attemp, retrying...");
 110                 Sleep(100);
 111         }
 112
 113         //Write data to file
 114         if(outFile.isOpen() && outFile.isWritable())
 115         {
 116                 if(outFile.write(reinterpret_cast<const char*>(resource->data()), resource->size()) != resource->size())
 117                 {
 118                         QFile::remove(QFileInfo(outFile).canonicalFilePath());
 119                         THROW_FMT("File '%s' could not be written!", QUTF8(QFileInfo(outFile).fileName()));
 120                 }
 121         }
 122         else
 123         {
 124                 THROW_FMT("File '%s' could not be created!", QUTF8(QFileInfo(outFile).fileName()));
 125         }
 126
 127         //Close file after it has been written
 128         outFile.close();
 129
 130         //Now lock the file!
 131         for(int i = 0; i < 64; i++)
 132         {
 133                 fileHandle = CreateFileW(QWCHAR(QDir::toNativeSeparators(m_filePath)), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
 134                 if((fileHandle != NULL) && (fileHandle != INVALID_HANDLE_VALUE)) break;
 135                 if(!i) qWarning("Failed to lock file on first attemp, retrying...");
 136                 Sleep(100);
 137         }
 138
 139         //Locked successfully?
 140         if((fileHandle == NULL) || (fileHandle == INVALID_HANDLE_VALUE))
 141         {
 142                 QFile::remove(QFileInfo(outFile).canonicalFilePath());
 143                 THROW_FMT("File '%s' could not be locked!", QUTF8(QFileInfo(m_filePath).fileName()));
 144         }
 145
 146         //Get file descriptor
 147         m_fileDescriptor = _open_osfhandle(reinterpret_cast<intptr_t>(fileHandle), _O_RDONLY | _O_BINARY);
 148         if(m_fileDescriptor < 0)
 149         {
 150                 THROW_FMT("Failed to obtain C Runtime file descriptor!");
 151         }
 152
 153         QFile checkFile;
 154
 155         //Now re-open the file for reading
 156         if(g_useFileDescrForQFile)
 157         {
 158                 checkFile.open(m_fileDescriptor, QIODevice::ReadOnly);
 159         }
 160         else
 161         {
 162                 checkFile.setFileName(m_filePath);
 163                 for(int i = 0; i < 64; i++)
 164                 {
 165                         if(checkFile.open(QIODevice::ReadOnly)) break;
 166                         if(!i) qWarning("Failed to re-open file on first attemp, retrying...");
 167                         Sleep(100);
 168                 }
 169         }
 170
 171         //Opened successfully
 172         if(!checkFile.isOpen())
 173         {
 174                 QFile::remove(m_filePath);
 175                 THROW_FMT("File '%s' could not be read!", QUTF8(QFileInfo(m_filePath).fileName()));
 176         }
 177
 178         //Verify file contents
 179         const QByteArray hash = fileHash(checkFile);
 180         checkFile.close();
 181
 182         //Compare hashes
 183         if(hash.isNull() || _stricmp(hash.constData(), expectedHash.constData()))
 184         {
 185                 qWarning("\nFile checksum error:\n A = %s\n B = %s\n", expectedHash.constData(), hash.constData());
 186                 LAMEXP_CLOSE(fileHandle);
 187                 QFile::remove(m_filePath);
 188                 THROW_FMT("File '%s' is corruputed, take care!", QUTF8(QFileInfo(m_filePath).fileName()));
 189         }
 190 }
 191
 192 LockedFile::LockedFile(const QString &filePath, const bool bOwnsFile)
 193 :
 194         m_bOwnsFile(bOwnsFile),
 195         m_filePath(QFileInfo(filePath).canonicalFilePath())
 196 {
 197         m_fileDescriptor = -1;
 198         HANDLE fileHandle = NULL;
 199
 200         QFileInfo existingFileInfo(filePath);
 201         existingFileInfo.setCaching(false);
 202
 203         //Make sure the file exists, before we try to lock it
 204         if(!(existingFileInfo.exists() && existingFileInfo.isFile()))
 205         {
 206                 THROW_FMT("File '%s' does not exist!", QUTF8(m_filePath));
 207         }
 208
 209         //Now lock the file
 210         for(int i = 0; i < 64; i++)
 211         {
 212                 fileHandle = CreateFileW(QWCHAR(QDir::toNativeSeparators(m_filePath)), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
 213                 if((fileHandle != NULL) && (fileHandle != INVALID_HANDLE_VALUE)) break;
 214                 if(!i) qWarning("Failed to lock file on first attemp, retrying...");
 215                 Sleep(100);
 216         }
 217
 218         //Locked successfully?
 219         if((fileHandle == NULL) || (fileHandle == INVALID_HANDLE_VALUE))
 220         {
 221                 THROW_FMT("File '%s' could not be locked!", QUTF8(QFileInfo(m_filePath).fileName()));
 222         }
 223
 224         //Get file descriptor
 225         m_fileDescriptor = _open_osfhandle(reinterpret_cast<intptr_t>(fileHandle), _O_RDONLY | _O_BINARY);
 226         if(m_fileDescriptor < 0)
 227         {
 228                 THROW_FMT("Failed to obtain C Runtime file descriptor!");
 229         }
 230 }
 231
 232 LockedFile::~LockedFile(void)
 233 {
 234         if(m_fileDescriptor >= 0)
 235         {
 236                 _close(m_fileDescriptor);
 237                 m_fileDescriptor = -1;
 238         }
 239         if(m_bOwnsFile)
 240         {
 241                 if(QFileInfo(m_filePath).exists())
 242                 {
 243                         for(int i = 0; i < 64; i++)
 244                         {
 245                                 if(QFile::remove(m_filePath)) break;
 246                                 lamexp_sleep(1);
 247                         }
 248                 }
 249         }
 250 }
 251
 252 const QString &LockedFile::filePath()
 253 {
 254         return m_filePath;
 255 }
 256
 257 void LockedFile::selfTest()
 258 {
 259         if(!QKeccakHash::selfTest())
 260         {
 261                 THROW("QKeccakHash self-test has failed!");
 262         }
 263 }