src/main/torrentmanager.cpp

   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 #include <cstdlib>
  18 #include <ctime>
  19 #include <fstream>
  20
  21 #include <tairon/core/config.h>
  22 #include <tairon/core/exceptions.h>
  23 #include <tairon/core/log.h>
  24 #include <tairon/core/tinyxml.h>
  25
  26 #include "torrentmanager.h"
  27
  28 #include "core/bencode.h"
  29 #include "torrentclient.h"
  30
  31 #define TAIRENT_VERSION "0.1"
  32
  33 namespace Tairent
  34 {
  35
  36 namespace Main
  37 {
  38
  39 TorrentManager *TorrentManager::torrentManager = 0;
  40
  41 /* {{{ TorrentManager::TorrentManager() */
  42 TorrentManager::TorrentManager()
  43 {
  44         if (torrentManager)
  45                 throw Tairon::Core::SingletonException("Cannot make another instance of Tairent::Main::TorrentManager");
  46
  47         makeClientID();
  48         loadTorrents();
  49
  50         torrentManager = this;
  51 }
  52 /* }}} */
  53
  54 /* {{{ TorrentManager::~TorrentManager() */
  55 TorrentManager::~TorrentManager()
  56 {
  57         torrentManager = 0;
  58 }
  59 /* }}} */
  60
  61 /* {{{ TorrentManager::destroy() */
  62 void TorrentManager::destroy()
  63 {
  64         for (std::map<String, TorrentStruct *>::const_iterator it = torrents.begin(); it != torrents.end(); ++it) {
  65                 if (it->second->client)
  66                         delete it->second->client;
  67                 if (it->second->metaInfo)
  68                         delete it->second->metaInfo;
  69                 delete it->second;
  70         }
  71         torrents.clear();
  72 }
  73 /* }}} */
  74
  75 /* {{{ TorrentManager::getClient(const String &) */
  76 TorrentClient *TorrentManager::getClient(const String &infoHash)
  77 {
  78         if (torrents.count(infoHash)) {
  79                 TorrentStruct *t = torrents[infoHash];
  80                 if (t->client)
  81                         return t->client;
  82
  83                 // TODO: create client
  84         }
  85
  86         return 0; // no client found
  87 }
  88 /* }}} */
  89
  90 /* {{{ TorrentManager::getClientID() */
  91 const String &TorrentManager::getClientID()
  92 {
  93         return clientID;
  94 }
  95 /* }}} */
  96
  97 /* {{{ TorrentManager::hexToBin(char) */
  98 char TorrentManager::hexToBin(char c)
  99 {
 100         if ((c >= '0') && (c <= '9'))
 101                 return c - '0';
 102         return c - 'a' + 10;
 103 }
 104 /* }}} */
 105
 106 /* {{{ TorrentManager::hexToBin(const String &) */
 107 String TorrentManager::hexToBin(const String &data)
 108 {
 109         String ret;
 110         ret.resize(data.length() / 2);
 111
 112         unsigned int i = 0;
 113         const char *d = data;
 114         while (*d) {
 115                 ret[i++] = (hexToBin(*d) << 4) | (hexToBin(*(d + 1)));
 116                 d += 2;
 117         }
 118
 119         return ret;
 120 }
 121 /* }}} */
 122
 123 /* {{{ TorrentManager::loadMetaInfo(const String &) */
 124 Tairent::Core::BEncode *TorrentManager::loadMetaInfo(const String &filename)
 125 {
 126         std::ifstream f(filename, std::ios_base::in);
 127         if (!f.is_open()) {
 128                 WARNING((const char *) String("Cannot load informations from " + filename));
 129                 return 0;
 130         }
 131
 132         Tairent::Core::BEncode *ret = new Tairent::Core::BEncode();
 133         try {
 134                 f >> (*ret);
 135         } catch (const Tairent::Core::BEncodeException &e) {
 136                 WARNING((const char *) String("Cannot load metainfo from " + filename + ": " + (const String &) e));
 137                 delete ret;
 138                 return 0;
 139         }
 140
 141         return ret;
 142 }
 143 /* }}} */
 144
 145 /* {{{ TorrentManager::loadTorrent(TiXmlNode *) */
 146 void TorrentManager::loadTorrent(TiXmlNode *t)
 147 {
 148         TiXmlElement *element = t->ToElement();
 149         const char *data = element->Attribute("file");
 150         if (!data)
 151                 return;
 152
 153         INFO((const char *) String(String("Loading informations about ") + data));
 154
 155         TorrentStruct *torrent = new TorrentStruct;
 156         torrent->client = 0;
 157
 158         torrent->torrentFile = data;
 159
 160         data = element->Attribute("complete");
 161         if (data && (data[0] == '1'))
 162                 torrent->complete = true;
 163         else
 164                 torrent->complete = false;
 165
 166         data = element->Attribute("hash");
 167         if (data) {
 168                 torrent->metaInfo = 0;
 169                 torrents[hexToBin(data)] = torrent;
 170         } else {
 171                 torrent->metaInfo = loadMetaInfo(torrent->torrentFile);
 172                 if (!torrent->metaInfo)
 173                         return;
 174                 String hash = (*torrent->metaInfo)["info"].computeSHA1();
 175                 torrents[hash] = torrent;
 176         }
 177 }
 178 /* }}} */
 179
 180 /* {{{ TorrentManager::loadTorrents() */
 181 void TorrentManager::loadTorrents()
 182 {
 183         TiXmlDocument document;
 184
 185         if (!document.LoadFile((*Tairon::Core::Config::self())["torrents-directory"] + "/torrents.xml"))
 186                 return;
 187
 188         TiXmlElement *root = document.RootElement();
 189         if (!root)
 190                 return;
 191
 192         if (root->ValueStr() != "torrents") // invalid file
 193                 return;
 194
 195         for (TiXmlNode *node = root->FirstChild(); node; node = node->NextSibling()) {
 196                 if (node->Type() != TiXmlNode::ELEMENT)
 197                         continue;
 198                 if (node->ValueStr() == "torrent")
 199                         loadTorrent(node);
 200         }
 201 }
 202 /* }}} */
 203
 204 /* {{{ TorrentManager::makeClientID() */
 205 void TorrentManager::makeClientID()
 206 {
 207         srandom(time(0));
 208
 209         clientID = "TA-" TAIRENT_VERSION "-";
 210         size_t len = clientID.length();
 211         clientID.resize(20);
 212
 213         std::ifstream f("/dev/urandom", std::ios_base::in);
 214         if (f.is_open()) {
 215                 for (size_t i = len; i < 20; ++i)
 216                         clientID[i] = (char) f.get();
 217                 f.close();
 218         } else { // cannot open /dev/urandom? fall back to standard random
 219                 srandom(time(0));
 220                 for (size_t i = len; i < 20; ++i)
 221                         clientID[i] = random() % 256;
 222         }
 223 }
 224 /* }}} */
 225
 226 /* {{{ TorrentManager::startTorrents() */
 227 void TorrentManager::startTorrents()
 228 {
 229         for (std::map<String, TorrentStruct *>::const_iterator it = torrents.begin(); it != torrents.end(); ++it) {
 230                 TorrentStruct *t = it->second;
 231                 if (t->complete)
 232                         continue;
 233
 234                 if (!t->metaInfo)
 235                         t->metaInfo = loadMetaInfo(t->torrentFile);
 236
 237                 if (!t->metaInfo) { // metainfo loading failed
 238                         WARNING((const char *) String("Cannot start torrent " + t->torrentFile));
 239                         continue;
 240                 }
 241
 242                 t->client = new TorrentClient(t, it->first);
 243         }
 244 }
 245 /* }}} */
 246
 247 /* {{{ TorrentManager::stopTorrents() */
 248 void TorrentManager::stopTorrents()
 249 {
 250         for (std::map<String, TorrentStruct *>::const_iterator it = torrents.begin(); it != torrents.end(); ++it)
 251                 it->second->client->stop();
 252 }
 253 /* }}} */
 254
 255 }; // namespace Main
 256
 257 }; // namespace Tairent
 258
 259 // vim: ai sw=4 ts=4 noet fdm=marker