d4708
/
qBittorrent
mirror of https://github.com/d47081/qBittorrent.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Reformat code

adaptive-webui-19844
Chocobo1 3 years ago
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
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 40
      src/app/qtlocalpeer/qtlocalpeer.cpp
  2. 12
      src/app/qtlocalpeer/qtlocalpeer.h
  3. 14
      src/app/qtlocalpeer/qtlockedfile.cpp
  4. 12
      src/app/qtlocalpeer/qtlockedfile.h
  5. 22
      src/app/qtlocalpeer/qtlockedfile_unix.cpp
  6. 167
      src/app/qtlocalpeer/qtlockedfile_win.cpp
  7. 4
      src/base/bittorrent/torrentimpl.cpp
  8. 6
      src/base/utils/misc.cpp

40
src/app/qtlocalpeer/qtlocalpeer.cpp
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
#define MAX_READERS MAXIMUM_WAIT_OBJECTS
#define QT_WA(unicode, ansi) unicode // Maximum number of concurrent read locks. Must not be greater than MAXIMUM_WAIT_OBJECTS
const int MAX_READERS = MAXIMUM_WAIT_OBJECTS;
Qt::HANDLE QtLockedFile::getMutexHandle(int idx, bool doCreate) Qt::HANDLE QtLockedFile::getMutexHandle(const int idx, const bool doCreate)
{ {
if (mutexname.isEmpty()) { if (m_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;
}
return nullptr;
} }
bool QtLockedFile::waitMutex(Qt::HANDLE mutex, bool doBlock) 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
Unescape 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
Unescape 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.

Write Preview
Loading…
Cancel
Save