Ben编码解析的C++实现

Ben编码的基本规则

B编码中有4种类型：字符串、整型、列表、字典。

字符串

字符串的编码格式为：<字符串的长度>:<字符串>，其中<>括号中的内容为必需。例如，有一个字符串spam，则经过B编码后为4:spam。

整型

整型的编码格式为：i<十进制的整型数>e，即B编码中的整数以i作为起始符，以e作为终结符，i为integer的第一个字母，e为end的第一个字母。例如，整数3，经过B编码后为i3e，整数?3的B编码为i?3e，整数0的B编码为i0e。

注意i03e不是合法的B编码，因为03不是十进制整数，而是八进制整数。

列表

列表的编码格式为：l<任何合法的类型>e，列表以l为起始符，以e为终结符，中间可以为任何合法的经过B编码的类型，l为list的第一个字母。例如，列表l4:spam4:eggse表示两个字符串，一个是spam，一个是eggs。

字典

字典的编码格式为：d<关键字><值>e，字典以d为起始符，以e为终结符，关键字是一个经过B编码的字符串，值可以是任何合法的B编码类型，在d和e之间可以出现多个关键字和值对，d是dictionary的第一个字母。例如，d4:spaml3:aaa3:bbbee，它是一个字典，该字典的关键字是spam，值是一个列表（以l开始，以e结束），列表中有两个字符串aaa和bbb。

又如：d9:publisher3:bob17:publisher-webpage15:www.example.come，它也是一个字典，第一个关键字是publisher，对应的值为bob，第二个关键字是publisher-webpage，对应的值是www.example.com。

对Ben编码的四种基本类型的封装

? 定义Ben编码类型的基类

四种基本类型(字符串、整型、列表、字典)均从此基类派生

class __declspec(dllexport) BCODE_TYPE_BASE

: public std::enable_shared_from_this<BCODE_TYPE_BASE>

{

public:

virtual int type() = 0;

virtual void add_child(std::shared_ptr<BCODE_TYPE_BASE> child)

{}

virtual void add_child(BCODE_TYPE_MAP_PAIR_ child) 

{}

};

? 字符串类型定义

class __declspec(dllexport) BCODE_TYPE_STRING

: public BCODE_TYPE_BASE

{

public:

virtual int type() { return BCODE_STRING;}

void append(char* pStr)

{

strBuf_.append(pStr);

}

std::string& to_string() { return strBuf_;}

protected:

std::string strBuf_;

};

? 整型类型定义

class __declspec(dllexport) BCODE_TYPE_INTEGER

: public BCODE_TYPE_BASE

{

public:

virtual int type() { return BCODE_INTEGER;}

LONGLONG& value() { return llNumer_;}

void value(LONGLONG llNum) { llNumer_ = llNum;}

protected:

LONGLONG llNumer_;

};

? 列表类型定义

typedef std::vector<std::shared_ptr<BCODE_TYPE_BASE>> BCODE_TYPE_LIST_;

class __declspec(dllexport) BCODE_TYPE_LIST 

: public BCODE_TYPE_BASE

{

public:

virtual int type() { return BCODE_LIST;}

void add_child(std::shared_ptr<BCODE_TYPE_BASE> child)

{

push_back(child);

}

inline std::shared_ptr<BCODE_TYPE_BASE> at(size_t index) 

{

if (index < 0 || index > list_.size()) return NULL;

return list_[index];

}

inline void remove(size_t index)

{

if (index < 0 || index > list_.size()) return;

list_.erase(list_.begin() + index);

}

inline void push_back(std::shared_ptr<BCODE_TYPE_BASE> data) 

{ list_.push_back(data);}

inline std::vector<std::shared_ptr<BCODE_TYPE_BASE>>& list()

{ return list_;}

protected:

BCODE_TYPE_LIST_ list_;

};

? 字典类型定义

_ptr<BCODE_T

typedef std::map<std::shared_ptr<BCODE_TYPE_STRING>,std::shared_ptr<BCODE_TYPE_BASE>> BCODE_TYPE_MAP_; 

class __declspec(dllexport) BCODE_TYPE_DICTIONARY 

: public BCODE_TYPE_BASE 

{ 

public: 

virtual int type() { return BCODE_DICTIONARY;} 

void add_child(BCODE_TYPE_MAP_PAIR_ child) 

{ 

insert(child.first,child.second); 

} 

inline void insert(std::shared_ptr<BCODE_TYPE_STRING> key, 

std::shared_ptr<BCODE_TYPE_BASE> value) 

{ 

map_.insert(BCODE_TYPE_MAP_PAIR_(key,value)); 

} 

BCODE_TYPE_MAP_PAIR_ find(std::shared

YPE_STRING> key)

{

BCODE_TYPE_MAP_::iterator iter = map_.find(key);

if (iter == map_.end())

return BCODE_TYPE_MAP_PAIR_(NULL,NULL);

return BCODE_TYPE_MAP_PAIR_(iter->first,iter->second);

}

protected:

BCODE_TYPE_MAP_ map_;

};

