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

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

P2P编程

开发平台：

Visual C++

StorageWrapper.cpp：源码内容
  1. // StorageWrapperEx.cpp: implementation of the CStorageWrapperEx class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "testbt.h"
  7. #include "StorageWrapper.h"
  8. #include "storage.h"
  9. #include "Downloader.h"
  11. #include "DownloaderFeedback.h"
  12. #include "Sha.h"
  14. #ifdef _DEBUG
  15. #undef THIS_FILE
  16. static char THIS_FILE[]=__FILE__;
  17. #define new DEBUG_NEW
  18. #endif
  20. //////////////////////////////////////////////////////////////////////
  21. // Construction/Destruction
  22. //////////////////////////////////////////////////////////////////////
  23. CStorageWrapper::CStorageWrapper(const vector<CSize>& vUnNeededFileInxs)
  24. {
  25. //
  26. // set file inxs. make it at the end of the function.
  27. // set it at the first, because it may be called while stroage is checking or allocating.
  28. //
  29. SetUnNeededFilesInxs(vUnNeededFileInxs);
  30. }
  32. CStorageWrapperEx::CStorageWrapperEx()
  33. {
  34. m_pMain = 0;
  35. m_hevDone = 0;
  36. m_hevUnPause = 0;
  37. m_pStorage = 0;
  38. m_pDownloader = 0;
  40. m_request_size = 0;
  41. m_piece_length = 0;
  42. m_lTotalLength = 0;
  43. m_lAmountLeft = 0;
  45. m_lAmountInactive = 0;
  47. m_bCheckHashes = true;
  48. m_eAllocType = m_eAllocType;
  49. m_bDoubleCheck = false;
  50. m_bTripleCheck = false;
  51. m_bBgallocEnabled = false;
  52. m_bBgallocActive = false;
  54. m_lStatNumflunked = 0;
  55. m_lStatMumdownloaded = 0;
  56. m_lStatNumfound = 0;
  58. time(&m_tLast);
  59. m_tTimeSpan = 1;
  61. m_vNone.push_back(size(-1, -1));
  63. //
  64. // switch Unneedfiles.
  65. m_bModified = false;
  66. m_lPartAmountLeft = 0;
  67. m_lPartTotalLength = 0;
  68. m_lPartAmountInactive = 0;
  69. }
  71. CStorageWrapperEx::~CStorageWrapperEx()
  72. {
  74. }
  76. bool CStorageWrapperEx::do_I_have(long index)
  77. {
  78. // if (IsUnNeededIndex(index))
  79. // return false;
  81. assert(index < m_vHave.size());
  82. return m_vHave[index];
  83. }
  85. vector<bool>& CStorageWrapperEx::get_have_list()
  86. {
  87. return m_vHave;
  88. }
  90. BLONG CStorageWrapperEx::get_total_legth()
  91. {
  92. return m_pStorage->GetTotalLength();
  93. }
  95. BLONG CStorageWrapperEx::get_amount_left()
  96. {
  97. return m_lAmountLeft;
  98. }
  100. bool CStorageWrapperEx::do_I_have_anything()
  101. {
  102. return m_lAmountLeft < m_lTotalLength;
  103. }
  105. bool CStorageWrapperEx::is_everything_pending()
  106. {
  107. assert(m_lPartAmountInactive >= 0);
  108. if (m_lPartAmountInactive <= 0)
  109. {
  110. return true;
  111. }
  112. return false;
  113. return m_lAmountInactive == 0;
  114. }
  116. bool CStorageWrapperEx::do_I_have_requests(long index)
  117. {
  118. assert (index < m_vInactiveRequests.size());
  120. // if (m_vNone == m_vInactiveRequests[index])
  121. //  return true;
  123. if (IsUnNeededIndex(index))
  124. return false;
  126. return m_vInactiveRequests[index].size() != 0;
  127. }
  129. bool CStorageWrapperEx::_do_I_have_requests(long index)
  130. {
  131. assert (index < m_vInactiveRequests.size());
  133. return m_vInactiveRequests[index].size() != 0;
  134. }
  136. void CStorageWrapperEx::new_request(long index, long& begin, long& length)
  137. {
  138. if (index < 0 || index >= m_vHave.size() || m_vHave[index] || !do_I_have_requests(index))
  139. {
  140. assert(false);
  141. return;
  142. }
  144. if (m_vNone == m_vInactiveRequests[index])
  145. _make_inactive(index);
  147. m_vNumActive[index]++;
  149. vector<size> & rs = m_vInactiveRequests[index];
  150. size r = *rs.begin();
  151. begin = r.x;
  152. length = r.y;
  153. rs.erase(rs.begin());
  155. m_lAmountInactive -= length;
  156. m_lPartAmountInactive --; //= length;
  157. assert(m_lPartAmountInactive >= 0);
  159. m_pMain->PutFractionsState(index, 2);
  161. // m_vStatActive[index] = true;
  162. }
  164. void CStorageWrapperEx::request_lost(long index, long begin, long length)
  165. {
  166. assert(index < m_vInactiveRequests.size() && index >= 0);
  168. m_vInactiveRequests[index].push_back(size(begin, length));
  169. m_vNumActive[index]--;
  170. assert(m_vNumActive[index] >= 0);
  171. m_lAmountInactive += length;
  172. m_lPartAmountInactive ++; // = length;
  173. assert(m_lPartAmountInactive >= 0);
  175. if (m_vNumActive[index] <= 0)
  176. m_pMain->PutFractionsState(index, 0);
  177. }
  180. void CStorageWrapperEx::_make_inactive(long index)
  181. {
  182. assert (index < m_vInactiveRequests.size() && m_request_size > 0 && index >= 0);
  183. assert(m_vInactiveRequests[index] == m_vNone);
  185. // long lLength = min(m_piece_length , m_lTotalLength - (BLONG)m_piece_length * index);
  186. // ASSERT(lLength >= 0 && lLength <= m_piece_length);
  187. long lLength = _piecelen(index);
  189. vector<size>& v = m_vInactiveRequests[index];
  190. v.clear();
  192. long x = 0; 
  193. while ((x + m_request_size) < lLength)
  194. {
  195. v.push_back(size(x, m_request_size));
  196. x += m_request_size;
  197. }
  198. v.push_back(size(x, lLength-x));
  199. }
  202. //////////////////////////////////////////////////////////////////////////////////////////////////////
  203. // switch Unneedfiles.
  204. //
  206. bool CStorageWrapperEx::_ReadIndexData(char *pBuf, const BLONG lPos, const BLONG lAmount, bool bFlushFirst)
  207. {
  208. if (!m_piece_length)
  209. {
  210. assert(false);
  211. return false;
  212. }
  214. long index = lPos / m_piece_length;
  215. ASSERT(index >= 0);
  216. bool bEdge = false;
  218. for (int i=0; i<m_vRangeHoles.size(); i++)
  219. {
  220. if (index < m_vRangeHoles[i])
  221. break;
  223. if (index == m_vRangeHoles[i])
  224. {
  225. bEdge = (i > 0);
  226. break;
  227. }
  228. }
  231. if (bEdge)
  232. {
  233. assert(i < m_vFileOffset.size());
  235. long lfileoffset = m_vFileOffset[i];
  236. long lPrePartIndex = m_vOffsetTrueIndex[i];
  238. if (lfileoffset == 0 || lPrePartIndex < 0)
  239. {
  240. if (!m_pStorage->read(pBuf, lPos, lAmount, bFlushFirst))
  241. return false;
  242. }
  243. else
  244. {
  245. long lbeg = lPos % m_piece_length;
  246. assert(lbeg >= 0);
  247. if (lbeg < lfileoffset)
  248. {
  249. long len = lfileoffset - lbeg;
  250. assert(len >= 0);
  251. if (len >= lAmount)
  252. {
  253. if (!m_pStorage->read(pBuf, (BLONG)lPrePartIndex * m_piece_length + lbeg, lAmount, bFlushFirst))
  254. return false;
  255. }
  256. else
  257. {
  258. if (!m_pStorage->read(pBuf, (BLONG)lPrePartIndex * m_piece_length + lbeg, len, bFlushFirst))
  259. return false;
  261. if (!m_pStorage->read(pBuf + len, (BLONG)index * m_piece_length + lfileoffset, lAmount - len, bFlushFirst))
  262. return false;
  263. }
  264. }
  265. else
  266. {
  267. if (!m_pStorage->read(pBuf, lPos, lAmount, bFlushFirst))
  268. return false;
  269. }
  270. }
  271. }
  272. else
  273. {
  274. if (!m_pStorage->read(pBuf, lPos, lAmount, bFlushFirst))
  275. return false;
  276. }
  278. return true;
  279. }
  281. bool CStorageWrapperEx::_WriteIndexData(char *pBuf, const BLONG lPos, const BLONG lAmount)
  282. {
  283. if (!m_piece_length)
  284. {
  285. assert(false);
  286. return false;
  287. }
  289. long index = lPos / m_piece_length;
  290. ASSERT(index >= 0);
  291. bool bEdge = false;
  293. for (int i=0; i<m_vRangeHoles.size(); i++)
  294. {
  295. if (index < m_vRangeHoles[i])
  296. break;
  298. if (index == m_vRangeHoles[i])
  299. {
  300. bEdge = (i > 0);
  301. break;
  302. }
  303. }
  305. if (bEdge)
  306. {
  307. assert(i < m_vFileOffset.size());
  309. long lfileoffset = m_vFileOffset[i];
  310. long lPrePartIndex = m_vOffsetTrueIndex[i];
  312. if (lfileoffset == 0 || lPrePartIndex < 0)
  313. {
  314. if (!m_pStorage->write(pBuf, lPos, lAmount))
  315. return false;
  316. }
  317. else
  318. {
  320. long lbeg = lPos % m_piece_length;
  321. assert(lbeg >= 0);
  322. if (lbeg < lfileoffset)
  323. {
  324. long len = lfileoffset - lbeg;
  325. assert(len >= 0);
  326. if (len >= lAmount)
  327. {
  328. if (!m_pStorage->write(pBuf, (BLONG)lPrePartIndex * m_piece_length + lbeg, lAmount))
  329. return false;
  330. }
  331. else
  332. {
  333. if (!m_pStorage->write(pBuf, (BLONG)lPrePartIndex * m_piece_length + lbeg, len))
  334. return false;
  336. if (!m_pStorage->write(pBuf + len, (BLONG)index * m_piece_length + lfileoffset, lAmount - len))
  337. return false;
  338. }
  339. }
  340. else
  341. {
  342. if (!m_pStorage->write(pBuf, lPos, lAmount))
  343. return false;
  344. }
  345. }
  346. }
  347. else
  348. {
  349. if (!m_pStorage->write(pBuf, lPos, lAmount))
  350. return false;
  351. }
  353. return true;
  354. }
  356. void CStorageWrapperEx::_FormatRangeHoles()
  357. {
  358. if (m_piece_length <= 0)
  359. {
  360. assert(false);
  361. return;
  362. }
  364. m_pStorage->GetFilesRange(m_vRangeHoles, m_vFileOffset, m_piece_length);
  365. for (int i=0;i<m_vRangeHoles.size(); i++)
  366. {
  367. m_vOffsetTrueIndex.push_back(-1);
  368. m_vFileOffsetPreAllocated.push_back(false);
  369. }
  371. int iRangeHolesSize = m_vRangeHoles.size();
  372. int iFileOffsetSize = m_vFileOffset.size();
  373. int iOffsetTrueIndexSize = m_vOffsetTrueIndex.size();
  374. assert(iRangeHolesSize == iFileOffsetSize);
  375. assert(iFileOffsetSize == iOffsetTrueIndexSize);
  376. }
  378. float CStorageWrapperEx::GetPartCompletedPercent()
  379. {
  380. if (m_lPartTotalLength <= 0)
  381. return 1;
  383. return (float)(m_lPartTotalLength - m_lPartAmountLeft) / m_lPartTotalLength;
  385. }
  387. BLONG CStorageWrapperEx::get_total_legth_part()
  388. {
  389. return m_lPartTotalLength;
  390. }
  392. BLONG CStorageWrapperEx::get_amount_left_part()
  393. {
  394. return m_lPartAmountLeft;
  395. }
  397. BLONG CStorageWrapperEx::get_amount_left_part_include_temp()
  398. {
  399. BLONG lLeft = m_lPartAmountLeft;
  400. #ifdef _DEBUG
  401. int iCount = 0;
  402. unsigned long lsize = m_mPartAmountIncome.size();
  403. #endif
  404. for (map<unsigned long, unsigned long>::iterator i=m_mPartAmountIncome.begin(); i!=m_mPartAmountIncome.end(); i++)
  405. {
  406. if (!IsUnNeededIndex((*i).first))
  407. {
  408. lLeft += (*i).second;
  409. }
  410. #ifdef _DEBUG
  411. iCount ++;
  412. #endif
  413. }
  414. return lLeft;
  415. }
  417. bool CStorageWrapperEx::IsUnNeededIndex(long lIndex)
  418. {
  419. assert(lIndex >= 0);
  421. for (int i=0; i<m_vUnNeededIndexs.size(); i++)
  422. {
  424. long cx = m_vUnNeededIndexs[i].cx;
  425. long cy = m_vUnNeededIndexs[i].cy;
  427. if (lIndex > cy)
  428. continue;
  430. if (lIndex >= cx)
  431. return true;
  433. return false;
  434. }
  436. return false;
  437. }
  439. void CStorageWrapperEx::SetUnNeededFilesInxs(const vector<CSize>& vUnNeededFileInxs)
  440. {
  441. CSingleLock singleLock(&m_criticalSection, true);
  443. m_vUnNeededFileInxs = vUnNeededFileInxs;
  444. m_bModified = true;
  445. }
  447. bool CStorageWrapperEx::_GetUnNeededFilesInxs(vector<CSize>& vUnNeededFileInxs)
  448. {
  449. CSingleLock singleLock(&m_criticalSection, true);
  451. if (!m_bModified) return false;
  453. vUnNeededFileInxs = m_vUnNeededFileInxs;
  454. m_bModified = false;
  455. return true;
  456. }
  458. long CStorageWrapperEx::_GetRequestSize(long index)
  459. {
  460. assert(index <m_vHave.size() && index >= 0 && m_request_size > 0);
  461. if (m_request_size <= 0)
  462. {
  463. assert(false);
  464. return -1;
  465. }
  467. // long lRequestLength = min(m_piece_length , m_lTotalLength - m_piece_length * index);
  468. long lRequestLength = _piecelen(index);
  469. long lRequestCount = lRequestLength / m_request_size + ((lRequestLength % m_request_size) ? 1 : 0);
  472. assert(lRequestCount > 0 && lRequestLength >= 0);
  473. return lRequestCount;
  474. }
  476. /*************************************************************************************
  478. lbeg and lend is the true value of file seeking pos,
  479. which return value is the index value.
  481. *************************************************************************************/
  483. bool CStorageWrapperEx::_NormalizeUneedRange(BLONG & lbegPos, BLONG & lendPos)
  484. {
  485. assert(lendPos >= 0 && lbegPos >= 0);
  486. assert(!m_vRangeHoles.empty());
  488. const long lbegold = lbegPos/m_piece_length, lendold = lendPos/m_piece_length;
  489. assert(lbegold >= 0 && lendold >= 0);
  490. if (lbegold > lendold)
  491. {
  492. assert(false);
  493. return false;
  494. }
  496. bool bfindbeg = false, bfindend = false;
  497. for (int i=0; i<m_vRangeHoles.size();i++)
  498. {
  499. int iHoleIndex = m_vRangeHoles[i];
  500. if (lbegold <= m_vRangeHoles[i] && !bfindbeg)
  501. {
  502. lbegPos = m_vRangeHoles[i];
  503. if (m_vFileOffset[i] != 0)
  504. lbegPos += 1;
  506. bfindbeg = true;
  507. }
  509. // long lsize = m_vRangeHoles.size();
  510. long x = m_vRangeHoles[i];
  511. ASSERT(x >= 0);
  513. if (lendold  < m_vRangeHoles[i] && !bfindend)
  514. {
  515. assert(bfindbeg);
  516. assert(i > 0);
  518. lendPos = m_vRangeHoles[i - 1];
  519. if (m_vFileOffset[i - 1] != 0)
  520. lendPos -= 1;
  522. bfindend = true;
  523. }
  524. if (bfindbeg && bfindend)
  525. break;
  526. }
  529. /*
  530. if (!bfindbeg)
  531. {
  532. lbeg = m_vRangeHoles[m_vRangeHoles.size() - 1];
  533. if (m_vFileOffset[m_vRangeHoles.size() - 1])
  534. {
  535. lbeg ++;
  536. }
  537. }
  538. //*/
  540. if (!bfindend)
  541. {
  542. if (lendPos >= m_lTotalLength)
  543. {
  544. lendPos = m_lTotalLength / m_piece_length;
  545. }
  546. /*
  547. else if (lendold >= (m_lTotalLength / m_piece_length) )
  548. {
  549. lend = m_lTotalLength / m_piece_length;
  550. if (m_lTotalLength % m_piece_length)
  551. {
  552. lend -= 1;
  553. }
  554. }
  555. //*/
  556. else
  557. {
  558. lendPos = m_vRangeHoles[m_vRangeHoles.size() - 1];
  559. if (m_vFileOffset[m_vRangeHoles.size() - 1] != 0)
  560. lendPos -= 1;
  562. }
  563. bfindend = true;
  564. }
  566. // assert(lend >= lbeg);
  568. return bfindbeg && bfindend && (lendPos >= lendPos);
  569. }
  571. void CStorageWrapperEx::_MakeUnNeededIndexs()
  572. {
  574. vector<CSize> vUnFileInxs;
  575. if (!_GetUnNeededFilesInxs(vUnFileInxs))
  576. return;
  578. if (!m_piece_length)
  579. {
  580. assert(false);
  581. return;
  582. }
  584. m_lPartTotalLength = m_lTotalLength;
  585. m_lPartAmountLeft = m_lAmountLeft;
  586. m_vUnNeededIndexs.clear();
  588. //
  589. // Get unNeeded files range.
  590. //
  591. vector<CSizeEx> vRanges;
  592. m_pStorage->GetUnNeededRanges(vUnFileInxs, vRanges);
  595. #ifdef _DEBUG
  597. TRACE("rn_MakeUnNeededIndexs(%d) : rn", m_vHave.size());
  598. for (int j=0; j<vRanges.size(); j++)
  599. {
  600. TRACE("(%d, %d)", vRanges[j].cx, vRanges[j].cy);
  601. }
  602. TRACE("rn*");
  603. #endif
  605. //
  606. // compute the unNeeded indexs.
  607. //
  608. for (int i=0; i<vRanges.size(); i++)
  609. {
  610. BLONG tx = vRanges[i].cx, ty = vRanges[i].cy;
  612. /*
  613. unsigned long cx = vRanges[i].cx/m_piece_length;
  614. unsigned long cy = vRanges[i].cy/m_piece_length ;
  616. if (vRanges[i].cx % m_piece_length)
  617. cx += 1;
  619. if (vRanges[i].cy % m_piece_length)
  620. cy -= 1;
  622. if (vRanges[i].cy >= m_lTotalLength)
  623. {
  624. if (vRanges[i].cy%m_piece_length)
  625. {
  626. cy ++;
  627. }
  628. }
  629. if (cy >= 0)
  630. assert(cy < m_vHave.size());
  631. //*/
  632. if (!_NormalizeUneedRange(tx, ty))
  633. continue;
  636. if (tx >= ty) continue;
  638. m_vUnNeededIndexs.push_back(CSize(tx, ty));
  639. }
  641. //
  642. // Compute the Needed indexs and amount which had been haved.
  643. //
  645. m_lPartAmountInactive = 0;
  646. m_lPartTotalLength = 0;
  648. BLONG lAmountHave = 0;
  649. BLONG lbeg = 0, lend = 0;
  651. bool bIncludeLastPiece = false;
  652. int iLastIndex = m_vHave.size() - 1;
  654. for (i=0; i<m_vUnNeededIndexs.size(); i++)
  655. {
  656. CSize range = m_vUnNeededIndexs[i];
  657. lend = range.cx;
  659. m_lPartTotalLength += (BLONG)(lend - lbeg) * m_piece_length;
  661. for (int j=lbeg; j<lend; j++)
  662. {
  663. //
  664. // compute have amount.
  665. //
  666. if (j >= m_vHave.size())
  667. {
  668. assert(false);
  669. break;
  670. }
  672. if (m_vHave[j])
  673. lAmountHave  += _piecelen(j);
  675. //
  676. // compute inactive requests amount.
  677. //
  678. if (m_vInactiveRequests[j] == m_vNone)
  679. {
  680. long lRequestCount = _GetRequestSize(j);
  681. assert(lRequestCount >= 0);
  682. m_lPartAmountInactive += lRequestCount;
  683. }
  684. else
  685. {
  686. m_lPartAmountInactive += m_vInactiveRequests[j].size();
  687. }
  689. }
  690. lbeg  = range.cy + 1;
  691. }
  693. if (lbeg <= iLastIndex)
  694. {
  695. m_lPartTotalLength += (BLONG)(iLastIndex - lbeg) * m_piece_length;
  696. m_lPartTotalLength += _piecelen(iLastIndex);
  698. for (int j=lbeg; j<=iLastIndex; j++)
  699. {
  700. //
  701. // compute have amount.
  702. //
  703. if (m_vHave[j])
  704. lAmountHave  += _piecelen(j);
  707. //
  708. // compute inactive requests amount.
  709. //
  710. if (m_vInactiveRequests[j] == m_vNone)
  711. {
  712. long lRequestCount = _GetRequestSize(j);
  713. m_lPartAmountInactive += lRequestCount;
  714. }
  715. else
  716. {
  717. m_lPartAmountInactive += m_vInactiveRequests[j].size();
  718. }
  719. }
  720. }
  721.  
  722. m_lPartAmountLeft = m_lPartTotalLength - lAmountHave;
  723. assert(m_lPartAmountLeft >= 0);
  725. if (m_pDownloader && m_pDownloader->IsCreate())
  726. {
  727. if (m_pDownloader->is_endgame()) // && (m_lPartAmountInactive > 0) )
  728. {
  729. m_pDownloader->cancel_endgame();
  730. }
  731. m_pDownloader->OnNeedFilesChanged();
  732. }
  735. #ifdef _DEBUG
  737. TRACE("rn_MakeUnNeededIndexs(%d) : rn", m_vHave.size());
  738. for (i=0; i<vUnFileInxs.size();i++)
  739. {
  740. TRACE("(%d, %d)", vUnFileInxs[i].cx, vUnFileInxs[i].cy);
  741. }
  742. TRACE("rn*");
  743. TRACE("rn_MakeUnNeededIndexs(%d) : rn", m_vHave.size());
  744. for (i=0; i<vRanges.size();i++)
  745. {
  746. TRACE("(%d, %d)", vRanges[i].cx, vRanges[i].cy);
  747. }
  748. TRACE("rn*");
  749. for (i=0; i<m_vUnNeededIndexs.size();i++)
  750. {
  751. TRACE("(%d, %d)", m_vUnNeededIndexs[i].cx, m_vUnNeededIndexs[i].cy);
  752. }
  753. TRACE("rn");
  754. #endif
  756. }
  758. //////////////////////////////////////////////////////////////////////////////////////////////////////
  759. //
  760. bool CStorageWrapperEx::get_piece(long index, char* pPieceBuf, long begin, long length)
  761. {
  762. try
  763. {
  764. return _get_piece(index, pPieceBuf, begin, length);
  765. }
  766. catch (string& e)
  767. {
  768. throw string(e);
  769. }
  770. }
  772. bool CStorageWrapperEx::_get_piece(long index, char* pPieceBuf, long begin, long length)
  773. {
  774. if (index >= m_vHave.size() || !m_vHave[index] || begin < 0)
  775. {
  776. // assert(false);
  777. return false;
  778. }
  780. if ((begin + length) > _piecelen(index))
  781. {
  782. assert(false);
  783. return false;
  784. }
  786. // If piece was not checked, check it.
  787. if (!m_vWasChecked[index])
  788. {
  789. char* pszBuf = new char[m_piece_length];
  790. auto_ptr<char> aszBuf(pszBuf);
  792. assert(m_mPlaces.find(index) != m_mPlaces.end());
  793. if (!_ReadIndexData(pszBuf, (BLONG)m_piece_length * m_mPlaces[index], _piecelen(index)))
  794. return false;
  796. unsigned char shasum[20] = {0};
  797. CSHA sha;
  798. sha.start();
  799. sha.update((unsigned char*)pszBuf, _piecelen(index));
  800. sha.finish(shasum);
  802. if (m_vHashs[index] != shasum)
  803. {
  804. // todo : self.failed('told file complete on start-up, but piece failed hash check')
  805. m_pMain->SetBadMsg("文件已被修改或移动，导致数据丢失，请重新下载"); // told file complete on start-up, but piece failed hash check");
  806. return false;
  807. }
  809. m_vWasChecked[index] = true;
  810. }
  812. assert(m_mPlaces.find(index) != m_mPlaces.end());
  814. if (!_ReadIndexData(pPieceBuf, (BLONG)m_piece_length * m_mPlaces[index] + begin, length))
  815. return false;
  817. return true;
  818. }
  820. void CStorageWrapperEx::piece_came_in(long index, char *pPieceBuf, long begin,  long length)
  821. {
  822. try
  823. {
  824. _piece_came_in(index, pPieceBuf, begin, length);
  825. }
  826. catch (string& e)
  827. {
  828. assert(false);
  829. throw string(e);
  830. }
  831. }
  833. bool CStorageWrapperEx::_piece_came_in(long index, char *pPieceBuf, long begin,  long length)
  834. {
  835. if (index >= m_vHave.size() || m_vHave[index] || m_vNumActive[index] <= 0 || begin <0)
  836. {
  837. bool bHave = m_vHave[index];
  838. long lNumAcive = m_vNumActive[index];
  839. assert(false);
  840. return false;
  841. }
  843. // If the index not in slits.
  844. if (m_mPlaces.find(index) == m_mPlaces.end())
  845. {
  846. if (!_FindPlaceForNewComeIndex(index, true))
  847. {
  848. assert(false);
  849. m_pMain->SetBadMsg("_FindPlaceForNewComeIndex error : ");
  850. return false;
  851. }
  852. }// endif dosn't exist.
  854. assert(m_mPlaces.find(index) != m_mPlaces.end());
  855. if (!_WriteIndexData(pPieceBuf, (BLONG)m_piece_length * (BLONG)m_mPlaces[index] + begin, length))
  856. return false;
  858. m_vNumActive[index] --;
  860. //
  861. // record the amount income of each uncompleted piece.
  862. // 
  863. map<unsigned long, unsigned long>::iterator itAmount = m_mPartAmountIncome.find(index);
  864. if (itAmount == m_mPartAmountIncome.end())
  865. {
  866. m_mPartAmountIncome[index] = 0;
  867. }
  868. m_mPartAmountIncome[index] += length;
  870. //
  871. // check whether the piece completed.
  872. //
  873. if (!_do_I_have_requests(index) && !m_vNumActive[index])
  874. {
  875. //
  876. // if  completed the amount completed tranfered to m_vHave.
  877. //
  878. itAmount = m_mPartAmountIncome.find(index);
  879. if (itAmount != m_mPartAmountIncome.end())
  880. m_mPartAmountIncome.erase(itAmount);
  882. if (!_check_single(index, true))
  883. return false;
  884. }
  886. return true;
  887. }
  889. bool CStorageWrapperEx::_FindPlaceForNewComeIndex(long index, bool bFirst)
  890. {
  891. char* pszBuf = new char[m_piece_length];
  892. auto_ptr<char> aszBuf(pszBuf);
  895. #ifdef _DEBUG
  897. if (m_vHoles.empty())
  898. {
  899. assert(false);
  900. return false;
  901. }
  902. #endif
  904. //////////////////////////////////////////////////////////////////////////////
  905. // get hole index from the holes list decided previous.
  906. // the hole index is caculated by the file range that the index belongs to.
  908. long lFileIndex = -1;
  909. bool bFind = false;
  910. for (int i=0; i<m_vRangeHoles.size(); i++)
  911. {
  912. if (index < m_vRangeHoles[i])
  913. {
  914. bFind = true;
  915. lFileIndex = i - 1;
  916. break;
  917. }
  918. }
  919. if (!bFind)
  920. lFileIndex = m_vRangeHoles.size() - 1;
  922. assert(lFileIndex >= 0);
  924. long lMinHoleIndex = m_vRangeHoles[lFileIndex];
  926. long lPopHoleIndex = -1;
  927. for (i=0; i<m_vHoles.size(); i++)
  928. {
  929. if (m_vHoles[i] >= lMinHoleIndex)
  930. {
  931. // lPopHoleIndex = (*pvHoles)[i];
  932. lPopHoleIndex = i;
  933. break;
  934. }
  935. }
  937. if (lPopHoleIndex < 0)
  938. {
  939. assert(false);
  940. return false;
  941. }
  944. // const int n = (*pvHoles)[0];
  945. const int n = m_vHoles[lPopHoleIndex];
  949. //////////////////////////////////////////////////////////////////////////////
  950. // if the hole is the first place of the file range.
  952. if (n == lMinHoleIndex && lFileIndex > 0)
  953. {
  954. long lfileoffset = m_vFileOffset[lFileIndex];
  955. long lPrePartIndex = m_vOffsetTrueIndex[lFileIndex];
  957. if (lfileoffset != 0 && lPrePartIndex >= 0)
  958. {
  959. char c = 'f';
  960. if (!m_pStorage->write(&c, (BLONG)lPrePartIndex * m_piece_length + lfileoffset - 1, sizeof(char)))
  961. return false;
  962. }
  963. }
  966. //////////////////////////////////////////////////////////////////////////////
  967. // if the hole is took by next file offset part, move it to next index.
  969. if (lFileIndex < (m_vRangeHoles.size() - 1))
  970. {
  971. if (m_vOffsetTrueIndex[lFileIndex + 1] == n)
  972. {
  973. long lNextIndex = m_vRangeHoles[lFileIndex + 1];
  975. if (m_vOffsetTrueIndex[lFileIndex + 1] >= lNextIndex)
  976. {
  977. assert(false);
  978. return false;
  979. }
  981. //
  982. // tell whether the next file offset part filled, if yes move it.
  983. //
  984. // map<long, long>::iterator iter = m_mPlaces.find(lNextIndex);
  985. // if (iter != m_mPlaces.end()) 
  986. if (find(m_vHoles.begin(), m_vHoles.end(), lNextIndex) == m_vHoles.end())
  987. {
  988. if (!m_pStorage->read(pszBuf, (BLONG)m_piece_length * n, m_vFileOffset[lFileIndex + 1]))
  989. return false;
  990. if (!m_pStorage->write(pszBuf, (BLONG)m_piece_length * (n + 1), m_vFileOffset[lFileIndex + 1]))
  991. return false;
  993. }
  995. //
  996. // mark the offset to next index, no matter whether it is filled.
  997. //
  998. m_vOffsetTrueIndex[lFileIndex + 1] ++;
  999. if (m_vOffsetTrueIndex[lFileIndex + 1] >= lNextIndex)
  1000. {
  1001. m_vOffsetTrueIndex[lFileIndex + 1] = -1;
  1002. }
  1003. }
  1004. }
  1006. //////////////////////////////////////////////////////////////
  1007. // find the index place, whether in holes or in place took by other piece.
  1008. //
  1009. long lIndexP = -1;
  1010. if (find(m_vHoles.begin(), m_vHoles.end(), index) == m_vHoles.end())
  1011. {
  1012. for (map<long, long>::iterator j = m_mPlaces.begin(); j != m_mPlaces.end(); j++)
  1013. {
  1014. if ((*j).second == index)
  1015. {
  1016. lIndexP = (*j).first;
  1017. break;
  1018. }
  1019. }
  1020. if (j == m_mPlaces.end())
  1021. {
  1022. assert(false);
  1023. return false;
  1024. }
  1025. }
  1028. //////////////////////////////////////////////////////////////////////////////
  1029. // old code. find the piece data to fill the hole, to free the true space for new coming piece.
  1031. map<long, long>::iterator iter = m_mPlaces.find(n);
  1033. // The new hole poped is needed by item in temps.
  1034. if (iter != m_mPlaces.end()) 
  1035. {
  1036. // Move data from temp to split newly created from holes.
  1037. long lOldPos = (*iter).second;
  1039. if (!_ReadIndexData(pszBuf, (BLONG)m_piece_length * lOldPos, _piecelen(n)))
  1040. return false;
  1042. if (!_WriteIndexData(pszBuf, (BLONG)m_piece_length * n, _piecelen(n)))
  1043. return false;
  1045. CheckAfterMoveing(n, pszBuf);
  1046. m_mPlaces[n] = n;
  1048. if(index == lOldPos ||  lIndexP < 0 )
  1049. {
  1050. m_mPlaces[index] = lOldPos;
  1051. }
  1052. else
  1053. {
  1054. if (!_ReadIndexData(pszBuf, (BLONG)m_piece_length * index, _piecelen(lIndexP)))
  1055. return false;
  1057. if (!_WriteIndexData(pszBuf, (BLONG)m_piece_length * lOldPos, _piecelen(lIndexP)))
  1058. return false;
  1060. m_mPlaces[lIndexP] = lOldPos;
  1061. m_mPlaces[index] = index;
  1062. }
  1064. }
  1065. else
  1066. {
  1067. if (index == n || lIndexP < 0)// index item out of space. find(m_vHoles.begin(), m_vHoles.end(), index) != m_vHoles.end())
  1068. {
  1069. memset(pszBuf, 0xff, _piecelen(n));
  1070. if (!_WriteIndexData(pszBuf, (BLONG)m_piece_length * n, _piecelen(n)))
  1071. return false;
  1073. m_mPlaces[index] = n;
  1074. }
  1075. else // Move item in index space to hole poped. Insert index item in space allocated. 
  1076. {
  1078. if (!_ReadIndexData(pszBuf, (BLONG)m_piece_length * index, _piecelen(lIndexP)))
  1079. return false;
  1081. if (!_WriteIndexData(pszBuf, (BLONG)m_piece_length * n, _piecelen(lIndexP)))
  1082. return false;
  1084. m_mPlaces[lIndexP] = n;
  1085. m_mPlaces[index] = index;
  1087. }// endif hole pop
  1088. }
  1090. //////////////////////////////////////////////////////////////////////////////
  1091. // erase the poped hole from the needed or notneeded holes, and must erase from m_vHoles which is the base 
  1092. // to generate the needed and notneeded holes when user change setup of files to be and not deleted .
  1094. {
  1095. vector<long>::iterator it = find(m_vHoles.begin(), m_vHoles.end(), n);
  1096. if (it == m_vHoles.end())
  1097. {
  1099. TRACE("sdfsdfrn");
  1100. for (i=0; i<m_vHoles.size(); i++)
  1101. {
  1102. TRACE("%d, ", m_vHoles[i]);
  1103. }
  1104. TRACE("rn");
  1105. assert(false);
  1107. return false;
  1108. }
  1110. // TRACE("rn *********erase holes(%d, %d, %d) **********rn", iState, n, m_vHoles.size());
  1112. m_vHoles.erase(it);
  1113. }
  1115. return true;
  1116. }
  1118. bool CStorageWrapperEx::_check_single(long index, bool check)
  1119. {
  1120. char* pszBuf = new char[m_piece_length];
  1121. auto_ptr<char> aszBuf(pszBuf);
  1123. assert(m_mPlaces.find(index) != m_mPlaces.end());
  1125. if (!_ReadIndexData(pszBuf, (BLONG)m_piece_length * m_mPlaces[index], _piecelen(index)))
  1126. {
  1127. assert(false);
  1128. return false;
  1129. }
  1131. unsigned char shasum[20] = {0};
  1132. CSHA sha;
  1133. sha.start();
  1134. sha.update((unsigned char*)pszBuf, _piecelen(index));
  1135. sha.finish(shasum);
  1137. if (m_vHashs[index] == shasum)
  1138. {
  1139. m_vHave[index] = true;
  1140. m_lAmountLeft -= _piecelen(index);
  1141. m_vInactiveRequests[index].clear();
  1142. m_vWasChecked[index] = m_bCheckHashes;
  1144. if (!IsUnNeededIndex(index))
  1145. {
  1146. m_lPartAmountLeft -= _piecelen(index);
  1147. if (m_lPartAmountLeft <= 0)
  1148. {
  1149. m_pMain->PartCompleted();
  1150. }
  1151. }
  1153. if (m_lAmountLeft <= 0)
  1154. {
  1155. // todo : finished();
  1156. m_pMain->Completed();
  1157. }
  1159. m_pMain->PutFractionsState(index, 1);
  1160. }
  1161. else
  1162. {
  1163. // todo: data_flunk().
  1164. m_pMain->data_flunked(_piecelen(index));
  1165. m_vInactiveRequests[index] = m_vNone;
  1166. m_lAmountInactive += _piecelen(index);
  1167. m_lPartAmountInactive += _GetRequestSize(index);
  1169. m_pMain->PutFractionsState(index, 0);
  1171. return false;
  1172. }
  1174. return true;
  1175. }
  1178. bool CStorageWrapperEx::CheckAfterMoveing(int iIndex, char* pszBuf)
  1179. {
  1180. if (m_bDoubleCheck && m_vHave[iIndex])
  1181. {
  1182. if (m_bTripleCheck)
  1183. {
  1184. if (!_ReadIndexData(pszBuf, (BLONG)m_piece_length * iIndex, _piecelen(iIndex), true))
  1185. return false;
  1186. }
  1188. unsigned char shasum[20] = {0};
  1189. CSHA sha;
  1190. sha.start();
  1191. sha.update((unsigned char*)pszBuf, _piecelen(iIndex));
  1192. sha.finish(shasum);
  1194. if (m_vHashs[iIndex] != shasum)
  1195. {
  1196. assert(false);
  1197. // todo : failed('download corrupted; please restart and resume').
  1198. m_pMain->SetBadMsg("download corrupted; please restart and resume");
  1199. return false;
  1200. }
  1201. }
  1203. return true;
  1204. }
  1206. /*************************************************************************************
  1207. parameter : 
  1208. lAllocateRate : (n)M allocated per second.
  1210. ************************************************************************************/
  1211. bool CStorageWrapperEx::Create(CDownloaderFeedback* pMain,
  1212.    HANDLE hevDone, HANDLE hevUnPause, CStorageEx* pStorageEx, CDownloader* pDownloader, vector<char*>& vPieces, 
  1213.    bool check_hashes, long request_size, long piece_length, 
  1214.    eAllocType eAllocType, 
  1215.    long lAllocateRate, bool m_bDoubleCheck, bool m_bTripleCheck)
  1216. {
  1217. assert(pMain && hevDone && pStorageEx && lAllocateRate > 0);
  1221. m_pMain = pMain;
  1222. m_hevDone = hevDone;
  1223. m_hevUnPause = hevUnPause;
  1224. m_pStorage = pStorageEx;
  1225. m_pDownloader = pDownloader;
  1227. for (int i=0; i<vPieces.size(); i++)
  1228. {
  1229. m_vHashs.push_back((const char* const)vPieces[i]);
  1230. m_vNumActive.push_back(0);
  1231. m_vInactiveRequests.push_back(m_vNone);
  1232. m_vHave.push_back(false);
  1234. // m_vStatActive.push_back(false);
  1235. m_vWasChecked.push_back(check_hashes);
  1236. }
  1239. m_bCheckHashes = check_hashes;
  1240. m_request_size = request_size;
  1241. m_piece_length = piece_length;
  1242. m_lTotalLength = m_pStorage->GetTotalLength();
  1243. m_lAmountLeft = m_lTotalLength;
  1244. m_lAmountInactive = m_lTotalLength;
  1245. // m_lPartAmountInactive = m_vHave.size(); // useless, but temp initialize the member data.
  1246. m_eAllocType = eAllocType;
  1248. if (m_lTotalLength <= ((BLONG)(vPieces.size()-1) * piece_length))
  1249. throw string("CStorageWrapper construct() error: bad data from tracker - total too small");
  1250. if (m_lTotalLength > ((BLONG)vPieces.size() * piece_length))
  1251. throw string("CStorageWrapper construct() error: bad data from tracker - total too big");
  1254. if (m_vHashs.size() <= 0)
  1255. {
  1256. m_pMain->Completed();
  1257. return true;
  1258. }
  1260. time(&m_tLast);
  1261. m_tTimeSpan = m_piece_length / (lAllocateRate * 1048576);
  1263. _FormatRangeHoles();
  1265. m_pMain->ShowSystemMessage("检查已下载数据,可能占用较多系统资源,请稍后.", CSystemMsg::eCmd);
  1266. m_pMain->ShowSystemMessage("开始检查...", CSystemMsg::eMsgOut);
  1268. if (!CheckFiles())
  1269. {
  1270. m_pMain->SetStorageChecking(false);
  1271. m_pMain->SetStorageAllocating(false);
  1272. return false;
  1273. }
  1275. m_pMain->SetStorageChecking(false);
  1276. m_pMain->SetStorageAllocating(false);
  1279. //
  1280. // Make UnNeeded files.
  1281. //
  1282. _MakeUnNeededIndexs();
  1284. if (!IsEventSet(m_hevDone))
  1285. {
  1286. float fCompleted = 0;
  1287. if (m_lTotalLength > 0)
  1288. fCompleted = ((float)(m_lTotalLength - m_lAmountLeft)) / m_lTotalLength;
  1290. m_pMain->SetCheckingDone(fCompleted, GetPartCompletedPercent());
  1291. m_pMain->ShowSystemMessage("检查完成.", CSystemMsg::eMsgIn);
  1292. }
  1295. return true;
  1296. }
  1298. bool CStorageWrapperEx::CheckFiles()
  1299. {
  1300. map<CHashItem, long> mTargets;
  1301. long lTotal = m_vHashs.size();
  1303. //
  1304. // compute the total length allocated to be checked, 
  1305. // but the critical index are skipped, it is a approximatetly value.
  1306. //
  1307. for (int i=0; i<m_vHashs.size(); i++)
  1308. {
  1309. if (!_waspre(i))
  1310. {
  1311. if (mTargets.find(m_vHashs[i]) == mTargets.end())
  1312. mTargets[m_vHashs[i]] = i;
  1313. else
  1314. mTargets.erase(m_vHashs[i]);
  1316. lTotal -= 1;
  1317. }
  1318. }
  1320. if (lTotal && m_bCheckHashes)
  1321. {
  1322. // todo : notify begin check.
  1323. m_pMain->SetStorageChecking(true);
  1324. }
  1326. long lNumChecked = 0;
  1327. long lLastLen = _piecelen(m_vHashs.size() - 1);
  1328. long lOutOfPlace = 0;
  1329. long lUpdateNum = lTotal/300 + 1;
  1330. long lUpdateCount = 0;
  1333. bool bFirstFileIndex = true;
  1334. bool bFirstNoPrepared = true;
  1335. long lNextHoleIdx = 0;
  1336. assert(m_vRangeHoles.size() == m_vFileOffset.size());
  1338. for (i=0; i<m_vHashs.size(); i++)
  1339. {
  1340. bFirstFileIndex = false;
  1342. bool bHaveNext = (lNextHoleIdx < (m_vRangeHoles.size()));
  1343. if (bHaveNext)
  1344. {
  1345. if (i == m_vRangeHoles[lNextHoleIdx])
  1346. {
  1347. bFirstFileIndex = true;
  1348. bFirstNoPrepared = true;
  1349. lNextHoleIdx ++;
  1350. }
  1351. }
  1353. char* pszBuf = new char[m_piece_length];
  1354. auto_ptr<char> aszBuf(pszBuf);
  1356. bool bSaveOffset = false;
  1358. if (!_waspre(i))
  1359. {
  1360. if (bFirstFileIndex)
  1361. {
  1362. assert((lNextHoleIdx - 1 ) >= 0);
  1363. long lcurIndex = lNextHoleIdx - 1;
  1364. if (m_vOffsetTrueIndex[lcurIndex] >= 0)
  1365. {
  1366. if (m_pStorage->was_preallocated((BLONG)m_vOffsetTrueIndex[lcurIndex] * m_piece_length, 
  1367. (BLONG)m_vFileOffset[lcurIndex]) && 
  1368. m_pStorage->was_preallocated((BLONG)i * m_piece_length + m_vFileOffset[lcurIndex], 
  1369. (BLONG)_piecelen(i) - m_vFileOffset[lcurIndex]))
  1370. {
  1371. m_vFileOffsetPreAllocated[lcurIndex] = true;
  1372. bSaveOffset = true;
  1373. }
  1374. }
  1375. }
  1376. else  if (bFirstNoPrepared)
  1377. {
  1378. bFirstNoPrepared = false;
  1380. if (bHaveNext)
  1381. m_vOffsetTrueIndex[lNextHoleIdx] = i;
  1382. }
  1384. if (!bSaveOffset)
  1385. {
  1386. if (!m_bCheckHashes)
  1387. {
  1388. // todo : told file complete on start-up, but data is missing.
  1389. m_pMain->SetBadMsg("文件已被修改或移动，导致数据丢失，请重新下载."); // told file complete on start-up, but data is missing.");
  1390. // assert(false);
  1391. return false;
  1392. }
  1394. m_vHoles.push_back(i);
  1395. continue;
  1396. }
  1397. }
  1398. else if (!m_bCheckHashes)
  1399. {
  1400. markgot(i, i);
  1401. continue;
  1402. }
  1405. //
  1406. // if the piece space was allocated, then check the data of it whether be valid.
  1407. //
  1408. if (!_ReadIndexData(pszBuf, (BLONG)m_piece_length * i, _piecelen(i)))
  1409. return false;
  1411. unsigned char shaPart[20] = {0};
  1412. unsigned char shaFull[20] = {0};
  1413. CSHA sha;
  1415. sha.start();
  1416. sha.update((unsigned char*)pszBuf, lLastLen);
  1417. sha.finish(shaPart);
  1419. sha.start();
  1420. sha.update((unsigned char*)pszBuf, _piecelen(i));
  1421. sha.finish(shaFull);
  1423. if (m_vHashs[i] == shaFull)
  1424. {
  1425. markgot(i, i);
  1426. }
  1427. else 
  1428. {
  1429. map<CHashItem, long>::iterator iter = mTargets.find(CHashItem((const char* const)shaFull));
  1431. if (iter != mTargets.end() && 
  1432. _piecelen(i) == _piecelen((*iter).second))
  1433. {
  1434. markgot((*iter).second, i);
  1435. mTargets.erase(iter);
  1436. lOutOfPlace += 1;
  1437. }
  1438. else if (!m_vHave[m_vHave.size()-1] &&
  1439. m_vHashs[m_vHashs.size() - 1] == shaPart &&
  1440. ((i == (m_vHashs.size() - 1)) || !_waspre(m_vHashs.size() - 1)) )
  1441. {
  1442. markgot(m_vHashs.size() - 1, i);
  1443. lOutOfPlace += 1;
  1444. }
  1445. else
  1446. {
  1447. m_mPlaces[i] = i;
  1448. }
  1449. }
  1452. if (!IsEventSet(m_hevUnPause))
  1453. {
  1454. m_pMain->ShowSystemMessage("用户暂停该任务...", CSystemMsg::eCmd);
  1455. DWORD dwRet = WaitForSingleObject(m_hevUnPause, INFINITE);
  1456. m_pMain->ShowSystemMessage("用户继续该任务...", CSystemMsg::eCmd);
  1457. }
  1459. if (IsEventSet(m_hevDone))
  1460. return false;
  1462. if (!bSaveOffset)
  1463. {
  1464. lNumChecked ++;
  1465. lUpdateCount ++;
  1466. if (lUpdateCount >= lUpdateNum)
  1467. {
  1468. lUpdateCount = 0;
  1469. if (lTotal > 0)
  1470. m_pMain->SetStorageChecking(true, (float)lNumChecked / lTotal);
  1471. }
  1472. }
  1475. } // end for 
  1477. // todo : Notify check complete.
  1478. m_pMain->SetStorageChecking(false);
  1479. m_pMain->PutFractions(m_vHave);
  1480. ShowDetailsTest();
  1482. if (m_lAmountLeft <= 0)
  1483. {
  1484. // todo : notify finished.
  1485. m_pMain->Completed();
  1486. }
  1489. if (m_eAllocType == eAllocSparse)
  1490. {
  1491. m_pStorage->top_off();
  1493. if (lOutOfPlace > 0)
  1494. {
  1495. // todo: statusfunc(activity = 'moving data', fractionDone = 1.0)
  1496. long lToMove = lOutOfPlace;
  1497. lUpdateNum = lOutOfPlace/300 + 1;
  1498. lUpdateCount = 0;
  1500. for (i=0; i<m_vHashs.size(); i++)
  1501. {
  1502. if (!IsEventSet(m_hevUnPause))
  1503. {
  1504. m_pMain->ShowSystemMessage("用户暂停该任务...", CSystemMsg::eCmd);
  1505. DWORD dwRet = WaitForSingleObject(m_hevUnPause, INFINITE);
  1506. m_pMain->ShowSystemMessage("用户继续该任务...", CSystemMsg::eCmd);
  1507. }
  1509. if (IsEventSet(m_hevDone))
  1510. return false;
  1512. if (m_mPlaces.find(i) == m_mPlaces.end())
  1513. {
  1514. m_mPlaces[i] = i;
  1515. }
  1516. else if (m_mPlaces[i] != i)
  1517. {
  1518. char* pszBuf = new char[m_piece_length];
  1519. auto_ptr<char> aszBuf(pszBuf);
  1521. if (!m_pStorage->read(pszBuf, (BLONG)m_piece_length * m_mPlaces[i], _piecelen(i)))
  1522. return false;
  1524. if (!m_pStorage->write(pszBuf, (BLONG)m_piece_length * i, _piecelen(i)))
  1525. return false;
  1528. // check move data result.
  1529. if (!CheckAfterMoveing(i, pszBuf))
  1530. return false;
  1532. m_mPlaces[i] = i;
  1533. lToMove --;
  1534. lUpdateCount ++;
  1535. if (lUpdateCount > lUpdateNum)
  1536. {
  1537. lUpdateCount = 0;
  1538. // todo : statusfunc(fractionDone = float(tomove)/out_of_place)
  1539. }
  1541. m_pStorage->flush();
  1542. // todo : statusfunc(fractionDone = 0.0)
  1544. }
  1546. } // endfor hashs
  1548. } 
  1549. else
  1550. {
  1551. for (int i=0; i<m_vHoles.size(); i++)
  1552. {
  1553. long j = m_vHoles[i];
  1554. m_mPlaces[j] = j;
  1555. }
  1557. } // endif outofplace
  1559. TRACE("rn *** after Sparse ***********************rn");
  1560. ShowDetailsTest();
  1561. m_vHoles.clear();
  1563. return true;
  1565. } // endif sparse
  1568. if (m_vHoles.empty())
  1569. return true;
  1571. //
  1572. // Pre allocate space, mark all pieces un completed to correct index.
  1573. //
  1574. if (m_eAllocType == eAllocPreAllocate)
  1575. {
  1576. m_pMain->SetStorageAllocating(true);
  1577. long lNumHoles = m_vHoles.size();
  1578. lUpdateNum = lNumHoles/300 + 1;
  1579. lUpdateCount = 0;
  1581. while (!m_vHoles.empty())
  1582. {
  1583. if (!IsEventSet(m_hevUnPause))
  1584. {
  1585. m_pMain->ShowSystemMessage("用户暂停该任务...", CSystemMsg::eCmd);
  1586. DWORD dwRet = WaitForSingleObject(m_hevUnPause, INFINITE);
  1587. m_pMain->ShowSystemMessage("用户继续该任务...", CSystemMsg::eCmd);
  1588. }
  1590. if (IsEventSet(m_hevDone))
  1591. return false;
  1593. if (!_doalloc())
  1594. return false;
  1596. lUpdateCount ++;
  1597. if (lUpdateCount > lUpdateNum)
  1598. {
  1599. lUpdateCount = 0;
  1601. if (lNumHoles)
  1602. m_pMain->SetStorageAllocating(true, (float)(m_vHoles.size())/lNumHoles);
  1603. }
  1604. }
  1606. m_pStorage->flush();
  1608. // todo : statusfunc(fractionDone = 0.0)
  1609. m_pMain->SetStorageAllocating(false);
  1611. return true;
  1613. } // endif PreAllocate
  1615. if (m_eAllocType == eAllocBackGound)
  1616. {
  1617. bgalloc();
  1618. }
  1620. return true;
  1621. }
  1623. void CStorageWrapperEx::OnIdle()
  1624. {
  1625. time_t t;
  1626. time(&t);
  1627. time_t tspan = t - m_tLast;
  1628. assert(tspan >= 0);
  1629. if (tspan < 0)
  1630. m_tLast = t;
  1632. if (tspan < m_tTimeSpan)
  1633. return ;
  1635. _MakeUnNeededIndexs();
  1637. if (!m_bBgallocActive)
  1638. return;
  1640. _bgalloc();
  1641. }
  1643. bool CStorageWrapperEx::bgalloc()
  1644. {
  1645. /*
  1646. if (!m_vHoles.empty() && !m_bBgallocEnabled) // useless when no need catch flush command.
  1647. {
  1648. m_bBgallocEnabled = true;
  1649. }
  1650. //*/
  1652. m_bBgallocActive = true;
  1653. return true;
  1654. }
  1656. bool CStorageWrapperEx::_bgalloc()
  1657. {
  1658. if (!m_vHoles.empty())
  1659. {
  1660. _doalloc();
  1661. }
  1662. else
  1663. {
  1664. m_pStorage->flush();
  1665. m_bBgallocActive = false;
  1666. }
  1668. return true;
  1669. }
  1671. bool CStorageWrapperEx::_MakeOffsetToTruePlace(const long index, const long n)
  1672. {
  1673. //////////////////////////////////////////////////////////////////////////////
  1674. // if the hole is took by next file offset part, move it to next index.
  1676. char* pszBuf = new char[m_piece_length];
  1677. auto_ptr<char> aszBuf(pszBuf);
  1679. long lFileIndex = -1;
  1680. bool bFind = false;
  1681. for (int i=0; i<m_vRangeHoles.size(); i++)
  1682. {
  1683. if (index < m_vRangeHoles[i])
  1684. {
  1685. bFind = true;
  1686. lFileIndex = i - 1;
  1687. break;
  1688. }
  1689. }
  1690. if (!bFind)
  1691. lFileIndex = m_vRangeHoles.size() - 1;
  1693. assert(lFileIndex >= 0);
  1695. if (lFileIndex < (m_vRangeHoles.size() - 1))
  1696. {
  1697. if (m_vOffsetTrueIndex[lFileIndex + 1] == n)
  1698. {
  1699. long lNextIndex = m_vRangeHoles[lFileIndex + 1];
  1701. if (m_vOffsetTrueIndex[lFileIndex + 1] >= lNextIndex)
  1702. {
  1703. assert(false);
  1704. return false;
  1705. }
  1707. //
  1708. // tell whether the next file offset part filled, if yes move it.
  1709. //
  1710. if (find(m_vHoles.begin(), m_vHoles.end(), lNextIndex) == m_vHoles.end())
  1711. {
  1712. if (!m_pStorage->read(pszBuf, (BLONG)m_piece_length * n, m_vFileOffset[lFileIndex + 1]))
  1713. return false;
  1714. if (!m_pStorage->write(pszBuf, (BLONG)m_piece_length * lNextIndex , m_vFileOffset[lFileIndex + 1]))
  1715. return false;
  1716. }
  1718. //
  1719. // mark the offset to next index, no matter whether it is filled.
  1720. //
  1721. m_vOffsetTrueIndex[lFileIndex + 1] = -1;
  1722. }
  1723. }
  1725. return true;
  1726. }
  1728. bool CStorageWrapperEx::_doalloc()
  1729. {
  1730. if (m_vHoles.empty())
  1731. {
  1732. assert(false);
  1733. return false;
  1734. }
  1736. int n = m_vHoles[0];
  1737. m_vHoles.erase(m_vHoles.begin());
  1738. char* pszBuf = new char[m_piece_length];
  1739. auto_ptr<char> aszBuf(pszBuf);
  1741. //
  1742. // check to see whether the space is took by offset.
  1743. //
  1744. if (!_MakeOffsetToTruePlace(n, n))
  1745. return false;
  1747. map<long, long >::iterator iter = m_mPlaces.find(n);
  1749. if (iter != m_mPlaces.end())
  1750. {
  1751. long lOldPos = (*iter).second;
  1752. m_mPlaces[lOldPos] = lOldPos;
  1755. if (!_ReadIndexData(pszBuf, (BLONG)m_piece_length * lOldPos, _piecelen(n)))
  1756. return false;
  1758. if (!_WriteIndexData(pszBuf, (BLONG)m_piece_length * n, _piecelen(n)))
  1759. return false;
  1761. // check move data result.
  1762. if (!CheckAfterMoveing(n, pszBuf))
  1763. return false;
  1765. }
  1766. else
  1767. {
  1768. memset(pszBuf, 0xff, m_piece_length);
  1770. if (!_WriteIndexData(pszBuf, (BLONG)m_piece_length * n, _piecelen(n)))
  1771. return false;
  1772. }
  1774. // allocate done.
  1775. m_mPlaces[n] = n;
  1777. return true;
  1778. }
  1780. bool CStorageWrapperEx::_waspre(int iIndex)
  1781. {
  1782. return m_pStorage->was_preallocated((BLONG)iIndex * m_piece_length, _piecelen(iIndex));
  1783. }
  1785. void CStorageWrapperEx::markgot(long iPiece, long lPos)
  1786. {
  1787. m_mPlaces[iPiece] = lPos;
  1788. m_vHave[iPiece] = true;
  1789. m_lAmountLeft -= _piecelen(iPiece);
  1790. m_lAmountInactive -= _piecelen(iPiece);
  1791. m_vInactiveRequests[iPiece].clear();
  1792. m_vWasChecked[iPiece] = m_bCheckHashes;
  1793. m_lStatNumfound ++;
  1794. }
  1796. long CStorageWrapperEx::_piecelen(int iPiece)
  1797. {
  1798. if (iPiece < (m_vHashs.size() - 1))
  1799. return m_piece_length;
  1801. return m_lTotalLength - ((BLONG)iPiece * m_piece_length);
  1802. }
  1804. void printHave(long x)
  1805. {
  1806. TRACE("%d, ", x);
  1807. }
  1809. void printPlace(pair<long, long> p)
  1810. {
  1811. TRACE("(%d, %d)", p.first, p.second);
  1812. }
  1814. void CStorageWrapperEx::ShowDetailsTest()
  1815. {
  1816. TRACE("rn places : {");
  1817. for_each(m_mPlaces.begin(), m_mPlaces.end(), printPlace);
  1818. TRACE("}rn");
  1820. TRACE("rn have : {");
  1821. for_each(m_vHave.begin(), m_vHave.end(), printHave);
  1822. TRACE("}rn");
  1824. TRACE("rn m_vHoles: {");
  1825. for_each(m_vHoles.begin(), m_vHoles.end(), printHave);
  1826. TRACE("}rn");
  1829. TRACE("m_lAmountLeft : %d rn",m_lAmountLeft);
  1830. TRACE("m_lAmountInactive : %d rn",m_lAmountInactive);
  1831. }
  1835. /*
  1836. bool CStorageWrapperEx::_piece_came_in(long index, char *pPieceBuf, long begin,  long length)
  1837. {
  1838. char* pszBuf = new char[m_piece_length];
  1839. auto_ptr<char> aszBuf(pszBuf);
  1841. if (m_vHoles.empty())
  1842. {
  1843. assert(false);
  1844. return false;
  1845. }
  1848. //////////////////////////////////////////////////////////////
  1849. // Get hole in needed files 
  1850. //
  1851. /*
  1852. // const int n = m_vHoles[0];
  1853. // m_vHoles.erase(m_vHoles.begin());
  1855. int iHoleIndex = -1;
  1856. if (!IsUnNeededIndex(index))
  1857. {
  1858. for (int ih =0; ih<m_vHoles.size(); ih++)
  1859. {
  1860. if (!IsUnNeededIndex(m_vHoles[ih]))
  1861. {
  1862. iHoleIndex = m_vHoles[ih];
  1863. m_vHoles.erase(m_vHoles.begin() + ih);
  1864. break;
  1865. }
  1866. }
  1867. }
  1868. else
  1869. {
  1870. int iHoleIndex = m_vHoles[0];
  1871. m_vHoles.erase(m_vHoles.begin());
  1872. }
  1874. // get hole fail.
  1875. if (iHoleIndex < 0)
  1876. {
  1877. int iHoleIndex = m_vHoles[0];
  1878. m_vHoles.erase(m_vHoles.begin());
  1880. TRACE("rn***** get hole fail ******rn");
  1881. assert(false);
  1882. }
  1884. const int n = iHoleIndex;
  1887. map<long, long>::iterator iter = m_mPlaces.find(n);
  1889. // The new hole poped is needed by item in temps.
  1890. if (iter != m_mPlaces.end()) 
  1891. {
  1892. // Move data from temp to split newly created from holes.
  1893. long lOldPos = (*iter).second;
  1895. if (!m_pStorage->read(pszBuf, m_piece_length * lOldPos, _piecelen(n)))
  1896. return false;
  1898. if (!m_pStorage->write(pszBuf, m_piece_length * n, _piecelen(n)))
  1899. return false;
  1901. CheckAfterMoveing(n, pszBuf);
  1902. m_mPlaces[n] = n;
  1905. // Don't move, just specify the index item in the split newly created from holes.
  1906. if (index == lOldPos || 
  1907. find(m_vHoles.begin(), m_vHoles.end(), index) != m_vHoles.end())
  1908. {
  1909. m_mPlaces[index] = lOldPos;
  1910. }
  1911. else // Move data from split which take the place of index item.
  1912. {
  1913. long p = 0;
  1914. for (map<long, long>::iterator j = m_mPlaces.begin(); j != m_mPlaces.end(); j++)
  1915. {
  1916. if ((*j).second == index)
  1917. {
  1918. p = (*j).first;
  1919. break;
  1920. }
  1921. }
  1922. if (j == m_mPlaces.end())
  1923. {
  1924. assert(false);
  1925. return false;
  1926. }
  1928. if (!m_pStorage->read(pszBuf, m_piece_length * index, _piecelen(p)))
  1929. return false;
  1931. if (!m_pStorage->write(pszBuf, m_piece_length * lOldPos, _piecelen(p)))
  1932. return false;
  1934. m_mPlaces[p] = lOldPos;
  1935. m_mPlaces[index] = index;
  1936. }
  1938. }
  1939. else if (index == n || // index item out of space.
  1940. find(m_vHoles.begin(), m_vHoles.end(), index) != m_vHoles.end())
  1941. {
  1942. memset(pszBuf, 0xff, _piecelen(n));
  1943. if (!m_pStorage->write(pszBuf, m_piece_length * n, _piecelen(n)))
  1944. return false;
  1946. m_mPlaces[index] = n;
  1947. }
  1948. else // Move item in index space to hole poped. Insert index item in space allocated. 
  1949. {
  1950. long p = 0;
  1951. for (map<long, long>::iterator j = m_mPlaces.begin(); j != m_mPlaces.end(); j++)
  1952. {
  1953. if ((*j).second == index)
  1954. {
  1955. p = (*j).first;
  1956. break;
  1957. }
  1958. }
  1959. if (j == m_mPlaces.end())
  1960. {
  1961. assert(false);
  1962. return false;
  1963. }
  1965. if (!m_pStorage->read(pszBuf, m_piece_length * index, _piecelen(p)))
  1966. return false;
  1968. if (!m_pStorage->write(pszBuf, m_piece_length * n, _piecelen(p)))
  1969. return false;
  1971. m_mPlaces[p] = n;
  1972. m_mPlaces[index] = index;
  1974. }// endif hole pop
  1975. }
  1976. //*/
  1980. /*
  1981. long CStorageWrapperEx::_GetMinHolesIndex(const long index)
  1982. {
  1983. if (m_vRangeHoles.size() <= 0)
  1984. {
  1985. assert(false);
  1986. return -1;
  1987. }
  1989. for (int i=0; i<m_vRangeHoles.size(); i++)
  1990. {
  1991. if (index < m_vRangeHoles[i])
  1992. {
  1993. assert(i > 0);
  1994. return m_vRangeHoles[i - 1];
  1995. }
  1996. }
  1998. return m_vRangeHoles[m_vRangeHoles.size() - 1];
  1999. // assert(false);
  2000. return -1;
  2001. }
  2003. CSize CStorageWrapperEx::_GetFileOffset(const long index)
  2004. {
  2005. assert(m_vRangeHoles.size() == m_vFileOffset.size());
  2007. for (int i=0; i<m_vRangeHoles.size(); i++)
  2008. {
  2009. if (index >= m_vRangeHoles[i])
  2010. {
  2011. if (i >= (m_vRangeHoles.size()-1))
  2012. return CSize(-1, -1);
  2013. return CSize (m_vRangeHoles[i+1], m_vFileOffset[i + 1]);
  2014. }
  2015. }
  2017. assert(false);
  2018. return -1;
  2019. }
  2020. //*/