src/base/http/server.cpp

   1 /*
   2  * Bittorrent Client using Qt and libtorrent.
   3  * Copyright (C) 2014  Vladimir Golovnev <glassez@yandex.ru>
   4  * Copyright (C) 2006  Christophe Dumez <chris@qbittorrent.org>
   5  * Copyright (C) 2006  Ishan Arora <ishan@qbittorrent.org>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20  *
  21  * In addition, as a special exception, the copyright holders give permission to
  22  * link this program with the OpenSSL project's "OpenSSL" library (or with
  23  * modified versions of it that use the same license as the "OpenSSL" library),
  24  * and distribute the linked executables. You must obey the GNU General Public
  25  * License in all respects for all of the code used other than "OpenSSL".  If you
  26  * modify file(s), you may extend this exception to your version of the file(s),
  27  * but you are not obligated to do so. If you do not wish to do so, delete this
  28  * exception statement from your version.
  29  */
  30
  31 #include "server.h"
  32
  33 #include <algorithm>
  34
  35 #include <QNetworkProxy>
  36 #include <QSslCipher>
  37 #include <QSslConfiguration>
  38 #include <QSslSocket>
  39 #include <QStringList>
  40 #include <QTimer>
  41
  42 #include "base/algorithm.h"
  43 #include "base/utils/net.h"
  44 #include "connection.h"
  45
  46 namespace
  47 {
  48     const int KEEP_ALIVE_DURATION = 7 * 1000;  // milliseconds
  49     const int CONNECTIONS_LIMIT = 500;
  50     const int CONNECTIONS_SCAN_INTERVAL = 2;  // seconds
  51
  52     QList<QSslCipher> safeCipherList()
  53     {
  54         const QStringList badCiphers {"idea", "rc4"};
  55         const QList<QSslCipher> allCiphers {QSslConfiguration::supportedCiphers()};
  56         QList<QSslCipher> safeCiphers;
  57         std::copy_if(allCiphers.cbegin(), allCiphers.cend(), std::back_inserter(safeCiphers), [&badCiphers](const QSslCipher &cipher)
  58         {
  59             return std::none_of(badCiphers.cbegin(), badCiphers.cend(), [&cipher](const QString &badCipher)
  60             {
  61                 return cipher.name().contains(badCipher, Qt::CaseInsensitive);
  62             });
  63         });
  64         return safeCiphers;
  65     }
  66 }
  67
  68 using namespace Http;
  69
  70 Server::Server(IRequestHandler *requestHandler, QObject *parent)
  71     : QTcpServer(parent)
  72     , m_requestHandler(requestHandler)
  73     , m_https(false)
  74 {
  75     setProxy(QNetworkProxy::NoProxy);
  76
  77     QSslConfiguration sslConf {QSslConfiguration::defaultConfiguration()};
  78     sslConf.setCiphers(safeCipherList());
  79     QSslConfiguration::setDefaultConfiguration(sslConf);
  80
  81     auto *dropConnectionTimer = new QTimer(this);
  82     connect(dropConnectionTimer, &QTimer::timeout, this, &Server::dropTimedOutConnection);
  83     dropConnectionTimer->start(CONNECTIONS_SCAN_INTERVAL * 1000);
  84 }
  85
  86 void Server::incomingConnection(const qintptr socketDescriptor)
  87 {
  88     if (m_connections.size() >= CONNECTIONS_LIMIT) return;
  89
  90     QTcpSocket *serverSocket;
  91     if (m_https)
  92         serverSocket = new QSslSocket(this);
  93     else
  94         serverSocket = new QTcpSocket(this);
  95
  96     if (!serverSocket->setSocketDescriptor(socketDescriptor))
  97     {
  98         delete serverSocket;
  99         return;
 100     }
 101
 102     if (m_https)
 103     {
 104         static_cast<QSslSocket *>(serverSocket)->setProtocol(QSsl::SecureProtocols);
 105         static_cast<QSslSocket *>(serverSocket)->setPrivateKey(m_key);
 106         static_cast<QSslSocket *>(serverSocket)->setLocalCertificateChain(m_certificates);
 107         static_cast<QSslSocket *>(serverSocket)->setPeerVerifyMode(QSslSocket::VerifyNone);
 108         static_cast<QSslSocket *>(serverSocket)->startServerEncryption();
 109     }
 110
 111     auto *c = new Connection(serverSocket, m_requestHandler, this);
 112     m_connections.insert(c);
 113     connect(serverSocket, &QAbstractSocket::disconnected, this, [c, this]() { removeConnection(c); });
 114 }
 115
 116 void Server::removeConnection(Connection *connection)
 117 {
 118     m_connections.remove(connection);
 119     connection->deleteLater();
 120 }
 121
 122 void Server::dropTimedOutConnection()
 123 {
 124     Algorithm::removeIf(m_connections, [](Connection *connection)
 125     {
 126         if (!connection->hasExpired(KEEP_ALIVE_DURATION))
 127             return false;
 128
 129         connection->deleteLater();
 130         return true;
 131     });
 132 }
 133
 134 bool Server::setupHttps(const QByteArray &certificates, const QByteArray &privateKey)
 135 {
 136     const QList<QSslCertificate> certs {Utils::Net::loadSSLCertificate(certificates)};
 137     const QSslKey key {Utils::Net::loadSSLKey(privateKey)};
 138
 139     if (certs.isEmpty() || key.isNull())
 140     {
 141         disableHttps();
 142         return false;
 143     }
 144
 145     m_key = key;
 146     m_certificates = certs;
 147     m_https = true;
 148     return true;
 149 }
 150
 151 void Server::disableHttps()
 152 {
 153     m_https = false;
 154     m_certificates.clear();
 155     m_key.clear();
 156 }