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 namespace Tairent
  29 {
  30
  31 namespace Core
  32 {
  33
  34 class BitField;
  35
  36 }; // namespace Core
  37
  38 namespace Main
  39 {
  40
  41 class Connection;
  42
  43 struct FileStruct
  44 {
  45         int fd;
  46         unsigned int refCount;
  47 };
  48
  49 struct FilePositionStruct
  50 {
  51         String name;
  52         uint64_t length;
  53         uint64_t start;
  54 };
  55
  56 struct PieceStruct
  57 {
  58         struct FilePieceStruct {
  59                 char *mem;
  60                 void *priv;
  61                 int fd;
  62                 uint32_t start;
  63                 uint32_t length;
  64                 uint32_t privLength;
  65         };
  66
  67         unsigned int refCount;
  68         std::list<FilePieceStruct> pieces;
  69 };
  70
  71 struct RequestStruct
  72 {
  73         std::set<uint32_t> queued;
  74         std::set<uint32_t> requested;
  75 };
  76
  77 /** \brief Storage is an abstraction layer over filesystem.
  78  */
  79 class Storage
  80 {
  81         public:
  82                 /** Constructs a new Storage object for a torrent.
  83                  *
  84                  * \param i Info part of the torrent metainfo.
  85                  */
  86                 Storage(const Tairent::Core::BEncode &i);
  87
  88                 /** Destroys the object.
  89                  */
  90                 ~Storage();
  91
  92                 /** Adds a bitfield to the availability list.
  93                  */
  94                 void addBitField(Tairent::Core::BitField *b);
  95
  96                 /** Starts downloading of the incoming piece.
  97                  */
  98                 void gotPiece(uint32_t index, uint32_t start, Connection *c);
  99
 100                 /** Picks a piece to download. If there is a piece to download then
 101                  * this method returns true; otherwise returns false.
 102                  *
 103                  * \param b Peer's bitfield.
 104                  * \param index Index of the block.
 105                  * \param start Start of the piece within the block.
 106                  * \param legnth Length of the piece.
 107                  */
 108                 bool pickPiece(Tairent::Core::BitField *b, uint32_t &index, uint32_t &start, uint32_t &length);
 109
 110                 /** Informs that a requested piece was downloaded.
 111                  */
 112                 void pieceDownloaded(uint32_t index, uint32_t start, Connection *c);
 113
 114                 /** Removes a bitfield from the availability list.
 115                  */
 116                 void removeBitField(Tairent::Core::BitField *b);
 117
 118                 /** Returns true if the client should be interested; otherwise returns
 119                  * false. (See BitTorrent protocol for details.)
 120                  */
 121                 bool shouldBeInterested(Tairent::Core::BitField *b);
 122
 123         public:
 124                 Tairon::Core::Signal2<void, Storage *, Connection *> invalidDataSignal;
 125
 126         private:
 127                 /** Fills files list and computes total length.
 128                  */
 129                 void buildFilesList();
 130
 131                 /** Closes opened file if it isn't used.
 132                  */
 133                 void closeFile(const String &name);
 134
 135                 /** Creates a file and truncates it to the specified length.
 136                  */
 137                 void createFile(const String &name, uint64_t length);
 138
 139                 /** Creates files for this torrent.
 140                  */
 141                 void createFiles();
 142
 143                 /** Returns length of a chunk.
 144                  *
 145                  * \param index Piece number.
 146                  * \param start Offset of the chunk within the piece.
 147                  */
 148                 inline uint32_t getChunkLength(uint32_t index, uint32_t start);
 149
 150                 /** Returns length of a piece.
 151                  *
 152                  * \param index Piece number.
 153                  */
 154                 inline uint32_t getPieceLength(uint32_t index);
 155
 156                 /** Converts a path list to a string.
 157                  */
 158                 String listToString(const Tairent::Core::BEncode::List &l);
 159
 160                 /** Maps a piece to the memory.
 161                  */
 162                 void mapPiece(uint32_t index);
 163
 164                 /** Opens a file.
 165                  *
 166                  * \param filename Path with the file including its name.
 167                  */
 168                 int openFile(const String &filename);
 169
 170                 /** Creates a permutation of pieces numbers.
 171                  */
 172                 void scramble();
 173
 174         private:
 175                 /** How many peers have specific piece.
 176                  */
 177                 unsigned short *availability;
 178
 179                 /** Bitfield of this storage.
 180                  */
 181                 Tairent::Core::BitField *bitfield;
 182
 183                 /** List of opened files.
 184                  */
 185                 std::map<String, FileStruct> files;
 186
 187                 /** List of positions of files.
 188                  */
 189                 std::list<FilePositionStruct> filesPositions;
 190
 191                 /** Info part of the torrent metainfo.
 192                  */
 193                 const Tairent::Core::BEncode &info;
 194
 195                 /** Number of pieces.
 196                  */
 197                 size_t pieceCount;
 198
 199                 /** Length of one piece.
 200                  */
 201                 uint32_t pieceLength;
 202
 203                 /** Mapping from piece index to its struct.
 204                  */
 205                 std::map<uint32_t, PieceStruct *> pieces;
 206
 207                 /** List of active requests. The key is a piece index.
 208                  */
 209                 std::map<uint32_t, RequestStruct *> requests;
 210
 211                 /** A permutation of length pieceCount.
 212                  */
 213                 std::list<uint32_t> scrambled;
 214
 215                 /** Sum of lengths of all files.
 216                  */
 217                 uint64_t totalLength;
 218 };
 219
 220 }; // namespace Main
 221
 222 }; // namespace Tairent
 223
 224 #endif
 225
 226 // vim: ai sw=4 ts=4 noet fdm=marker