C++字符操作--BT种子文件解析 sourcefile

study_wuwenyao 2013-11-13 03:35:38
声明:原创文章,转载请注明出处
这个东西主要涉及字符操作,网上有一份C语言格式的源代码,这份代码是我借助那份代码写出来的,具体源代码已经找不到了,有兴趣的自己可以去搜索下

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

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

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


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

#ifndef RESOLVERMETAFILE_H_
#define RESOLVERMETAFILE_H_

#define DEBUG

#include <iostream>
#include <cstdio>
#include <vector>
#include <string>
#include <cstring>
#include <cstdlib>
#include <fstream>
#include <cctype>
#include "sha1.h"
using namespace std;


typedef int FILETYPE; //文件类型

/*状态标识*/
typedef int STATE; //状态
const int NOFILE = 2; //文件为空
const int OK = 0; //成功标识
const int ERROR = -1; //错误标识

/*文件类型标识*/
const int ISSIMPLE =1; //单文件标识
const int ISMULTIPLE =2; //多文件标识

struct Files //多文件中的多个文件
{
int length; //单个文件的长度
char* path; //单个文件的路径及文件名
};

/****************************************************************************************************************
** 种子文件信息结构体
** 用于存储种子文件的主要信息
** 成员说明
flagFileType 标识文件是单文件还是多文件,
当其值为ISSIMPLE的时候表示单文件,所有的多文件特有属性(m_name,files,)失效
当其值为ISMULTIPLE的时候表示多文件,多有单文件特有属性失效(s_name,length)
pieceLen 指定piece的大小 通常为256KB、亦有128kb或512kb 单位为字节
pieces 每个piece对应hash值
file_name 单文件的文件名
fileLength 文件的总文件长度
dir_name 多文件存放所有文件的目录名称
multi_files 多文件中包含的所有文件的信息
tracker_list tracker地址列表,其类型为一个string类型的vector数组
第一个元素是主tracker地址
info_hash 根据info关键字的值计算的哈希值,固定为20字节
*****************************************************************************************************************/
typedef struct MetafileInfo
{
/*标识文件属性*/
int fileType;
/*单文件、多文件共有属性*/
long pieceLen; //每个piece的长度
char* pieces; //每个piece对应的hash值
long long fileLength; //文件总大小
vector<const char*> trackerList; //tracker地址列表
/*单文件特有属性*/
char* fileName; //文件名
/*多文件特有属性*/
char* dirName; //存放所有文件的文件夹名
vector<Files> multiFiles; //多文件中所有文件信息
unsigned char info_hash[20]; //根据info关键字的值计算的哈希值。
}* pMetaInfo;


