src/main/connection.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_connection_h
  18 #define _main_connection_h
  19
  20 #include <list>
  21 #include <map>
  22 #include <set>
  23
  24 #include <tairon/core/signals.h>
  25
  26 using Tairon::Core::String;
  27
  28 namespace Tairon
  29 {
  30
  31 namespace Net
  32 {
  33
  34 class Limiter;
  35 class Reader;
  36 class Socket;
  37 class Writer;
  38
  39 }; // namespace Net
  40
  41 }; // namespace Tairon
  42
  43 namespace Tairent
  44 {
  45
  46 namespace Core
  47 {
  48
  49 class BitField;
  50
  51 }; // namespace Core
  52
  53 namespace Main
  54 {
  55
  56 class RateMeasurer;
  57 class TorrentClient;
  58
  59 /** \brief Struct for informations about piece readers.
  60  *
  61  * Piece readers are used for reading a piece from the peer. This struct holds
  62  * a list with all readers used to read the piece and piece's index.
  63  */
  64 struct PieceReadersStruct
  65 {
  66         /** Index of the piece.
  67          */
  68         uint32_t index;
  69
  70         /** List of piece's readers.
  71          */
  72         std::list<Tairon::Net::Reader *> readers;
  73 };
  74
  75 /** \brief Struct for informations about piece writers.
  76  *
  77  * Piece writers are used for writing a piece to the peer. This struct holds a
  78  * list with all writers used to write the piece and piece's index.
  79  */
  80 struct PieceWritersStruct
  81 {
  82         /** Index of the piece.
  83          */
  84         uint32_t index;
  85
  86         /** Length of the piece.
  87          */
  88         uint32_t length;
  89
  90         /** list of piece's writers.
  91          */
  92         std::list<Tairon::Net::Writer *> writers;
  93 };
  94
  95 /** \brief Connection between two torrent clients.
  96  *
  97  * This class handles low level things around BitTorrent protocol.
  98  */
  99 class Connection
 100 {
 101         public:
 102                 /** Constructs a Connection object.
 103                  *
 104                  * \param fd Descriptor of the socket.
 105                  * \param c Client for this connection. If there is no client
 106                  * specified, then the connection is incoming and the client will wait
 107                  * for a peer id and info hash before handshaking.
 108                  */
 109                 Connection(int fd, TorrentClient *c = 0);
 110
 111                 /** Destroys the obejct.
 112                  */
 113                 ~Connection();
 114
 115                 /** Appends a writer to the command queue. It immediately starts
 116                  * writing if the queue is empty.
 117                  */
 118                 void addCommandWriter(Tairon::Net::Writer *writer);
 119
 120                 /** Adds a list of writers that will send peer some piece.
 121                  */
 122                 void addWriters(PieceWritersStruct *writers);
 123
 124                 /** Clears mapping with requested pieces.
 125                  */
 126                 void clearRequested();
 127
 128                 /** Closes the connection.
 129                  */
 130                 void close();
 131
 132                 /** Destroys piece readers that are in the queue.
 133                  */
 134                 void destroyPieceReaders();
 135
 136                 /** Destroys piece writers that are in the queue.
 137                  */
 138                 void destroyPieceWriters();
 139
 140                 /** Returns this peer's bitfield.
 141                  */
 142                 Tairent::Core::BitField *getBitField() {
 143                         return bitfield;
 144                 };
 145
 146                 /** Returns current incoming rate.
 147                  */
 148                 double getIncomingRate();
 149
 150                 /** Returns length of the piece incoming right now.
 151                  */
 152                 uint32_t getPieceLength();
 153
 154                 /** Returns current piece reader. If there is no piece reader then this method returns 0.
 155                  */
 156                 PieceReadersStruct *getPieceReader() {
 157                         return pieceReaders;
 158                 };
 159
 160                 /** Returns list with queued piece writers.
 161                  */
 162                 const std::list<PieceWritersStruct *> &getPieceWriters() {
 163                         return pieceWriters;
 164                 };
 165
 166                 /** Returns pointer to the limiter that limits reading.
 167                  */
 168                 Tairon::Net::Limiter *getReadingLimiter();
 169
 170                 /** Returns reference to the mapping with requested pieces.
 171                  */
 172                 const std::map<uint32_t, std::set<uint32_t> > &getRequested() {
 173                         return requests;
 174                 };
 175
 176                 /** Returns pointer to the connection's socket.
 177                  */
 178                 Tairon::Net::Socket *getSocket() {
 179                         return socket;
 180                 };
 181
 182                 /** Returns pointer to the limiter that limits writing.
 183                  */
 184                 Tairon::Net::Limiter *getWritingLimiter();
 185
 186                 /** Returns true it we are being choked by the peer; otheriwse returns
 187                  * false.
 188                  */
 189                 bool isChoked() {
 190                         return choked;
 191                 };
 192
 193                 /** Returns true if we are interested; otherwise returns false.
 194                  */
 195                 bool isInterested() {
 196                         return interested;
 197                 };
 198
 199                 /** Returns true if we are choking the peer; otherise returns false.
 200                  */
 201                 bool isPeerChoked() {
 202                         return peerChoked;
 203                 };
 204
 205                 /** Returns true if the peer is interested; otherwise returns false.
 206                  */
 207                 bool isPeerInterested() {
 208                         return peerInterested;
 209                 };
 210
 211                 /** Returns true if this connection is snubbed; otherwise returns false.
 212                  *
 213                  * TODO: write what snubbed means
 214                  */
 215                 bool isSnubbed();
 216
 217                 /** Sends choke message to the peer.
 218                  */
 219                 void sendChoke();
 220
 221                 /** Sends handshake sequence to the peer.
 222                  *
 223                  * \param infoHash 20 byte length SHA1 hash of the info part of the torrent.
 224                  */
 225                 void sendHandshake(const String &infoHash);
 226
 227                 /** Sends have message to the peer.
 228                  *
 229                  * \param index Number of the piece that we currently have.
 230                  */
 231                 void sendHave(uint32_t index);
 232
 233                 /** Sends interested message to the peer.
 234                  */
 235                 void sendInterested();
 236
 237                 /** Sends not interested message to the peer.
 238                  */
 239                 void sendNotInterested();
 240
 241                 /** Sends request message to the peer.
 242                  */
 243                 void sendRequest(uint32_t index, uint32_t start, uint32_t length);
 244
 245                 /** Sends unchoke message to the peer.
 246                  */
 247                 void sendUnchoke();
 248
 249                 /** Sets list of readers that read a piece.
 250                  */
 251                 void setReaders(PieceReadersStruct *readers);
 252
 253         public:
 254                 /** Signal emitted when the connection is closed.
 255                  */
 256                 Tairon::Core::Signal1<void, Connection *> closedSignal;
 257
 258         private:
 259                 /** Called when a Writer has written data to the socket.
 260                  */
 261                 void dataWritten(Tairon::Net::Writer *writer);
 262
 263                 /** Called when a piece Writer has written data to the socket.
 264                  */
 265                 void pieceDataWritten(Tairon::Net::Writer *writer);
 266
 267                 /** Called by a piece reader. Frees all remaining piece readers, closes
 268                  * the connection and emits the closedSignal.
 269                  */
 270                 void pieceReaderError(Tairon::Net::Reader *, Tairon::Net::Socket *);
 271
 272                 /** Reads peer's bitfield.
 273                  */
 274                 void readBitField(Tairon::Net::Reader *);
 275
 276                 /** Reads one byte command (i.e. message type).
 277                  */
 278                 void readCommand(Tairon::Net::Reader *);
 279
 280                 /** Called when a socket error occured while reading by a reader. Emits
 281                  * the closedSignal.
 282                  */
 283                 void readerError(Tairon::Net::Reader *, Tairon::Net::Socket *);
 284
 285                 /** Reads first command.
 286                  */
 287                 void readFirstCommand(Tairon::Net::Reader *);
 288
 289                 /** Reads length of the first command.
 290                  */
 291                 void readFirstLength(Tairon::Net::Reader *);
 292
 293                 /** Reads handshake sequence.
 294                  */
 295                 void readHandshake(Tairon::Net::Reader *);
 296
 297                 /** Reads have message.
 298                  */
 299                 void readHave(Tairon::Net::Reader *);
 300
 301                 /** Reads length of the message.
 302                  */
 303                 void readLength(Tairon::Net::Reader *);
 304
 305                 /** Reads peer ID.
 306                  */
 307                 void readPeerID(Tairon::Net::Reader *);
 308
 309                 /** Reads index and start of the piece.
 310                  */
 311                 void readPiece(Tairon::Net::Reader *);
 312
 313                 /** Reads index, start and length of a peer's request.
 314                  */
 315                 void readRequest(Tairon::Net::Reader *);
 316
 317                 /** Called when the socket is ready to read.
 318                  */
 319                 void readyRead(Tairon::Net::Socket *);
 320
 321                 /** Called when the socket is ready to write.
 322                  */
 323                 void readyWrite(Tairon::Net::Socket *);
 324
 325                 /** Sets the next reader used for reading a piece.
 326                  */
 327                 void setNextReader(Tairon::Net::Reader *);
 328
 329                 /** Called when a socket error occured. Closes the connection and emits
 330                  * the closedSignal.
 331                  */
 332                 void socketError(Tairon::Net::Socket *, int);
 333
 334                 /** Called when a socket error occured while writing to the socket by a
 335                  * writer. Emits the closedSignal.
 336                  */
 337                 void writerError(Tairon::Net::Writer *, Tairon::Net::Socket *);
 338
 339         private:
 340                 /** Peer's bitfield of pieces.
 341                  */
 342                 Tairent::Core::BitField *bitfield;
 343
 344                 /** Whether we are choked by the peer.
 345                  */
 346                 bool choked;
 347
 348                 /** Client for this connection.
 349                  */
 350                 TorrentClient *client;
 351
 352                 /** Length of the current command.
 353                  */
 354                 uint32_t commandLength;
 355
 356                 /** Queue with unsent commands. The first element may be writing to the
 357                  * socket.
 358                  */
 359                 std::list<Tairon::Net::Writer *> commandQueue;
 360
 361                 /** Reader used for reading commands.
 362                  */
 363                 Tairon::Net::Reader *commandReader;
 364
 365                 /** Whether the current reader should be deleted.
 366                  */
 367                 bool deleteReader;
 368
 369                 /** Measurer for incoming rate.
 370                  */
 371                 RateMeasurer *incomingRate;
 372
 373                 /** Are we interested?
 374                  */
 375                 bool interested;
 376
 377                 /** Time (in miliseconds) of last piece arrival.
 378                  */
 379                 uint64_t lastPieceTime;
 380
 381                 /** Reader used for reading length of messages.
 382                  */
 383                 Tairon::Net::Reader *lengthReader;
 384
 385                 bool peerChoked;
 386
 387                 /** Is the peer interested?
 388                  */
 389                 bool peerInterested;
 390
 391                 /** Index of the piece that is being downloaded now.
 392                  */
 393                 uint32_t pieceIndex;
 394
 395                 /** List of readers used for reading a piece.
 396                  */
 397                 PieceReadersStruct *pieceReaders;
 398
 399                 /** List of lists with piece writers.
 400                  */
 401                 std::list<PieceWritersStruct *> pieceWriters;
 402
 403                 /** Start of the piece that is being downloaded now.
 404                  */
 405                 uint32_t pieceStart;
 406
 407                 /** Reader used for reading from the socket.
 408                  */
 409                 Tairon::Net::Reader *reader;
 410
 411                 /** Method that will read data from the socket.
 412                  */
 413                 void (Connection::*readMethod)();
 414
 415                 /** Lists of requests sent to the peer.
 416                  */
 417                 std::map<uint32_t, std::set<uint32_t> > requests;
 418
 419                 /** Whether we are sending a piece to the peer.
 420                  */
 421                 bool sendingPiece;
 422
 423                 /** Socket associated with this connection.
 424                  */
 425                 Tairon::Net::Socket *socket;
 426 };
 427
 428 }; // namespace Main
 429
 430 }; // namespace Tairent
 431
 432 #endif
 433
 434 // vim: ai sw=4 ts=4 noet fdm=marker