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