/*种子文件解析类*/
class ResolverMetafile
{
public:
/*构造及析构函数*/
ResolverMetafile(string MetafilePath);
~ResolverMetafile();

/********************************************************************
*功能:获取共享文件信息
*返回:函数返回存储种子文件信息的m_metaInfo结构体对象
*参数:st_info是一个MetafileInfo类型的常引用,用于接收种子文件信息
存放点地址
*附注:该函数是文件解析类对外提供的主要接口
*********************************************************************/
MetafileInfo GetMetafileInfo(pMetaInfo*const ppst_info);
/*
* 功能:向tracker列表添加一个tracker服务器地址
* 返回:成功添加tracker返回1,tracker已经存在返回0
* 函数成功执行失败返回-1
* 参数:url指定添加的tracker地址,如果该地址存在与tracker
* 列表中,则函数退出
* 附注:当连接某些tarcker地址的时候,服务器会返回一个重定向地址,函数用于
* 添加该类地址,当调用该函数后,调用者应该重新调用GetMetafileInfo获取数据
*/
STATE AddTracker(const char* url);
protected:
/*
* 功能:更具info关键字的值计算其对应的哈希值,将其填充与m_metaInfo.info_hash内
* 返回:成功返回0,失败返回-1
* 附注:info关键字对应的值为一个字典。
*/
STATE CalcInfoHash();

/*
* 功能:读取m_metafilePath指定的种子文件,将文件内容保存到m_metafile中
* 返回:函数成功执行返回1,m_metafilePath为空返回2,失败返回-1
* 附注:文件读取方式为二进制读取
*/
STATE ReadMetafile();

/*
* 功能:判断种子文件类型
* 返回:单文件返回ISSIMPLE,多文件返回ISMULTIPLE,m_metafile为空返回2
* 附注:ISSIMPLE值为1,ISMULTIPLE值为2
*/
FILETYPE FileType();

/*
*功能:在m_metafile中查找指定关键字
*返回:函数查找到指定的关键字返回1,没有找到返回0,函数执行出错返回-1
*参数:word为需要查找的指定关键字,index为查找到的字符串的起始下标
*/
STATE FindWord(const char* word, long long& index);

/*
* 功能:解析种子文件的tracker服务器列表,将其放入m_metaInfo.trackerList
* 返回:函数成功执行返回0,失败返回-1
* 附注:m_metaInfo.trackerList第一个值为主tracker服务器
*/
STATE ResTracker();

/*
* 功能:解析piece快大小,将其放入m_metaInfo.pieceLen
* 返回:成功执行返回0,失败返回-1,m_metafile为空返回2
*/
STATE ResPieceLen();

/*
* 功能:解析每个块对应的hash值字符串,将其放入m_metaInfo.pieces
* 返回:函数成功执行返回0,失败返回-1,m_metafile为空返回2
*/
STATE ResPieces();

/*
* 功能:解析文件名,对于多文件而言解析目录名,
* 若解析单文件,放入m_metaInfo.filename,若解析多文件,放入dirName
* 返回:函数成功执行返回0,失败返回-1,m_metafile为空返回2
*/
STATE ResFileName();

/*
* 功能:解析总文件大小,填充m_metaInfo.fileLength
* 返回:函数成功执行返回0,失败返回-1,m_metafile为空返回2
*/
STATE ResFileLength();

/*
* 功能:解析文件大小和路径,仅对多文件有效,填充m_metaInfo.multiFiles结构体
* 返回:函数成功执行返回0,失败返回-1,m_metafile为空返回2
*/
STATE ResFilePathLen();

/*
* 功能:释放类资源
*/
void ReleaseMem();
protected:
/*种子文件信息*/
MetafileInfo m_metaInfo;
/*存储种子文件路径*/
string m_metafilePath;
/*存储种子文件的内容*/
unsigned char* m_metafile;
/*种子文件大小*/
long long int m_metafileLen;

#ifdef DEBUG
public:
/*测试函数*/
void Test();
#endif
};

#endif


源代码
阿弥陀佛,老衲CSDN没下载分了,源文件我上传到CSDN下载里面了,并且还要了几分来着。
...全文
506 12 打赏 收藏 转发到动态 举报
AI 作业
写回复
用AI写文章
12 条回复
切换为时间正序
请发表友善的回复…
发表回复
s9203612 2014-05-31
  • 打赏
  • 举报
回复
C++新手,下載了表示不知道怎麼用............
study_wuwenyao 2014-03-21
  • 打赏
  • 举报
回复
引用 9 楼 liudanai2844 的回复:
楼主,编译不通过
#include "sha1.h" 这个哈希值计算文件需要自己去下载一个。另外,编译环境为g++,运行环境文linux。windows下是没法编译通的
zjwangmin 2014-03-21
  • 打赏
  • 举报
回复
mark,以后备用。
liudanai2844 2014-03-20
  • 打赏
  • 举报
回复
楼主,编译不通过
huangxiangbo316 2014-03-06
  • 打赏
  • 举报
回复
多谢分享,顶一个。
study_wuwenyao 2014-03-06
  • 打赏
  • 举报
回复

