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                 /** Returns bitfield of this storage.
 156                  */
 157                 Tairent::Core::BitField *getBitField() {
 158                         return bitfield;
 159                 };
 160
 161                 /** Returns info part of the torrent metainfo.
 162                  */
 163                 const Tairent::Core::BEncode &getMetaInfo() {
 164                         return info;
 165                 };
 166
 167                 /** Returns informations about piece.
 168                  */
 169                 PieceStruct *getPiece(uint32_t index);
 170
 171                 /** Returns number of bytes that are still left to download.
 172                  */
 173                 uint64_t getRemainingSize();
 174
 175                 /** Informs this storage that a peer has something new. Returns true if
 176                  * the piece is interesting for us.
 177                  *
 178                  * \param index Piece index the peer has.
 179                  */
 180                 bool gotHave(uint32_t index);
 181
 182                 /** Starts downloading of the incoming piece.
 183                  */
 184                 void gotPiece(uint32_t index, uint32_t start, Connection *c);
 185
 186                 /** Sends requested piece to the peer.
 187                  *
 188                  * \param index Index of the piece.
 189                  * \param start Start of the chunk within the piece.
 190                  * \param length Length of the requested chunk.
 191                  * \param c Connection to the peer.
 192                  */
 193                 void gotRequest(uint32_t index, uint32_t start, uint32_t length, Connection *c);
 194
 195                 /** Returns true if this storage has stored some piece; otherwise
 196                  * returns false.
 197                  */
 198                 bool hasSomething();
 199
 200                 /** Picks a piece to download. If there is a piece to download then
 201                  * this method returns true; otherwise returns false.
 202                  *
 203                  * \param b Peer's bitfield.
 204                  * \param index Index of the block.
 205                  * \param start Start of the piece within the block.
 206                  * \param length Length of the piece.
 207                  */
 208                 bool pickPiece(Tairent::Core::BitField *b, uint32_t &index, uint32_t &start, uint32_t &length);
 209
 210                 /** Informs that a requested piece was downloaded.
 211                  */
 212                 void pieceDownloaded(uint32_t index, uint32_t start);
 213
 214                 /** Informs that a piece requested by a peer has been sent.
 215                  */
 216                 void pieceSent(uint32_t index);
 217
 218                 /** Removes a bitfield from the availability list.
 219                  */
 220                 void removeBitField(Tairent::Core::BitField *b);
 221
 222                 /** Informs this storage that we don't expect some pieces to arrive so
 223                  * it should rerequest them.
 224                  *
 225                  * \param r Mapping piece index => list of piece parts to rerequest.
 226                  */
 227                 void reRequest(const std::map<uint32_t, std::set<uint32_t> > &r);
 228
 229                 /** Returns an XML element that contains informations needed to fast
 230                  * resume this storage.
 231                  */
 232                 TiXmlElement *save();
 233
 234                 /** Returns true if the client should be interested; otherwise returns
 235                  * false. (See BitTorrent protocol for details.)
 236                  */
 237                 bool shouldBeInterested(Tairent::Core::BitField *b);
 238
 239                 /** Unmaps piece that hasn't been read.
 240                  */
 241                 void unmapPieces(PieceReadersStruct *readers);
 242
 243                 /** Unmaps piece that hasn't been sent.
 244                  */
 245                 void unmapPieces(PieceWritersStruct *writers);
 246
 247         public:
 248                 /** This signal is emitted when a peer has sent an invalid data.
 249                  */
 250                 Tairon::Core::Signal1<void, Connection *> invalidDataSignal;
 251
 252                 /** Emitted when a piece has been successfuly downloaded and its hash
 253                  * checked against the one from metainfo.
 254                  */
 255                 Tairon::Core::Signal1<void, uint32_t> pieceDownloadedSignal;
 256
 257         private:
 258                 /** Fills files list and computes total length.
 259                  */
 260                 void buildFilesList();
 261
 262                 /** Closes opened file if it isn't used.
 263                  */
 264                 void closeFile(const String &name);
 265
 266                 /** Creates a file and truncates it to the specified length.
 267                  */
 268                 void createFile(const String &name, uint64_t length);
 269
 270                 /** Creates files for this torrent.
 271                  */
 272                 void createFiles();
 273
 274                 /** Returns length of a chunk.
 275                  *
 276                  * \param index Piece number.
 277                  * \param start Offset of the chunk within the piece.
 278                  */
 279                 inline uint32_t getChunkLength(uint32_t index, uint32_t start);
 280
 281                 /** Returns length of a piece.
 282                  *
 283                  * \param index Piece number.
 284                  */
 285                 inline uint32_t getPieceLength(uint32_t index);
 286
 287                 /** Called when a recieved piece's hash is the same as in the info.
 288                  */
 289                 void hashCorrect(uint32_t index, HashChecker *checker);
 290
 291                 /** Called when a recieved piece's hash isn't the same as in the info.
 292                  */
 293                 void hashIncorrect(uint32_t index, HashChecker *checker);
 294
 295                 /** Converts a path list to a string.
 296                  */
 297                 String listToString(const Tairent::Core::BEncode::List &l);
 298
 299                 /** Loads fast resume data from an XML node.
 300                  */
 301                 void load(TiXmlNode *n);
 302
 303                 /** Loads bitfield from a node.
 304                  */
 305                 void loadBitField(TiXmlNode *n);
 306
 307                 /** Loads information about queued parts from a node.
 308                  */
 309                 void loadQueued(TiXmlNode *n);
 310
 311                 /** Maps a piece to the memory.
 312                  */
 313                 void mapPiece(uint32_t index);
 314
 315                 /** Opens a file and returns its descriptor.
 316                  *
 317                  * \param filename Path with the file including its name.
 318                  */
 319                 int openFile(const String &filename);
 320
 321                 /** Creates a permutation of pieces numbers.
 322                  */
 323                 void scramble();
 324
 325                 /** Unmaps apiece from the memory. The piece isn't actually unmapped
 326                  * but moved to the cache from which it will be deleted when it will be
 327                  * needed.
 328                  */
 329                 void unmapPiece(uint32_t index);
 330
 331         private:
 332                 /** How many peers have specific piece.
 333                  */
 334                 unsigned short *availability;
 335
 336                 /** Bitfield of this storage.
 337                  */
 338                 Tairent::Core::BitField *bitfield;
 339
 340                 /** List of opened files.
 341                  */
 342                 std::map<String, FileStruct> files;
 343
 344                 /** List of positions of files.
 345                  */
 346                 std::list<FilePositionStruct> filesPositions;
 347
 348                 /** List of active checkers.
 349                  */
 350                 std::set<HashChecker *> hashCheckers;
 351
 352                 /** Info part of the torrent metainfo.
 353                  */
 354                 const Tairent::Core::BEncode &info;
 355
 356                 /** Number of pieces.
 357                  */
 358                 size_t pieceCount;
 359
 360                 /** Length of one piece.
 361                  */
 362                 uint32_t pieceLength;
 363
 364                 /** Mapping from piece index to its struct.
 365                  */
 366                 std::map<uint32_t, PieceStruct *> pieces;
 367
 368                 /** List of active requests. The key is a piece index.
 369                  */
 370                 std::map<uint32_t, RequestStruct *> requests;
 371
 372                 /** A permutation of length pieceCount.
 373                  */
 374                 std::list<uint32_t> scrambled;
 375
 376                 /** Sum of lengths of all files.
 377                  */
 378                 uint64_t totalLength;
 379 };
 380
 381 }; // namespace Main
 382
 383 }; // namespace Tairent
 384
 385 #endif
 386
 387 // vim: ai sw=4 ts=4 noet fdm=marker