BCode解码练习

在学习BT协议中的一个小练习

参考了 https://github.com/airtrack/bitwave

具体B编码解释 可以自行搜索或者参考 这篇文章

bittorrent 学习(一) 种子文件分析与bitmap位图

代码

 #pragma once
 #include "pre.h"
 #include <string>
 #include <vector>
 #include <iostream>
 #include <list>
 #include <map>

 NAMESPACE(DEF)

 class BCode
 {
 public:
     enum BCODE_TYPE {
         BCODE_BASE_TYPE = ,
         BCODE_STRING_TYPE = ,
         BCODE_INTENGER_TYPE = ,
         BCODE_LIST_TYPE = ,
         BCODE_DICT_TYPE =
     };

     BCode(BCODE_TYPE type);
     BCODE_TYPE GetBCodeType()const  { return type_; }
     virtual ~BCode();

 protected:
     BCODE_TYPE type_;
     long long begin_;
     long long end_;
 };

 class BCodeString :public BCode {
 public:
     explicit BCodeString(long long& begin, long long& end,
         const std::vector<char>& data);

     bool ReadString(long long& begin,long long& end,int stringLen );
     int ReadStringLen(long long& begin, long long& end);
     std::string std_string() { return bcodeStr_; }
 private:
     const std::vector<char>& data_;
     std::string bcodeStr_;
 };

 class BCodeIntenger :public BCode {
 public:
     explicit BCodeIntenger(long long& begin, long long& end,
         const std::vector<char>& data);

 private:
     const std::vector<char>& data_;
     long long bcodeInt_;
 };

 class BCodeList :public BCode {
 public:
     typedef std::list<std::shared_ptr<BCode>> BCodeLists;
     explicit BCodeList(long long& begin, long long& end,
         const std::vector<char>& data);

 private:
     BCodeList(const BCodeList&) = delete;
     BCodeList& operator=(const BCodeList&) = delete;
     BCodeLists bcodeList_;
     const std::vector<char>& data_;
 };

 class BCodeDictionary :public BCode {
 public:
     typedef std::map<std::string, std::shared_ptr<BCode> > BCodemap;
     typedef BCodemap::value_type pair_type;

     explicit BCodeDictionary(long long& begin, long long& end,
         const std::vector<char>& data);
 private:
     BCodeDictionary(const BCodeDictionary&) = delete;
     BCodeDictionary& operator=(const BCodeDictionary&) = delete;
     const std::vector<char>& data_;
     BCodemap bcodeMap_;
 };

 std::shared_ptr<BCode> GetBCodeObject(long long& begin,
     long long& end,const std::vector<char>& data);

 NAMESPACEEND(DEF)

