src/main/torrentmanager.h

   1 /***************************************************************************
   2  *                                                                         *
   3  *   Copyright (C) 2006-2007 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_torrentmanager_h
  18 #define _main_torrentmanager_h
  19
  20 #include <map>
  21
  22 #include <tairon/core/string.h>
  23
  24 using Tairon::Core::String;
  25
  26 class TiXmlNode;
  27
  28 namespace Tairon
  29 {
  30
  31 namespace Net
  32 {
  33
  34 class Timer;
  35
  36 }; // namespace Net
  37
  38 }; // namespace Tairon
  39
  40 namespace Tairent
  41 {
  42
  43 namespace Core
  44 {
  45
  46 class BEncode;
  47
  48 }; // namespace Core
  49
  50 namespace Main
  51 {
  52
  53 class Storage;
  54 class TorrentClient;
  55
  56 /** \brief Holds informations about managed torrents.
  57  *
  58  * This class is a singleton.
  59  */
  60 struct TorrentStruct
  61 {
  62         /** Client for this torrent. If there is no such client then it is zero.
  63          */
  64         TorrentClient *client;
  65
  66         /** This client's storage. It is used for fast-resuming.
  67          */
  68         Storage *storage;
  69
  70         /** Meta info of the torrent. If the metainfo has not been loaded yet then
  71          * it is zero.
  72          */
  73         Tairent::Core::BEncode *metaInfo;
  74
  75         /** Whether this torrent is completely downloaded.
  76          */
  77         bool complete;
  78
  79         /** Filename of torrent.
  80          */
  81         String torrentFile;
  82 };
  83
  84 /** \brief TorrentManager keeps informations about managed torrents.
  85  */
  86 class TorrentManager
  87 {
  88         public:
  89                 /** Constructs a TorrentManager object; calls loadTorrent().
  90                  */
  91                 TorrentManager();
  92
  93                 /** Destroys the object.
  94                  */
  95                 ~TorrentManager();
  96
  97                 /** Converts data in bin to its hexadecimal variant.
  98                  */
  99                 static String binToHex(const String &data);
 100
 101                 /** Deletes all active clients.
 102                  */
 103                 void destroy();
 104
 105                 /** Returns a TorrentClient object associated with given info hash. The
 106                  * method returns 0 if there is no such client.
 107                  */
 108                 TorrentClient *getClient(const String &infoHash);
 109
 110                 /** Returns client ID.
 111                  */
 112                 const String &getClientID();
 113
 114                 /** Returns TorrentStruct for given info hash.
 115                  */
 116                 TorrentStruct *getTorrent(const String &infoHash);
 117
 118                 /** Returns dictionary with torrents.
 119                  */
 120                 const std::map<String, TorrentStruct *> &getTorrents() {
 121                         return torrents;
 122                 };
 123
 124                 /** Converts data in hex to its binary original.
 125                  */
 126                 static String hexToBin(const String &data);
 127
 128                 /** Returns true if the torrent has set the private flag; otherwise
 129                  * returns false.
 130                  */
 131                 bool isPrivate(const Tairent::Core::BEncode &metaInfo);
 132
 133                 /** Saves informations about managed torrents to resume.xml file in
 134                  * torrents-directory configuration option.
 135                  */
 136                 void save();
 137
 138                 /** Returns pointer to the instance of this class.
 139                  */
 140                 static TorrentManager *self() {
 141                         return torrentManager;
 142                 };
 143
 144                 /** Starts downloading unfinished torrents.
 145                  */
 146                 void startTorrents();
 147
 148                 /** Stops downloading torrents.
 149                  */
 150                 void stopTorrents();
 151
 152         private:
 153                 /** Helper method for converting hex char to an integer.
 154                  */
 155                 static char hexToBin(char c);
 156
 157                 /** Loads metainfo from a file with given filename. A new
 158                  * Tairent::Core::BEncode object is created and filled with
 159                  * informations from the file. Zero is returned if any error occurs
 160                  * while loading.
 161                  */
 162                 Tairent::Core::BEncode *loadMetaInfo(const String &filename);
 163
 164                 /** Loads informations about torrents from file resume.xml stored in a
 165                  * directory whose name is stored in Tairon::Core::Config as
 166                  * "torrents-directory". This file is created for fast-resuming
 167                  * torrents.
 168                  */
 169                 void loadResume();
 170
 171                 /** Loads informations about one torrent from a node.
 172                  *
 173                  * \param t Element with informations about torrent.
 174                  */
 175                 void loadTorrent(TiXmlNode *t);
 176
 177                 /** Loads fast-resume data about one torrent from a node.
 178                  *
 179                  * \param n Element with fast-resume data.
 180                  */
 181                 void loadTorrentResume(TiXmlNode *n);
 182
 183                 /** Loads informations about torrents from file torrents.xml stored in
 184                  * a directory whose name is stored in Tairon::Core::Config as
 185                  * "torrents-directory".
 186                  */
 187                 void loadTorrents();
 188
 189                 /** Creates client ID.
 190                  */
 191                 void makeClientID();
 192
 193         private:
 194                 /** Client ID.
 195                  */
 196                 String clientID;
 197
 198                 /** Timer for calling save() method.
 199                  */
 200                 Tairon::Net::Timer *saveTimer;
 201
 202                 /** Pointer to the instance of this class.
 203                  */
 204                 static TorrentManager *torrentManager;
 205
 206                 /** Mapping hash (raw, not human-readable) -> info about torrent.
 207                  */
 208                 std::map<String, TorrentStruct *> torrents;
 209 };
 210
 211 }; // namespace Main
 212
 213 }; // namespace Tairent
 214
 215 #endif
 216
 217 // vim: ai sw=4 ts=4 noet fdm=marker