解析Bencode编码文件

我们从*.torrent文件中读取Ben编码的数据内容。参照Ben编码规则，我们将数据分类型读取保存到列表中即可。核心算法如下：

int BenCoder::parser( FILE* fp,std::shared_ptr<BCODE_TYPE_BASE> parent)

{

if (fp == NULL) return -1;

char ch,szBuf[1024] = {0};

// 分析BenCode编码文件

while(1)

{

// 默认每次读取1个字符

if (getChar(fp,&ch) == -1)

break;

// 分类处理字符串、整型、列表、字典

// 以数字开头则为字符串类型

if (is_digit(ch))

{

memset(szBuf,0,1024);

*szBuf = ch;

// 读取字符串的长度信息，读取到‘:’停止

if (read_until(fp,‘:‘,szBuf + 1,1024) == -1)

return -1;

LONGLONG llNumber = _atoi64(szBuf);

LTM::DbgPrint("Type[String] Length[%s]",szBuf);

// 读取字符串内容

memset(szBuf,0,1024);

std::shared_ptr<BCODE_TYPE_STRING> bString(new BCODE_TYPE_STRING);

// 若读取的字符串内容超过1024则分段读取，反之则一次读取成功

while (llNumber > 0)

{

if (llNumber < 1024)

{

if (getChars(fp,szBuf,llNumber,1024) == -1)

{

return -1;

}

llNumber = 0;

bString->append(szBuf);

LTM::DbgPrint(" Content[%s]\n",szBuf);

}

else

{

if (getChars(fp,szBuf,1024,1024) == -1)

{

return -1;

}

llNumber = llNumber - 1024;

bString->append(szBuf);

LTM::DbgPrint("->[%s]\n",szBuf);

}

}

if (parent)

{

// 若父结点为字典类型，则读取字符串类型时

if (parent->type() == BCODE_DICTIONARY)

{

// 若KEY为空，则表明之前未读取字符串做为关键值，此次读取的字符串应该为KEY

if (key_ == NULL)

key_ = bString;

// KEY不为空，则表明之前已经读取字符串做为关键值，此次读取的字符串应该为VALUE

else

{

parent->add_child(BCODE_TYPE_MAP_PAIR_(key_,bString));

key_ = NULL;

}

}

else if (parent->type() == BCODE_LIST)

parent->add_child(bString);

else

data_list_.push_back(bString);

}

else

data_list_.push_back(bString);

}

else if (is_letter(ch))

{

// 整型

if (ch == ‘i‘ || ch == ‘I‘)

{

memset(szBuf,0,1024);

if (read_until(fp,‘e‘,szBuf,1024) == -1)

return -1;

LONGLONG llNumber = _atoi64(szBuf);

std::shared_ptr<BCODE_TYPE_INTEGER> bInteger(new BCODE_TYPE_INTEGER);

bInteger->value(llNumber);

if (parent)

{

if (parent->type() == BCODE_DICTIONARY)

{

parent->add_child(BCODE_TYPE_MAP_PAIR_(key_,bInteger));

key_ = NULL;

}

else if (parent->type() == BCODE_LIST)

parent->add_child(bInteger);

else

data_list_.push_back(bInteger);

}

else

data_list_.push_back(bInteger);

LTM::DbgPrint("Type[Integer] Value[%s]\n",szBuf);

}

// 列表

else if (ch == ‘l‘ || ch == ‘L‘)

{

LTM::DbgPrint("Type[List]\n");

std::shared_ptr<BCODE_TYPE_LIST> bList(new BCODE_TYPE_LIST);

if (parent)

{

if (parent->type() == BCODE_DICTIONARY)

{

parent->add_child(BCODE_TYPE_MAP_PAIR_(key_,bList));

key_ = NULL;

}

else if (parent->type() == BCODE_LIST)

parent->add_child(bList);

else

data_list_.push_back(bList);

}

else

data_list_.push_back(bList);

parser(fp,bList);

}

// 字典

else if (ch == ‘d‘ || ch == ‘D‘)

{

LTM::DbgPrint("Type[Dictionary]\n");

std::shared_ptr<BCODE_TYPE_DICTIONARY> bMap(new BCODE_TYPE_DICTIONARY);

if (parent)

{

if (parent->type() == BCODE_DICTIONARY)

{

parent->add_child(BCODE_TYPE_MAP_PAIR_(key_,bMap));

key_ = NULL;

}

else if (parent->type() == BCODE_LIST)

parent->add_child(bMap);

else

data_list_.push_back(bMap);

}

else

data_list_.push_back(bMap);

parser(fp,bMap);

}

else if (ch == ‘e‘)

{

LTM::DbgPrint("end when read of ‘e‘\n");

break;

}

// 未知

else

{

LTM::DbgPrint("It has a unknow type when parser BCode File!\n");

}

}

else

{

LTM::DbgPrint("It has a unknow error when parser BCode File!\n");

}

}

return 0;

}

