开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > P2P编程 > 查看源码
MakeMetaFile.cpp
资源名称：GGBT.rar　[点击查看]
上传用户：lds876
上传日期：2013-05-25
资源大小：567k
文件大小：11k
源码类别：

P2P编程

开发平台：

Visual C++

MakeMetaFile.cpp：源码内容
  1. // MakeMetaFile.cpp: implementation of the CMakeMetaFile class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "testbt.h"
  7. #include "MakeMetaFile.h"
  9. #include "filebase.h"
  10. #include "Val.h"
  11. #include "sha.h"
  12. #include "btformat.h"
  13. #include "Bdecode.h"
  15. #ifdef _DEBUG
  16. #undef THIS_FILE
  17. static char THIS_FILE[]=__FILE__;
  18. #define new DEBUG_NEW
  19. #endif
  21. //////////////////////////////////////////////////////////////////////
  22. // Construction/Destruction
  23. //////////////////////////////////////////////////////////////////////
  24. CMakeMetaFile::CMakeMetaFile()
  25. {
  26. m_hevDone = CreateEvent(0, true, false, 0);
  27. m_hThreadDone = CreateEvent(0, true, true, 0);
  28. m_bResult =false;
  30. m_lPieceLenExp = 0;
  31. m_hWnd = 0;
  32. }
  34. CMakeMetaFile::~CMakeMetaFile()
  35. {
  36. Close();
  37. assert(IsEventSet(m_hThreadDone));
  38. CloseHandle(m_hevDone);
  39. CloseHandle(m_hThreadDone);
  40. }
  42. /////////////////////////////////////////////////////////////////
  43. // return value : the state of making meta file.
  45. bool CMakeMetaFile::Close()
  46. {
  47. if (!IsEventSet(m_hThreadDone))
  48. {
  49. SetEvent(m_hevDone);
  50. DWORD dwRet = WaitForSingleObject(m_hThreadDone, INFINITE);
  51. switch (dwRet)
  52. {
  53. case WAIT_OBJECT_0:
  54. break;
  55. case WAIT_TIMEOUT:
  56. break;
  57. }
  58. }
  59. return m_bResult;
  60. }
  62. string CMakeMetaFile::GetSrcPath() const
  63. {
  64. return m_strFilePath;
  65. }
  67. string CMakeMetaFile::GetSavePath() const 
  68. {
  69. return m_strSaveAs;
  70. }
  72. bool CMakeMetaFile::IsMaking()
  73. {
  74. return !IsEventSet(m_hThreadDone);
  75. }
  77. bool CMakeMetaFile::GetResult() const 
  78. {
  79. return m_bResult;
  80. }
  82. string CMakeMetaFile::GetErrorMsg() const 
  83. {
  84. return m_strErr;
  85. }
  87. bool CMakeMetaFile::MakeMetaFileEx(string strFilePath, string strSaveAs, string strUrl, string strComment, long lPieceLenExp, HWND hWnd)
  88. {
  89. // assert.
  90. assert(lPieceLenExp> 0 && lPieceLenExp< 25 && 
  91. !strFilePath.empty() && 
  92. !strSaveAs.empty() && 
  93. ::IsWindow(hWnd));
  95. m_strFilePath = strFilePath;
  96. m_strSaveAs = strSaveAs ;
  97. m_strUrl = strUrl;
  98. m_strComment = strComment;
  99. m_lPieceLenExp = lPieceLenExp;
  100. m_hWnd = hWnd;
  101. assert(::IsWindow(m_hWnd));
  104. m_bResult = false;
  105. m_strErr.erase();
  107. if (IsMaking())
  108. {
  109. assert(false);
  110. return false;
  111. }
  112. ResetEvent(m_hThreadDone);
  113. ResetEvent(m_hevDone);
  115. DWORD dwThreadId = 0;
  116. ::CreateThread(0, 0, MakeMetaFiledProc, this, 0, &dwThreadId);
  118. return true;
  119. }
  121. DWORD WINAPI CMakeMetaFile::MakeMetaFiledProc(void *pParam)
  122. {
  123. CMakeMetaFile* pMakeMetaFiled= (CMakeMetaFile* )pParam;
  124. pMakeMetaFiled->MakeMetaFiledProcEx();
  126. return 0;
  127. }
  129. void CMakeMetaFile::MakeMetaFiledProcEx()
  130. {
  131. m_bResult = MakeMetaFile();
  132. if (!IsEventSet(m_hevDone))
  133. PostMessage(m_hWnd, MAKE_METAFILE_FINISHED, 0, 0);
  134. SetEvent(m_hThreadDone);
  135. }
  137. bool CMakeMetaFile::MakeMetaFile()
  138. {
  139. // make info
  140. CVal* pInfo = makeinfo(m_strFilePath, pow(2, m_lPieceLenExp));
  141. if (!pInfo) 
  142. {
  143. m_strErr += "makeinfo error";
  144. return false;
  145. }
  147. PVALMAP pMsg = new VALMAP();
  148. (*pMsg)["info"] = pInfo;
  149. (*pMsg)["announce"] = new CVal(m_strUrl);
  150. if (!m_strComment.empty())
  151. (*pMsg)["comment"] = new CVal(string(m_strComment));
  153. CVal* pValMsg = new CVal(pMsg);
  154. auto_ptr<CVal> aMsg(pValMsg);
  156. if (IsEventSet(m_hevDone))
  157. return false;
  159. // check info.
  160. try
  161. {
  162. CBTFormat::CheckInfo(pInfo);
  163. }
  164. catch (string e)
  165. {
  166. m_strErr += "check info error";
  167. return false;
  168. }
  170. // encode.
  171. memstream memBuf;
  172. CBdecode::bencode(pValMsg, memBuf);
  174. // save as torrent file.
  175. FILE* pfile = fopen(m_strSaveAs.data(), "wb");
  176. if (!pfile)
  177. {
  178. m_strErr = string("write torrent file (") + m_strSaveAs + ") error";
  179. return false;
  180. }
  181. long lWrite = fwrite(memBuf, sizeof(char), memBuf.size(), pfile);
  182. fclose(pfile);
  184. return true;
  185. }
  187. CVal* CMakeMetaFile::makeinfo(string strFilePath, long lPieceLength)
  188. {
  189. DWORD dwAttr = GetFileAttributes(strFilePath.data());
  190. if (dwAttr ==  0xffffffff)
  191. return false;
  193. // get name map.
  194. if (strFilePath[strFilePath.size() - 1] == '\')
  195. strFilePath.erase(strFilePath.size() - 1);
  196. char *pszFileName = 0;
  197. char szPathName[MAX_PATH] = {0};
  198. if (!GetFullPathName(strFilePath.data(), MAX_PATH, szPathName, &pszFileName))
  199. {
  200. assert(false);
  201. return 0;
  202. }
  203. if (pszFileName == 0) // strFilePath is the root driver.
  204. {
  205. assert(false);
  206. return 0;
  207. }
  209. if (dwAttr & FILE_ATTRIBUTE_DIRECTORY)
  210. {
  211. // get vFiles.
  212. vector<string> vSubPaths;
  213. CSubFilesList SubFilesList;
  214. if (!SubFiles(strFilePath, vSubPaths, SubFilesList, m_hevDone))
  215. {
  216. for (int i=0; i<SubFilesList.size(); i++)
  217. {
  218. if (SubFilesList[i].m_pPathList)
  219. delete SubFilesList[i].m_pPathList;
  220. }
  221. return 0;
  222. }
  224. //
  225. // get pieces and files map.
  226. //
  227. int iPiecesCount = 0;
  228. memstream memPieces;
  229. PVALLIST pFileList = new VALLIST();
  231. long lDone = 0;
  232. long lTotalHashsed = 0;
  233. long lTotalSize = 0;
  234. for (int i=0; i<SubFilesList.size(); i++)
  235. {
  236. if (IsEventSet(m_hevDone))
  237. return 0;
  238. lTotalSize += GetFileSize(SubFilesList[i].m_strPath);
  239. }
  241. CSHA sha;
  242. sha.start();
  243. unsigned char sha1sum[20];
  245. for (i=0; i<SubFilesList.size(); i++)
  246. {
  247. FILE* pfile = fopen(SubFilesList[i].m_strPath.data(), "rb");
  248. if (!pfile) 
  249. {
  250. m_strErr = "no such file : (" + SubFilesList[i].m_strPath + ")";
  251. break;
  252. }
  254. long lsize = GetFileSize(SubFilesList[i].m_strPath);
  256. long lPos = 0;
  257. unsigned char* pszBuf = new unsigned char[lPieceLength];
  258. auto_ptr<unsigned char> aszBuf(pszBuf);
  260. while (lPos < lsize)
  261. {
  262. long lLeftLen = min(lsize - lPos, lPieceLength - lDone);
  263. int iRead = fread(pszBuf, sizeof(char), lLeftLen, pfile);
  264. if (iRead != lLeftLen)
  265. {
  266. assert(false);
  267. fclose(pfile);
  268. break;
  269. }
  271. TRACE("Iseventset read in filern");
  272. if (IsEventSet(m_hevDone))
  273. break;
  275. lPos += iRead;
  276. lDone += iRead;
  277. lTotalHashsed += iRead;
  278. sha.update(pszBuf, lLeftLen);
  280. if (lDone == lPieceLength)
  281. {
  282. lDone = 0;
  283. sha.finish(sha1sum);
  284. memPieces.write((char*)sha1sum, 20);
  285. sha.start();
  287. iPiecesCount++;
  288. }
  290. if (lTotalSize > 0)
  291. ProgressInfo(float(lTotalHashsed)/ lTotalSize);
  292. else
  293. ProgressInfo(float(1));
  295. } // end while
  297. if (lPos < lsize)
  298. {
  299. // assert(false);
  300. fclose(pfile);
  301. break;
  302. }
  304. PVALMAP pFileMap = new VALMAP;
  305. (*pFileMap) ["length"] = new CVal(lsize);
  307. assert(SubFilesList[i].m_pPathList);
  308. (*pFileMap) ["path"] = SubFilesList[i].m_pPathList;
  309. SubFilesList[i].m_pPathList = 0;
  311. pFileList->push_back(new CVal(pFileMap));
  313. fclose(pfile);
  315. TRACE("Iseventset end for rn");
  316. if (IsEventSet(m_hevDone))
  317. break;
  318. } // end for
  320. if (i != SubFilesList.size()) // fail
  321. {
  322. delete new CVal(pFileList);
  324. // clear not detached pathlist CVal;
  325. for (int j=0; j<SubFilesList.size(); j++)
  326. {
  327. if (SubFilesList[j].m_pPathList)
  328. delete SubFilesList[j].m_pPathList;
  329. }
  330. return 0;
  331. }
  333. if (lDone > 0)
  334. {
  335. sha.finish(sha1sum);
  336. memPieces.write((char*)sha1sum, 20);
  337. iPiecesCount++;
  338. }
  340. PVALMAP pRet = new VALMAP();
  341. if (memPieces.size() <= 0)
  342. (*pRet)["pieces"] = new CVal(0, 0);
  343. else
  344. (*pRet)["pieces"] = new CVal(memPieces, memPieces.size());
  345. (*pRet)["piece length"] = new CVal(lPieceLength);
  346. (*pRet)["files"] = new CVal(pFileList);
  347. (*pRet)["name"] = new CVal(string(pszFileName));
  348. return new CVal(pRet);
  350. }
  351. else
  352. {
  353. long lsize = GetFileSize(strFilePath);
  354. FILE* pfile = fopen(strFilePath.data(), "rb");
  355. if (!pfile) return 0;
  357. memstream memPieces;
  359. CSHA sha;
  360. sha.start();
  361. unsigned char sha1sum[20];
  363. long lLeftLen = 0;
  364. long lPos = 0;
  365. unsigned char* pszBuf = new unsigned char[lPieceLength];
  366. auto_ptr<unsigned char> aszBuf(pszBuf);
  368. while (lPos < lsize)
  369. {
  370. lLeftLen = min(lsize - lPos, lPieceLength);
  371. int iRead = fread(pszBuf, sizeof(char), lLeftLen, pfile);
  372. if (iRead != lLeftLen)
  373. {
  374. assert(false);
  375. fclose(pfile);
  376. break;
  377. }
  379. if (IsEventSet(m_hevDone))
  380. break;
  382. lPos += iRead;
  383. sha.update(pszBuf, lLeftLen);
  384. sha.finish(sha1sum);
  385. memPieces.write((char*)sha1sum, 20);
  386. sha.start();
  388. if (lsize> 0)
  389. ProgressInfo(float(lPos)/ lsize);
  390. else
  391. ProgressInfo(float(1));
  392. }
  394. if (lPos < lsize) // fail
  395. {
  396. // assert(false);
  397. return 0;
  398. }
  400. fclose(pfile);
  402. PVALMAP pRet = new VALMAP();
  403. // (*pRet)["pieces"] = new CVal(memPieces, memPieces.size());
  404. if (memPieces.size() <= 0)
  405. (*pRet)["pieces"] = new CVal(0, 0);
  406. else
  407. (*pRet)["pieces"] = new CVal(memPieces, memPieces.size());
  408. (*pRet)["piece length"] = new CVal(lPieceLength);
  409. (*pRet)["length"] = new CVal(lsize);
  410. (*pRet)["name"] = new CVal(string(pszFileName));
  411. return new CVal(pRet);
  412. }
  413. return 0;
  414. }
  416. bool CMakeMetaFile::SubFiles(string strPath, vector<string> vSubPaths, CSubFilesList& SubFilesList, HANDLE hevDone)
  417. {
  418. DWORD dwAttr = GetFileAttributes(strPath.data());
  419. if (dwAttr ==  0xffffffff)
  420. return false;
  422. WIN32_FIND_DATA FileData;
  423. BOOL fFinished = FALSE;
  424. if (strPath[strPath.size() - 1] != '\')
  425. strPath += '\';
  426. string strFind = strPath + "*.*";
  428. // TRACE("%srn", strPath.data());
  430. HANDLE hSearch = FindFirstFile(strFind.data(), &FileData); 
  431. if (hSearch == INVALID_HANDLE_VALUE) 
  432. return false;
  434. while (!fFinished) 
  435. {
  436. if (string(FileData.cFileName) != "." &&
  437. string(FileData.cFileName) != ".." )
  438. {
  440. if (FileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
  441. {
  442. vector<string> vChildPaths = vSubPaths;
  443. vChildPaths.push_back(FileData.cFileName);
  444. if (!SubFiles(strPath + FileData.cFileName, vChildPaths, SubFilesList, hevDone))
  445. {
  446. FindClose(hSearch);
  447. return false;
  448. }
  449. }
  450. else
  451. {
  452. PVALLIST pvFileSubPath = new VALLIST();
  453. for (int i=0; i<vSubPaths.size(); i++)
  454. {
  455. (*pvFileSubPath).push_back(new CVal(vSubPaths[i]));
  456. }
  457. (*pvFileSubPath).push_back(new CVal(FileData.cFileName));
  458. SubFilesList.push_back(CSubFilesItem(new CVal(pvFileSubPath), strPath + FileData.cFileName));
  459. // TRACE("(%s)rn", FileData.cFileName);
  460. }
  461. }
  463. if (IsEventSet(hevDone))
  464. return false;
  466. if (!FindNextFile(hSearch, &FileData)) 
  467. {
  468. fFinished = TRUE;
  469. if (GetLastError() == ERROR_NO_MORE_FILES) { } 
  470. else { } 
  471. }
  472. } 
  473. FindClose(hSearch);
  475. return true;
  476. }
  478. void CMakeMetaFile::ProgressInfo(float fPercent)
  479. {
  480. if (::IsWindow(m_hWnd))
  481. ::PostMessage(m_hWnd, MAKE_METAFILE_PROGRESS, fPercent*100, 0);
  482. }
  484. bool CMakeMetaFile::FormatSaveAS(string strFilePath, string& strToSavePath)
  485. {
  486. assert(!strToSavePath.empty() && !strFilePath.empty());
  488. string strName;
  489. if (!GetName(strFilePath, strName))
  490. return false;
  492. strToSavePath = formatDir(strToSavePath);
  493. strToSavePath += strName + ".torrent";
  495. return true;
  496. }
  498. bool CMakeMetaFile::GetName(string strFilePath, string& strName)
  499. {
  500. // get name map.
  501. if (strFilePath[strFilePath.size() - 1] == '\')
  502. strFilePath.erase(strFilePath.size() - 1);
  504. char *pszFileName = 0;
  505. char szPathName[MAX_PATH] = {0};
  506. if (!GetFullPathName(strFilePath.data(), MAX_PATH, szPathName, &pszFileName))
  507. {
  508. assert(false);
  509. return false;
  510. }
  512. if (pszFileName == 0) // strFilePath is the root driver.
  513. {
  514. assert(false);
  515. return 0;
  516. }
  517. strName = pszFileName;
  518. return true;
  519. }