字符串解析--BT种子文件信息解析

猫/db鱼

一楼拜大神

猫/db鱼

作者：猫鱼　日期：2013-10-15　原文地址：http://www.skywj.com/thread-9201-1-1.html

这个东西主要涉及字符操作，没有啥高深的技术。难度的话大专学生水平。

种子文件的编码方式为B编码，可百度B编码了解详细信息。B编码内容略多，不在此发出。

注释我敲得很多了。如果不明白的回复我尽量回答。

代码涉及小部分linux函数，很简单的函数，不懂可回帖或者百度。

猫/db鱼

代码设计思路 ---希望以定义类对象A，A.info（）的形式获得种子文件的信息
1.定义一个数据结构存放种子文件相关信息！
2.将文件解析操作函数封装到一个类中，并提供一个公有调用接口，该接口执行后返回1步骤定义的数据类型，其中保存指定的种子文件的相关信息。
封装不足之处：公有调用接口返回的数据是定义在类中的私有成员变量的地址，封装的隐蔽不足。但鉴于该代码在项目中只调用一次， 本人以容忍的态度忽略这个问题。若各位有更好的想法，如果可以，希望能回复一下。

猫/db鱼

-------------头文件---------------------权限不够，不能回帖了，=会我在发上源文件

1. /*****************************************************************************
   
2. **        文件名：                ResovlerMetafile.h
   
3. **        文件职能：                声明bt种子文件解析类，
   
4. **        创建日期：                2013-08-06
   
5. **        创建人：                        tmfish
   
6. ******************************************************************************/
   
7. 
   
8. #ifndef                 RESOLVERMETAFILE_H_
   
9. #define                 RESOLVERMETAFILE_H_
   
10. 
    
11. #define DEBUG
    
12. 
    
13. #include <iostream>
    
14. #include <cstdio>
    
15. #include <vector>
    
16. #include <string>
    
17. #include <cstring>
    
18. #include <cstdlib>
    
19. #include <fstream>
    
20. #include <cctype>
    
21. #include "sha1.h"
    
22. using namespace std;
    
23. 
    
24. 
    
25. typedef        int         FILETYPE;                                //文件类型
    
26. 
    
27. /*状态标识*/
    
28. typedef        int          STATE;                                //状态
    
29. const        int                NOFILE      = 2;                //文件为空
    
30. const        int                OK                        = 0;                //成功标识
    
31. const        int         ERROR                = -1;                //错误标识
    
32. 
    
33. /*文件类型标识*/
    
34. const        int                ISSIMPLE        =1;                        //单文件标识
    
35. const        int                ISMULTIPLE        =2;                        //多文件标识
    
36. 
    
37. struct Files                                        //多文件中的多个文件
    
38. {
    
39.         int                length;                                //单个文件的长度
    
40.         char*        path;                                //单个文件的路径及文件名
    
41. };        
    
42. 
    
43. /****************************************************************************************************************
    
44. **        种子文件信息结构体
    
45. **        用于存储种子文件的主要信息
    
46. **        成员说明
    
47.         flagFileType        标识文件是单文件还是多文件，
    
48.                                         当其值为ISSIMPLE的时候表示单文件，所有的多文件特有属性(m_name,files,)失效
    
49.                                         当其值为ISMULTIPLE的时候表示多文件，多有单文件特有属性失效(s_name,length)
    
50.         pieceLen                指定piece的大小 通常为256KB、亦有128kb或512kb 单位为字节
    
51.         pieces                        每个piece对应hash值
    
52.         file_name                单文件的文件名
    
53.         fileLength                文件的总文件长度
    
54.         dir_name                多文件存放所有文件的目录名称
    
55.         multi_files                多文件中包含的所有文件的信息
    
56.         tracker_list        tracker地址列表，其类型为一个string类型的vector数组
    
57.                                         第一个元素是主tracker地址
    
58.         info_hash                根据info关键字的值计算的哈希值，固定为20字节
    
59. *****************************************************************************************************************/
    
60. typedef struct MetafileInfo
    
61. {
    
62.         /*标识文件属性*/
    
63.         int                        fileType;
    
64.         /*单文件、多文件共有属性*/
    
65.         long                 pieceLen;                                //每个piece的长度
    
66.         char*                pieces;                                        //每个piece对应的hash值
    
67.         long long         fileLength;                                //文件总大小
    
68.         vector<const char*>        trackerList;                //tracker地址列表
    
69.         /*单文件特有属性*/
    
70.         char*                fileName;                                //文件名
    
71.         /*多文件特有属性*/
    
72.         char*                 dirName;                                //存放所有文件的文件夹名
    
73.         vector<Files>        multiFiles;                        //多文件中所有文件信息
    
74.         unsigned char        info_hash[20];                        //根据info关键字的值计算的哈希值。
    
75. }* pMetaInfo;
    
