src/main/storage.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_storage_h
  18 #define _main_storage_h
  19
  20 #include <list>
  21 #include <map>
  22 #include <set>
  23
  24 #include <tairon/core/signals.h>
  25
  26 #include "core/bencode.h"
  27
  28 class TiXmlElement;
  29 class TiXmlNode;
  30
  31 namespace Tairent
  32 {
  33
  34 namespace Core
  35 {
  36
  37 class BitField;
  38
  39 }; // namespace Core
  40
  41 namespace Main
  42 {
  43
  44 class Connection;
  45 class HashChecker;
  46
  47 struct PieceReadersStruct;
  48 struct PieceWritersStruct;
  49
  50 /** \brief Struct for file descriptor and number of references to the file.
  51  */
  52 struct FileStruct
  53 {
  54         /** File descriptor.
  55          */
  56         int fd;
  57
  58         /** Number of references.
  59          */
  60         unsigned int refCount;
  61 };
  62
  63 /** \brief Struct containing informations about file's offset and its length.
  64  */
  65 struct FilePositionStruct
  66 {
  67         /** Filename.
  68          */
  69         String name;
  70
  71         /** Length of the file.
  72          */
  73         uint64_t length;
  74
  75         /** Offset of the file from the beginning.
  76          */
  77         uint64_t start;
  78 };
  79
  80 /** \brief Struct for informations about piece mapped to the memory.
  81  */
  82 struct PieceStruct
  83 {
  84         /** \brief Struct for part of the piece that belongs to one file.
  85          */
  86         struct FilePieceStruct {
  87                 /** File from which this piece is mapped.
  88                  */
  89                 const String *filename;
  90
  91                 /** Beginning of the piece in the memory.
  92                  */
  93                 char *mem;
  94
  95                 /** Real beginning of the piece in the memory due to alignment.
  96                  */
  97                 void *priv;
  98
  99                 /** Position of the part in the piece.
 100                  */
 101                 uint32_t start;
 102
 103                 /** Length of the part.
 104                  */
 105                 uint32_t length;
 106
 107                 /** Real length of the part.
 108                  */
 109                 uint32_t privLength;
 110         };
 111
 112         /** Number of references to the piece.
 113          */
 114         unsigned int refCount;
 115
 116         /** List of piece's parts.
 117          */
 118         std::list<FilePieceStruct> pieces;
 119 };
 120
 121 /** \brief Struct for piece's requests.
 122  */
 123 struct RequestStruct
 124 {
 125         /** Contains indexes of chunks that haven't been requested yet.
 126          */
 127         std::set<uint32_t> queued;
 128
 129         /** Contains indexes of chunks that have been requested.
 130          */
 131         std::set<uint32_t> requested;
 132 };
 133
 134 /** \brief Storage is an abstraction layer over filesystem.
 135  */
 136 class Storage
 137 {
 138         public:
 139                 /** Constructs a new Storage object and loads fast-resume info (if
 140                  * available).
 141                  *
 142                  * \param i Info part of the torrent metainfo;
 143                  * \param n Node with fast-resume data.
 144                  */
 145                 Storage(const Tairent::Core::BEncode &i, TiXmlNode *n = 0);
 146
 147                 /** Destroys the object.
 148                  */
 149                 ~Storage();
 150
 151                 /** Adds a bitfield to the availability list.
 152                  */
 153                 void addBitField(Tairent::Core::BitField *b);
 154
 155                 /** Tells this storage that everything has been downloaded.
 156                  */
 157                 void complete();
 158
 159                 /** Returns bitfield of this storage.
 160                  */
 161                 Tairent::Core::BitField *getBitField() {
 162                         return bitfield;
 163                 };
 164
 165                 /** Returns info part of the torrent metainfo.
 166                  */
 167                 const Tairent::Core::BEncode &getMetaInfo() {
 168                         return info;
 169                 };
 170
 171                 /** Returns informations about piece.
 172                  */
 173                 PieceStruct *getPiece(uint32_t index);
 174
 175                 /** Returns number of bytes that are still left to download.
 176                  */
 177                 uint64_t getRemainingSize();
 178
 179                 /** Informs this storage that a peer has something new. Returns true if
 180                  * the piece is interesting for us.
 181                  *
 182                  * \param index Piece index the peer has.
 183                  */
 184                 bool gotHave(uint32_t index);
 185
 186                 /** Starts downloading of the incoming piece.
 187                  */
 188                 void gotPiece(uint32_t index, uint32_t start, Connection *c);
 189
 190                 /** Sends requested piece to the peer.
 191                  *
 192                  * \param index Index of the piece.
 193                  * \param start Start of the chunk within the piece.
 194                  * \param length Length of the requested chunk.
 195                  * \param c Connection to the peer.
 196                  */
 197                 void gotRequest(uint32_t index, uint32_t start, uint32_t length, Connection *c);
 198
 199                 /** Returns true if this storage has stored some piece; otherwise
 200                  * returns false.
 201                  */
 202                 bool hasSomething();
 203
 204                 /** Returns true if there is nothing left to be downloaded; otherwise
 205                  * returns false.
 206                  */
 207                 bool isComplete();
 208
 209                 /** Picks a piece to download. If there is a piece to download then
 210                  * this method returns true; otherwise returns false.
 211                  *
 212                  * \param b Peer's bitfield.
 213                  * \param index Index of the block.
 214                  * \param start Start of the piece within the block.
 215                  * \param length Length of the piece.
 216                  */
 217                 bool pickPiece(Tairent::Core::BitField *b, uint32_t &index, uint32_t &start, uint32_t &length);
 218
 219                 /** Informs that a requested piece was downloaded.
 220                  */
 221                 void pieceDownloaded(uint32_t index, uint32_t start);
 222
 223                 /** Informs that a piece requested by a peer has been sent.
 224                  */
 225                 void pieceSent(uint32_t index);
 226
 227                 /** Removes a bitfield from the availability list.
 228                  */
 229                 void removeBitField(Tairent::Core::BitField *b);
 230
 231                 /** Informs this storage that we don't expect some pieces to arrive so
 232                  * it should rerequest them.
 233                  *
 234                  * \param r Mapping piece index => list of piece parts to rerequest.
 235                  */
 236                 void reRequest(const std::map<uint32_t, std::set<uint32_t> > &r);
 237
 238                 /** Returns an XML element that contains informations needed to fast
 239                  * resume this storage.
 240                  */
 241                 TiXmlElement *save();
 242
 243                 /** Returns true if the client should be interested; otherwise returns
 244                  * false. (See BitTorrent protocol for details.)
 245                  */
 246                 bool shouldBeInterested(Tairent::Core::BitField *b);
 247
 248                 /** Unmaps piece that hasn't been read.
 249                  */
 250                 void unmapPieces(PieceReadersStruct *readers);
 251
 252                 /** Unmaps piece that hasn't been sent.
 253                  */
 254                 void unmapPieces(PieceWritersStruct *writers);
 255
 256         public:
 257                 /** This signal is emitted when a peer has sent an invalid data.
 258                  */
 259                 Tairon::Core::Signal1<void, Connection *> invalidDataSignal;
 260
 261                 /** Emitted when a piece has been successfuly downloaded and its hash
 262                  * checked against the one from metainfo.
 263                  */
 264                 Tairon::Core::Signal1<void, uint32_t> pieceDownloadedSignal;
 265
 266         private:
 267                 /** Fills files list and computes total length.
 268                  */
 269                 void buildFilesList();
 270
 271                 /** Closes opened file if it isn't used.
 272                  */
 273                 void closeFile(const String &name);
 274
 275                 /** Creates a file and truncates it to the specified length.
 276                  */
 277                 void createFile(const String &name, uint64_t length);
 278
 279                 /** Creates files for this torrent.
 280                  */
 281                 void createFiles();
 282
 283                 /** Returns length of a chunk.
 284                  *
 285                  * \param index Piece number.
 286                  * \param start Offset of the chunk within the piece.
 287                  */
 288                 inline uint32_t getChunkLength(uint32_t index, uint32_t start);
 289
 290                 /** Returns length of a piece.
 291                  *
 292                  * \param index Piece number.
 293                  */
 294                 inline uint32_t getPieceLength(uint32_t index);
 295
 296                 /** Called when a recieved piece's hash is the same as in the info.
 297                  */
 298                 void hashCorrect(uint32_t index, HashChecker *checker);
 299
 300                 /** Called when a recieved piece's hash isn't the same as in the info.
 301                  */
 302                 void hashIncorrect(uint32_t index, HashChecker *checker);
 303
 304                 /** Converts a path list to a string.
 305                  */
 306                 String listToString(const Tairent::Core::BEncode::List &l);
 307
 308                 /** Loads fast resume data from an XML node.
 309                  */
 310                 void load(TiXmlNode *n);
 311
 312                 /** Loads bitfield from a node.
 313                  */
 314                 void loadBitField(TiXmlNode *n);
 315
 316                 /** Loads information about queued parts from a node.
 317                  */
 318                 void loadQueued(TiXmlNode *n);
 319
 320                 /** Maps a piece to the memory.
 321                  */
 322                 void mapPiece(uint32_t index);
 323
 324                 /** Opens a file and returns its descriptor.
 325                  *
 326                  * \param filename Path with the file including its name.
 327                  */
 328                 int openFile(const String &filename);
 329
 330                 /** Creates a permutation of pieces numbers.
 331                  */
 332                 void scramble();
 333
 334                 /** Unmaps apiece from the memory. The piece isn't actually unmapped
 335                  * but moved to the cache from which it will be deleted when it will be
 336                  * needed.
 337                  */
 338                 void unmapPiece(uint32_t index);
 339
 340         private:
 341                 /** How many peers have specific piece.
 342                  */
 343                 unsigned short *availability;
 344
 345                 /** Bitfield of this storage.
 346                  */
 347                 Tairent::Core::BitField *bitfield;
 348
 349                 /** List of opened files.
 350                  */
 351                 std::map<String, FileStruct> files;
 352
 353                 /** List of positions of files.
 354                  */
 355                 std::list<FilePositionStruct> filesPositions;
 356
 357                 /** List of active checkers.
 358                  */
 359                 std::set<HashChecker *> hashCheckers;
 360
 361                 /** Info part of the torrent metainfo.
 362                  */
 363                 const Tairent::Core::BEncode &info;
 364
 365                 /** Number of pieces.
 366                  */
 367                 size_t pieceCount;
 368
 369                 /** Length of one piece.
 370                  */
 371                 uint32_t pieceLength;
 372
 373                 /** Mapping from piece index to its struct.
 374                  */
 375                 std::map<uint32_t, PieceStruct *> pieces;
 376
 377                 /** List of active requests. The key is a piece index.
 378                  */
 379                 std::map<uint32_t, RequestStruct *> requests;
 380
 381                 /** A permutation of length pieceCount.
 382                  */
 383                 std::list<uint32_t> scrambled;
 384
 385                 /** Sum of lengths of all files.
 386                  */
 387                 uint64_t totalLength;
 388 };
 389
 390 }; // namespace Main
 391
 392 }; // namespace Tairent
 393
 394 #endif
 395
 396 // vim: ai sw=4 ts=4 noet fdm=marker