源代码下载

最后附上完整代码的下载地址：http://download.csdn.net/detail/ltm5180/8001439

工程为DLL工程，对Ben编码文件的读取操作全部封装到BenCoder类中，使用示例：

BenCoder* coder = BenCoder::getInstance();

if (coder)

{

coder->SetstrFilepath("E:\\WorkSpaces\\proj\\BTLoader\\trunk\\Win32\\Debug\\ 0035.torrent");

coder->load();

}

BenCoder::freeInstance(coder);

时间： 2024-08-26 16:59:09

Ben编码解析的C++实现的相关文章

HTTP1.1中CHUNKED编码解析(转载)

HTTP1.1中CHUNKED编码解析 一般HTTP通信时,会使用Content-Length头信息性来通知用户代理(通常意义上是浏览器)服务器发送的文档内容长度,该头信息定义于HTTP1.0协议RFC  1945  10.4章节中.浏览器接收到此头信息后,接受完Content-Length中定义的长度字节后开始解析页面,但如果服务端有部分数据延迟发送吗,则会出现浏览器白屏,造成比较糟糕的用户体验. 解决方案是在HTTP1.1协议中,RFC  2616中14.41章节中定义的Transfer-E

scrapy gbk编码解析失败的问题

在使用scrpay 采集网易游戏网页时,遇到了编码失败的问题 http://play.163.com/17/0520/15/CKT0U63D00318PFI.html code_datas = byte.decode('gbk') 这里的'gbk'编码解析失败,查询原因得知,中文有三大编码,后面的标准是前面标准的扩展. GB2312 < GBK < GB18030 将命令换成 code_datas = byte.decode('GB18030') 后解析正常.

Python解析xml文件遇到的编码解析的问题

使用python对xml文件进行解析的时候,如果xml文件的头文件是utf-8格式的编码,那么解析是ok的,但如果是其他格式将会出现如下异常: xml.parsers.expat.ExpatError: unknown encoding 因此,为了保证程序的正常运行,我们需要对读取的文件进行编码处理. 1.首先将读取的字符从原来的编码解析,并编码成utf-8: 2.修改xml的encoding: 代码如下: import sys import os import datetime import

中国天气网 JSON接口的城市编码解析及结果

最近在弄一个Android应用,其中一个功能是天气情况展示,准备使用google的天气API服务(http://www.google.com/ig/api?hl=zh-cn&weather=,,,, ),不想这个接口已经在几个月前关闭服务了.于是各种资料,最终决定使用 中国天气网 的服务. 中国天气网提供有两种数据格式的接口: 一. XML接口 http://flash.weather.com.cn/wmaps/xml/china.xml http://flash.weather.com.cn/

字符串编码解析及字符编码输出

package 字符串编码解析; import java.io.UnsupportedEncodingException; public class Demo1 { public static void main(String[] args) throws UnsupportedEncodingException { String str = "中国"; //使用默认编码 byte[] gbk = str.getBytes("GBK"); //使用utf-8来编码

Spring第七弹—依赖注入之注解方式注入及编码解析@Resource原理

    注入依赖对象可以采用手工装配或自动装配,在实际应用中建议使用手工装配,因为自动装配会产生未知情况,开发人员无法预见最终的装配结果. 手工装配依赖对象  手工装配依赖对象,在这种方式中又有两种编程方式 在xml配置文件中,通过在bean节点下配置,上边博客已经讲解,再次不在缀余. 在java代码中使用@Autowired或@Resource注解方式进行装配.但我们需要在xml配置文件中配置以下信息: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 <be

utf-8编码解析

java中InputStream.OutputStream读取以字节为单位,而Reader.Writer以字符为读写单位.下面例子模仿Reader直接读取utf-8格式编码字符: public class Utf8Reader {     private InputStream inputStream;     //10000000取反     private static int back10head=127;     //11000000取反     private static int b

iOS地址编码解析

- (void)viewDidLoad { [super viewDidLoad]; // 创建地址解析器 self.geocoder = [[CLGeocoder alloc] init]; } - (IBAction)encodeTapped:(id)sender { // 获取用户输入的地址字符串 NSString* addr = self.addrField.text; if(addr != nil && addr.length > 0) { [self.geocoder g

用Google的gflags轻松的编码解析命令行参数

支持的参数类型 gflags支持的类型有bool,int32,int64,uint64,double和string.可以说这些基本类型大体上满足了我们的需求. DEFINE_bool: boolean DEFINE_int32: 32-bit integer DEFINE_int64: 64-bit integer DEFINE_uint64: unsigned 64-bit integer DEFINE_double: double DEFINE_string: C++ string 比如上文