76. 
    
77. 
    
78. /*种子文件解析类*/
    
79. class ResolverMetafile
    
80. {
    
81. public:
    
82.         /*构造及析构函数*/
    
83.         ResolverMetafile(string MetafilePath);
    
84.         ~ResolverMetafile();
    
85. 
    
86.         /********************************************************************
    
87.         *功能：获取共享文件信息
    
88.         *返回：函数返回存储种子文件信息的m_metaInfo结构体对象
    
89.         *参数：st_info是一个MetafileInfo类型的常引用，用于接收种子文件信息
    
90.                    存放点地址
    
91.         *附注：该函数是文件解析类对外提供的主要接口
    
92.         *********************************************************************/
    
93.         MetafileInfo GetMetafileInfo(pMetaInfo*const ppst_info);
    
94.         /*
    
95.          * 功能：向tracker列表添加一个tracker服务器地址
    
96.          * 返回：成功添加tracker返回1，tracker已经存在返回0
    
97.          *                  函数成功执行失败返回-1
    
98.          * 参数：url指定添加的tracker地址，如果该地址存在与tracker
    
99.          *                  列表中，则函数退出
    
100.          * 附注：当连接某些tarcker地址的时候，服务器会返回一个重定向地址，函数用于
     
101.          *                  添加该类地址,当调用该函数后，调用者应该重新调用GetMetafileInfo获取数据
     
102.          */
     
103.         STATE AddTracker(const char* url);
     
104. protected:
     
105.         /*
     
106.          * 功能：更具info关键字的值计算其对应的哈希值，将其填充与m_metaInfo.info_hash内
     
107.          * 返回：成功返回0,失败返回-1
     
108.          * 附注：info关键字对应的值为一个字典。
     
109.          */
     
110.          STATE CalcInfoHash();
     
111. 
     
112.         /*
     
113.          * 功能：读取m_metafilePath指定的种子文件，将文件内容保存到m_metafile中
     
114.          * 返回：函数成功执行返回1，m_metafilePath为空返回2，失败返回-1
     
115.          * 附注：文件读取方式为二进制读取
     
116.         */
     
117.         STATE        ReadMetafile();
     
118. 
     
119.         /*
     
120.          * 功能：判断种子文件类型
     
121.          * 返回：单文件返回ISSIMPLE，多文件返回ISMULTIPLE,m_metafile为空返回2
     
122.          * 附注：ISSIMPLE值为1，ISMULTIPLE值为2
     
123.         */
     
124.         FILETYPE        FileType();
     
125. 
     
126.         /*
     
127.          *功能：在m_metafile中查找指定关键字
     
128.          *返回：函数查找到指定的关键字返回1，没有找到返回0，函数执行出错返回-1
     
129.          *参数：word为需要查找的指定关键字,index为查找到的字符串的起始下标
     
130.         */
     
131.         STATE        FindWord(const char* word, long long& index);
     
132. 
     
133.         /*
     
134.          * 功能：解析种子文件的tracker服务器列表,将其放入m_metaInfo.trackerList
     
135.          * 返回：函数成功执行返回0，失败返回-1
     
136.          * 附注：m_metaInfo.trackerList第一个值为主tracker服务器
     
137.         */
     
138.         STATE        ResTracker();
     
139. 
     
140.         /*
     
141.          * 功能：解析piece快大小，将其放入m_metaInfo.pieceLen
     
142.          * 返回：成功执行返回0，失败返回-1，m_metafile为空返回2
     
143.         */
     
144.          STATE        ResPieceLen();
     
145. 
     
146.         /*
     
147.          * 功能：解析每个块对应的hash值字符串,将其放入m_metaInfo.pieces
     
148.          * 返回：函数成功执行返回0，失败返回-1，m_metafile为空返回2
     
149.          */
     
150.          STATE        ResPieces();
     
151. 
     
152.          /*
     
153.          * 功能：解析文件名，对于多文件而言解析目录名,
     
154.          *       若解析单文件，放入m_metaInfo.filename,若解析多文件，放入dirName
     
155.          * 返回：函数成功执行返回0，失败返回-1，m_metafile为空返回2
     
156.          */
     
157.          STATE        ResFileName();
     
158. 
     
159.         /*
     
160.          * 功能：解析总文件大小，填充m_metaInfo.fileLength
     
161.          * 返回：函数成功执行返回0，失败返回-1，m_metafile为空返回2
     
162.          */
     
163.          STATE ResFileLength();
     
164. 
     
165.         /*
     
166.          * 功能：解析文件大小和路径，仅对多文件有效,填充m_metaInfo.multiFiles结构体
     
167.          * 返回：函数成功执行返回0，失败返回-1，m_metafile为空返回2
     
168.          */
     
169.          STATE        ResFilePathLen();
     
170. 
     
171.          /*
     
172.          * 功能：释放类资源
     
173.          */
     
174.          void ReleaseMem();
     
175. protected:
     
176.         /*种子文件信息*/
     
177.         MetafileInfo        m_metaInfo;
     
178.          /*存储种子文件路径*/
     
179.          string        m_metafilePath;
     
180.          /*存储种子文件的内容*/
     
181.          unsigned char*  m_metafile;
     
182.          /*种子文件大小*/
     
183.         long long int m_metafileLen;
     
184. 
     
185. #ifdef DEBUG
     
186. public:
     
187.         /*测试函数*/
     
188.         void Test();
     
189. #endif
     
190. };
     
