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

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

P2P编程

开发平台：

Visual C++

CategoryFileDB.cpp：源码内容
  1. // CategoryFileDB.cpp: implementation of the CCategoryFileDB class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "testbt.h"
  7. #include "CategoryFileDB.h"
  10. #include "BTFormat.h"
  11. #include "FileBase.h"
  12. #include "val.h"
  13. #include "FileDB.h"
  14. #include "download.h"
  16. #include "SetupRegister.h"
  18. #ifdef _DEBUG
  19. #undef THIS_FILE
  20. static char THIS_FILE[]=__FILE__;
  21. #define new DEBUG_NEW
  22. #endif
  25. #define LOLONG(x) ((ULONG) x)
  26. #define HILONG(x) ((ULONG) (x / 0x100000000))
  27. #define MAKELONG64(x, y)((_int64) x * 0x100000000 | (ULONG)y)
  29. string m_strDBFileSection = "Database";
  30. string m_strDBFileKey = "path";
  31. //////////////////////////////////////////////////////////////////////
  32. // Construction/Destruction
  33. //////////////////////////////////////////////////////////////////////
  35. CCategoryFileDB::CCategoryFileDB()
  36. {
  37. m_bNoNotifications = false;
  38. m_lDirectoryIDMax = 0;
  39. m_pSetupRegister = 0;
  40. m_bModified = false;
  41. }
  43. CCategoryFileDB::~CCategoryFileDB()
  44. {
  46. }
  48. BOOL CCategoryFileDB::CreateEx(CWnd *pParent, CRect &rc, long lParam, CSetupRegister* pSetupRegister)
  49. {
  50. m_pSetupRegister = pSetupRegister;
  51. // SetDBSavePath(m_pSetupRegister);
  53. return Create(WS_VISIBLE|WS_CHILD|WS_BORDER|TVS_HASBUTTONS | TVS_LINESATROOT | TVS_HASLINES|TVS_SHOWSELALWAYS, 
  54. rc, pParent, 32563215);
  55. }
  59. void CCategoryFileDB::DeleteAllData(CTreeCursor& curDel) 
  60. {
  61. assert(false);
  62. }
  64. CSetupRegister* CCategoryFileDB::GetSetupRegister() const
  65. {
  66. assert(m_pSetupRegister);
  67. return m_pSetupRegister;
  68. }
  70. /*
  71. bool CCategoryFileDB::IsLinkFileDBItem(CTreeCursor curItem, CFileDBItem* pFileDBItem)
  72. {
  73. if (curItem != m_curDownloading)
  74. return false;
  76. CCategoryDBItem* pCategoryDBItem = (CCategoryDBItem*)m_curDownloading.GetData();
  77. if (pCategoryDBItem->m_lDirectoryID == pFileDBItem->m_lDirectoryID)
  78. return false;
  80. return true;
  81. }
  82. //*/
  84. ////////////////////////////////////////////////////////////////////////
  85. // file manipulate.
  87. bool CCategoryFileDB::OpenDBFile(string strDatabasePath)
  88. {
  89. if (strDatabasePath.empty())
  90. return false;
  92. // assert(!m_bModified);
  93. m_bModified = false;
  94. // clear data loaded from db file
  95. DeleteAllData(GetRootItem());
  96. GetRootItem().Delete();
  97. m_curRoot = m_curDownloading = m_curDownloaded = m_curRecycle = CTreeCursor();
  99. if (!LoadDatabase(strDatabasePath))
  100. {
  101. AfxMessageBox(CString("load db file(") + strDatabasePath.data() + ")error" );
  102. NewDatabase();
  103. return false;
  104. }
  106. GetRootItem().Select();
  107. AfxGetApp()->WriteProfileString(m_strDBFileSection.data(), m_strDBFileKey.data(), strDatabasePath.data());
  108. m_strDatabaseFileName = strDatabasePath;
  109. return false;
  110. }
  112. void CCategoryFileDB::LoadDBFile()
  113. {
  114. CString strDatabasePath = AfxGetApp()->GetProfileString(m_strDBFileSection.data(), m_strDBFileKey.data());
  115. if (!strDatabasePath.IsEmpty())
  116. {
  117. if (LoadDatabase(strDatabasePath.GetBuffer(0)))
  118. {
  119. m_strDatabaseFileName = strDatabasePath;
  120. return;
  121. }
  122. else
  123. {
  124. AfxMessageBox(CString("load db file(") + strDatabasePath + ")error");
  125. }
  126. }
  128. // load default database left by the uninstalled, create new database, register it.
  129. strDatabasePath = GetDefaultDatabasePath().data();
  130. if (!LoadDatabase(strDatabasePath.GetBuffer(0)))
  131. {
  132. NewDatabase();
  133. SaveDatabase(strDatabasePath.GetBuffer(0));
  134. }
  136. AfxGetApp()->WriteProfileString(m_strDBFileSection.data(), m_strDBFileKey.data(), strDatabasePath);
  137. m_strDatabaseFileName = strDatabasePath;
  138. }
  140. void CCategoryFileDB::NewDatabase()
  141. {
  142. m_bModified = true;
  144. // clear data loaded from db file
  145. DeleteAllData(GetRootItem());
  146. GetRootItem().Delete();
  147. m_curRoot = m_curDownloading = m_curDownloaded = m_curRecycle = CTreeCursor();
  149. // create default dir.
  150. m_lDirectoryIDMax = 0;
  152. m_curRoot = GetRootItem().AddTail("根目录", IID_ROOT);
  153. m_curRoot.SetData((long) new CCategoryDBItem("c:\download", m_lDirectoryIDMax++));
  155. m_curDownloading = m_curRoot.AddTail("未完成任务", IID_DOWNLOADING_DIRECTORY);
  156. m_curDownloading.SetData((long) new CCategoryDBItem("c:\download\downloading", m_lDirectoryIDMax++));
  158. m_curDownloaded = m_curRoot.AddTail("下载保存目录", IID_DOWNLOADED_DIRECTORY);
  159. m_curDownloaded.SetData((long) new CCategoryDBItem("c:\download\downloaded", m_lDirectoryIDMax++));
  161. CTreeCursor curMusic = m_curDownloaded.AddTail("音乐", IID_DIRECTORY);
  162. curMusic.SetData((long) new CCategoryDBItem("c:\download\downloaded\music", m_lDirectoryIDMax++));
  164. CTreeCursor cuMovie = m_curDownloaded.AddTail("影视", IID_DIRECTORY);
  165. cuMovie.SetData((long) new CCategoryDBItem("c:\download\downloaded\Movie", m_lDirectoryIDMax++));
  167. CTreeCursor cuSoftware = m_curDownloaded.AddTail("软件", IID_DIRECTORY);
  168. cuSoftware.SetData((long) new CCategoryDBItem("c:\download\downloaded\SoftWare", m_lDirectoryIDMax++));
  170. m_curRecycle = m_curRoot.AddTail("回收站", IID_RECYCLE);
  171. m_curRecycle.SetData((long) new CCategoryDBItem("c:\download\recycle", m_lDirectoryIDMax++));
  173. assert(m_curRoot == GetRootItem() != 0);
  175. // m_strDatabaseFileName = "Untitled";
  176. }
  178. void CCategoryFileDB::SaveAs(string strDatabasePath)
  179. {
  180. if (strDatabasePath.empty())
  181. {
  182. assert(false);
  183. return;
  184. }
  185. if (m_strDatabaseFileName == strDatabasePath)
  186. return;
  188. string strOldTorrentDir = _GetDBSavePath(m_strDatabaseFileName),
  189. strNewTorrentDir = _GetDBSavePath(strDatabasePath);
  191. SaveDatabase(strDatabasePath);
  192. AfxGetApp()->WriteProfileString(m_strDBFileSection.data(), m_strDBFileKey.data(), strDatabasePath.data());
  193. m_strDatabaseFileName = strDatabasePath;
  197. DWORD dwAttr = GetFileAttributes(strNewTorrentDir.data());
  198. if (dwAttr == 0xffffffff )
  199. {
  200. if (!MakeDirecotry(strNewTorrentDir))
  201. {
  202. AfxMessageBox(CString("can't create direcotry (") + strNewTorrentDir.data() + ")" );
  203. return ;
  204. }
  205. }
  206. else if (!(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
  207. {
  208. AfxMessageBox(CString("can't create direcotry (") + strNewTorrentDir.data() + ")" );
  209. return ;
  210. }
  212. if (strOldTorrentDir != strNewTorrentDir)
  213. {
  214. if (!MoveDiretory(strOldTorrentDir, strNewTorrentDir))
  215. {
  216. AfxMessageBox(CString("move from (") + strOldTorrentDir.data() + ") to (" + strNewTorrentDir.data() + ") error." );
  217. return ;
  218. }
  219. }
  220. }
  222. void CCategoryFileDB::Save()
  223. {
  224. if (m_bModified)
  225. {
  226. assert(false);
  227. return;
  228. }
  230. CString strDatabasePath = AfxGetApp()->GetProfileString(m_strDBFileSection.data(), m_strDBFileKey.data());
  231. if (strDatabasePath.IsEmpty())
  232. {
  233. assert(false);
  234. return;
  235. }
  236. SaveDatabase(strDatabasePath.GetBuffer(0));
  237. }
  239. bool CCategoryFileDB::IsModifyed()
  240. {
  241. return m_bModified;
  242. }
  244. void CCategoryFileDB::SetModifed(bool bModified)
  245. {
  246. m_bModified = bModified;
  247. }
  250. string CCategoryFileDB::GetDBSavePath() const
  251. {
  252. if (m_strDatabaseFileName.empty())
  253. {
  254. assert(false);
  255. }
  257. string strSavePath = _GetDBSavePath(m_strDatabaseFileName);
  258. return strSavePath;
  259. /*
  260. string strName;
  261. string strSavePath;
  262. bool bRet = SplitPathName(m_strDatabaseFileName, strSavePath, strName);
  263. assert(bRet && strSavePath.empty());
  265. strSavePath = formatDir(strSavePath) + "Torrent Files\";
  267. return strSavePath;
  268. //*/
  269. }
  271. string CCategoryFileDB::_GetDBSavePath(const string strDatabaseFileName) const
  272. {
  273. string strName;
  274. string strSavePath;
  275. bool bRet = SplitPathName(strDatabaseFileName, strSavePath, strName);
  276. assert(bRet && !strSavePath.empty());
  278. strSavePath = formatDir(strSavePath) + "Torrent Files\";
  280. return strSavePath;
  281. }
  283. string CCategoryFileDB::GetDatabaseFullPath()
  284. {
  285. return m_strDatabaseFileName;
  286. }
  288. string CCategoryFileDB::GetDatabaseName()
  289. {
  290. if (IsModifyed())
  291. return "无标题";
  293. string strName;
  294. string strSavePath;
  295. SplitPathName(m_strDatabaseFileName, strSavePath, strName);
  297. if (strName.empty())
  298. strName = "无标题";
  300. return strName;
  301. }
  303. string CCategoryFileDB::GetDefaultDatabasePath()
  304. {
  305. // get the directory in which the exe file exist.
  306. char szModuleFileName[1024] = {0};
  307. if (!GetModuleFileName(AfxGetApp()->m_hInstance, szModuleFileName, 1024))
  308. {
  309. assert(false);
  310. return "";
  311. }
  313. char path_buffer[_MAX_PATH];
  314. char drive[_MAX_DRIVE];
  315. char dir[_MAX_DIR];
  316. char fname[_MAX_FNAME];
  317. char ext[_MAX_EXT];
  319. _splitpath(szModuleFileName, drive, dir, fname, ext );
  320. _makepath(path_buffer, drive, dir, 0, 0);
  321. string strDatabasePath = path_buffer;
  322. if (strDatabasePath.size() <= 0)
  323. {
  324. assert(false);
  325. return "";
  326. }
  328. if (strDatabasePath[strDatabasePath.size() - 1] != '\')
  329. strDatabasePath+= '\';
  331. strDatabasePath += "default.bt";
  333. return strDatabasePath;
  334. }
  335. ////////////////////////////////////////////////////////////////////////
  336. // file db save.
  338. void CCategoryFileDB::SaveDatabase(string strDatabasePath)
  339. {
  340. m_bModified = false;
  342. try
  343. {
  344. CVal* pRet = bencode_rec(m_curRoot);
  345. if (!pRet) 
  346. {
  347. AfxMessageBox("encode tree data error");
  348. return;
  349. }
  351. auto_ptr<CVal> aRet(pRet);
  352. CFileDB::WriteFileEx(strDatabasePath, pRet);
  353. }
  354. catch (string e)
  355. {
  356. AfxMessageBox((string("SaveDatabase error : ") + e).data());
  357. }
  358. }
  360. CVal* CCategoryFileDB::bencode_FileDBItems(vector<CFileDBItem*>& vFileDbItems)
  361. {
  362. // format data
  363. PVALLIST pFileList = new VALLIST();
  365. for (int i=0; i<vFileDbItems.size(); i++)
  366. {
  367. CFileDBItem* pItem = vFileDbItems[i];
  369. PVALMAP pFileInfoMap = new VALMAP();
  370. (*pFileInfoMap)["TFileName"] = new CVal(pItem->m_strTorrentFileName);
  371. (*pFileInfoMap)["filename"] = new CVal(pItem->m_strFileName);
  372. (*pFileInfoMap)["complete"] = new CVal((long)(((float)pItem->m_fComplete)*100));
  373. (*pFileInfoMap)["time"] = new CVal(pItem->m_tTime);
  374. (*pFileInfoMap)["infohash"] = new CVal(pItem->m_strHash);
  375. (*pFileInfoMap)["dirid"] = new CVal(pItem->m_lDirectoryID);
  376. (*pFileInfoMap)["ModifiedTime"] = new CVal(pItem->m_tModifiedTime);
  377. (*pFileInfoMap)["PieceCount"] = new CVal(pItem->m_lPieceCount);
  379. (*pFileInfoMap)["special"] = new CVal(pItem->m_bSpecialRunParameter ? 1L : 0L);
  380. (*pFileInfoMap)["SpeedMode"] = new CVal(pItem->m_lUploadSpeedMode);
  381. (*pFileInfoMap)["UpMaxSpeed"] = new CVal(pItem->m_lUploadSpeedMax);
  382. (*pFileInfoMap)["UpMaxpeers"] = new CVal(pItem->m_lUploadPeerMax);
  383. (*pFileInfoMap)["fc"] = new CVal((long)(((float)pItem->m_fCompletePart)*100));
  385. (*pFileInfoMap)["kpHour"] = new CVal(pItem->m_lCompleteKeepSeedHour);
  386. (*pFileInfoMap)["PeersMin"] = new CVal(pItem->m_lPeersMin);
  387. (*pFileInfoMap)["PeersMax"] = new CVal(pItem->m_lPeersMax);
  388. (*pFileInfoMap)["errMax"] = new CVal(pItem->m_lConnectErrorMax);
  389. (*pFileInfoMap)["ConIntval"] = new CVal(pItem->m_lConnectIntval);
  392. //
  393. // file size.
  394. //
  395. ASSERT(pItem->m_lFileSize >= 0);
  397. (*pFileInfoMap)["size"] = new CVal(LOLONG(pItem->m_lFileSize));
  399. if (HILONG(pItem->m_lFileSize))
  400. (*pFileInfoMap)["sizeh"] = new CVal(HILONG(pItem->m_lFileSize));
  403. if (!pItem->m_strComment.empty())
  404. (*pFileInfoMap)["comment"] = new CVal(pItem->m_strComment);
  408. // UnneededFiles.
  409. if (!pItem->m_vUnneededFileInx.empty())
  410. (*pFileInfoMap)["UnNeed"] = bencode_UnNeededFiles(pItem->m_vUnneededFileInx);
  412. // mark the unclosed.
  413. if (pItem->m_bUnclosed)// && pItem->m_pDownload->IsDownloading())
  414. (*pFileInfoMap)["Unclosed"] = new CVal(1);
  416. memstream memBuf;
  417. pItem->GetHave(memBuf);
  418. if (memBuf.size())
  419. {
  420. (*pFileInfoMap)["haves"] = new CVal(memBuf, memBuf.size());
  421. }
  423. pFileList->push_back(new CVal(pFileInfoMap));
  424. }
  426. CVal* pVal = new CVal(pFileList);
  427. return pVal;
  428. }
  430. CVal* CCategoryFileDB::bencode_UnNeededFiles(vector<CSize>& vUnNeededFiles)
  431. {
  432. // format data
  433. PVALLIST pFileList = new VALLIST();
  435. for (int i=0; i<vUnNeededFiles.size(); i++)
  436. {
  437. CSize sizeUnNeedFile = vUnNeededFiles[i];
  438. PVALMAP pFileInfoMap = new VALMAP();
  440. (*pFileInfoMap)["x"] = new CVal(sizeUnNeedFile.cx);
  441. (*pFileInfoMap)["y"] = new CVal(sizeUnNeedFile.cy);
  443. pFileList->push_back(new CVal(pFileInfoMap));
  444. }
  446. CVal* pVal = new CVal(pFileList);
  447. return pVal;
  448. }
  451. CVal* CCategoryFileDB::bencode_rec(CTreeCursor& curItem)
  452. {
  453. if (!curItem)
  454. {
  455. assert(curItem);
  456. return 0;
  457. }
  459. PVALLIST pChildList = new VALLIST();
  460. if (curItem.HasChildren())
  461. {
  462. CTreeCursor curChild = curItem.GetChild();
  463. while (curChild)
  464. {
  465. CVal* pRet = bencode_rec(curChild);
  466. pChildList->push_back(pRet);
  467. curChild = curChild.GetNext(TVGN_NEXT);
  468. }
  469. }
  471. CCategoryDBItem* pItem = (CCategoryDBItem*)curItem.GetData();
  473. PVALMAP pDirInfoMap = new VALMAP();
  474. (*pDirInfoMap)["dirname"] = new CVal(string(curItem.GetText()));
  475. (*pDirInfoMap)["directory"] = new CVal(pItem->m_strDefaultDirectory);
  476. (*pDirInfoMap)["childlist"] = new CVal(pChildList);
  477. (*pDirInfoMap)["type"] = new CVal((long)curItem.GetImageID());
  478. (*pDirInfoMap)["id"] = new CVal(pItem->m_lDirectoryID);
  479. (*pDirInfoMap)["filedbitems"] = bencode_FileDBItems(pItem->m_vFileDBItems);
  481. CVal* pRetVal = new CVal(pDirInfoMap);
  482. return pRetVal;
  483. }
  485. ////////////////////////////////////////////////////////////////////////
  486. // file db load.
  488. bool CCategoryFileDB::LoadDatabase(string strDatabasePath)
  489. {
  490. m_bNoNotifications = true;
  492. string strErr;
  493. bool bRet = true;
  494. try
  495. {
  496. CVal* pVal = CFileDB::OpenFileEx(strDatabasePath);
  497. auto_ptr<CVal> aVal(pVal);
  498. if (pVal && bdencode_rec(pVal, GetRootItem()))
  499. bRet = true;
  500. else 
  501. {
  502. m_bNoNotifications = false;
  503. return false;
  504. }
  506. /*
  507. if (!LoadGenerateLinks())
  508. bRet = false;
  509. //*/
  511. m_bNoNotifications = false;
  512. }
  513. catch (string e)
  514. {
  515. strErr = e;
  516. bRet = false;
  517. m_bNoNotifications = false;
  518. }
  520. if (!bRet || !m_curRoot || !m_curDownloading || !m_curDownloaded || !m_curRecycle)
  521. {
  522. m_bNoNotifications = true;
  523. DeleteAllData(GetRootItem());
  524. GetRootItem().Delete();
  525. m_curRoot = m_curDownloading = m_curDownloaded = m_curRecycle = CTreeCursor();
  526. m_bNoNotifications = false;
  527. return false;
  528. }
  530. return true;
  531. }
  533. bool CCategoryFileDB::bdencode_FileDBItems(CVal* pVal, vector<CFileDBItem*>& vFileDbItems, HTREEITEM hTreeItem)
  534. {
  535. if (pVal->vt != VT_PLIST)
  536. return false;
  537. VALLIST& FileList = *(pVal->plistVal);
  539. for (int i=0; i<FileList.size(); i++)
  540. {
  541. if (FileList[i]->vt != VT_PMAP)
  542. return false;
  543. PVALMAP pFileInfoMap = FileList[i]->pmapVal; 
  545. if (!HasKey(pFileInfoMap, "TFileName") ||
  546. !HasKey(pFileInfoMap, "filename") || 
  547. !HasKey(pFileInfoMap, "size") ||
  548. !HasKey(pFileInfoMap, "complete") ||
  549. !HasKey(pFileInfoMap, "time") ||
  550. !HasKey(pFileInfoMap, "infohash") ||
  551. !HasKey(pFileInfoMap, "dirid") ||
  552. !HasKey(pFileInfoMap, "ModifiedTime") ||
  553. !HasKey(pFileInfoMap, "PieceCount") 
  554. )
  555. return false;
  559. //
  560. // filesize.
  561. //
  562. long lFileSizeLow = (*pFileInfoMap)["size"]->lVal;
  563. long lFileSizeHigh = 0;
  565. if (HasKey(pFileInfoMap, "sizeh"))
  566. lFileSizeHigh = (*pFileInfoMap)["sizeh"]->lVal;
  568. BLONG lFileSize = MAKELONG64(lFileSizeHigh, lFileSizeLow);
  570. //
  571. // comment
  572. //
  573. string strComment;
  574. if (HasKey(pFileInfoMap, "comment"))
  575. {
  576. strComment = (*pFileInfoMap)["comment"]->pstrVal;
  577. }
  579. CFileDBItem * pFileDBItem = new CFileDBItem((*pFileInfoMap)["TFileName"]->pstrVal, 
  580. (*pFileInfoMap)["filename"]->pstrVal,
  581. lFileSize,
  582. ((float)(*pFileInfoMap)["complete"]->lVal)/100,
  583. (*pFileInfoMap)["time"]->lVal,
  584. (*pFileInfoMap)["infohash"]->pstrVal,
  585. (*pFileInfoMap)["dirid"]->lVal,
  586. (*pFileInfoMap)["ModifiedTime"]->lVal,
  587. (*pFileInfoMap)["PieceCount"]->lVal,
  588. strComment);
  590. if (HasKey(pFileInfoMap, "special") &&
  591. HasKey(pFileInfoMap, "SpeedMode") &&
  592. HasKey(pFileInfoMap, "UpMaxSpeed") &&
  593. HasKey(pFileInfoMap, "UpMaxpeers"))
  594. {
  595. pFileDBItem->m_bSpecialRunParameter = (*pFileInfoMap)["special"]->lVal > 0;
  596. pFileDBItem->m_lUploadSpeedMode = (*pFileInfoMap)["SpeedMode"]->lVal;
  597. pFileDBItem->m_lUploadSpeedMax = (*pFileInfoMap)["UpMaxSpeed"]->lVal;
  598. pFileDBItem->m_lUploadPeerMax = (*pFileInfoMap)["UpMaxpeers"]->lVal;
  600. if (
  601. !HasKey(pFileInfoMap, "kpHour") ||
  602. !HasKey(pFileInfoMap, "PeersMin") ||
  603. !HasKey(pFileInfoMap, "PeersMax") ||
  604. !HasKey(pFileInfoMap, "errMax") ||
  605. !HasKey(pFileInfoMap, "ConIntval")
  606. )
  607. {
  608. return false;
  609. }
  611. pFileDBItem->m_lCompleteKeepSeedHour = (*pFileInfoMap)["kpHour"]->lVal;
  612. pFileDBItem->m_lPeersMin = (*pFileInfoMap)["PeersMin"]->lVal;
  613. pFileDBItem->m_lPeersMax = (*pFileInfoMap)["PeersMax"]->lVal;
  614. pFileDBItem->m_lConnectErrorMax = (*pFileInfoMap)["errMax"]->lVal;
  615. pFileDBItem->m_lConnectIntval = (*pFileInfoMap)["ConIntval"]->lVal;
  616. }
  618. // UnNeedFiles.
  619. if (HasKey(pFileInfoMap, "UnNeed"))
  620. {
  621. if (!bdencode_UnNeedFiles((*pFileInfoMap)["UnNeed"], pFileDBItem->m_vUnneededFileInx))
  622. return false;
  623. }
  624. if (HasKey(pFileInfoMap, "fc"))
  625. pFileDBItem->m_fCompletePart = ((float)(*pFileInfoMap)["fc"]->lVal)/100;
  627. if (HasKey(pFileInfoMap, "haves"))
  628. {
  629. assert((pFileDBItem->m_fComplete < 1) || pFileDBItem->m_fComplete != 0);
  631. memstream memBuf;
  632. memBuf.write((*pFileInfoMap)["haves"]->pstrVal, (*pFileInfoMap)["haves"]->lstrLen);
  633. pFileDBItem->SetHave(memBuf);
  634. }
  636. // mark the unclosed.
  637. if (HasKey(pFileInfoMap, "Unclosed"))
  638. m_vUncloseds.push_back(CUnclosed(pFileDBItem, hTreeItem));
  640. vFileDbItems.push_back(pFileDBItem);
  641. }
  643. return true;
  644. }
  646. bool CCategoryFileDB::bdencode_UnNeedFiles(CVal* pVal, vector<CSize>& vFileDbItems)
  647. {
  648. if (pVal->vt != VT_PLIST)
  649. return false;
  651. VALLIST& FileList = *(pVal->plistVal);
  653. for (int i=0; i<FileList.size(); i++)
  654. {
  655. if (FileList[i]->vt != VT_PMAP)
  656. return false;
  658. PVALMAP pFileInfoMap = FileList[i]->pmapVal; 
  660. if (!HasKey(pFileInfoMap, "x") || !HasKey(pFileInfoMap, "y"))
  661. return false;
  664. CSize size((*pFileInfoMap)["x"]->lVal, (*pFileInfoMap)["y"]->lVal);
  666. vFileDbItems.push_back(size);
  667. }
  668. return true;
  669. }
  671. bool CCategoryFileDB::bdencode_rec(CVal* pVal, CTreeCursor& curItem)
  672. {
  673. // check type.
  674. if (pVal->vt != VT_PMAP)
  675. return false;
  677. if (!HasKey(pVal->pmapVal, "dirname") ||
  678. !HasKey(pVal->pmapVal, "directory") || 
  679. !HasKey(pVal->pmapVal, "childlist") ||
  680. !HasKey(pVal->pmapVal, "type") ||
  681. !HasKey(pVal->pmapVal, "filedbitems")||
  682. !HasKey(pVal->pmapVal, "id"))
  683. return false;
  685. if ((*pVal)["dirname"]->vt != VT_PSTR || 
  686. (*pVal)["directory"]->vt != VT_PSTR ||
  687. (*pVal)["childlist"]->vt != VT_PLIST ||
  688. (*pVal)["type"]->vt != VT_LONG ||
  689. (*pVal)["filedbitems"]->vt != VT_PLIST ||
  690. (*pVal)["id"]->vt != VT_LONG)
  691. return false;
  693. // ltype is imageid, default item has identity imageid, others must be IID_DIRECTORY.
  694. long lType = (*pVal)["type"]->lVal;
  695. assert(lType >= IID_ROOT && lType <= IID_DIRECTORY);
  697. long lDirectoryId = (*pVal)["id"]->lVal;
  698. if (lDirectoryId >= m_lDirectoryIDMax)
  699. m_lDirectoryIDMax = lDirectoryId + 1;
  701. // fill the data.***
  702. CTreeCursor curNew = curItem.AddTail((*pVal)["dirname"]->pstrVal, lType);
  703. CCategoryDBItem* pDBItem = new CCategoryDBItem((*pVal)["directory"]->pstrVal, lDirectoryId);
  704. curNew.SetData((long)pDBItem);
  705. if (!bdencode_FileDBItems((*pVal)["filedbitems"], pDBItem->m_vFileDBItems, curNew))
  706. return false;
  708. // check whether the default items exist, if not the db file corrupted.
  709. switch (lType)
  710. {
  711. case IID_ROOT:
  712. if (m_curRoot)
  713. return false;
  714. else
  715. {
  716. m_curRoot = curNew;
  717. m_curRoot.SetText("根目录");
  718. }
  719. break;
  721. case IID_DOWNLOADED_DIRECTORY:
  722. if (m_curDownloaded)
  723. return false;
  724. else
  725. {
  726. m_curDownloaded = curNew;
  727. m_curDownloaded.SetText("下载保存目录");
  728. }
  729. break;
  731. case IID_DOWNLOADING_DIRECTORY:
  732. if (m_curDownloading)
  733. return false;
  734. else
  735. {
  736. m_curDownloading = curNew;
  737. m_curDownloading.SetText("未完成任务");
  738. }
  739. break;
  741. case IID_RECYCLE:
  742. if (m_curRecycle)
  743. return false;
  744. else
  745. {
  746. m_curRecycle = curNew;
  747. m_curRecycle.SetText("回收站");
  748. }
  749. break;
  751. case IID_DIRECTORY:
  752. break;
  754. default:
  755. return false;
  756. break;
  757. }
  759. // recurse into childs.
  760. VALLIST& ChildList = *(*pVal)["childlist"]->plistVal;
  761. for (int i=0; i<ChildList.size(); i++)
  762. {
  763. if (!bdencode_rec(ChildList[i], curNew))
  764. return false;
  765. }
  767. return true;
  768. }
  771. /*
  772. CFileDBItem* CCategoryFileDB::GetLinkTrueFileDBItem(CFileDBItem* pLinkFileDBItem)
  773. {
  774. CTreeCursor curTrueCategory = findCursorByDirid(pLinkFileDBItem->m_lDirectoryID);
  775. CCategoryDBItem* pTrueCategory = (CCategoryDBItem*)curTrueCategory.GetData();
  776. assert(curTrueCategory && pTrueCategory);
  778. for (int i=0; i<pTrueCategory->m_vFileDBItems.size(); i++)
  779. {
  780. if (pTrueCategory->m_vFileDBItems[i]->m_strHash == pLinkFileDBItem->m_strHash)
  781. {
  782. return pTrueCategory->m_vFileDBItems[i];
  783. }
  784. }
  786. return 0;
  787. }
  789. bool CCategoryFileDB::LoadGenerateLinks()
  790. {
  791. CCategoryDBItem* pItem = (CCategoryDBItem*)m_curDownloading.GetData();
  792. assert(pItem && m_curDownloading);
  794. bool bRet = true;
  795. for (int i=0; i<pItem->m_vFileDBItems.size(); i++)
  796. {
  797. if (IsLinkFileDBItem(m_curDownloading, pItem->m_vFileDBItems[i]))
  798. {
  799. // get true FileDBItem.can't return. continue release mem. otherwise destroy wnd not release the mem.
  800. assert(!pItem->m_vFileDBItems[i]->m_pDownload);
  801. CFileDBItem* pTrueFileDBItem = GetLinkTrueFileDBItem(pItem->m_vFileDBItems[i]);
  802. if (!pTrueFileDBItem)
  803. {
  804. assert(pTrueFileDBItem);
  805. bRet = false;
  806. }
  808. delete pItem->m_vFileDBItems[i];
  809. pItem->m_vFileDBItems[i] = pTrueFileDBItem;
  810. }
  811. }
  813. return bRet;
  814. }
  815. //*/
  817. CTreeCursor CCategoryFileDB::findCursorByDirid(long lDirectoryID)
  818. {
  819. return findCursorByDiridRec(GetRootItem(), lDirectoryID);
  820. }
  822. CTreeCursor CCategoryFileDB::findCursorByDiridRec(CTreeCursor curItem, long lDirectoryID)
  823. {
  824. CCategoryDBItem* pItem = (CCategoryDBItem*)curItem.GetData();
  826. if (pItem->m_lDirectoryID == lDirectoryID)
  827. return curItem;
  829. if (curItem.HasChildren())
  830. {
  831. CTreeCursor curChild = curItem.GetChild();
  832. while (curChild)
  833. {
  834. CTreeCursor curRet = findCursorByDiridRec(curChild, lDirectoryID);
  835. if (curRet) 
  836. {
  837. return curRet;
  838. }
  839. curChild = curChild.GetNext(TVGN_NEXT);
  840. }
  841. }
  843. return CTreeCursor(0, 0);
  844. }
  847. /*
  848. void CCategoryFileDB::SetDBSavePath(CSetupRegister* pSetupRegister)
  849. {
  850. assert(pSetupRegister);
  851. m_strDBSavePath = pSetupRegister->m_strTorrentDir;
  852. }
  853. string CCategoryFileDB::GetDBSavePath() const
  854. {
  855. assert(!m_strDBSavePath.empty());
  856. return formatDir(m_strDBSavePath);
  857. }
  858. //*/