/*
* 功能:解析总文件大小,填充m_metaInfo.fileLength
* 返回:函数成功执行返回0,失败返回-1,m_metafile为空返回2
*/
STATE ResolverMetafile::ResFileLength()
{
        if (NULL == m_metafile)
        {
                cerr << "种子内容为空" << endl;
                return ERROR;
        }
        long long index = 0;
        long long size = 0;
        if (ISSIMPLE == m_metaInfo.fileType )
        {
                cout << "enter simple file process " << endl;
                if (1 == FindWord("6:length",index)) //单文件
                {
                        index = index+strlen("6:length"); //跳过"6:length"
                        index ++ ;        //跳过'i'
                        while(isdigit(m_metafile[index]))
                        {
                                size = size*10 + (m_metafile[index]-'0');
                                index++;
                        }
                        m_metaInfo.fileLength = size;
                } //end if
        }else if(ISMULTIPLE == m_metaInfo.fileType)
        {
                for(int i=0; i<int(m_metaInfo.multiFiles.size()); i++)
                {
                        m_metaInfo.fileLength = m_metaInfo.fileLength +
                                                                        m_metaInfo.multiFiles[i].length;
                }
        }else
        {
                return ERROR;
        }
        return OK;
}

/*
* 功能:解析文件大小和路径,仅对多文件有效,填充m_metaInfo.multiFiles结构体
*                  并将files填充,代表多文件的文件个数
* 返回:函数成功执行返回0,失败返回-1,m_metafile为空返回2
*/
STATE ResolverMetafile::ResFilePathLen()
{
        if (NULL == m_metafile)
        {
                cerr << "种子内容为空" << endl;
                return NOFILE;
        }
        //不是多文件该函数无效
        if (ISMULTIPLE != m_metaInfo.fileType)
        {
                return ERROR;
        }

        int         length          = 0;
//        char*         path          = NULL;
        int         pathSize = 0;
        Files   mfBuf         ;
        memset(&mfBuf, 0, sizeof(mfBuf));

        for(long i=0; i<(m_metafileLen-8); i++) //-8预留空间,防内存溢出
        {
                //获取多文件中各个文件的大小
                if (0 == memcmp(&m_metafile[i], "6:length", 8))
                {
                        i+=8;        //跳过"6:length"
                        i++;        //跳过'i'
                        length = 0;
                        while('e' != m_metafile[i])
                        {
                                length = length*10 + (m_metafile[i]-'0');
                                i++;
                        }
                        mfBuf.length = length;
                        //填充m_metaInfo.multiFiles成员,于末尾追加
                        m_metaInfo.multiFiles.push_back(mfBuf);

                }//end if

                //获取多文件中文件路径
                if (0 == memcmp(&m_metafile[i], "4:path", 4))
                {
                        i+=6; //跳过"4:path"
                        i++;  //跳过 'l'
                        pathSize = 0;
                        while(':' != m_metafile[i])
                        {
                                pathSize = pathSize*10 + (m_metafile[i] - '0');
                                i++;
                        }
                        i++; //跳过':'
                        //填充m_metaInfo.multiFiles成员,于末尾追加
                        int end = m_metaInfo.multiFiles.size();
                        (m_metaInfo.multiFiles[end-1]).path = new char[pathSize+1];
                        memcpy((m_metaInfo.multiFiles[end-1]).path, &m_metafile[i], pathSize);
                        (m_metaInfo.multiFiles[end-1]).path[pathSize]  = '\0';
                }//end if
        } //end for
        return OK;
}

/*
 * 功能:更具info关键字的值计算其对应的哈希值,将其填充与m_metaInfo.info_hash内
 * 返回:成功返回0,失败返回-1
 * 附注:info关键字对应的值为一个字典。
 */