191. 
     
192. #endif
     

复制代码

猫/db鱼

源代码

1. 
   
2. /*
   
3. * resolvermetafile.cpp
   
4. * 对resolverMetafile类的具体实现
   
5. *  Created on: 2013-8-6
   
6. *      Author: tmfish
   
7. */
   
8. #include "resolverMetafile.h"
   
9. 
   
10. #ifdef DEBUG
    
11. //测试函数
    
12. void ResolverMetafile::Test()
    
13. {
    
14.         cout << "测试函数" << endl;
    
15.         //合格测试
    
16.         //*successful
    
17.         cout << "filetype:  "        << m_metaInfo.fileType         << endl;
    
18.         cout << "piecelen:        "        << m_metaInfo.pieceLen         << endl;
    
19.         if (ISSIMPLE == m_metaInfo.fileType)
    
20.         {
    
21.                 cout << "filename:        "        << m_metaInfo.fileName        << endl;
    
22.         }else if (ISMULTIPLE == m_metaInfo.fileType)
    
23.         {
    
24.                 cout << "dirname:        "        << m_metaInfo.dirName        << endl;
    
25.         }
    
26. 
    
27.         cout << "multiple files number: " << m_metaInfo.multiFiles.size() << endl;
    
28.         for (int i=0; i<int(m_metaInfo.multiFiles.size()); i++)
    
29.         {
    
30.                 cout << "path:           " << m_metaInfo.multiFiles[i].path << endl;
    
31.                 cout << "length:         " << m_metaInfo.multiFiles[i].length << endl;
    
32.         }
    
33. 
    
34.         cout << "fileLen:        "        << m_metaInfo.fileLength<< endl;
    
35.         for(int i=0; i<int(m_metaInfo.trackerList.size()); i++)
    
36.         {
    
37.                 cout << "trackerList" << i << ": " << m_metaInfo.trackerList[i] << endl;
    
38.         }
    
39.         cout << "test for add " << endl;
    
40.         char url[] = "一个URL地址，随意填";
    
41.         AddTracker(url);
    
42.         for(int i=0; i<int(m_metaInfo.trackerList.size()); i++)
    
43.         {
    
44.                 cout << "trackerList" << i << ": " << m_metaInfo.trackerList[i] << endl;
    
45.         }
    
46. }
    
47. #endif
    
48. 
    
49. //构造函数
    
50. ResolverMetafile::ResolverMetafile(string path)
    
51. {
    
52.         memset(&m_metaInfo, 0, sizeof(m_metaInfo));
    
53.         m_metafile                = NULL;
    
54.         m_metafilePath         = path;
    
55.         m_metafileLen         = 0;
    
56.         ReadMetafile();
    
57.         FileType();
    
58.         ResTracker();
    
59.         ResPieceLen();
    
60.         ResPieces();
    
61.         ResFileName();
    
62.         ResFilePathLen();
    
63.         ResFileLength();
    
64.         CalcInfoHash();
    
65. }
    
66. 
    
67. //析构函数
    
68. ResolverMetafile::~ResolverMetafile()
    
69. {
    
70.         /*某些释放*/
    
71.         ReleaseMem();
    
72. }
    
73. 
    
74. /********************************************************************
    
75. *功能：获取共享文件信息
    
76. *返回：函数返回存储种子文件信息的m_metaInfo结构体对象
    
77. *参数：pst_info是一个MetafileInfo类型的指针的指针，用于接收种子文件信息
    
78.            存放点地址
    
79. *********************************************************************/
    
80. MetafileInfo ResolverMetafile::GetMetafileInfo(pMetaInfo*const ppst_info)
    
81. {
    
82.         *ppst_info = &m_metaInfo;
    
83. 
    
84.         return m_metaInfo;
    
85. }
    
86. 
    
