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         return (*map)[key];
 281 }
 282 /* }}} */
 283
 284 /* {{{ BEncode::operator[](const String &key) const */
 285 const BEncode &BEncode::operator[](const String &key) const
 286 {
 287         if (type != BEncode::MAP)
 288                 throw BEncodeException("Wrong type for BEncode operator [" + key + "]");
 289
 290         BEncode::Map::const_iterator it = map->find(key);
 291
 292         if (it == map->end())
 293                 throw BEncodeException("BEncode operator [] could not find element " + key);
 294
 295         return it->second;
 296 }
 297 /* }}} */
 298
 299 /* {{{ BEncode::readString(std::istream &s, String &str) */
 300 bool BEncode::readString(std::istream &s, String &str)
 301 {
 302         int size;
 303         s >> size;
 304
 305         if (s.fail() || s.get() != ':')
 306                 return false;
 307
 308         str.resize(size);
 309
 310         size_t len = str.length();
 311         for (size_t i = 0; i < len && s.good(); ++i)
 312                 str[i] = s.get();
 313
 314         return !s.fail();
 315 }
 316 /* }}} */
 317
 318 /* {{{ operator>>(std::istream &s, BEncode &b) */
 319 std::istream &operator>>(std::istream &s, BEncode &b)
 320 {
 321         b.clear();
 322
 323         if (s.peek() < 0) {
 324                 s.setstate(std::istream::failbit);
 325                 return s;
 326         }
 327
 328         char c;
 329
 330         const char *reason = 0;
 331
 332         switch (c = s.peek()) {
 333                 case 'i':
 334                         s.get();
 335                         s >> b.value;
 336
 337                         if (s.fail() || s.get() != 'e') {
 338                                 reason = "Failed to load integer";
 339                                 break;
 340                         }
 341
 342                         b.type = BEncode::VALUE;
 343
 344                         return s;
 345
 346                 case 'l':
 347                         s.get();
 348
 349                         b.list = new BEncode::List;
 350                         b.type = BEncode::LIST;
 351
 352                         while (s.good()) {
 353                                 if (s.peek() == 'e') {
 354                                         s.get();
 355                                         return s;
 356                                 }
 357
 358                                 BEncode::List::iterator it = b.list->insert(b.list->end(), BEncode());
 359
 360                                 s >> *it;
 361                         }
 362
 363                         reason = "Failed to load list";
 364
 365                         break;
 366
 367                 case 'd':
 368                         s.get();
 369
 370                         b.map = new BEncode::Map;
 371                         b.type = BEncode::MAP;
 372
 373                         while (s.good()) {
 374                                 if (s.peek() == 'e') {
 375                                         s.get();
 376                                         return s;
 377                                 }
 378
 379                                 String str;
 380
 381                                 if (!BEncode::readString(s, str))
 382                                         break;
 383
 384                                 s >> (*b.map)[str];
 385                         }
 386
 387                         reason = "Failed to load dictionary";
 388
 389                         break;
 390
 391                 default:
 392                         if (c >= '0' && c <= '9') {
 393                                 b.string = new String();
 394                                 b.type = BEncode::STRING;
 395
 396                                 if (b.readString(s, *b.string))
 397                                         return s;
 398                         }
 399
 400                         reason = "Failed to load string";
 401
 402                         break;
 403         }
 404
 405         std::stringstream stream;
 406         stream << reason << " at position " << s.tellg();
 407
 408         s.setstate(std::istream::failbit);
 409         b.clear();
 410
 411         throw BEncodeException(stream.str());
 412
 413         return s;
 414 }
 415 /* }}} */
 416
 417 /* {{{ operator<<(std::ostream &s, const BEncode &b) */
 418 std::ostream &operator<<(std::ostream &s, const BEncode &b)
 419 {
 420         switch (b.type) {
 421                 case BEncode::VALUE:
 422                         return s << 'i' << b.value << 'e';
 423                 case BEncode::STRING:
 424                         return s << b.string->size() << ':' << *(b.string);
 425                 case BEncode::LIST:
 426                         s << 'l';
 427
 428                         for (BEncode::List::const_iterator it = b.list->begin(); it != b.list->end(); ++it)
 429                                 s << *it;
 430
 431                         return s << 'e';
 432                 case BEncode::MAP:
 433                         s << 'd';
 434
 435                         for (BEncode::Map::const_iterator it = b.map->begin(); it != b.map->end(); ++it)
 436                                 s << it->first.size() << ':' << it->first << it->second;
 437
 438                         return s << 'e';
 439                 default:
 440                         break;
 441         }
 442
 443         return s;
 444 }
 445 /* }}} */
 446
 447 }; // namespace Core
 448
 449 }; // namespace Tairent
 450
 451 // vim: ai sw=4 ts=4 noet fdm=marker