STATE ResolverMetafile::CalcInfoHash()
{
        if (NULL == m_metafile)
        {
                cerr << "种子内容为空" << endl;
                return NOFILE;
        }
        //begin 为info关键字值开始下标,end为结束
        int push_pop = 0;
        long long index=0,begin=0,end=0;

        if (1 == FindWord("4:info", index))
        {
                begin = index+6;
        }else
        {
                return ERROR;
        }
        index +=6; //跳过"4:info"
        /*
         * 核心算法: 遍历info关键字后的值,当遇到d,l时push_pop++,
         *                           如果遇到e,则push_pop--当push_pop为0的时候,
         *                           则证明info关键字后的字典结束,遇见i则直接遍历
         *                           i的内容,遇见数字则直接计算其后字串内容
         */
        for (;index<m_metafileLen;)
        {
                if ('d' == m_metafile[index])
                {
                        push_pop++;
                        index++;
                }else if ('l' == m_metafile[index])
                {
                        push_pop++;
                        index++;
                }else if ('i' == m_metafile[index])
                {
                        index++;//跳过'i'
                        if (index > m_metafileLen)
                        {
                                return ERROR;
                        }
                        while ('e' != m_metafile[index])
                        {
                                if (index+1 == m_metafileLen)
                                {
                                        return ERROR;
                                }else
                                {
                                        index ++;
                                }
                        }//end while
                        index ++; //跳过'e'
                }else if(('0'<=m_metafile[index]) && (m_metafile[index] <= '9'))
                {
                        int len =0;
                        while (isdigit(m_metafile[index]))
                        {
                                len = len*10 + (m_metafile[index]-'0');
                                index++;
                        }
                        index++;        //跳过':'
                        index+=len;
                }else if ('e' == m_metafile[index])
                {
                        push_pop --;
                        if (0 == push_pop)
                        {
                                end = index; break;
                        }
                        index++;
                }else
                {
                        return ERROR;
                }
        }//end for

        //计算hash值
        SHA1_CTX context;
        SHA1Init(&context);
        SHA1Update(&context,&m_metafile[begin], end-begin+1);
        SHA1Final(m_metaInfo.info_hash,&context);
        cout << endl;
        return OK;
}

/*
 * 功能:释放类资源
 */
void ResolverMetafile::ReleaseMem()
{
        if (NULL != m_metafile)
        {
                delete[] m_metafile;
                m_metafile = NULL;
        }
        if (NULL != m_metaInfo.pieces)
        {
                delete[] m_metaInfo.pieces;
        }

        if (!m_metaInfo.trackerList.empty())
        {
                for (int i=0; i< int(m_metaInfo.trackerList.size()); i++)
                {
                        delete[] m_metaInfo.trackerList.at(i);
                        m_metaInfo.trackerList.at(i) = NULL;
                }
        }
        m_metaInfo.trackerList.clear();
        if (!m_metaInfo.multiFiles.empty())
        {
                for (int i=0; i<int(m_metaInfo.multiFiles.size()); i++)
                {
                        if (NULL != (m_metaInfo.multiFiles.at(i).path))
                        delete[] m_metaInfo.multiFiles.at(i).path;
                        m_metaInfo.multiFiles.at(i).path = NULL;
                }
        }
        m_metaInfo.multiFiles.clear();

        memset(&m_metaInfo, 0, sizeof(m_metaInfo));
}
study_wuwenyao 2014-03-06
  • 打赏
  • 举报
回复

/*
*功能:在m_metafile中查找指定关键字
*返回:函数查找到指定的关键字返回1,没有找到返回0,函数执行出错返回-1
*参数:word为需要查找的指定关键字,index为查找到的字符串的起始下标的引用
*/
STATE ResolverMetafile::FindWord(const char* word, long long& index)
{
        if (NULL == m_metafile)
        {
                cerr << "种子内容为空" << endl;
                return ERROR;
        }
        for (long long  int i=0; i<(m_metafileLen-long(strlen(word))); i++)
        {
                if (0 == memcmp(&m_metafile[i], word, strlen(word)))
                {
                        index = i;
                        return 1;
                }
        }
        //未找到
        return 0;
}