87. /*
    
88. * 功能：向tracker列表添加一个tracker服务器地址
    
89. * 返回：成功添加tracker返回1，tracker已经存在返回0
    
90. *                  函数成功执行失败返回-1
    
91. * 参数：strTracker指定添加的tracker地址，如果该地址存在与tracker
    
92. *                  列表中，则函数退出
    
93. * 附注：当连接某些tarcker地址的时候，服务器会返回一个重定向地址，函数用于
    
94. *                  添加该类地址
    
95. */
    
96. STATE ResolverMetafile::AddTracker(const char* url)
    
97. {
    
98.         char* bufTmp = new char[strlen(url)+1];
    
99.         memcpy(bufTmp,url,strlen(url)+1);
    
100.         int size = m_metaInfo.trackerList.size();
     
101.         //若地址存在，则无需添加
     
102.         for (int i=0; i<size; i++)
     
103.         {
     
104.                 if (0 == strcmp(m_metaInfo.trackerList.at(i),url))
     
105.                 {
     
106.                         return OK;
     
107.                 }
     
108.         }
     
109.         //于末尾追加元素
     
110.         m_metaInfo.trackerList.push_back(bufTmp);
     
111.         return OK;
     
112. }
     
113. 
     
114. /*
     
115. * 功能：判断种子文件类型
     
116. * 返回：单文件返回ISSIMPLE，多文件返回ISMULTIPLE,m_metafile为空返回2
     
117. * 附注：ISSIMPLE值为1，ISMULTIPLE值为2
     
118. */
     
119. FILETYPE ResolverMetafile::FileType()
     
120. {
     
121. //        cout << m_metafile << endl;
     
122.         long long  index;
     
123.          //种子文件中files代表多文件
     
124.         if (1 == FindWord("5:files",index))
     
125.         {
     
126.                 m_metaInfo.fileType = ISMULTIPLE;
     
127.                 return ISMULTIPLE;
     
128.         }else
     
129.         {
     
130.                 m_metaInfo.fileType = ISSIMPLE;
     
131.                 return ISSIMPLE;
     
132.         }
     
133.         return ERROR;
     
134. }
     
135. 
     
136. /*
     
137. * 功能：读取m_metafilePath指定的种子文件，将文件内容保存到m_metafile中
     
138. * 返回：函数成功执行返回0，m_metafilePath为空返回2，失败返回-1
     
139. * 附注：文件读取方式为二进制读取
     
140. */
     
141. STATE ResolverMetafile::ReadMetafile()
     
142. {
     
143.         if (m_metafilePath.empty())
     
144.         {
     
145.                 cerr << "文件路径为空!" << endl;
     
146.                 return ERROR;
     
147.         }
     
148.         /*
     
149.         ifstream fin(m_metafilePath.c_str(), ios_base::in | ios_base::binary);
     
150. //        fin.open("in");
     
151.         if (!fin.is_open())
     
152.         {
     
153.                 cerr<< "文件打开失败!" << endl;
     
154.                 return ERROR;
     
155.         }
     
156.         //获取种子文件长度
     
157.         fin.seekg(0,ios::end);
     
158.         m_metafileLen = fin.tellg();
     
159.         m_metafile = new char[m_metafileLen+1];
     
160. //        fin.read(m_metafile, m_metafileLen);]
     
161.         fin >> m_metafile;
     
162.         if (NULL == m_metafile)
     
163.         {
     
164.                 cerr << "文件读取失败" << endl;
     
165.                 return ERROR;
     
166.         }
     
167.         m_metafile[m_metafileLen] = '\0';
     
168.         cout << m_metafile[3] << endl;
     
169.         fin.close();
     
170.         */
     
171. 
     
172.         //以二进制、只读方式打开文件
     
173.         FILE* fp = fopen(m_metafilePath.c_str(), "rb");
     
174.         if (NULL == fp)
     
175.         {
     
176.                 cout << "文件打开失败" << endl;
     
177.                 return -1;
     
178.         }
     
179. 
     
180.         //获取种子文件的长度,
     
181.         fseek(fp, 0, SEEK_END);
     
182.         m_metafileLen        = ftell(fp);
     
183.         if (-1 == m_metafileLen)
     
184.         {
     
185.                 cout << "文件长度错误" << endl;
     
186.                 return -1;
     
187.         }
     
188.         m_metafile = new unsigned char[m_metafileLen+1];
     
189.         if (NULL == m_metafile)
     
190.         {
     
191.                 cout << "内存分配失败" << endl;
     
192.                 return -1;
     
193.         }
     
194. 
     
195.         //读取种子文件的内容到m_metafile
     
196.         fseek(fp, 0, SEEK_SET);
     
197.         long i;
     
198.         for ( i=0; i<m_metafileLen; i++)
     
199.         {
     
200.                 m_metafile[i] = fgetc(fp);
     
201.         }
     
202.         m_metafile[i] = '\0';
     
203. 
     
204.         fclose(fp);
     
205. 
     
206.         return OK;
     
207. }
     
