mirrors/qBittorrent
1
0
Fork 0
mirror of https://github.com/qbittorrent/qBittorrent.git synced 2024-10-22 18:56:08 +03:00
Code Issues Projects Releases Packages Wiki Activity

Reformat code

Browse source
This commit is contained in:
Chocobo1 2021-11-04 12:23:31 +08:00
parent 22abbc1d41
commit 71270260bf
No known key found for this signature in database
GPG key ID: 210D9C873253A68C
8 changed files with 147 additions and 130 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

40
src/app/qtlocalpeer/qtlocalpeer.cpp
View file

@ -90,49 +90,49 @@ namespace QtLP_Private
#endif #endif
} }
const char* QtLocalPeer::ack = "ack"; const char ACK[] = "ack";
QtLocalPeer::QtLocalPeer(const QString &path, QObject *parent) QtLocalPeer::QtLocalPeer(const QString &path, QObject *parent)
: QObject(parent) : QObject(parent)
, socketName(path + QLatin1String("/ipc-socket")) , m_socketName(path + QLatin1String("/ipc-socket"))
, server(new QLocalServer(this)) , m_server(new QLocalServer(this))
{ {
server->setSocketOptions(QLocalServer::UserAccessOption); m_server->setSocketOptions(QLocalServer::UserAccessOption);
lockFile.setFileName(path + QLatin1String("/lockfile")); m_lockFile.setFileName(path + QLatin1String("/lockfile"));
lockFile.open(QIODevice::ReadWrite); m_lockFile.open(QIODevice::ReadWrite);
} }
QtLocalPeer::~QtLocalPeer() QtLocalPeer::~QtLocalPeer()
{ {
if (!isClient()) if (!isClient())
{ {
lockFile.unlock(); m_lockFile.unlock();
lockFile.remove(); m_lockFile.remove();
} }
} }
bool QtLocalPeer::isClient() bool QtLocalPeer::isClient()
{ {
if (lockFile.isLocked()) if (m_lockFile.isLocked())
return false; return false;
if (!lockFile.lock(QtLP_Private::QtLockedFile::WriteLock, false)) if (!m_lockFile.lock(QtLP_Private::QtLockedFile::WriteLock, false))
return true; return true;
bool res = server->listen(socketName); bool res = m_server->listen(m_socketName);
#if defined(Q_OS_UNIX) #if defined(Q_OS_UNIX)
// ### Workaround // ### Workaround
if (!res && server->serverError() == QAbstractSocket::AddressInUseError) if (!res && m_server->serverError() == QAbstractSocket::AddressInUseError)
{ {
QFile::remove(socketName); QFile::remove(m_socketName);
res = server->listen(socketName); res = m_server->listen(m_socketName);
} }
#endif #endif
if (!res) if (!res)
qWarning("QtSingleCoreApplication: listen on local socket failed, %s", qPrintable(server->errorString())); qWarning("QtSingleCoreApplication: listen on local socket failed, %s", qUtf8Printable(m_server->errorString()));
connect(server, &QLocalServer::newConnection, this, &QtLocalPeer::receiveConnection); connect(m_server, &QLocalServer::newConnection, this, &QtLocalPeer::receiveConnection);
return false; return false;
} }
@ -146,7 +146,7 @@ bool QtLocalPeer::sendMessage(const QString &message, const int timeout)
for(int i = 0; i < 2; i++) for(int i = 0; i < 2; i++)
{ {
// Try twice, in case the other instance is just starting up // Try twice, in case the other instance is just starting up
socket.connectToServer(socketName); socket.connectToServer(m_socketName);
connOk = socket.waitForConnected(timeout/2); connOk = socket.waitForConnected(timeout/2);
if (connOk || i) if (connOk || i)
break; break;
@ -169,14 +169,14 @@ bool QtLocalPeer::sendMessage(const QString &message, const int timeout)
{ {
res &= socket.waitForReadyRead(timeout); // wait for ack res &= socket.waitForReadyRead(timeout); // wait for ack
if (res) if (res)
res &= (socket.read(qstrlen(ack)) == ack); res &= (socket.read(qstrlen(ACK)) == ACK);
} }
return res; return res;
} }
void QtLocalPeer::receiveConnection() void QtLocalPeer::receiveConnection()
{ {
QLocalSocket* socket = server->nextPendingConnection(); QLocalSocket *socket = m_server->nextPendingConnection();
if (!socket) if (!socket)
return; return;
@ -220,7 +220,7 @@ void QtLocalPeer::receiveConnection()
return; return;
} }
QString message(QString::fromUtf8(uMsg)); QString message(QString::fromUtf8(uMsg));
socket->write(ack, qstrlen(ack)); socket->write(ACK, qstrlen(ACK));
socket->waitForBytesWritten(1000); socket->waitForBytesWritten(1000);
socket->waitForDisconnected(1000); // make sure client reads ack socket->waitForDisconnected(1000); // make sure client reads ack
delete socket; delete socket;