/*
* 功能:解析种子文件的tracker服务器列表,将其放入m_metaInfo.trackerList
* 返回:函数成功执行返回0,失败返回-1
* 附注:m_metaInfo.trackerList第一个值为主tracker服务器
*/
STATE ResolverMetafile::ResTracker()
{
        if (NULL == m_metafile)
        {
                cerr << "种子内容为空" << endl;
                return ERROR;
        }
        long long index = 0;


        if (0 == FindWord("13:announce-list",index)) //单文件处理
        {
                if (1 == FindWord("8:annouce",index))
                {
                        int len  = 0;         //tracker长度
                        index = index + strlen("8:announce"); //跳过"8:announce"
                        while (isdigit(m_metafile[index]))
                        {
                                len = len*10 + (m_metafile[index] - '0');
                                index++;
                        }
                        index ++; //跳过':'
                        //填充m_metaInfo.trackerList数据成员
                        char* tmpBuf  = new char[len+1];
                        memcpy(tmpBuf, &m_metafile[index], len);
                        tmpBuf[len] = '\0';
                        if(!m_metaInfo.trackerList.empty())
                        {
                                m_metaInfo.trackerList.clear();
                        }
                        m_metaInfo.trackerList.push_back(tmpBuf);
                }//end if

        }else   //如果有“13:announce-list”关键字,则不用处理"8:annoucne"关键字
        {
                index+=strlen("13:announce-list"); //跳过"13:announce-list"
                index++;//跳过'l'
                index++;//跳过'l'
                int len = 0;

                while('e' != m_metafile[index])
                {
                        while(isdigit(m_metafile[index]))
                        {
                                len = len*10 + (m_metafile[index]-'0');
                                index++;
                        }
                        index++;//跳过':'
                        //提取tracker 放入m_metafile.trackerList容器
                        //只处理"http"开头的地址
                        if (0 == memcmp(&m_metafile[index],"http",4))
                        {
                                char* tmpBuf  = new char[len+1];
                                memcpy(tmpBuf, &m_metafile[index], len);
                                tmpBuf[len] = '\0';
                                m_metaInfo.trackerList.push_back(tmpBuf);
                        }
                        //准备读取下一个tracker地址
                        index = index + len;
                        len =0;
                } //end while 1
        }  //end if else
        return OK;
}

/*
* 功能:解析piece快大小,将其放入m_metaInfo.pieceLen
* 返回:成功执行返回0,失败返回-1,m_metafile为空返回2
*/
STATE ResolverMetafile::ResPieceLen()
{
        if (NULL == m_metafile)
        {
                cerr << "种子内容为空" << endl;
                return ERROR;
        }
        m_metaInfo.pieceLen = 0;
        long long index  =0;
        if (1 == FindWord("12:piece length", index))
        {
                index += strlen("12:piece length"); //跳过"12:piece length"
                index ++;                                                        //跳过':'
                //填充m_metaInfo.pieceLen
                while(isdigit(m_metafile[index]))
                {
                        m_metaInfo.pieceLen = 10*(m_metaInfo.pieceLen) + (m_metafile[index]-'0');
                        index++;
                }
        }else
        {
                return ERROR;
        }
        return OK;
}

/*
* 功能:解析每个块对应的hash值字符串,将其放入m_metaInfo.pieces
* 返回:函数成功执行返回0,失败返回-1,m_metafile为空返回2
*/
STATE ResolverMetafile::ResPieces()
{
        if (NULL == m_metafile)
        {
                cerr << "种子内容为空" << endl;
                return ERROR;
        }
        long long index = 0;
        if (1 == FindWord("6:pieces", index))
        {
                index += strlen("6:pieces");
                long len = 0;
                while (isdigit(m_metafile[index]))
                {
                        len = len*10 + (m_metafile[index]-'0');
                        index++;
                }
                //填充m_metaInfo.pieces
                index++;//跳过':'
                m_metaInfo.pieces = new char[len+1];
                memcpy(m_metaInfo.pieces, &m_metafile[index], len);
                m_metaInfo.pieces[len] = '\0';
        }else
        {
                return ERROR;
        }
        return OK;
}

/*
* 功能:解析文件名,对于多文件而言解析目录名,
*       若解析单文件,放入m_metaInfo.filename,若解析多文件,放入dirName
* 返回:函数成功执行返回0,失败返回-1,m_metafile为空返回2
*/
STATE ResolverMetafile::ResFileName()
{
        if (NULL == m_metafile)
        {
                cerr << "种子内容为空" << endl;
                return ERROR;
        }
        long long  index;
        int count = 0;
        if (1 == FindWord("4:name", index))
        {
                index = index + 6;        //跳过'4:name'
                while (':' != m_metafile[index] )
                {
                        count = count*10+(m_metafile[index]-'0');
                        index++;
                }
                index++;//跳过':'
                if (ISSIMPLE == m_metaInfo.fileType)
                {
                        m_metaInfo.fileName  = new char[count+1];
                        memcpy(m_metaInfo.fileName,&m_metafile[index], count);
                        m_metaInfo.fileName[count] ='\0';
                }else if(ISMULTIPLE == m_metaInfo.fileType)
                {
                        m_metaInfo.dirName  = new char[count+1];
                        memcpy(m_metaInfo.dirName,&m_metafile[index], count);
                        m_metaInfo.dirName[count] ='\0';

                }
        }else
        {
                return ERROR;
        }
        return OK;
}
study_wuwenyao 2014-03-06
  • 打赏
  • 举报