208. 
     
209. /*
     
210. *功能：在m_metafile中查找指定关键字
     
211. *返回：函数查找到指定的关键字返回1，没有找到返回0，函数执行出错返回-1
     
212. *参数：word为需要查找的指定关键字,index为查找到的字符串的起始下标的引用
     
213. */
     
214. STATE ResolverMetafile::FindWord(const char* word, long long& index)
     
215. {
     
216.         if (NULL == m_metafile)
     
217.         {
     
218.                 cerr << "种子内容为空" << endl;
     
219.                 return ERROR;
     
220.         }
     
221.         for (long long  int i=0; i<(m_metafileLen-long(strlen(word))); i++)
     
222.         {
     
223.                 if (0 == memcmp(&m_metafile[i], word, strlen(word)))
     
224.                 {
     
225.                         index = i;
     
226.                         return 1;
     
227.                 }
     
228.         }
     
229.         //未找到
     
230.         return 0;
     
231. }
     
232. 
     
233. /*
     
234. * 功能：解析种子文件的tracker服务器列表,将其放入m_metaInfo.trackerList
     
235. * 返回：函数成功执行返回0，失败返回-1
     
236. * 附注：m_metaInfo.trackerList第一个值为主tracker服务器
     
237. */
     
238. STATE ResolverMetafile::ResTracker()
     
239. {
     
240.         if (NULL == m_metafile)
     
241.         {
     
242.                 cerr << "种子内容为空" << endl;
     
243.                 return ERROR;
     
244.         }
     
245.         long long index = 0;
     
246. 
     
247. 
     
248.         if (0 == FindWord("13:announce-list",index)) //单文件处理
     
249.         {
     
250.                 if (1 == FindWord("8:annouce",index))
     
251.                 {
     
252.                         int len  = 0;         //tracker长度
     
253.                         index = index + strlen("8:announce"); //跳过"8:announce"
     
254.                         while (isdigit(m_metafile[index]))
     
255.                         {
     
256.                                 len = len*10 + (m_metafile[index] - '0');
     
257.                                 index++;
     
258.                         }
     
259.                         index ++; //跳过':'
     
260.                         //填充m_metaInfo.trackerList数据成员
     
261.                         char* tmpBuf  = new char[len+1];
     
262.                         memcpy(tmpBuf, &m_metafile[index], len);
     
263.                         tmpBuf[len] = '\0';
     
264.                         if(!m_metaInfo.trackerList.empty())
     
265.                         {
     
266.                                 m_metaInfo.trackerList.clear();
     
267.                         }
     
268.                         m_metaInfo.trackerList.push_back(tmpBuf);
     
269.                 }//end if
     
270. 
     
271.         }else   //如果有“13:announce-list”关键字，则不用处理"8:annoucne"关键字
     
272.         {
     
273.                 index+=strlen("13:announce-list"); //跳过"13:announce-list"
     
274.                 index++;//跳过'l'
     
275.                 index++;//跳过'l'
     
276.                 int len = 0;
     
277. 
     
278.                 while('e' != m_metafile[index])
     
279.                 {
     
280.                         while(isdigit(m_metafile[index]))
     
281.                         {
     
282.                                 len = len*10 + (m_metafile[index]-'0');
     
283.                                 index++;
     
284.                         }
     
285.                         index++;//跳过':'
     
286.                         //提取tracker 放入m_metafile.trackerList容器
     
287.                         //只处理"http"开头的地址
     
288.                         if (0 == memcmp(&m_metafile[index],"http",4))
     
289.                         {
     
290.                                 char* tmpBuf  = new char[len+1];
     
291.                                 memcpy(tmpBuf, &m_metafile[index], len);
     
292.                                 tmpBuf[len] = '\0';
     
293.                                 m_metaInfo.trackerList.push_back(tmpBuf);
     
294.                         }
     
295.                         //准备读取下一个tracker地址
     
296.                         index = index + len;
     
297.                         len =0;
     
298.                 } //end while 1
     
299.         }  //end if else
     
300.         return OK;
     
301. }
     
302. 
     
303. /*
     
304. * 功能：解析piece快大小，将其放入m_metaInfo.pieceLen
     
305. * 返回：成功执行返回0，失败返回-1，m_metafile为空返回2
     
306. */
     
307. STATE ResolverMetafile::ResPieceLen()
     
