Warning: That file was not part of the compilation database. It may have many parsing errors.
1 | /**************************************************************************** |
---|---|
2 | ** |
3 | ** Copyright (C) 2013 David Faure <faure+bluesystems@kde.org> |
4 | ** Copyright (C) 2016 The Qt Company Ltd. |
5 | ** Copyright (C) 2017 Intel Corporation. |
6 | ** Contact: https://www.qt.io/licensing/ |
7 | ** |
8 | ** This file is part of the QtCore module of the Qt Toolkit. |
9 | ** |
10 | ** $QT_BEGIN_LICENSE:LGPL$ |
11 | ** Commercial License Usage |
12 | ** Licensees holding valid commercial Qt licenses may use this file in |
13 | ** accordance with the commercial license agreement provided with the |
14 | ** Software or, alternatively, in accordance with the terms contained in |
15 | ** a written agreement between you and The Qt Company. For licensing terms |
16 | ** and conditions see https://www.qt.io/terms-conditions. For further |
17 | ** information use the contact form at https://www.qt.io/contact-us. |
18 | ** |
19 | ** GNU Lesser General Public License Usage |
20 | ** Alternatively, this file may be used under the terms of the GNU Lesser |
21 | ** General Public License version 3 as published by the Free Software |
22 | ** Foundation and appearing in the file LICENSE.LGPL3 included in the |
23 | ** packaging of this file. Please review the following information to |
24 | ** ensure the GNU Lesser General Public License version 3 requirements |
25 | ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |
26 | ** |
27 | ** GNU General Public License Usage |
28 | ** Alternatively, this file may be used under the terms of the GNU |
29 | ** General Public License version 2.0 or (at your option) the GNU General |
30 | ** Public license version 3 or any later version approved by the KDE Free |
31 | ** Qt Foundation. The licenses are as published by the Free Software |
32 | ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
33 | ** included in the packaging of this file. Please review the following |
34 | ** information to ensure the GNU General Public License requirements will |
35 | ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
36 | ** https://www.gnu.org/licenses/gpl-3.0.html. |
37 | ** |
38 | ** $QT_END_LICENSE$ |
39 | ** |
40 | ****************************************************************************/ |
41 | |
42 | #include "private/qlockfile_p.h" |
43 | #include "private/qfilesystementry_p.h" |
44 | #include <qt_windows.h> |
45 | |
46 | #include "QtCore/qfileinfo.h" |
47 | #include "QtCore/qdatetime.h" |
48 | #include "QtCore/qdebug.h" |
49 | #include "QtCore/qthread.h" |
50 | |
51 | QT_BEGIN_NAMESPACE |
52 | |
53 | static inline bool fileExists(const wchar_t *fileName) |
54 | { |
55 | WIN32_FILE_ATTRIBUTE_DATA data; |
56 | return GetFileAttributesEx(fileName, GetFileExInfoStandard, &data); |
57 | } |
58 | |
59 | QLockFile::LockError QLockFilePrivate::tryLock_sys() |
60 | { |
61 | const QFileSystemEntry fileEntry(fileName); |
62 | // When writing, allow others to read. |
63 | // When reading, QFile will allow others to read and write, all good. |
64 | // Adding FILE_SHARE_DELETE would allow forceful deletion of stale files, |
65 | // but Windows doesn't allow recreating it while this handle is open anyway, |
66 | // so this would only create confusion (can't lock, but no lock file to read from). |
67 | const DWORD dwShareMode = FILE_SHARE_READ; |
68 | #ifndef Q_OS_WINRT |
69 | SECURITY_ATTRIBUTES securityAtts = { sizeof(SECURITY_ATTRIBUTES), NULL, FALSE }; |
70 | HANDLE fh = CreateFile((const wchar_t*)fileEntry.nativeFilePath().utf16(), |
71 | GENERIC_READ | GENERIC_WRITE, |
72 | dwShareMode, |
73 | &securityAtts, |
74 | CREATE_NEW, // error if already exists |
75 | FILE_ATTRIBUTE_NORMAL, |
76 | NULL); |
77 | #else // !Q_OS_WINRT |
78 | HANDLE fh = CreateFile2((const wchar_t*)fileEntry.nativeFilePath().utf16(), |
79 | GENERIC_READ | GENERIC_WRITE, |
80 | dwShareMode, |
81 | CREATE_NEW, // error if already exists |
82 | NULL); |
83 | #endif // Q_OS_WINRT |
84 | if (fh == INVALID_HANDLE_VALUE) { |
85 | const DWORD lastError = GetLastError(); |
86 | switch (lastError) { |
87 | case ERROR_SHARING_VIOLATION: |
88 | case ERROR_ALREADY_EXISTS: |
89 | case ERROR_FILE_EXISTS: |
90 | return QLockFile::LockFailedError; |
91 | case ERROR_ACCESS_DENIED: |
92 | // readonly file, or file still in use by another process. |
93 | // Assume the latter if the file exists, since we don't create it readonly. |
94 | return fileExists((const wchar_t*)fileEntry.nativeFilePath().utf16()) |
95 | ? QLockFile::LockFailedError |
96 | : QLockFile::PermissionError; |
97 | default: |
98 | qWarning("Got unexpected locking error %llu", quint64(lastError)); |
99 | return QLockFile::UnknownError; |
100 | } |
101 | } |
102 | |
103 | // We hold the lock, continue. |
104 | fileHandle = fh; |
105 | QByteArray fileData = lockFileContents(); |
106 | DWORD bytesWritten = 0; |
107 | QLockFile::LockError error = QLockFile::NoError; |
108 | if (!WriteFile(fh, fileData.constData(), fileData.size(), &bytesWritten, NULL) || !FlushFileBuffers(fh)) |
109 | error = QLockFile::UnknownError; // partition full |
110 | return error; |
111 | } |
112 | |
113 | bool QLockFilePrivate::removeStaleLock() |
114 | { |
115 | // QFile::remove fails on Windows if the other process is still using the file, so it's not stale. |
116 | return QFile::remove(fileName); |
117 | } |
118 | |
119 | bool QLockFilePrivate::isProcessRunning(qint64 pid, const QString &appname) |
120 | { |
121 | // On WinRT there seems to be no way of obtaining information about other |
122 | // processes due to sandboxing |
123 | #ifndef Q_OS_WINRT |
124 | HANDLE procHandle = ::OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid); |
125 | if (!procHandle) |
126 | return false; |
127 | |
128 | // We got a handle but check if process is still alive |
129 | DWORD exitCode = 0; |
130 | if (!::GetExitCodeProcess(procHandle, &exitCode)) |
131 | exitCode = 0; |
132 | ::CloseHandle(procHandle); |
133 | if (exitCode != STILL_ACTIVE) |
134 | return false; |
135 | |
136 | const QString processName = processNameByPid(pid); |
137 | if (!processName.isEmpty() && processName != appname) |
138 | return false; // PID got reused by a different application. |
139 | |
140 | #else // !Q_OS_WINRT |
141 | Q_UNUSED(pid); |
142 | Q_UNUSED(appname); |
143 | #endif // Q_OS_WINRT |
144 | |
145 | return true; |
146 | } |
147 | |
148 | QString QLockFilePrivate::processNameByPid(qint64 pid) |
149 | { |
150 | #if !defined(Q_OS_WINRT) |
151 | typedef DWORD (WINAPI *GetModuleFileNameExFunc)(HANDLE, HMODULE, LPTSTR, DWORD); |
152 | |
153 | HMODULE hPsapi = LoadLibraryA("psapi"); |
154 | if (!hPsapi) |
155 | return QString(); |
156 | GetModuleFileNameExFunc qGetModuleFileNameEx = reinterpret_cast<GetModuleFileNameExFunc>( |
157 | reinterpret_cast<QFunctionPointer>(GetProcAddress(hPsapi, "GetModuleFileNameExW"))); |
158 | if (!qGetModuleFileNameEx) { |
159 | FreeLibrary(hPsapi); |
160 | return QString(); |
161 | } |
162 | |
163 | HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, DWORD(pid)); |
164 | if (!hProcess) { |
165 | FreeLibrary(hPsapi); |
166 | return QString(); |
167 | } |
168 | wchar_t buf[MAX_PATH]; |
169 | const DWORD length = qGetModuleFileNameEx(hProcess, NULL, buf, sizeof(buf) / sizeof(wchar_t)); |
170 | CloseHandle(hProcess); |
171 | FreeLibrary(hPsapi); |
172 | if (!length) |
173 | return QString(); |
174 | QString name = QString::fromWCharArray(buf, length); |
175 | int i = name.lastIndexOf(QLatin1Char('\\')); |
176 | if (i >= 0) |
177 | name.remove(0, i + 1); |
178 | i = name.lastIndexOf(QLatin1Char('.')); |
179 | if (i >= 0) |
180 | name.truncate(i); |
181 | return name; |
182 | #else |
183 | Q_UNUSED(pid); |
184 | return QString(); |
185 | #endif |
186 | } |
187 | |
188 | void QLockFile::unlock() |
189 | { |
190 | Q_D(QLockFile); |
191 | if (!d->isLocked) |
192 | return; |
193 | CloseHandle(d->fileHandle); |
194 | int attempts = 0; |
195 | static const int maxAttempts = 500; // 500ms |
196 | while (!QFile::remove(d->fileName) && ++attempts < maxAttempts) { |
197 | // Someone is reading the lock file right now (on Windows this prevents deleting it). |
198 | QThread::msleep(1); |
199 | } |
200 | if (attempts == maxAttempts) { |
201 | qWarning() << "Could not remove our own lock file"<< d->fileName << ". Either other users of the lock file are reading it constantly for 500 ms, or we (no longer) have permissions to delete the file"; |
202 | // This is bad because other users of this lock file will now have to wait for the stale-lock-timeout... |
203 | } |
204 | d->lockError = QLockFile::NoError; |
205 | d->isLocked = false; |
206 | } |
207 | |
208 | QT_END_NAMESPACE |
209 |
Warning: That file was not part of the compilation database. It may have many parsing errors.