回复

/*
 * resolvermetafile.cpp
 * 对resolverMetafile类的具体实现
 *  Created on: 2013-8-6
 *      Author: tmfish
 */
#include "resolverMetafile.h"

#ifdef DEBUG
//测试函数
void ResolverMetafile::Test()
{
        cout << "测试函数" << endl;
        //合格测试
        //*successful
        cout << "filetype:  "        << m_metaInfo.fileType         << endl;
        cout << "piecelen:        "        << m_metaInfo.pieceLen         << endl;
        if (ISSIMPLE == m_metaInfo.fileType)
        {
                cout << "filename:        "        << m_metaInfo.fileName        << endl;
        }else if (ISMULTIPLE == m_metaInfo.fileType)
        {
                cout << "dirname:        "        << m_metaInfo.dirName        << endl;
        }

        cout << "multiple files number: " << m_metaInfo.multiFiles.size() << endl;
        for (int i=0; i<int(m_metaInfo.multiFiles.size()); i++)
        {
                cout << "path:           " << m_metaInfo.multiFiles[i].path << endl;
                cout << "length:         " << m_metaInfo.multiFiles[i].length << endl;
        }

        cout << "fileLen:        "        << m_metaInfo.fileLength<< endl;
        for(int i=0; i<int(m_metaInfo.trackerList.size()); i++)
        {
                cout << "trackerList" << i << ": " << m_metaInfo.trackerList[i] << endl;
        }
        cout << "test for add " << endl;
        char url[] = "一个URL地址,随意填";
        AddTracker(url);
        for(int i=0; i<int(m_metaInfo.trackerList.size()); i++)
        {
                cout << "trackerList" << i << ": " << m_metaInfo.trackerList[i] << endl;
        }
}
#endif

//构造函数
ResolverMetafile::ResolverMetafile(string path)
{
        memset(&m_metaInfo, 0, sizeof(m_metaInfo));
        m_metafile                = NULL;
        m_metafilePath         = path;
        m_metafileLen         = 0;
        ReadMetafile();
        FileType();
        ResTracker();
        ResPieceLen();
        ResPieces();
        ResFileName();
        ResFilePathLen();
        ResFileLength();
        CalcInfoHash();
}

//析构函数
ResolverMetafile::~ResolverMetafile()
{
        /*某些释放*/
        ReleaseMem();
}

/********************************************************************
*功能:获取共享文件信息
*返回:函数返回存储种子文件信息的m_metaInfo结构体对象
*参数:pst_info是一个MetafileInfo类型的指针的指针,用于接收种子文件信息
           存放点地址
*********************************************************************/
MetafileInfo ResolverMetafile::GetMetafileInfo(pMetaInfo*const ppst_info)
{
        *ppst_info = &m_metaInfo;

        return m_metaInfo;
}

/*
 * 功能:向tracker列表添加一个tracker服务器地址
 * 返回:成功添加tracker返回1,tracker已经存在返回0
 *                  函数成功执行失败返回-1
 * 参数:strTracker指定添加的tracker地址,如果该地址存在与tracker
 *                  列表中,则函数退出
 * 附注:当连接某些tarcker地址的时候,服务器会返回一个重定向地址,函数用于
 *                  添加该类地址
 */
STATE ResolverMetafile::AddTracker(const char* url)
{
        char* bufTmp = new char[strlen(url)+1];
        memcpy(bufTmp,url,strlen(url)+1);
        int size = m_metaInfo.trackerList.size();
        //若地址存在,则无需添加
        for (int i=0; i<size; i++)
        {
                if (0 == strcmp(m_metaInfo.trackerList.at(i),url))
                {
                        return OK;
                }
        }
        //于末尾追加元素
        m_metaInfo.trackerList.push_back(bufTmp);
        return OK;
}