308. {
     
309.         if (NULL == m_metafile)
     
310.         {
     
311.                 cerr << "种子内容为空" << endl;
     
312.                 return ERROR;
     
313.         }
     
314.         m_metaInfo.pieceLen = 0;
     
315.         long long index  =0;
     
316.         if (1 == FindWord("12:piece length", index))
     
317.         {
     
318.                 index += strlen("12:piece length"); //跳过"12:piece length"
     
319.                 index ++;                                                        //跳过':'
     
320.                 //填充m_metaInfo.pieceLen
     
321.                 while(isdigit(m_metafile[index]))
     
322.                 {
     
323.                         m_metaInfo.pieceLen = 10*(m_metaInfo.pieceLen) + (m_metafile[index]-'0');
     
324.                         index++;
     
325.                 }
     
326.         }else
     
327.         {
     
328.                 return ERROR;
     
329.         }
     
330.         return OK;
     
331. }
     
332. 
     
333. /*
     
334. * 功能：解析每个块对应的hash值字符串,将其放入m_metaInfo.pieces
     
335. * 返回：函数成功执行返回0，失败返回-1，m_metafile为空返回2
     
336. */
     
337. STATE ResolverMetafile::ResPieces()
     
338. {
     
339.         if (NULL == m_metafile)
     
340.         {
     
341.                 cerr << "种子内容为空" << endl;
     
342.                 return ERROR;
     
343.         }
     
344.         long long index = 0;
     
345.         if (1 == FindWord("6:pieces", index))
     
346.         {
     
347.                 index += strlen("6:pieces");
     
348.                 long len = 0;
     
349.                 while (isdigit(m_metafile[index]))
     
350.                 {
     
351.                         len = len*10 + (m_metafile[index]-'0');
     
352.                         index++;
     
353.                 }
     
354.                 //填充m_metaInfo.pieces
     
355.                 index++;//跳过':'
     
356.                 m_metaInfo.pieces = new char[len+1];
     
357.                 memcpy(m_metaInfo.pieces, &m_metafile[index], len);
     
358.                 m_metaInfo.pieces[len] = '\0';
     
359.         }else
     
360.         {
     
361.                 return ERROR;
     
362.         }
     
363.         return OK;
     
364. }
     
365. 
     
366. /*
     
367. * 功能：解析文件名，对于多文件而言解析目录名,
     
368. *       若解析单文件，放入m_metaInfo.filename,若解析多文件，放入dirName
     
369. * 返回：函数成功执行返回0，失败返回-1，m_metafile为空返回2
     
370. */
     
371. STATE ResolverMetafile::ResFileName()
     
372. {
     
373.         if (NULL == m_metafile)
     
374.         {
     
375.                 cerr << "种子内容为空" << endl;
     
376.                 return ERROR;
     
377.         }
     
378.         long long  index;
     
379.         int count = 0;
     
380.         if (1 == FindWord("4:name", index))
     
381.         {
     
382.                 index = index + 6;        //跳过'4:name'
     
383.                 while (':' != m_metafile[index] )
     
384.                 {
     
385.                         count = count*10+(m_metafile[index]-'0');
     
386.                         index++;
     
387.                 }
     
388.                 index++;//跳过':'
     
389.                 if (ISSIMPLE == m_metaInfo.fileType)
     
390.                 {
     
391.                         m_metaInfo.fileName  = new char[count+1];
     
392.                         memcpy(m_metaInfo.fileName,&m_metafile[index], count);
     
393.                         m_metaInfo.fileName[count] ='\0';
     
394.                 }else if(ISMULTIPLE == m_metaInfo.fileType)
     
395.                 {
     
396.                         m_metaInfo.dirName  = new char[count+1];
     
397.                         memcpy(m_metaInfo.dirName,&m_metafile[index], count);
     
398.                         m_metaInfo.dirName[count] ='\0';
     
399. 
     
400.                 }
     
401.         }else
     
402.         {
     
403.                 return ERROR;
     
404.         }
     
405.         return OK;
     
406. }
     
407. 
     
408. /*
     
409. * 功能：解析总文件大小，填充m_metaInfo.fileLength
     
410. * 返回：函数成功执行返回0，失败返回-1，m_metafile为空返回2
     
411. */
     
412. STATE ResolverMetafile::ResFileLength()
     