12
src/app/qtlocalpeer/qtlocalpeer.h
View file

@ -89,15 +89,11 @@ public:
signals: signals:
void messageReceived(const QString &message); void messageReceived(const QString &message);
protected slots: private slots:
void receiveConnection(); void receiveConnection();
protected:
QString id;
QString socketName;
QLocalServer *server = nullptr;
QtLP_Private::QtLockedFile lockFile;
private: private:
static const char* ack; QString m_socketName;
QLocalServer *m_server = nullptr;
QtLP_Private::QtLockedFile m_lockFile;
}; };

14
src/app/qtlocalpeer/qtlockedfile.cpp
View file

@ -108,11 +108,7 @@
\sa QFile::QFile() \sa QFile::QFile()
*/ */
QtLockedFile::QtLockedFile() QtLockedFile::QtLockedFile() = default;
: QFile()
{
m_lock_mode = NoLock;
}
/*! /*!
Constructs an unlocked QtLockedFile object with file \a name. This Constructs an unlocked QtLockedFile object with file \a name. This
@ -124,7 +120,6 @@ QtLockedFile::QtLockedFile()
QtLockedFile::QtLockedFile(const QString &name) QtLockedFile::QtLockedFile(const QString &name)
: QFile(name) : QFile(name)
{ {
m_lock_mode = NoLock;
} }
/*! /*!
@ -142,7 +137,8 @@ QtLockedFile::QtLockedFile(const QString &name)
*/ */
bool QtLockedFile::open(const OpenMode mode) bool QtLockedFile::open(const OpenMode mode)
{ {
if (mode & QIODevice::Truncate) { if (mode & QIODevice::Truncate)
{
qWarning("QtLockedFile::open(): Truncate mode not allowed."); qWarning("QtLockedFile::open(): Truncate mode not allowed.");
return false; return false;
} }
@ -157,7 +153,7 @@ bool QtLockedFile::open(const OpenMode mode)
*/ */
bool QtLockedFile::isLocked() const bool QtLockedFile::isLocked() const
{ {
return m_lock_mode != NoLock; return m_lockMode != NoLock;
} }
/*! /*!
@ -168,7 +164,7 @@ bool QtLockedFile::isLocked() const
*/ */
QtLockedFile::LockMode QtLockedFile::lockMode() const QtLockedFile::LockMode QtLockedFile::lockMode() const
{ {
return m_lock_mode; return m_lockMode;
} }
/*! /*!

12
src/app/qtlocalpeer/qtlockedfile.h
View file

@ -101,14 +101,14 @@ namespace QtLP_Private
private: private:
#ifdef Q_OS_WIN #ifdef Q_OS_WIN
Qt::HANDLE getMutexHandle(int idx, bool doCreate); Qt::HANDLE getMutexHandle(int idx, bool doCreate);
bool waitMutex(Qt::HANDLE mutex, bool doBlock); bool waitMutex(Qt::HANDLE mutex, bool doBlock) const;
Qt::HANDLE wmutex = nullptr; Qt::HANDLE m_writeMutex = nullptr;
Qt::HANDLE rmutex = nullptr; Qt::HANDLE m_readMutex = nullptr;
QVector<Qt::HANDLE> rmutexes; QVector<Qt::HANDLE> m_readMutexes;
QString mutexname; QString m_mutexName;
#endif #endif
LockMode m_lock_mode; LockMode m_lockMode = NoLock;
}; };
} }

22
src/app/qtlocalpeer/qtlockedfile_unix.cpp
View file

@ -73,9 +73,10 @@
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
bool QtLockedFile::lock(LockMode mode, bool block) bool QtLockedFile::lock(const LockMode mode, const bool block)
{
if (!isOpen())
{ {
if (!isOpen()) {
qWarning("QtLockedFile::lock(): file is not opened"); qWarning("QtLockedFile::lock(): file is not opened");
return false; return false;
} }
@ -83,10 +84,10 @@ bool QtLockedFile::lock(LockMode mode, bool block)
if (mode == NoLock) if (mode == NoLock)
return unlock(); return unlock();
if (mode == m_lock_mode) if (mode == m_lockMode)
return true; return true;
if (m_lock_mode != NoLock) if (m_lockMode != NoLock)
unlock(); unlock();
struct flock fl; struct flock fl;
@ -97,19 +98,21 @@ bool QtLockedFile::lock(LockMode mode, bool block)
int cmd = block ? F_SETLKW : F_SETLK; int cmd = block ? F_SETLKW : F_SETLK;
int ret = fcntl(handle(), cmd, &fl); int ret = fcntl(handle(), cmd, &fl);
if (ret == -1) { if (ret == -1)
{
if (errno != EINTR && errno != EAGAIN) if (errno != EINTR && errno != EAGAIN)
qWarning("QtLockedFile::lock(): fcntl: %s", strerror(errno)); qWarning("QtLockedFile::lock(): fcntl: %s", strerror(errno));
return false; return false;
} }
m_lock_mode = mode; m_lockMode = mode;
return true; return true;
} }
bool QtLockedFile::unlock() bool QtLockedFile::unlock()
{ {
if (!isOpen()) { if (!isOpen())
{
qWarning("QtLockedFile::unlock(): file is not opened"); qWarning("QtLockedFile::unlock(): file is not opened");
return false; return false;
} }
@ -124,12 +127,13 @@ bool QtLockedFile::unlock()
fl.l_type = F_UNLCK; fl.l_type = F_UNLCK;
int ret = fcntl(handle(), F_SETLKW, &fl); int ret = fcntl(handle(), F_SETLKW, &fl);
if (ret == -1) { if (ret == -1)
{
qWarning("QtLockedFile::lock(): fcntl: %s", strerror(errno)); qWarning("QtLockedFile::lock(): fcntl: %s", strerror(errno));
return false; return false;
} }
m_lock_mode = NoLock; m_lockMode = NoLock;
return true; return true;
} }

167
src/app/qtlocalpeer/qtlockedfile_win.cpp
View file

@ -70,64 +70,73 @@
#include <QFileInfo> #include <QFileInfo>
#define MUTEX_PREFIX "QtLockedFile mutex " #include "base/global.h"
// Maximum number of concurrent read locks. Must not be greater than MAXIMUM_WAIT_OBJECTS // Maximum number of concurrent read locks. Must not be greater than MAXIMUM_WAIT_OBJECTS
#define MAX_READERS MAXIMUM_WAIT_OBJECTS const int MAX_READERS = MAXIMUM_WAIT_OBJECTS;
#define QT_WA(unicode, ansi) unicode Qt::HANDLE QtLockedFile::getMutexHandle(const int idx, const bool doCreate)
{
Qt::HANDLE QtLockedFile::getMutexHandle(int idx, bool doCreate) if (m_mutexName.isEmpty())
{ {
if (mutexname.isEmpty()) {
QFileInfo fi(*this); QFileInfo fi(*this);
mutexname = QString::fromLatin1(MUTEX_PREFIX) m_mutexName = QString::fromLatin1("QtLockedFile mutex ") + fi.absoluteFilePath().toLower();
+ fi.absoluteFilePath().toLower();
} }
QString mname(mutexname);
QString mname = m_mutexName;
if (idx >= 0) if (idx >= 0)
mname += QString::number(idx); mname += QString::number(idx);
Qt::HANDLE mutex; if (doCreate)
if (doCreate) { {
QT_WA( { mutex = CreateMutexW(NULL, FALSE, reinterpret_cast<const TCHAR *>(mname.utf16())); }, const Qt::HANDLE mutex = ::CreateMutexW(NULL, FALSE, reinterpret_cast<const TCHAR *>(mname.utf16()));
{ mutex = CreateMutexA(NULL, FALSE, mname.toLocal8Bit().constData()); } ); if (!mutex)
if (!mutex) { {
qErrnoWarning("QtLockedFile::lock(): CreateMutex failed"); qErrnoWarning("QtLockedFile::lock(): CreateMutex failed");
return 0; return nullptr;
} }
return mutex;
} }
else { else
QT_WA( { mutex = OpenMutexW(SYNCHRONIZE | MUTEX_MODIFY_STATE, FALSE, reinterpret_cast<const TCHAR *>(mname.utf16())); }, {
{ mutex = OpenMutexA(SYNCHRONIZE | MUTEX_MODIFY_STATE, FALSE, mname.toLocal8Bit().constData()); } ); const Qt::HANDLE mutex = ::OpenMutexW((SYNCHRONIZE | MUTEX_MODIFY_STATE), FALSE, reinterpret_cast<const TCHAR *>(mname.utf16()));
if (!mutex) { if (!mutex)
{
if (GetLastError() != ERROR_FILE_NOT_FOUND) if (GetLastError() != ERROR_FILE_NOT_FOUND)
qErrnoWarning("QtLockedFile::lock(): OpenMutex failed"); qErrnoWarning("QtLockedFile::lock(): OpenMutex failed");
return 0; return nullptr;
}
} }
return mutex; return mutex;
} }
bool QtLockedFile::waitMutex(Qt::HANDLE mutex, bool doBlock) return nullptr;
}
bool QtLockedFile::waitMutex(const Qt::HANDLE mutex, const bool doBlock) const
{ {
Q_ASSERT(mutex); Q_ASSERT(mutex);
DWORD res = WaitForSingleObject(mutex, doBlock ? INFINITE : 0);
switch (res) { const DWORD res = ::WaitForSingleObject(mutex, (doBlock ? INFINITE : 0));
switch (res)
{
case WAIT_OBJECT_0: case WAIT_OBJECT_0:
case WAIT_ABANDONED: case WAIT_ABANDONED:
return true; return true;
break;
case WAIT_TIMEOUT: case WAIT_TIMEOUT:
break; return false;
default: default:
qErrnoWarning("QtLockedFile::lock(): WaitForSingleObject failed"); qErrnoWarning("QtLockedFile::lock(): WaitForSingleObject failed");
break;
} }
return false; return false;
} }
bool QtLockedFile::lock(LockMode mode, bool block) bool QtLockedFile::lock(const LockMode mode, const bool block)
{
if (!isOpen())
{ {
if (!isOpen()) {
qWarning("QtLockedFile::lock(): file is not opened"); qWarning("QtLockedFile::lock(): file is not opened");
return false; return false;
} }
@ -135,72 +144,85 @@ bool QtLockedFile::lock(LockMode mode, bool block)
if (mode == NoLock) if (mode == NoLock)
return unlock(); return unlock();
if (mode == m_lock_mode) if (mode == m_lockMode)
return true; return true;
if (m_lock_mode != NoLock) if (m_lockMode != NoLock)
unlock(); unlock();
if (!wmutex && !(wmutex = getMutexHandle(-1, true))) if (!m_writeMutex && !(m_writeMutex = getMutexHandle(-1, true)))
return false; return false;
if (!waitMutex(wmutex, block)) if (!waitMutex(m_writeMutex, block))
return false; return false;
if (mode == ReadLock) { if (mode == ReadLock)
{
int idx = 0; int idx = 0;
for (; idx < MAX_READERS; idx++) { for (; idx < MAX_READERS; ++idx)
rmutex = getMutexHandle(idx, false); {
if (!rmutex || waitMutex(rmutex, false)) m_readMutex = getMutexHandle(idx, false);
if (!m_readMutex || waitMutex(m_readMutex, false))
break; break;
CloseHandle(rmutex); ::CloseHandle(m_readMutex);
} }
bool ok = true; bool ok = true;
if (idx >= MAX_READERS) { if (idx >= MAX_READERS)
{
qWarning("QtLockedFile::lock(): too many readers"); qWarning("QtLockedFile::lock(): too many readers");
rmutex = 0; m_readMutex = nullptr;
ok = false; ok = false;
} }
else if (!rmutex) { else if (!m_readMutex)
rmutex = getMutexHandle(idx, true); {
if (!rmutex || !waitMutex(rmutex, false)) m_readMutex = getMutexHandle(idx, true);
if (!m_readMutex || !waitMutex(m_readMutex, false))
ok = false; ok = false;
} }
if (!ok && rmutex) {
CloseHandle(rmutex); if (!ok && m_readMutex)
rmutex = 0; {
::CloseHandle(m_readMutex);
m_readMutex = nullptr;
} }
ReleaseMutex(wmutex);
::ReleaseMutex(m_writeMutex);
if (!ok) if (!ok)
return false; return false;
} }
else { else
Q_ASSERT(rmutexes.isEmpty()); {
for (int i = 0; i < MAX_READERS; i++) { Q_ASSERT(m_readMutexes.isEmpty());
Qt::HANDLE mutex = getMutexHandle(i, false); for (int i = 0; i < MAX_READERS; ++i)
{
const Qt::HANDLE mutex = getMutexHandle(i, false);
if (mutex) if (mutex)
rmutexes.append(mutex); m_readMutexes.append(mutex);
} }
if (rmutexes.size()) { if (m_readMutexes.size())
DWORD res = WaitForMultipleObjects(rmutexes.size(), rmutexes.constData(), {
TRUE, block ? INFINITE : 0); const DWORD res = ::WaitForMultipleObjects(m_readMutexes.size(), m_readMutexes.constData(),
if (res != WAIT_OBJECT_0 && res != WAIT_ABANDONED) { TRUE, (block ? INFINITE : 0));
if ((res != WAIT_OBJECT_0) && (res != WAIT_ABANDONED))
{
if (res != WAIT_TIMEOUT) if (res != WAIT_TIMEOUT)
qErrnoWarning("QtLockedFile::lock(): WaitForMultipleObjects failed"); qErrnoWarning("QtLockedFile::lock(): WaitForMultipleObjects failed");
m_lock_mode = WriteLock; // trick unlock() to clean up - semiyucky m_lockMode = WriteLock; // trick unlock() to clean up - semiyucky
unlock(); unlock();
return false; return false;
} }
} }
} }
m_lock_mode = mode; m_lockMode = mode;
return true; return true;
} }
bool QtLockedFile::unlock() bool QtLockedFile::unlock()
{ {
if (!isOpen()) { if (!isOpen())
{
qWarning("QtLockedFile::unlock(): file is not opened"); qWarning("QtLockedFile::unlock(): file is not opened");
return false; return false;
} }
@ -208,21 +230,24 @@ bool QtLockedFile::unlock()
if (!isLocked()) if (!isLocked())
return true; return true;
if (m_lock_mode == ReadLock) { if (m_lockMode == ReadLock)
ReleaseMutex(rmutex); {
CloseHandle(rmutex); ::ReleaseMutex(m_readMutex);
rmutex = 0; ::CloseHandle(m_readMutex);
m_readMutex = nullptr;
} }
else { else
foreach(Qt::HANDLE mutex, rmutexes) { {
ReleaseMutex(mutex); for (const Qt::HANDLE &mutex : asConst(m_readMutexes))
CloseHandle(mutex); {
::ReleaseMutex(mutex);
::CloseHandle(mutex);
} }
rmutexes.clear(); m_readMutexes.clear();
ReleaseMutex(wmutex); ::ReleaseMutex(m_writeMutex);
} }
m_lock_mode = QtLockedFile::NoLock; m_lockMode = QtLockedFile::NoLock;
return true; return true;
} }
@ -230,6 +255,6 @@ QtLockedFile::~QtLockedFile()
{ {
if (isOpen()) if (isOpen())
unlock(); unlock();
if (wmutex) if (m_writeMutex)
CloseHandle(wmutex); ::CloseHandle(m_writeMutex);
} }

4
src/base/bittorrent/torrentimpl.cpp
View file

@ -33,10 +33,6 @@
#include <memory> #include <memory>
#include <type_traits> #include <type_traits>
#ifdef Q_OS_WIN
#include <Windows.h>
#endif
#include <libtorrent/address.hpp> #include <libtorrent/address.hpp>
#include <libtorrent/alert_types.hpp> #include <libtorrent/alert_types.hpp>
#include <libtorrent/magnet_uri.hpp> #include <libtorrent/magnet_uri.hpp>

6
src/base/utils/misc.cpp
View file

@ -133,18 +133,18 @@ void Utils::Misc::shutdownComputer(const ShutdownDialogAction &action)
if (action == ShutdownDialogAction::Suspend) if (action == ShutdownDialogAction::Suspend)
{ {
::SetSuspendState(false, false, false); ::SetSuspendState(FALSE, FALSE, FALSE);
} }
else if (action == ShutdownDialogAction::Hibernate) else if (action == ShutdownDialogAction::Hibernate)
{ {
::SetSuspendState(true, false, false); ::SetSuspendState(TRUE, FALSE, FALSE);
} }
else else
{ {
const QString msg = QCoreApplication::translate("misc", "qBittorrent will shutdown the computer now because all downloads are complete."); const QString msg = QCoreApplication::translate("misc", "qBittorrent will shutdown the computer now because all downloads are complete.");
auto msgWchar = std::make_unique<wchar_t[]>(msg.length() + 1); auto msgWchar = std::make_unique<wchar_t[]>(msg.length() + 1);
msg.toWCharArray(msgWchar.get()); msg.toWCharArray(msgWchar.get());
::InitiateSystemShutdownW(nullptr, msgWchar.get(), 10, true, false); ::InitiateSystemShutdownW(nullptr, msgWchar.get(), 10, TRUE, FALSE);
} }
// Disable shutdown privilege. // Disable shutdown privilege.