src/core/bencode.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 <sstream>
  18
  19 #include <tairon/crypto/sha1.h>
  20
  21 #include "bencode.h"
  22
  23 namespace Tairent
  24 {
  25
  26 namespace Core
  27 {
  28
  29 /* {{{ BEncode::BEncode() */
  30 BEncode::BEncode() : type(BEncode::NONE)
  31 {
  32 }
  33 /* }}} */
  34
  35 /* {{{ BEncode::BEncode(const int64_t v) */
  36 BEncode::BEncode(const int64_t v) : type(BEncode::VALUE), value(v)
  37 {
  38 }
  39 /* }}} */
  40
  41 /* {{{ BEncode::BEncode(const String &s) */
  42 BEncode::BEncode(const String &s) : type(BEncode::STRING), string(new String(s))
  43 {
  44 }
  45 /* }}} */
  46
  47 /* {{{ BEncode::BEncode(const BEncode &b) */
  48 BEncode::BEncode(const BEncode &b) : type(b.type)
  49 {
  50         switch (b.type) {
  51                 case BEncode::VALUE:
  52                         value = b.value;
  53                         break;
  54                 case BEncode::STRING:
  55                         string = new String(*(b.string));
  56                         break;
  57                 case BEncode::LIST:
  58                         list = new BEncode::List(*(b.list));
  59                         break;
  60                 case BEncode::MAP:
  61                         map = new BEncode::Map(*(b.map));
  62                         break;
  63                 default:
  64                         break;
  65         }
  66 }
  67 /* }}} */
  68
  69 /* {{{ BEncode::BEncode(BEncode::Type t) */
  70 BEncode::BEncode(BEncode::Type t) : type(t)
  71 {
  72         switch (t) {
  73                 case BEncode::VALUE:
  74                         value = 0;
  75                         break;
  76                 case BEncode::STRING:
  77                         string = new String();
  78                         break;
  79                 case BEncode::LIST:
  80                         list = new List();
  81                         break;
  82                 case BEncode::MAP:
  83                         map = new Map();
  84                         break;
  85                 default:
  86                         break;
  87         }
  88 }
  89 /* }}} */
  90
  91 /* {{{ BEncode::~BEncode() */
  92 BEncode::~BEncode()
  93 {
  94         clear();
  95 }
  96 /* }}} */
  97
  98 /* {{{ BEncode::asList() */
  99 BEncode::List &BEncode::asList()
 100 {
 101         if (!isList())
 102                 throw BEncodeException("BEncode is not type list");
 103
 104         return *list;
 105 }
 106 /* }}} */
 107
 108 /* {{{ BEncode::asList() const */
 109 const BEncode::List &BEncode::asList() const
 110 {
 111         if (!isList())
 112                 throw BEncodeException("BEncode is not type list");
 113
 114         return *list;
 115 }
 116 /* }}} */
 117
 118 /* {{{ BEncode::asMap() */
 119 BEncode::Map &BEncode::asMap()
 120 {
 121         if (!isMap())
 122                 throw BEncodeException("BEncode is not type map");
 123
 124         return *map;
 125 }
 126 /* }}} */
 127
 128 /* {{{ BEncode::asMap() const */
 129 const BEncode::Map &BEncode::asMap() const
 130 {
 131         if (!isMap())
 132                 throw BEncodeException("BEncode is not type map");
 133
 134         return *map;
 135 }
 136 /* }}} */
 137
 138 /* {{{ BEncode::asString() */
 139 String &BEncode::asString()
 140 {
 141         if (!isString())
 142                 throw BEncodeException("BEncode is not type string");
 143
 144         return *string;
 145 }
 146 /* }}} */
 147
 148 /* {{{ BEncode::asString() const */
 149 const String &BEncode::asString() const
 150 {
 151         if (!isString())
 152                 throw BEncodeException("BEncode is not type string");
 153
 154         return *string;
 155 }
 156 /* }}} */
 157
 158 /* {{{ BEncode::asValue() */
 159 int64_t &BEncode::asValue()
 160 {
 161         if (!isValue())
 162                 throw BEncodeException("BEncode is not type value");
 163
 164         return value;
 165 }
 166 /* }}} */
 167
 168 /* {{{ BEncode::asValue() const */
 169 const int64_t &BEncode::asValue() const
 170 {
 171         if (!isValue())
 172                 throw BEncodeException("BEncode is not type value");
 173
 174         return value;
 175 }
 176 /* }}} */
 177
 178 /* {{{ BEncode::clear */
 179 void BEncode::clear()
 180 {
 181         switch (type) {
 182                 case BEncode::STRING:
 183                         delete string;
 184                         break;
 185                 case BEncode::LIST:
 186                         delete list;
 187                         break;
 188                 case BEncode::MAP:
 189                         delete map;
 190                         break;
 191                 default:
 192                         break;
 193         }
 194
 195         type = BEncode::NONE;
 196 }
 197 /* }}} */
 198
 199 /* {{{ BEncode::computeSHA1() const */
 200 String BEncode::computeSHA1() const
 201 {
 202         std::stringstream stream;
 203         stream << *this;
 204
 205         if (stream.fail())
 206                 throw BEncodeException("Cannot write BEncode to stream");
 207
 208         return Tairon::Crypto::SHA1::hash(stream.str());
 209 }
 210 /* }}} */
 211
 212 /* {{{ BEncode::isList() const */
 213 bool BEncode::isList() const
 214 {
 215         return (type == BEncode::LIST);
 216 }
 217 /* }}} */
 218
 219 /* {{{ BEncode::isMap() const */
 220 bool BEncode::isMap() const
 221 {
 222         return (type == BEncode::MAP);
 223 }
 224 /* }}} */
 225
 226 /* {{{ BEncode::isString() const */
 227 bool BEncode::isString() const
 228 {
 229         return (type == BEncode::STRING);
 230 }
 231 /* }}} */
 232
 233 /* {{{ BEncode::isValue() const */
 234 bool BEncode::isValue() const
 235 {
 236         return (type == BEncode::VALUE);
 237 }
 238 /* }}} */
 239
 240 /* {{{ BEncode::getType() const */
 241 BEncode::Type BEncode::getType() const
 242 {
 243         return type;
 244 }
 245 /* }}} */
 246
 247 /* {{{ BEncode::operator=(const BEncode &b) */
 248 BEncode &BEncode::operator=(const BEncode &b)
 249 {
 250         clear();
 251
 252         type = b.type;
 253         switch (type) {
 254                 case BEncode::VALUE:
 255                         value = b.value;
 256                         break;
 257                 case BEncode::STRING:
 258                         string = new String(*(b.string));
 259                         break;
 260                 case BEncode::LIST:
 261                         list = new BEncode::List(*(b.list));
 262                         break;
 263                 case BEncode::MAP:
 264                         map = new BEncode::Map(*(b.map));
 265                         break;
 266                 default:
 267                         break;
 268         }
 269
 270         return *this;
 271 }
 272 /* }}} */
 273
 274 /* {{{ BEncode::operator[](const String &key) */
 275 BEncode &BEncode::operator[](const String &key)
 276 {
 277         if (type != BEncode::MAP)
 278                 throw BEncodeException("Wrong type for BEncode operator [" + key + "]");
 279
 280         BEncode::Map::iterator it = map->find(key);
 281
 282         if (it == map->end())
 283                 throw BEncodeException("BEncode operator [] could not find element " + key);
 284
 285         return it->second;
 286 }
 287 /* }}} */
 288
 289 /* {{{ BEncode::operator[](const String &key) const */
 290 const BEncode &BEncode::operator[](const String &key) const
 291 {
 292         if (type != BEncode::MAP)
 293                 throw BEncodeException("Wrong type for BEncode operator [" + key + "]");
 294
 295         BEncode::Map::const_iterator it = map->find(key);
 296
 297         if (it == map->end())
 298                 throw BEncodeException("BEncode operator [] could not find element " + key);
 299
 300         return it->second;
 301 }
 302 /* }}} */
 303
 304 /* {{{ BEncode::readString(std::istream &s, String &str) */
 305 bool BEncode::readString(std::istream &s, String &str)
 306 {
 307         int size;
 308         s >> size;
 309
 310         if (s.fail() || s.get() != ':')
 311                 return false;
 312
 313         str.resize(size);
 314
 315         size_t len = str.length();
 316         for (size_t i = 0; i < len && s.good(); ++i)
 317                 str[i] = s.get();
 318
 319         return !s.fail();
 320 }
 321 /* }}} */
 322
 323 /* {{{ operator>>(std::istream &s, BEncode &b) */
 324 std::istream &operator>>(std::istream &s, BEncode &b)
 325 {
 326         b.clear();
 327
 328         if (s.peek() < 0) {
 329                 s.setstate(std::istream::failbit);
 330                 return s;
 331         }
 332
 333         char c;
 334
 335         const char *reason = 0;
 336
 337         switch (c = s.peek()) {
 338                 case 'i':
 339                         s.get();
 340                         s >> b.value;
 341
 342                         if (s.fail() || s.get() != 'e') {
 343                                 reason = "Failed to load integer";
 344                                 break;
 345                         }
 346
 347                         b.type = BEncode::VALUE;
 348
 349                         return s;
 350
 351                 case 'l':
 352                         s.get();
 353
 354                         b.list = new BEncode::List;
 355                         b.type = BEncode::LIST;
 356
 357                         while (s.good()) {
 358                                 if (s.peek() == 'e') {
 359                                         s.get();
 360                                         return s;
 361                                 }
 362
 363                                 BEncode::List::iterator it = b.list->insert(b.list->end(), BEncode());
 364
 365                                 s >> *it;
 366                         }
 367
 368                         reason = "Failed to load list";
 369
 370                         break;
 371
 372                 case 'd':
 373                         s.get();
 374
 375                         b.map = new BEncode::Map;
 376                         b.type = BEncode::MAP;
 377
 378                         while (s.good()) {
 379                                 if (s.peek() == 'e') {
 380                                         s.get();
 381                                         return s;
 382                                 }
 383
 384                                 String str;
 385
 386                                 if (!BEncode::readString(s, str))
 387                                         break;
 388
 389                                 s >> (*b.map)[str];
 390                         }
 391
 392                         reason = "Failed to load dictionary";
 393
 394                         break;
 395
 396                 default:
 397                         if (c >= '0' && c <= '9') {
 398                                 b.string = new String();
 399                                 b.type = BEncode::STRING;
 400
 401                                 if (b.readString(s, *b.string))
 402                                         return s;
 403                         }
 404
 405                         reason = "Failed to load string";
 406
 407                         break;
 408         }
 409
 410         std::stringstream stream;
 411         stream << reason << " at position " << s.tellg();
 412
 413         s.setstate(std::istream::failbit);
 414         b.clear();
 415
 416         throw BEncodeException(stream.str());
 417
 418         return s;
 419 }
 420 /* }}} */
 421
 422 /* {{{ operator<<(std::ostream &s, const BEncode &b) */
 423 std::ostream &operator<<(std::ostream &s, const BEncode &b)
 424 {
 425         switch (b.type) {
 426                 case BEncode::VALUE:
 427                         return s << 'i' << b.value << 'e';
 428                 case BEncode::STRING:
 429                         return s << b.string->size() << ':' << *(b.string);
 430                 case BEncode::LIST:
 431                         s << 'l';
 432
 433                         for (BEncode::List::const_iterator it = b.list->begin(); it != b.list->end(); ++it)
 434                                 s << *it;
 435
 436                         return s << 'e';
 437                 case BEncode::MAP:
 438                         s << 'd';
 439
 440                         for (BEncode::Map::const_iterator it = b.map->begin(); it != b.map->end(); ++it)
 441                                 s << it->first.size() << ':' << it->first << it->second;
 442
 443                         return s << 'e';
 444                 default:
 445                         break;
 446         }
 447
 448         return s;
 449 }
 450 /* }}} */
 451
 452 }; // namespace Core
 453
 454 }; // namespace Tairent
 455
 456 // vim: ai sw=4 ts=4 noet fdm=marker