src/main/torrentclient.h

   1 /***************************************************************************
   2  *                                                                         *
   3  *   Copyright (C) 2006 David Brodsky                                      *
   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 as        *
   7  *   published by the Free Software Foundation and appearing               *
   8  *   in the file LICENSE.GPL included in the packaging of this file.       *
   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 GNU      *
  13  *   General Public License for more details.                              *
  14  *                                                                         *
  15  ***************************************************************************/
  16
  17 #ifndef _main_torrentclient_h
  18 #define _main_torrentclient_h
  19
  20 #include <map>
  21
  22 #include <tairon/core/string.h>
  23
  24 using Tairon::Core::String;
  25
  26 namespace Tairon
  27 {
  28
  29 namespace Net
  30 {
  31
  32 class Timer;
  33
  34 };
  35
  36 };
  37
  38 namespace Tairent
  39 {
  40
  41 namespace Core
  42 {
  43
  44 class BEncode;
  45
  46 };
  47
  48 namespace Main
  49 {
  50
  51 struct TorrentStruct;
  52
  53 class Connection;
  54 class Storage;
  55 class TrackerClient;
  56
  57 /** Struct with informations about one peer that this client can connect to.
  58  */
  59 struct PeerStruct
  60 {
  61         /** Peer's id.
  62          */
  63         String id;
  64
  65         /** IP address of the peer.
  66          */
  67         String ip;
  68
  69         /** Port on which the peer is listening.
  70          */
  71         uint16_t port;
  72 };
  73
  74 /** \brief TorrentClient manages running of one torrent.
  75  */
  76 class TorrentClient
  77 {
  78         public:
  79                 /** Creates a TorrentClient object.
  80                  *
  81                  * \param t Structure that contains informations about this torrent.
  82                  * \param ih 20 byte SHA1 hash of the info field of metainfo.
  83                  * \param s Storage created with fast-resume data.
  84                  */
  85                 TorrentClient(TorrentStruct *t, const String &ih, Storage *s = 0);
  86
  87                 /** Destroys the object.
  88                  */
  89                 ~TorrentClient();
  90
  91                 /** Informs this client about new possible peers.
  92                  */
  93                 void addPeers(const std::list<PeerStruct> &peers);
  94
  95                 /** Called when a connecting to a peer failed. Erases connection from
  96                  * the list pending connections and deletes that connection.
  97                  */
  98                 void connectingFailed(Connection *c);
  99
 100                 /** Called when a connection has been closed.
 101                  */
 102                 void connectionClosed(Connection *c);
 103
 104                 /** Returns number of bytes downloaded so far.
 105                  */
 106                 uint64_t getDownloadedSize() {
 107                         return downloaded;
 108                 };
 109
 110                 /** Returns 20 byte SHA1 hash of the info field of metainfo.
 111                  */
 112                 const String &getInfoHash();
 113
 114                 /** Returns metainfo associated with this client.
 115                  */
 116                 const Tairent::Core::BEncode &getMetaInfo();
 117
 118                 /** Returns number of bytes that are still left to download.
 119                  */
 120                 uint64_t getRemainingSize();
 121
 122                 /** Returns client's Storage object.
 123                  */
 124                 Storage *getStorage();
 125
 126                 /** Returns number of bytes uploaded so far.
 127                  */
 128                 uint64_t getUploadedSize() {
 129                         return uploaded;
 130                 };
 131
 132                 /** Called when we get a peer bitfield.
 133                  */
 134                 void gotBitField(Connection *c);
 135
 136                 /** Called when we get a choke.
 137                  */
 138                 void gotChoke(Connection *c);
 139
 140                 /** Called when we get a message that a peer has something new.
 141                  *
 142                  * \param index Index of the piece the peer has.
 143                  * \param c Connection with the peer.
 144                  */
 145                 void gotHave(uint32_t index, Connection *c);
 146
 147                 /** Called when the peer changes its interested state.
 148                  */
 149                 void gotInterestedChange(Connection *c);
 150
 151                 /** Called when we get a piece.
 152                  *
 153                  * \param index Index of the piece.
 154                  * \param start Start of the chunk within the piece.
 155                  * \param c Connection that got this message.
 156                  */
 157                 void gotPiece(uint32_t index, uint32_t start, Connection *c);
 158
 159                 /** Called when we get an unchoke.
 160                  */
 161                 void gotUnchoke(Connection *c);
 162
 163                 /** Called when a new peer is completely connected.
 164                  */
 165                 void newConnection(Connection *c);
 166
 167                 /** Called when a complete piece is downloaded.
 168                  *
 169                  * \param index Index of the piece.
 170                  * \param start Start of the chunk within the piece.
 171                  * \param c Connection that got this message.
 172                  */
 173                 void pieceDownloaded(uint32_t index, uint32_t start, Connection *c);
 174
 175                 /** Called when a piece has been sent to the peer.
 176                  *
 177                  * \param index Index of the piece.
 178                  * \param length Length of the piece.
 179                  * \param c Connection with the peer.
 180                  */
 181                 void pieceSent(uint32_t index, uint32_t length, Connection *c);
 182
 183                 /** Stops this client.
 184                  */
 185                 void stop();
 186
 187         private:
 188                 /** This is connected to Storage::invalidDataSignal and closes the connection.
 189                  */
 190                 void invalidDataReceived(Connection *c);
 191
 192                 /** Chokes/unchokes peers.
 193                  */
 194                 void rechoke();
 195
 196                 /** Requests more pieces from the peer.
 197                  */
 198                 void requestMore(Connection *c);
 199
 200                 /** Informs this client that a piece has been downloaded and its hash
 201                  * is correct.
 202                  */
 203                 void pieceDownloadedAndChecked(uint32_t index);
 204
 205         private:
 206                 /** Mapping peer id => connection object. These connections are fully
 207                  * established.
 208                  */
 209                 std::map<String, Connection *> connections;
 210
 211                 /** Number of bytes downloaded so far.
 212                  */
 213                 uint64_t downloaded;
 214
 215                 /** 20 byte SHA1 hash of the info field of metainfo.
 216                  */
 217                 const String &infoHash;
 218
 219                 /** Maximum number of connections this client will handle.
 220                  */
 221                 unsigned int maxConnections;
 222
 223                 /** Maximum number of uploading slots.
 224                  */
 225                 int maxUploads;
 226
 227                 /** Minimum number of uploading slots.
 228                  */
 229                 int minUploads;
 230
 231                 /** Mapping peer id => connection object. These connections are not
 232                  * fully established.
 233                  */
 234                 std::map<String, Connection *> pendingConnections;
 235
 236                 /** Storage for this torrent.
 237                  */
 238                 Storage *storage;
 239
 240                 /** Timer used for rechoking.
 241                  */
 242                 Tairon::Net::Timer *timer;
 243
 244                 /** Informations about this torrent.
 245                  */
 246                 TorrentStruct *torrent;
 247
 248                 /** Tracker used for this torrent.
 249                  */
 250                 TrackerClient *trackerClient;
 251
 252                 /** Number of bytes uploaded so far.
 253                  */
 254                 uint64_t uploaded;
 255 };
 256
 257 }; // namespace Main
 258
 259 }; // namespace Tairent
 260
 261 #endif
 262
 263 // vim: ai sw=4 ts=4 noet fdm=marker