/*
 * 功能:判断种子文件类型
 * 返回:单文件返回ISSIMPLE,多文件返回ISMULTIPLE,m_metafile为空返回2
 * 附注:ISSIMPLE值为1,ISMULTIPLE值为2
*/
FILETYPE ResolverMetafile::FileType()
{
//        cout << m_metafile << endl;
        long long  index;
         //种子文件中files代表多文件
        if (1 == FindWord("5:files",index))
        {
                m_metaInfo.fileType = ISMULTIPLE;
                return ISMULTIPLE;
        }else
        {
                m_metaInfo.fileType = ISSIMPLE;
                return ISSIMPLE;
        }
        return ERROR;
}

/*
* 功能:读取m_metafilePath指定的种子文件,将文件内容保存到m_metafile中
* 返回:函数成功执行返回0,m_metafilePath为空返回2,失败返回-1
* 附注:文件读取方式为二进制读取
*/
STATE ResolverMetafile::ReadMetafile()
{
        if (m_metafilePath.empty())
        {
                cerr << "文件路径为空!" << endl;
                return ERROR;
        }
        /*
        ifstream fin(m_metafilePath.c_str(), ios_base::in | ios_base::binary);
//        fin.open("in");
        if (!fin.is_open())
        {
                cerr<< "文件打开失败!" << endl;
                return ERROR;
        }
        //获取种子文件长度
        fin.seekg(0,ios::end);
        m_metafileLen = fin.tellg();
        m_metafile = new char[m_metafileLen+1];
//        fin.read(m_metafile, m_metafileLen);]
        fin >> m_metafile;
        if (NULL == m_metafile)
        {
                cerr << "文件读取失败" << endl;
                return ERROR;
        }
        m_metafile[m_metafileLen] = '\0';
        cout << m_metafile[3] << endl;
        fin.close();
        */

        //以二进制、只读方式打开文件
        FILE* fp = fopen(m_metafilePath.c_str(), "rb");
        if (NULL == fp)
        {
                cout << "文件打开失败" << endl;
                return -1;
        }

        //获取种子文件的长度,
        fseek(fp, 0, SEEK_END);
        m_metafileLen        = ftell(fp);
        if (-1 == m_metafileLen)
        {
                cout << "文件长度错误" << endl;
                return -1;
        }
        m_metafile = new unsigned char[m_metafileLen+1];
        if (NULL == m_metafile)
        {
                cout << "内存分配失败" << endl;
                return -1;
        }

        //读取种子文件的内容到m_metafile
        fseek(fp, 0, SEEK_SET);
        long i;
        for ( i=0; i<m_metafileLen; i++)
        {
                m_metafile[i] = fgetc(fp);
        }
        m_metafile[i] = '\0';

        fclose(fp);

        return OK;
}
Defonds 2013-11-13
  • 打赏
  • 举报
回复
感谢分享,先收一下,以备参考
study_wuwenyao 2013-11-13
  • 打赏
  • 举报
回复
http://download.csdn.net/detail/study_wuwenyao/6545595 这个是源码下载地址。。。有分的给几分下载分哇,。源码其实我已经贴出来,不愿给分的可以自己找找。。
max_min_ 2013-11-13
  • 打赏
  • 举报
回复
谢谢分享!确实不错!
  • 打赏
  • 举报
回复
不明觉厉。 不过赞楼主的分享精神,是种子文件的精神体现~~

65,186

社区成员

发帖
与我相关
我的任务
社区描述
C++ 语言相关问题讨论,技术干货分享,前沿动态等
c++ 技术论坛(原bbs)
社区管理员
  • C++ 语言社区
  • encoderlee
  • paschen
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告
  1. 请不要发布与C++技术无关的贴子
  2. 请不要发布与技术无关的招聘、广告的帖子
  3. 请尽可能的描述清楚你的问题,如果涉及到代码请尽可能的格式化一下

试试用AI创作助手写篇文章吧