BCode.h

 #include "BCode.h"

 NAMESPACE(DEF)

 BCode::BCode(BCODE_TYPE type)
     :type_(type),begin_(),end_(){}

 BCode::~BCode(){}

 bool BCodeString::ReadString(
     long long& begin,
     long long& end,
     int stringLen)
 {
     bool b = false;
     long long stringEnd = begin + stringLen;
     if (stringEnd > end) {
         std::cerr << __FUNCTION__ << ". string range error!" << std::endl;
         return b;
     }
     bcodeStr_.assign(&data_[begin], stringLen);
     begin = stringEnd;
 #ifdef _DEBUG_PRINT
     std::cout << __FUNCTION__ << ". BCodeString = "
         << bcodeStr_ << std::endl;

 #endif // DEBUG

     b = true;
     return b;
 }

 BCodeString::BCodeString(long long& begin, long long& end,
     const std::vector<char>& data)
     :bcodeStr_(), BCode(BCODE_STRING_TYPE), data_(data)
 {
     begin_ = begin;
     int stringLen = ReadStringLen(begin, end);
     if (stringLen <=  || begin >= end || data_[begin] != ':') {
         std::cerr << __FUNCTION__ << ". string length error!" << std::endl;
         return;
     }
     begin++;
     ReadString(begin, end, stringLen);
     end_ = begin;
 }

 int BCodeString::ReadStringLen(
     long long& begin,
     long long& end)
 {
     std::vector<char> tmp;
     if (isdigit(data_[begin]) == ) {
         std::cerr << __FUNCTION__ << ". read num error!" << std::endl;
         return ;
     }
     while (begin != end && isdigit(data_[begin])) {
         tmp.push_back(data_[begin++]);
     }
     return atoi(&tmp[]);
 }

 BCodeIntenger::BCodeIntenger(long long& begin, long long& end,
     const std::vector<char>& data)
     :bcodeInt_(), BCode(BCODE_INTENGER_TYPE), data_(data)
 {
     begin_ = begin;
     if (begin >= end || data_[begin] != 'i') {
         std::cerr << __FUNCTION__ << ". intenger flag error!" << std::endl;
         return;
     }
     ++begin; //skip 'i'

     std::string intstr;
     std::vector<char> tmp;
     while (begin != end && data_[begin] != 'e'  ) {
         if (!isdigit(data_[begin])) {
             std::cerr << __FUNCTION__ << ". get intenger error!" << std::endl;
             return;
         }
         tmp.push_back(data_[begin++]);
     }
     end_ = begin;
     ++begin; //skip 'e'
     if (begin > end) {
         std::cerr << __FUNCTION__ << ". range error!" << std::endl;
         return;
     }

     bcodeInt_ = _atoi64(&tmp[]);

 #ifdef _DEBUG_PRINT
     std::cout << __FUNCTION__ << ". BCodeIntenger = "
         << bcodeInt_ << std::endl;
 #endif // DEBUG
 }

 BCodeList::BCodeList(long long& begin, long long& end,
     const std::vector<char>& data)
     :bcodeList_(), BCode(BCODE_LIST_TYPE),data_(data)
 {
     begin_ = begin;
     if (begin >= end || data_[begin] != 'l') {
         std::cerr << __FUNCTION__ << ". BCodeList error!" << std::endl;
         return;
     }
     ++begin;
 #ifdef _DEBUG_PRINT
     std::cout << "start List" << std::endl;
 #endif // _DEBUG

     while (begin != end && data_[begin] != 'e') {
         bcodeList_.push_back(GetBCodeObject(begin,end,data_));
     }
     end_ = begin;
     if (begin >= end || data[end_] != 'e' ) {
         std::cerr << __FUNCTION__ << ". BCodeList end error!" << std::endl;
         return;
     }

     ++begin;
 #ifdef _DEBUG_PRINT
     std::cout << "end List" << std::endl;
 #endif // _DEBUG
 }

 BCodeDictionary::BCodeDictionary(long long& begin, long long& end,
     const std::vector<char>& data)
     :bcodeMap_(), BCode(BCODE_DICT_TYPE), data_(data)
 {
     begin_ = begin;
     if (begin >= end || data_[begin] != 'd') {
         std::cerr << __FUNCTION__ << ". range error!" << std::endl;
         return;
     }
     ++begin; //skip 'd'
 #ifdef _DEBUG_PRINT
     std::cout << "dict start " << std::endl;
 #endif
     while (begin != end && data[begin] != 'e') {
 #ifdef _DEBUG_PRINT
         std::cout << "key is ";
 #endif
         BCodeString key(begin, end,data);
         std::shared_ptr<BCode> value = GetBCodeObject(begin,end,data);
         if (value) {
             bcodeMap_.insert(BCodemap::value_type(key.std_string(), value));
         }
     }
 #ifdef _DEBUG_PRINT
     std::cout << "dict end " << std::endl;
 #endif
     end_ = begin;
     if (begin >= end || data[end_] != 'e') {
         std::cerr << __FUNCTION__ << ". BCodeDictionary end error!" << std::endl;
         return;
     }
     ++begin;    //skip 'e'

     return;
 }

 std::shared_ptr<BCode> GetBCodeObject(long long& begin,
     long long& end, const std::vector<char>& data) {
     if (begin >= end || end > data.size()) {
         std::cerr << __FUNCTION__ << ". Range error!" << std::endl;
         return NULL;
     }

     switch (data[begin]) {
     case 'i':
         return std::shared_ptr<BCode>(new BCodeIntenger(begin, end, data));
     case 'l':
         return std::make_shared<BCode>(BCodeList(begin, end, data));
     case 'd':
         return std::make_shared<BCode>(BCodeDictionary(begin,end,data));
     default:
         return std::make_shared<BCode>(BCodeString(begin, end, data));
     }

 }

 NAMESPACEEND(DEF)

BCode.cpp

测试代码

#include <iostream>
#include "MetaFIleManager.h"

#include "BCode.h"

using namespace DEF;

void BCodetest() {
std::string s = "li1234e8:12345678l3:def3:abce4:1234i56789ee";
//std::string s = "8:123456783:def2:121:a";
std::vector<char> test(s.begin(), s.end());
long long size = test.size();
long long idx0 = 0;
//while (idx0 < size) {
std::shared_ptr<BCode> p = GetBCodeObject(idx0, size, test);
//}

std::cout << std::endl << std::endl;;

std::string s1 = "d4:key1d9:innerKey14:teste9:innerkey2li23456ei1234ei45678eee";
std::vector<char> test1(s1.begin(), s1.end());
long long size1 = test1.size();
long long idx1 = 0;

std::shared_ptr<BCode> p1 = GetBCodeObject(idx1, size1, test1);
}

int main()
{

BCodetest();

}

运行效果如图: