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         /** Are these readers fake? That means that we want to read the piece buf
  67          * we don't want the data.
  68          */
  69         bool fake;
  70
  71         /** Index of the piece.
  72          */
  73         uint32_t index;
  74
  75         /** Length of the requested piece.
  76          */
  77         uint32_t length;
  78
  79         /** List of piece's readers.
  80          */
  81         std::list<Tairon::Net::Reader *> readers;
  82 };
  83
  84 /** \brief Struct with informations about one peer's request.
  85  */
  86 struct PieceRequestStruct
  87 {
  88         /** Index of the piece.
  89          */
  90         uint32_t index;
  91
  92         /** Length of the chunk.
  93          */
  94         uint32_t length;
  95
  96         /** Offset of the chunk within the piece.
  97          */
  98         uint32_t start;
  99 };
 100
 101 /** \brief Struct for informations about piece writers.
 102  *
 103  * Piece writers are used for writing a piece to the peer. This struct holds a
 104  * list with all writers used to write the piece and piece's index.
 105  */
 106 struct PieceWritersStruct
 107 {
 108         /** Index of the piece.
 109          */
 110         uint32_t index;
 111
 112         /** Length of the piece.
 113          */
 114         uint32_t length;
 115
 116         /** list of piece's writers.
 117          */
 118         std::list<Tairon::Net::Writer *> writers;
 119 };
 120
 121 /** \brief Connection between two torrent clients.
 122  *
 123  * This class handles low level things around BitTorrent protocol.
 124  */
 125 class Connection
 126 {
 127         public:
 128                 /** Constructs a Connection object.
 129                  *
 130                  * \param fd Descriptor of the socket.
 131                  */
 132                 Connection(int fd);
 133
 134                 /** Constructs a Connection object. Creates a new socket and connects
 135                  * it to the peer.
 136                  *
 137                  * \param ip IP address of the peer.
 138                  * \param port Port on which the peer is listening.
 139                  * \param pID Peer's ID.
 140                  * \param c Client of this connection.
 141                  */
 142                 Connection(const String &ip, uint16_t port, const String &pID, TorrentClient *c);
 143
 144                 /** Destroys the obejct.
 145                  */
 146                 ~Connection();
 147
 148                 /** Appends a writer to the command queue. It immediately starts
 149                  * writing if the queue is empty.
 150                  */
 151                 void addCommandWriter(Tairon::Net::Writer *writer);
 152
 153                 /** Clears mapping with requested pieces.
 154                  */
 155                 void clearRequested();
 156
 157                 /** Closes the connection.
 158                  */
 159                 void close();
 160
 161                 /** Destroys piece readers that are in the queue.
 162                  */
 163                 void destroyPieceReaders();
 164
 165                 /** Destroys piece writers that are in the queue.
 166                  */
 167                 void destroyPieceWriters();
 168
 169                 /** Returns this peer's bitfield.
 170                  */
 171                 Tairent::Core::BitField *getBitField() {
 172                         return bitfield;
 173                 };
 174
 175                 /** Returns current incoming rate.
 176                  */
 177                 double getIncomingRate();
 178
 179                 /** Returns current outgoing rate.
 180                  */
 181                 double getOutgoingRate();
 182
 183                 /** Returns length of the piece incoming right now.
 184                  */
 185                 uint32_t getPieceLength();
 186
 187                 /** Returns current piece reader. If there is no piece reader then this
 188                  * method returns 0.
 189                  */
 190                 PieceReadersStruct *getPieceReader() {
 191                         return pieceReaders;
 192                 };
 193
 194                 /** Returns current piece writer. If there is no piece writer then this
 195                  * method returs 0.
 196                  */
 197                 PieceWritersStruct *getPieceWriter() {
 198                         return pieceWriters;
 199                 };
 200
 201                 /** Returns peer's ID.
 202                  */
 203                 const String &getPeerID() {
 204                         return peerID;
 205                 };
 206
 207                 /** Returns pointer to the limiter that limits reading.
 208                  */
 209                 Tairon::Net::Limiter *getReadingLimiter();
 210
 211                 /** Returns reference to the mapping with requested pieces.
 212                  */
 213                 const std::map<uint32_t, std::set<uint32_t> > &getRequested() {
 214                         return requests;
 215                 };
 216
 217                 /** Returns number of currently requested pieces.
 218                  */
 219                 unsigned int getRequestsCount();
 220
 221                 /** Returns pointer to the connection's socket.
 222                  */
 223                 Tairon::Net::Socket *getSocket() {
 224                         return socket;
 225                 };
 226
 227                 /** Returns time when the peer was unchoked.
 228                  */
 229                 int getUnchokeTime() {
 230                         return unchokeTime;
 231                 };
 232
 233                 /** Returns pointer to the limiter that limits writing.
 234                  */
 235                 Tairon::Net::Limiter *getWritingLimiter();
 236
 237                 /** Returns true it we are being choked by the peer; otheriwse returns
 238                  * false.
 239                  */
 240                 bool isChoked() {
 241                         return choked;
 242                 };
 243
 244                 /** Returns true if we are interested; otherwise returns false.
 245                  */
 246                 bool isInterested() {
 247                         return interested;
 248                 };
 249
 250                 /** Returns true if we are choking the peer; otherise returns false.
 251                  */
 252                 bool isPeerChoked() {
 253                         return peerChoked;
 254                 };
 255
 256                 /** Returns true if the peer is interested; otherwise returns false.
 257                  */
 258                 bool isPeerInterested() {
 259                         return peerInterested;
 260                 };
 261
 262                 /** Returns true if this connection is snubbed; otherwise returns false.
 263                  *
 264                  * TODO: write what snubbed means
 265                  */
 266                 bool isSnubbed();
 267
 268                 /** Sends choke message to the peer.
 269                  */
 270                 void sendChoke();
 271
 272                 /** Sends handshake sequence to the peer.
 273                  *
 274                  * \param infoHash 20 byte length SHA1 hash of the info part of the torrent.
 275                  */
 276                 void sendHandshake(const String &infoHash);
 277
 278                 /** Sends have message to the peer.
 279                  *
 280                  * \param index Number of the piece that we currently have.
 281                  */
 282                 void sendHave(uint32_t index);
 283
 284                 /** Sends interested message to the peer.
 285                  */
 286                 void sendInterested();
 287
 288                 /** Sends not interested message to the peer.
 289                  */
 290                 void sendNotInterested();
 291
 292                 /** Sends request message to the peer.
 293                  */
 294                 void sendRequest(uint32_t index, uint32_t start, uint32_t length);
 295
 296                 /** Sends unchoke message to the peer.
 297                  */
 298                 void sendUnchoke(int time);
 299
 300                 /** Sets peer's ID of this connection. It should be called only when we
 301                  * are trying to connect to that peer.
 302                  */
 303                 void setPeerID(const String &pID) {
 304                         peerID = pID;
 305                 };
 306
 307                 /** Sets list of readers that read a piece.
 308                  */
 309                 void setReaders(PieceReadersStruct *readers);
 310
 311                 /** Sets list of writers that writes a piece.
 312                  */
 313                 void setWriters(PieceWritersStruct *writers);
 314
 315         public:
 316                 /** Signal emitted when the connection is closed.
 317                  */
 318                 Tairon::Core::Signal1<void, Connection *> closedSignal;
 319
 320         private:
 321                 /** Called when a socket error occured while connecting to the socket.
 322                  */
 323                 void connectingError(Tairon::Net::Socket *, int);
 324
 325                 /** Called when a Writer has written data to the socket.
 326                  */
 327                 void dataWritten(Tairon::Net::Writer *writer);
 328
 329                 /** Initializes socket's signals and creates the first reader.
 330                  */
 331                 void init();
 332
 333                 /** Called when a piece Writer has written data to the socket.
 334                  */
 335                 void pieceDataWritten(Tairon::Net::Writer *writer);
 336
 337                 /** Reads peer's bitfield.
 338                  */
 339                 void readBitField(Tairon::Net::Reader *);
 340
 341                 /** Reads cancel message.
 342                  */
 343                 void readCancel(Tairon::Net::Reader *);
 344
 345                 /** Reads one byte command (i.e. message type).
 346                  */
 347                 void readCommand(Tairon::Net::Reader *);
 348
 349                 /** Called when a socket error occured while reading by a reader. Emits
 350                  * the closedSignal.
 351                  */
 352                 void readerError(Tairon::Net::Reader *, Tairon::Net::Socket *);
 353
 354                 /** Reads first command.
 355                  */
 356                 void readFirstCommand(Tairon::Net::Reader *);
 357
 358                 /** Reads length of the first command.
 359                  */
 360                 void readFirstLength(Tairon::Net::Reader *);
 361
 362                 /** Reads handshake sequence.
 363                  */
 364                 void readHandshake(Tairon::Net::Reader *);
 365
 366                 /** Reads have message.
 367                  */
 368                 void readHave(Tairon::Net::Reader *);
 369
 370                 /** Reads length of the message.
 371                  */
 372                 void readLength(Tairon::Net::Reader *);
 373
 374                 /** Reads peer ID.
 375                  */
 376                 void readPeerID(Tairon::Net::Reader *);
 377
 378                 /** Reads index and start of the piece.
 379                  */
 380                 void readPiece(Tairon::Net::Reader *);
 381
 382                 /** Reads length of the protocol name. The first byte that arrives
 383                  * should be 0x13.
 384                  */
 385                 void readProtocolLength(Tairon::Net::Reader *, size_t);
 386
 387                 /** Reads index, start and length of a peer's request.
 388                  */
 389                 void readRequest(Tairon::Net::Reader *);
 390
 391                 /** Called when the socket is ready to read.
 392                  */
 393                 void readyRead(Tairon::Net::Socket *);
 394
 395                 /** Called when the socket is ready to write.
 396                  */
 397                 void readyWrite(Tairon::Net::Socket *);
 398
 399                 /** Sets the next reader used for reading a piece.
 400                  */
 401                 void setNextReader(Tairon::Net::Reader *);
 402
 403                 /** Called when the socket has been connected to the peer.
 404                  */
 405                 void socketConnected(Tairon::Net::Socket *);
 406
 407                 /** Called when a socket error occured. Closes the connection and emits
 408                  * the closedSignal.
 409                  */
 410                 void socketError(Tairon::Net::Socket *, int);
 411
 412                 /** Called when a socket error occured while writing to the socket by a
 413                  * writer. Emits the closedSignal.
 414                  */
 415                 void writerError(Tairon::Net::Writer *, Tairon::Net::Socket *);
 416
 417         private:
 418                 /** Peer's bitfield of pieces.
 419                  */
 420                 Tairent::Core::BitField *bitfield;
 421
 422                 /** Whether we are choked by the peer.
 423                  */
 424                 bool choked;
 425
 426                 /** Client for this connection.
 427                  */
 428                 TorrentClient *client;
 429
 430                 /** Length of the current command.
 431                  */
 432                 uint32_t commandLength;
 433
 434                 /** Queue with unsent commands. The first element may be writing to the
 435                  * socket.
 436                  */
 437                 std::list<Tairon::Net::Writer *> commandQueue;
 438
 439                 /** Reader used for reading commands.
 440                  */
 441                 Tairon::Net::Reader *commandReader;
 442
 443                 /** Whether the current reader should be deleted.
 444                  */
 445                 bool deleteReader;
 446
 447                 /** Measurer for incoming rate.
 448                  */
 449                 RateMeasurer *incomingRate;
 450
 451                 /** Are we interested?
 452                  */
 453                 bool interested;
 454
 455                 /** Time (in miliseconds) of last piece arrival.
 456                  */
 457                 uint64_t lastPieceTime;
 458
 459                 /** Reader used for reading length of messages.
 460                  */
 461                 Tairon::Net::Reader *lengthReader;
 462
 463                 /** Measurer for outgoing rate.
 464                  */
 465                 RateMeasurer *outgoingRate;
 466
 467                 /** Is the peer choked?
 468                  */
 469                 bool peerChoked;
 470
 471                 /** Peer's ID.
 472                  */
 473                 String peerID;
 474
 475                 /** Is the peer interested?
 476                  */
 477                 bool peerInterested;
 478
 479                 /** List of the peer's requests.
 480                  */
 481                 std::list<PieceRequestStruct> peersRequests;
 482
 483                 /** Index of the piece that is being downloaded now.
 484                  */
 485                 uint32_t pieceIndex;
 486
 487                 /** List of readers used for reading a piece.
 488                  */
 489                 PieceReadersStruct *pieceReaders;
 490
 491                 /** List of writers used for writing a piece to the peer.
 492                  */
 493                 PieceWritersStruct *pieceWriters;
 494
 495                 /** Start of the piece that is being downloaded now.
 496                  */
 497                 uint32_t pieceStart;
 498
 499                 /** Reader used for reading from the socket.
 500                  */
 501                 Tairon::Net::Reader *reader;
 502
 503                 /** Method that will read data from the socket.
 504                  */
 505                 void (Connection::*readMethod)();
 506
 507                 /** Lists of requests sent to the peer.
 508                  */
 509                 std::map<uint32_t, std::set<uint32_t> > requests;
 510
 511                 /** Socket associated with this connection.
 512                  */
 513                 Tairon::Net::Socket *socket;
 514
 515                 /** Time when we unchoked the peer.
 516                  */
 517                 int unchokeTime;
 518 };
 519
 520 }; // namespace Main
 521
 522 }; // namespace Tairent
 523
 524 #endif
 525
 526 // vim: ai sw=4 ts=4 noet fdm=marker