413. {
     
414.         if (NULL == m_metafile)
     
415.         {
     
416.                 cerr << "种子内容为空" << endl;
     
417.                 return ERROR;
     
418.         }
     
419.         long long index = 0;
     
420.         long long size = 0;
     
421.         if (ISSIMPLE == m_metaInfo.fileType )
     
422.         {
     
423.                 cout << "enter simple file process " << endl;
     
424.                 if (1 == FindWord("6:length",index)) //单文件
     
425.                 {
     
426.                         index = index+strlen("6:length"); //跳过"6:length"
     
427.                         index ++ ;        //跳过'i'
     
428.                         while(isdigit(m_metafile[index]))
     
429.                         {
     
430.                                 size = size*10 + (m_metafile[index]-'0');
     
431.                                 index++;
     
432.                         }
     
433.                         m_metaInfo.fileLength = size;
     
434.                 } //end if
     
435.         }else if(ISMULTIPLE == m_metaInfo.fileType)
     
436.         {
     
437.                 for(int i=0; i<int(m_metaInfo.multiFiles.size()); i++)
     
438.                 {
     
439.                         m_metaInfo.fileLength = m_metaInfo.fileLength +
     
440.                                                                         m_metaInfo.multiFiles[i].length;
     
441.                 }
     
442.         }else
     
443.         {
     
444.                 return ERROR;
     
445.         }
     
446.         return OK;
     
447. }
     
448. 
     
449. /*
     
450. * 功能：解析文件大小和路径，仅对多文件有效,填充m_metaInfo.multiFiles结构体
     
451. *                  并将files填充，代表多文件的文件个数
     
452. * 返回：函数成功执行返回0，失败返回-1，m_metafile为空返回2
     
453. */
     
454. STATE ResolverMetafile::ResFilePathLen()
     
455. {
     
456.         if (NULL == m_metafile)
     
457.         {
     
458.                 cerr << "种子内容为空" << endl;
     
459.                 return NOFILE;
     
460.         }
     
461.         //不是多文件该函数无效
     
462.         if (ISMULTIPLE != m_metaInfo.fileType)
     
463.         {
     
464.                 return ERROR;
     
465.         }
     
466. 
     
467.         int         length          = 0;
     
468. //        char*         path          = NULL;
     
469.         int         pathSize = 0;
     
470.         Files   mfBuf         ;
     
471.         memset(&mfBuf, 0, sizeof(mfBuf));
     
472. 
     
473.         for(long i=0; i<(m_metafileLen-8); i++) //-8预留空间，防内存溢出
     
474.         {
     
475.                 //获取多文件中各个文件的大小
     
476.                 if (0 == memcmp(&m_metafile[i], "6:length", 8))
     
477.                 {
     
478.                         i+=8;        //跳过"6：length"
     
479.                         i++;        //跳过'i'
     
480.                         length = 0;
     
481.                         while('e' != m_metafile[i])
     
482.                         {
     
483.                                 length = length*10 + (m_metafile[i]-'0');
     
484.                                 i++;
     
485.                         }
     
486.                         mfBuf.length = length;
     
487.                         //填充m_metaInfo.multiFiles成员，于末尾追加
     
488.                         m_metaInfo.multiFiles.push_back(mfBuf);
     
489. 
     
490.                 }//end if
     
491. 
     
492.                 //获取多文件中文件路径
     
493.                 if (0 == memcmp(&m_metafile[i], "4:path", 4))
     
494.                 {
     
495.                         i+=6; //跳过"4:path"
     
496.                         i++;  //跳过 'l'
     
497.                         pathSize = 0;
     
498.                         while(':' != m_metafile[i])
     
499.                         {
     
500.                                 pathSize = pathSize*10 + (m_metafile[i] - '0');
     
501.                                 i++;
     
502.                         }
     
503.                         i++; //跳过':'
     
504.                         //填充m_metaInfo.multiFiles成员，于末尾追加
     
505.                         int end = m_metaInfo.multiFiles.size();
     
506.                         (m_metaInfo.multiFiles[end-1]).path = new char[pathSize+1];
     
507.                         memcpy((m_metaInfo.multiFiles[end-1]).path, &m_metafile[i], pathSize);
     
508.                         (m_metaInfo.multiFiles[end-1]).path[pathSize]  = '\0';
     
509.                 }//end if
     
510.         } //end for
     
511.         return OK;
     
512. }
     
513. 
     
514. /*
     
515. * 功能：更具info关键字的值计算其对应的哈希值，将其填充与m_metaInfo.info_hash内
     
516. * 返回：成功返回0,失败返回-1
     
517. * 附注：info关键字对应的值为一个字典。
     
518. */
     
519. STATE ResolverMetafile::CalcInfoHash()
     
