ground/gcs/src/shared/qtlockedfile/qtlockedfile_win.cpp

   1 /**
   2  ******************************************************************************
   3  *
   4  * @file       qtlockedfile_win.cpp
   5  * @author     The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
   6  *             Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009.
   7  * @brief
   8  * @see        The GNU Public License (GPL) Version 3
   9  * @defgroup
  10  * @{
  11  *
  12  *****************************************************************************/
  13 /*
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 3 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful, but
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  21  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  22  * for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License along
  25  * with this program; if not, write to the Free Software Foundation, Inc.,
  26  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  27  */
  28
  29 #include "qtlockedfile.h"
  30
  31 #include <qt_windows.h>
  32 #include <QtCore/QFileInfo>
  33
  34 #if QT_VERSION >= 0x050000
  35 #define QT_WA(unicode, ansi) unicode
  36 #endif
  37
  38 namespace SharedTools {
  39 #define SEMAPHORE_PREFIX "QtLockedFile semaphore "
  40 #define MUTEX_PREFIX     "QtLockedFile mutex "
  41 #define SEMAPHORE_MAX    100
  42
  43 static QString errorCodeToString(DWORD errorCode)
  44 {
  45     QString result;
  46     char *data = 0;
  47
  48     FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
  49                    0, errorCode, 0,
  50                    (char *)&data, 0, 0);
  51     result = QString::fromLocal8Bit(data);
  52     if (data != 0) {
  53         LocalFree(data);
  54     }
  55
  56     if (result.endsWith("\n")) {
  57         result.truncate(result.length() - 1);
  58     }
  59
  60     return result;
  61 }
  62
  63 bool QtLockedFile::lock(LockMode mode, bool block)
  64 {
  65     if (!isOpen()) {
  66         qWarning("QtLockedFile::lock(): file is not opened");
  67         return false;
  68     }
  69
  70     if (mode == m_lock_mode) {
  71         return true;
  72     }
  73
  74     if (m_lock_mode != 0) {
  75         unlock();
  76     }
  77
  78     if (m_semaphore_hnd == 0) {
  79         QFileInfo fi(*this);
  80         QString sem_name = QString::fromLatin1(SEMAPHORE_PREFIX)
  81                            + fi.absoluteFilePath().toLower();
  82
  83         QT_WA({
  84                   m_semaphore_hnd = CreateSemaphoreW(0, SEMAPHORE_MAX, SEMAPHORE_MAX,
  85                                                      (TCHAR *)sem_name.utf16());
  86               }, {
  87                   m_semaphore_hnd = CreateSemaphoreA(0, SEMAPHORE_MAX, SEMAPHORE_MAX,
  88                                                      sem_name.toLocal8Bit().constData());
  89               }
  90               );
  91
  92         if (m_semaphore_hnd == 0) {
  93             qWarning("QtLockedFile::lock(): CreateSemaphore: %s",
  94                      errorCodeToString(GetLastError()).toLatin1().constData());
  95             return false;
  96         }
  97     }
  98
  99     bool gotMutex = false;
 100     int decrement;
 101     if (mode == ReadLock) {
 102         decrement = 1;
 103     } else {
 104         decrement = SEMAPHORE_MAX;
 105         if (m_mutex_hnd == 0) {
 106             QFileInfo fi(*this);
 107             QString mut_name = QString::fromLatin1(MUTEX_PREFIX)
 108                                + fi.absoluteFilePath().toLower();
 109             QT_WA({
 110                       m_mutex_hnd = CreateMutexW(NULL, FALSE, (TCHAR *)mut_name.utf16());
 111                   }, {
 112                       m_mutex_hnd = CreateMutexA(NULL, FALSE, mut_name.toLocal8Bit().constData());
 113                   }
 114                   );
 115
 116             if (m_mutex_hnd == 0) {
 117                 qWarning("QtLockedFile::lock(): CreateMutex: %s",
 118                          errorCodeToString(GetLastError()).toLatin1().constData());
 119                 return false;
 120             }
 121         }
 122         DWORD res = WaitForSingleObject(m_mutex_hnd, block ? INFINITE : 0);
 123         if (res == WAIT_TIMEOUT) {
 124             return false;
 125         }
 126         if (res == WAIT_FAILED) {
 127             qWarning("QtLockedFile::lock(): WaitForSingleObject (mutex): %s",
 128                      errorCodeToString(GetLastError()).toLatin1().constData());
 129             return false;
 130         }
 131         gotMutex = true;
 132     }
 133
 134     for (int i = 0; i < decrement; ++i) {
 135         DWORD res = WaitForSingleObject(m_semaphore_hnd, block ? INFINITE : 0);
 136         if (res == WAIT_TIMEOUT) {
 137             if (i) {
 138                 // A failed nonblocking rw locking. Undo changes to semaphore.
 139                 if (ReleaseSemaphore(m_semaphore_hnd, i, NULL) == 0) {
 140                     qWarning("QtLockedFile::unlock(): ReleaseSemaphore: %s",
 141                              errorCodeToString(GetLastError()).toLatin1().constData());
 142                     // Fall through
 143                 }
 144             }
 145             if (gotMutex) {
 146                 ReleaseMutex(m_mutex_hnd);
 147             }
 148             return false;
 149         }
 150         if (res != WAIT_OBJECT_0) {
 151             if (gotMutex) {
 152                 ReleaseMutex(m_mutex_hnd);
 153             }
 154             qWarning("QtLockedFile::lock(): WaitForSingleObject (semaphore): %s",
 155                      errorCodeToString(GetLastError()).toLatin1().constData());
 156             return false;
 157         }
 158     }
 159
 160     m_lock_mode = mode;
 161     if (gotMutex) {
 162         ReleaseMutex(m_mutex_hnd);
 163     }
 164     return true;
 165 }
 166
 167 bool QtLockedFile::unlock()
 168 {
 169     if (!isOpen()) {
 170         qWarning("QtLockedFile::unlock(): file is not opened");
 171         return false;
 172     }
 173
 174     if (!isLocked()) {
 175         return true;
 176     }
 177
 178     int increment;
 179     if (m_lock_mode == ReadLock) {
 180         increment = 1;
 181     } else {
 182         increment = SEMAPHORE_MAX;
 183     }
 184
 185     DWORD ret = ReleaseSemaphore(m_semaphore_hnd, increment, 0);
 186     if (ret == 0) {
 187         qWarning("QtLockedFile::unlock(): ReleaseSemaphore: %s",
 188                  errorCodeToString(GetLastError()).toLatin1().constData());
 189         return false;
 190     }
 191
 192     m_lock_mode = QtLockedFile::NoLock;
 193     return true;
 194 }
 195
 196 QtLockedFile::~QtLockedFile()
 197 {
 198     if (isOpen()) {
 199         unlock();
 200     }
 201     if (m_mutex_hnd != 0) {
 202         DWORD ret = CloseHandle(m_mutex_hnd);
 203         if (ret == 0) {
 204             qWarning("QtLockedFile::~QtLockedFile(): CloseHandle (mutex): %s",
 205                      errorCodeToString(GetLastError()).toLatin1().constData());
 206         }
 207         m_mutex_hnd = 0;
 208     }
 209     if (m_semaphore_hnd != 0) {
 210         DWORD ret = CloseHandle(m_semaphore_hnd);
 211         if (ret == 0) {
 212             qWarning("QtLockedFile::~QtLockedFile(): CloseHandle (semaphore): %s",
 213                      errorCodeToString(GetLastError()).toLatin1().constData());
 214         }
 215         m_semaphore_hnd = 0;
 216     }
 217 }
 218 } // namespace SharedTools