src/base/bittorrent/peerinfo.cpp

   1 /*
   2  * Bittorrent Client using Qt and libtorrent.
   3  * Copyright (C) 2015-2023  Vladimir Golovnev <glassez@yandex.ru>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  *
  19  * In addition, as a special exception, the copyright holders give permission to
  20  * link this program with the OpenSSL project's "OpenSSL" library (or with
  21  * modified versions of it that use the same license as the "OpenSSL" library),
  22  * and distribute the linked executables. You must obey the GNU General Public
  23  * License in all respects for all of the code used other than "OpenSSL".  If you
  24  * modify file(s), you may extend this exception to your version of the file(s),
  25  * but you are not obligated to do so. If you do not wish to do so, delete this
  26  * exception statement from your version.
  27  */
  28
  29 #include "peerinfo.h"
  30
  31 #include <QBitArray>
  32
  33 #include "base/bittorrent/ltqbitarray.h"
  34 #include "base/net/geoipmanager.h"
  35 #include "base/unicodestrings.h"
  36 #include "base/utils/bytearray.h"
  37 #include "peeraddress.h"
  38
  39 using namespace BitTorrent;
  40
  41 PeerInfo::PeerInfo(const lt::peer_info &nativeInfo, const QBitArray &allPieces)
  42     : m_nativeInfo(nativeInfo)
  43     , m_relevance(calcRelevance(allPieces))
  44 {
  45     determineFlags();
  46 }
  47
  48 bool PeerInfo::fromDHT() const
  49 {
  50     return static_cast<bool>(m_nativeInfo.source & lt::peer_info::dht);
  51 }
  52
  53 bool PeerInfo::fromPeX() const
  54 {
  55     return static_cast<bool>(m_nativeInfo.source & lt::peer_info::pex);
  56 }
  57
  58 bool PeerInfo::fromLSD() const
  59 {
  60     return static_cast<bool>(m_nativeInfo.source & lt::peer_info::lsd);
  61 }
  62
  63 QString PeerInfo::country() const
  64 {
  65     if (m_country.isEmpty())
  66         m_country = Net::GeoIPManager::instance()->lookup(address().ip);
  67     return m_country;
  68 }
  69
  70 bool PeerInfo::isInteresting() const
  71 {
  72     return static_cast<bool>(m_nativeInfo.flags & lt::peer_info::interesting);
  73 }
  74
  75 bool PeerInfo::isChocked() const
  76 {
  77     return static_cast<bool>(m_nativeInfo.flags & lt::peer_info::choked);
  78 }
  79
  80 bool PeerInfo::isRemoteInterested() const
  81 {
  82     return static_cast<bool>(m_nativeInfo.flags & lt::peer_info::remote_interested);
  83 }
  84
  85 bool PeerInfo::isRemoteChocked() const
  86 {
  87     return static_cast<bool>(m_nativeInfo.flags & lt::peer_info::remote_choked);
  88 }
  89
  90 bool PeerInfo::isSupportsExtensions() const
  91 {
  92     return static_cast<bool>(m_nativeInfo.flags & lt::peer_info::supports_extensions);
  93 }
  94
  95 bool PeerInfo::isLocalConnection() const
  96 {
  97     return static_cast<bool>(m_nativeInfo.flags & lt::peer_info::local_connection);
  98 }
  99
 100 bool PeerInfo::isHandshake() const
 101 {
 102     return static_cast<bool>(m_nativeInfo.flags & lt::peer_info::handshake);
 103 }
 104
 105 bool PeerInfo::isConnecting() const
 106 {
 107     return static_cast<bool>(m_nativeInfo.flags & lt::peer_info::connecting);
 108 }
 109
 110 bool PeerInfo::isOnParole() const
 111 {
 112     return static_cast<bool>(m_nativeInfo.flags & lt::peer_info::on_parole);
 113 }
 114
 115 bool PeerInfo::isSeed() const
 116 {
 117     return static_cast<bool>(m_nativeInfo.flags & lt::peer_info::seed);
 118 }
 119
 120 bool PeerInfo::optimisticUnchoke() const
 121 {
 122     return static_cast<bool>(m_nativeInfo.flags & lt::peer_info::optimistic_unchoke);
 123 }
 124
 125 bool PeerInfo::isSnubbed() const
 126 {
 127     return static_cast<bool>(m_nativeInfo.flags & lt::peer_info::snubbed);
 128 }
 129
 130 bool PeerInfo::isUploadOnly() const
 131 {
 132     return static_cast<bool>(m_nativeInfo.flags & lt::peer_info::upload_only);
 133 }
 134
 135 bool PeerInfo::isEndgameMode() const
 136 {
 137     return static_cast<bool>(m_nativeInfo.flags & lt::peer_info::endgame_mode);
 138 }
 139
 140 bool PeerInfo::isHolepunched() const
 141 {
 142     return static_cast<bool>(m_nativeInfo.flags & lt::peer_info::holepunched);
 143 }
 144
 145 bool PeerInfo::useI2PSocket() const
 146 {
 147     return static_cast<bool>(m_nativeInfo.flags & lt::peer_info::i2p_socket);
 148 }
 149
 150 bool PeerInfo::useUTPSocket() const
 151 {
 152     return static_cast<bool>(m_nativeInfo.flags & lt::peer_info::utp_socket);
 153 }
 154
 155 bool PeerInfo::useSSLSocket() const
 156 {
 157     return static_cast<bool>(m_nativeInfo.flags & lt::peer_info::ssl_socket);
 158 }
 159
 160 bool PeerInfo::isRC4Encrypted() const
 161 {
 162     return static_cast<bool>(m_nativeInfo.flags & lt::peer_info::rc4_encrypted);
 163 }
 164
 165 bool PeerInfo::isPlaintextEncrypted() const
 166 {
 167     return static_cast<bool>(m_nativeInfo.flags & lt::peer_info::plaintext_encrypted);
 168 }
 169
 170 PeerAddress PeerInfo::address() const
 171 {
 172     if (useI2PSocket())
 173         return {};
 174
 175     // fast path for platforms which boost.asio internal struct maps to `sockaddr`
 176     return {QHostAddress(m_nativeInfo.ip.data()), m_nativeInfo.ip.port()};
 177     // slow path for the others
 178     //return {QHostAddress(QString::fromStdString(m_nativeInfo.ip.address().to_string()))
 179     //    , m_nativeInfo.ip.port()};
 180 }
 181
 182 QString PeerInfo::I2PAddress() const
 183 {
 184     if (!useI2PSocket())
 185         return {};
 186
 187 #ifdef QBT_USES_LIBTORRENT2
 188     if (m_I2PAddress.isEmpty())
 189     {
 190         const lt::sha256_hash destHash = m_nativeInfo.i2p_destination();
 191         const QByteArray base32Dest = Utils::ByteArray::toBase32({destHash.data(), destHash.size()}).replace('=', "").toLower();
 192         m_I2PAddress = QString::fromLatin1(base32Dest) + u".b32.i2p";
 193     }
 194 #endif
 195
 196     return m_I2PAddress;
 197 }
 198
 199 QString PeerInfo::client() const
 200 {
 201     return QString::fromStdString(m_nativeInfo.client);
 202 }
 203
 204 QString PeerInfo::peerIdClient() const
 205 {
 206     // when peer ID is not known yet it contains only zero bytes,
 207     // do not create string in such case, return empty string instead
 208     if (m_nativeInfo.pid.is_all_zeros())
 209         return {};
 210
 211     QString result;
 212
 213     // interesting part of a typical peer ID is first 8 chars
 214     for (int i = 0; i < 8; ++i)
 215     {
 216         const std::uint8_t c = m_nativeInfo.pid[i];
 217
 218         // ensure that the peer ID slice consists only of printable ASCII characters,
 219         // this should filter out most of the improper IDs
 220         if ((c < 32) || (c > 126))
 221             return tr("Unknown");
 222
 223         result += QChar::fromLatin1(c);
 224     }
 225
 226     return result;
 227 }
 228
 229 qreal PeerInfo::progress() const
 230 {
 231     return m_nativeInfo.progress;
 232 }
 233
 234 int PeerInfo::payloadUpSpeed() const
 235 {
 236     return m_nativeInfo.payload_up_speed;
 237 }
 238
 239 int PeerInfo::payloadDownSpeed() const
 240 {
 241     return m_nativeInfo.payload_down_speed;
 242 }
 243
 244 qlonglong PeerInfo::totalUpload() const
 245 {
 246     return m_nativeInfo.total_upload;
 247 }
 248
 249 qlonglong PeerInfo::totalDownload() const
 250 {
 251     return m_nativeInfo.total_download;
 252 }
 253
 254 QBitArray PeerInfo::pieces() const
 255 {
 256     return LT::toQBitArray(m_nativeInfo.pieces);
 257 }
 258
 259 QString PeerInfo::connectionType() const
 260 {
 261     if (m_nativeInfo.flags & lt::peer_info::utp_socket)
 262         return C_UTP;
 263
 264     return (m_nativeInfo.connection_type == lt::peer_info::standard_bittorrent)
 265         ? u"BT"_qs
 266         : u"Web"_qs;
 267 }
 268
 269 qreal PeerInfo::calcRelevance(const QBitArray &allPieces) const
 270 {
 271     const int localMissing = allPieces.count(false);
 272     if (localMissing <= 0)
 273         return 0;
 274
 275     const QBitArray peerPieces = pieces();
 276     const int remoteHaves = (peerPieces & (~allPieces)).count(true);
 277     return static_cast<qreal>(remoteHaves) / localMissing;
 278 }
 279
 280 qreal PeerInfo::relevance() const
 281 {
 282     return m_relevance;
 283 }
 284
 285 void PeerInfo::determineFlags()
 286 {
 287     const auto updateFlags = [this](const QChar specifier, const QString &explanation)
 288     {
 289         m_flags += (specifier + u' ');
 290         m_flagsDescription += u"%1 = %2\n"_qs.arg(specifier, explanation);
 291     };
 292
 293     if (isInteresting())
 294     {
 295         if (isRemoteChocked())
 296         {
 297             // d = Your client wants to download, but peer doesn't want to send (interested and choked)
 298             updateFlags(u'd', tr("Interested (local) and choked (peer)"));
 299         }
 300         else
 301         {
 302             // D = Currently downloading (interested and not choked)
 303             updateFlags(u'D', tr("Interested (local) and unchoked (peer)"));
 304         }
 305     }
 306
 307     if (isRemoteInterested())
 308     {
 309         if (isChocked())
 310         {
 311             // u = Peer wants your client to upload, but your client doesn't want to (interested and choked)
 312             updateFlags(u'u', tr("Interested (peer) and choked (local)"));
 313         }
 314         else
 315         {
 316             // U = Currently uploading (interested and not choked)
 317             updateFlags(u'U', tr("Interested (peer) and unchoked (local)"));
 318         }
 319     }
 320
 321     // K = Peer is unchoking your client, but your client is not interested
 322     if (!isRemoteChocked() && !isInteresting())
 323         updateFlags(u'K', tr("Not interested (local) and unchoked (peer)"));
 324
 325     // ? = Your client unchoked the peer but the peer is not interested
 326     if (!isChocked() && !isRemoteInterested())
 327         updateFlags(u'?', tr("Not interested (peer) and unchoked (local)"));
 328
 329     // O = Optimistic unchoke
 330     if (optimisticUnchoke())
 331         updateFlags(u'O', tr("Optimistic unchoke"));
 332
 333     // S = Peer is snubbed
 334     if (isSnubbed())
 335         updateFlags(u'S', tr("Peer snubbed"));
 336
 337     // I = Peer is an incoming connection
 338     if (!isLocalConnection())
 339         updateFlags(u'I', tr("Incoming connection"));
 340
 341     // H = Peer was obtained through DHT
 342     if (fromDHT())
 343         updateFlags(u'H', tr("Peer from DHT"));
 344
 345     // X = Peer was included in peerlists obtained through Peer Exchange (PEX)
 346     if (fromPeX())
 347         updateFlags(u'X', tr("Peer from PEX"));
 348
 349     // L = Peer is local
 350     if (fromLSD())
 351         updateFlags(u'L', tr("Peer from LSD"));
 352
 353     // E = Peer is using Protocol Encryption (all traffic)
 354     if (isRC4Encrypted())
 355         updateFlags(u'E', tr("Encrypted traffic"));
 356
 357     // e = Peer is using Protocol Encryption (handshake)
 358     if (isPlaintextEncrypted())
 359         updateFlags(u'e', tr("Encrypted handshake"));
 360
 361     // P = Peer is using uTorrent uTP
 362     if (useUTPSocket())
 363         updateFlags(u'P', C_UTP);
 364
 365     m_flags.chop(1);
 366     m_flagsDescription.chop(1);
 367 }
 368
 369 QString PeerInfo::flags() const
 370 {
 371     return m_flags;
 372 }
 373
 374 QString PeerInfo::flagsDescription() const
 375 {
 376     return m_flagsDescription;
 377 }
 378
 379 int PeerInfo::downloadingPieceIndex() const
 380 {
 381     return static_cast<int>(m_nativeInfo.downloading_piece_index);
 382 }