520. {
     
521.         if (NULL == m_metafile)
     
522.         {
     
523.                 cerr << "种子内容为空" << endl;
     
524.                 return NOFILE;
     
525.         }
     
526.         //begin 为info关键字值开始下标，end为结束
     
527.         int push_pop = 0;
     
528.         long long index=0,begin=0,end=0;
     
529. 
     
530.         if (1 == FindWord("4:info", index))
     
531.         {
     
532.                 begin = index+6;
     
533.         }else
     
534.         {
     
535.                 return ERROR;
     
536.         }
     
537.         index +=6; //跳过"4:info"
     
538.         /*
     
539.          * 核心算法： 遍历info关键字后的值，当遇到d,l时push_pop++,
     
540.          *                           如果遇到e，则push_pop--当push_pop为0的时候，
     
541.          *                           则证明info关键字后的字典结束，遇见i则直接遍历
     
542.          *                           i的内容，遇见数字则直接计算其后字串内容
     
543.          */
     
544.         for (;index<m_metafileLen;)
     
545.         {
     
546.                 if ('d' == m_metafile[index])
     
547.                 {
     
548.                         push_pop++;
     
549.                         index++;
     
550.                 }else if ('l' == m_metafile[index])
     
551.                 {
     
552.                         push_pop++;
     
553.                         index++;
     
554.                 }else if ('i' == m_metafile[index])
     
555.                 {
     
556.                         index++;//跳过'i'
     
557.                         if (index > m_metafileLen)
     
558.                         {
     
559.                                 return ERROR;
     
560.                         }
     
561.                         while ('e' != m_metafile[index])
     
562.                         {
     
563.                                 if (index+1 == m_metafileLen)
     
564.                                 {
     
565.                                         return ERROR;
     
566.                                 }else
     
567.                                 {
     
568.                                         index ++;
     
569.                                 }
     
570.                         }//end while
     
571.                         index ++; //跳过'e'
     
572.                 }else if(('0'<=m_metafile[index]) && (m_metafile[index] <= '9'))
     
573.                 {
     
574.                         int len =0;
     
575.                         while (isdigit(m_metafile[index]))
     
576.                         {
     
577.                                 len = len*10 + (m_metafile[index]-'0');
     
578.                                 index++;
     
579.                         }
     
580.                         index++;        //跳过':'
     
581.                         index+=len;
     
582.                 }else if ('e' == m_metafile[index])
     
583.                 {
     
584.                         push_pop --;
     
585.                         if (0 == push_pop)
     
586.                         {
     
587.                                 end = index; break;
     
588.                         }
     
589.                         index++;
     
590.                 }else
     
591.                 {
     
592.                         return ERROR;
     
593.                 }
     
594.         }//end for
     
595. 
     
596.         //计算hash值
     
597.         SHA1_CTX context;
     
598.         SHA1Init(&context);
     
599.         SHA1Update(&context,&m_metafile[begin], end-begin+1);
     
600.         SHA1Final(m_metaInfo.info_hash,&context);
     
601.         cout << endl;
     
602.         return OK;
     
603. }
     
604. 
     
605. /*
     
606. * 功能：释放类资源
     
607. */
     
608. void ResolverMetafile::ReleaseMem()
     
609. {
     
610.         if (NULL != m_metafile)
     
611.         {
     
612.                 delete[] m_metafile;
     
613.                 m_metafile = NULL;
     
614.         }
     
615.         if (NULL != m_metaInfo.pieces)
     
616.         {
     
617.                 delete[] m_metaInfo.pieces;
     
618.         }
     
619. 
     
620.         if (!m_metaInfo.trackerList.empty())
     
621.         {
     
622.                 for (int i=0; i< int(m_metaInfo.trackerList.size()); i++)
     
623.                 {
     
624.                         delete[] m_metaInfo.trackerList.at(i);
     
625.                         m_metaInfo.trackerList.at(i) = NULL;
     
626.                 }
     
627.         }
     
628.         m_metaInfo.trackerList.clear();
     
629.         if (!m_metaInfo.multiFiles.empty())
     
630.         {
     
631.                 for (int i=0; i<int(m_metaInfo.multiFiles.size()); i++)
     
632.                 {
     
633.                         if (NULL != (m_metaInfo.multiFiles.at(i).path))
     
634.                         delete[] m_metaInfo.multiFiles.at(i).path;
     
635.                         m_metaInfo.multiFiles.at(i).path = NULL;
     
636.                 }
     
637.         }
     
638.         m_metaInfo.multiFiles.clear();
     
639. 
     
640.         memset(&m_metaInfo, 0, sizeof(m_metaInfo));
     
641. }
     

复制代码

Kill

谢谢猫鱼的优秀技术贴！

SKY流氓兔

喵呜~好评。虽然我看不懂。。。

猫/db鱼

Kill 发表于 2013-10-16 13:19
谢谢猫鱼的优秀技术贴！

kill老师客气了，我入行软件开发4350给了我蛮大的帮助，这个是我该做的。

猫/db鱼

SKY流氓兔 发表于 2013-10-16 13:28
喵呜~好评。虽然我看不懂。。。

感谢对我的认可！

SKY流氓兔

猫/db鱼 发表于 2013-10-16 15:13
感谢对我的认可！

不客气。你乖乖来歪歪被调戏就好。。