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

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

P2P编程

开发平台：

Visual C++

SingleDownload.cpp：源码内容
  1. // SingleDownload.cpp: implementation of the CSingleDownload class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "testbt.h"
  7. #include "SingleDownload.h"
  10. #include "Downloader.h"
  11. #include "PiecePicker.h"
  12. #include "StorageWrapper.h"
  13. #include "Connection.h"
  14. #include "RateMeasure.h"
  16. #include "DownloaderFeedback.h"
  18. #ifdef _DEBUG
  19. #undef THIS_FILE
  20. static char THIS_FILE[]=__FILE__;
  21. #define new DEBUG_NEW
  22. #endif
  24. bool bitfield_to_booleans(memstream& membitfield, long l, memstream& memRet);
  25.  
  26. //////////////////////////////////////////////////////////////////////
  27. // Construction/Destruction
  28. //////////////////////////////////////////////////////////////////////
  30. CSingleDownload::CSingleDownload(CDownloaderFeedback* pDownloaderFeedback, CDownloader* pDownloader, CConnection* pConnection)
  31. :m_measure(pDownloader->m_lMaxRatePeriod)
  32. {
  33. m_pDownloader = pDownloader;
  34. m_pConnection = pConnection;
  36. m_bChoked = true;
  37. m_bInterested = false;
  38. m_tLast = 0;
  40. for (int i=0; i<pDownloader->m_lNumPieces; i++)
  41. m_vHave.push_back(false);
  43. // for endgame.
  44. m_bEndgame = false;
  45. m_lHave = 0;
  47. // for feedback
  48. m_pDownloaderFeedback = pDownloaderFeedback;
  49. m_pConnection->GetIP(m_lAddr, m_sPort);
  50. }
  52. CSingleDownload::~CSingleDownload()
  53. {
  55. }
  57. void CSingleDownload::disconnected()
  58. {
  59. if (m_bEndgame)
  60. {
  61. // disconnected_end();
  62. // return ;
  63. }
  65. vector<CSingleDownload*>::iterator it = 
  66. find(m_pDownloader->m_vDownloads.begin(), m_pDownloader->m_vDownloads.end(), this);
  67. assert(it != m_pDownloader->m_vDownloads.end());
  69. m_pDownloader->m_vDownloads.erase(it);
  71. for (int i=0; i<m_vHave.size(); i++)
  72. {
  73. if (m_vHave[i])
  74. m_pDownloader->m_pPicker->lost_have(i);
  75. }
  77. if (m_bEndgame) return;
  79. _letgo();
  80. }
  82. void CSingleDownload::_letgo()
  83. {
  84. vector<long> vHit;
  85. for (int i=0; i<m_vActiveRequests.size(); i++)
  86. {
  87. CRequestsItem& item = m_vActiveRequests[i];
  88. bool bBefore = m_pDownloader->m_pstrorage->do_I_have_requests(item.m_index);
  89. m_pDownloader->m_pstrorage->request_lost(item.m_index, item.m_begin, item.m_length);
  90. if (!bBefore)
  91. vHit.push_back(item.m_index);
  92. }
  94. m_vActiveRequests.erase(m_vActiveRequests.begin(), m_vActiveRequests.end());
  96. if (vHit.size() > 0)
  97. {
  98. for (i=0; i<m_pDownloader->m_vDownloads.size(); i++)
  99. {
  100. m_pDownloader->m_vDownloads[i]->_check_interest(vHit);
  101. m_pDownloader->m_vDownloads[i]->download_more(vHit);
  102. }
  103. }
  104. }
  106. void CSingleDownload::got_choke()
  107. {
  108. if (m_bEndgame)
  109. {
  110. got_choke_end();
  111. return ;
  112. }
  114. // ShowMessage(m_pConnection->m_pEConnection, "got_choke()");
  115. m_pDownloaderFeedback->ShowSocketMessage(m_lAddr, m_sPort, "got_choke()");
  116. if (!m_bChoked)
  117. {
  118. m_bChoked = true;
  119. _letgo();
  120. }
  121. }
  123. void CSingleDownload::got_unchoke()
  124. {
  125. if (m_bEndgame)
  126. {
  127. got_unchoke_end();
  128. return ;
  129. }
  131. // ShowMessage(m_pConnection->m_pEConnection, "got_unchoke()");
  132. m_pDownloaderFeedback->ShowSocketMessage(m_lAddr, m_sPort, "got_unchoke()");
  134. if (m_bChoked)
  135. {
  136. m_bChoked = false;
  137. download_more();
  138. }
  139. }
  141. void CSingleDownload::got_have(long index)
  142. {
  143. if (m_bEndgame)
  144. {
  145. got_have_end(index);
  146. return;
  147. }
  149. if (m_vHave[index])
  150. return;
  152. m_lHave ++;
  153. assert(m_lHave <= m_vHave.size());
  155. m_vHave[index] = true;
  156. m_pDownloader->m_pPicker->got_have(index);
  157. m_vNewHave.push_back(index);
  160. vector<long> vHit;
  161. vHit.push_back(index);
  162. _check_interest(vHit);
  163. download_more(vHit);
  166. char szText[100] = {0};
  167. sprintf(szText, "got_have() : index = %d, ", index);
  168. // ShowMessage(m_pConnection->m_pEConnection, szText);
  169. m_pDownloaderFeedback->ShowSocketMessage(m_lAddr, m_sPort, szText);
  170. }
  172. void CSingleDownload::got_have_bitfield(vector<bool>& vHave)
  173. {
  174. if (m_bEndgame)
  175. {
  176. got_have_bitfield_end(vHave);
  177. return;
  178. }
  180. assert(vHave.size() == m_pDownloader->m_lNumPieces);
  182. for (int i=0; i<vHave.size(); i++)
  183. m_vHave[i] = vHave[i];
  185. vector<long> vHit;
  186. for (i=0; i<m_vHave.size(); i++)
  187. {
  188. if (m_vHave[i])
  189. {
  190. m_pDownloader->m_pPicker->got_have(i);
  191. m_vNewHave.push_back(i);
  193. vHit.push_back(i);
  194. m_lHave++;
  195. assert(m_lHave <= m_vHave.size());
  196. }
  197. }
  199. _check_interest(vHit);
  200. download_more();
  202. // ShowMessage(m_pConnection->m_pEConnection, "got_have_bitfield()");
  203. m_pDownloaderFeedback->ShowSocketMessage(m_lAddr, m_sPort, "got_have_bitfield()");
  204. }
  207. void CSingleDownload::_check_interest(vector<long>& vHit)
  208. {
  209. if (m_bInterested)
  210. return ;
  212. for (int i=0; i<vHit.size(); i++)
  213. {
  214. long index = vHit[i];
  215. if (m_vHave[index] && m_pDownloader->m_pstrorage->do_I_have_requests(index))
  216. {
  217. m_pConnection->send_interested();
  218. m_bInterested = true;
  219. break;
  220. }
  221. }
  222. }
  225. void CSingleDownload::_lost_interest(vector<long>& vHit)
  226. {
  227. if ( (!m_bInterested) || m_vActiveRequests.size() > 0)
  228. return;
  230. for (int i=0; i<vHit.size(); i++)
  231. {
  232. long index = vHit[i];
  233. if (m_vHave[index])
  234. break;
  235. }
  237. // can't find
  238. if (i == vHit.size())
  239. return;
  241. for (i=0; i<m_vHave.size(); i++)
  242. if (m_vHave[i] && m_pDownloader->m_pstrorage->do_I_have_requests(i))
  243. return;
  245. m_bInterested = false;
  246. m_pConnection->send_not_interested();
  248. }
  250. void CSingleDownload::download_more( vector<long>& vPieces)
  251. {
  252. assert(!m_bEndgame);
  254. if (m_bChoked || (m_vActiveRequests.size() >= m_pDownloader->m_lBacklog) || 
  255. m_pConnection->IsPause())
  256. return;
  258. if (vPieces.size() <= 0)
  259. vPieces = m_pDownloader->m_pPicker->GetResult();
  261. vector<long> vHit;
  262. _d(vPieces, vHit);
  264. if (vHit.size() > 0)
  265. {
  266. for (int i=0; i<m_pDownloader->m_vDownloads.size(); i++)
  267. {
  268. m_pDownloader->m_vDownloads[i]->_lost_interest(vHit);
  269. }
  270. }
  271. }
  273. void CSingleDownload::_d(vector<long>&vPieces, vector<long>& vHit)
  274. {
  275. for (int i=0; i<vPieces.size(); i++)
  276. {
  277. long index = vPieces[i];
  278. if (m_vHave[index])
  279. {
  280. while(m_pDownloader->m_pstrorage->do_I_have_requests(index))
  281. {
  282. long begin = 0, length = 0;
  283. m_pDownloader->m_pstrorage->new_request(index, begin, length);
  284. m_vActiveRequests.push_back(CRequestsItem(index, begin, length));
  285. m_pConnection->send_request(index, begin, length);
  287. char szText[100] = {0};
  288. sprintf(szText, "send request () index = %d, begin = %d, length = %d", index, begin, length);
  289. // ShowMessage(m_pConnection->m_pEConnection, szText);
  290. m_pDownloaderFeedback->ShowSocketMessage(m_lAddr, m_sPort, szText);
  293. if (!m_pDownloader->m_pstrorage->do_I_have_requests(index))
  294. vHit.push_back(index);
  295. if (m_vActiveRequests.size() >= m_pDownloader->m_lBacklog)
  296. return;
  297. }
  298. }
  299. }
  301. }
  304. bool CSingleDownload::got_piece(long index, long begin, memstream& memPiece)
  305. {
  306. if (m_bEndgame)
  307. {
  308. return got_piece_end(index, begin, memPiece);
  309. }
  311. char szText[100] = {0};
  312. sprintf(szText, "got_piece() : index = %d, begin = %d, length = %d", index, begin, memPiece.size());
  313. // ShowMessage(m_pConnection->m_pEConnection, szText);
  314. m_pDownloaderFeedback->ShowSocketMessage(m_lAddr, m_sPort, szText);
  316. bool bfind = false;
  317. for (int i=0; i<m_vActiveRequests.size(); i++)
  318. {
  319. CRequestsItem& item = m_vActiveRequests[i];
  320. if (item.m_index == index && item.m_begin == begin && item.m_length == memPiece.size())
  321. {
  322. m_vActiveRequests.erase(m_vActiveRequests.begin() + i);
  323. bfind = true;
  324. break;
  325. }
  326. }
  327. if (!bfind)
  328. {
  329. // assert(bfind);
  330. return false;
  331. }
  334. time(&m_tLast);
  335. m_measure.update_rate(memPiece.size());
  336. m_pDownloader->m_pDownMeasure->update_rate(memPiece.size());
  337. m_pDownloader->m_pPicker->came_in(index);
  338. m_pDownloader->m_pstrorage->piece_came_in(index, memPiece, begin, memPiece.size());
  339. m_pDownloader->m_pRateMeasure->data_came_in(memPiece.size());
  340. if (m_pDownloader->m_pstrorage->do_I_have(index))
  341. {
  342. sprintf(szText, "complete : index = %d", index);
  343. // ShowMessage(m_pConnection->m_pEConnection, szText);
  344. m_pDownloaderFeedback->ShowSocketMessage(m_lAddr, m_sPort, szText);
  346. m_pDownloader->m_pPicker->complete(index);
  347. }
  348. download_more();
  349. if (m_vActiveRequests.size() <= 0)
  350. {
  351. m_bInterested = false;
  352. m_pConnection->send_not_interested();
  353. }
  355. return m_pDownloader->m_pstrorage->do_I_have(index);
  356. }
  358. long CSingleDownload::get_rate()
  359. {
  360. return m_measure.get_rate();
  361. }
  363. long CSingleDownload::get_total()
  364. {
  365. return m_measure.get_total();
  366. }
  368. bool CSingleDownload::is_snubbed()
  369. {
  370. time_t t;
  371. time(&t);
  372. if (t < m_tLast)
  373. {
  374. assert(false);
  375. m_tLast = t;
  376. }
  378. return ((t - m_tLast) > m_pDownloader->m_lSnubTime);
  379. }
  381. bool CSingleDownload::is_choked()
  382. {
  383. return m_bChoked;
  384. }
  386. bool CSingleDownload::is_interested()
  387. {
  388. return m_bInterested;
  389. }
  391. float CSingleDownload::GetHaveCountPercent()
  392. {
  393. if (m_vHave.size() <= 0)
  394. {
  395. assert(false);
  396. return 0;
  397. }
  399. float lPer = (float)m_lHave/m_vHave.size();
  400. return lPer;
  401. }
  403. long CSingleDownload:: get_have_count() const
  404. {
  405. return m_vHave.size();
  406. }
  408. void CSingleDownload:: get_have(vector<bool>& vHave) 
  409. {
  410. vHave = m_vHave;
  411. m_vNewHave.clear();
  412. }
  414. void CSingleDownload:: get_new_have(vector<bool>& vHave) 
  415. {
  416. for (int i=0; i<m_vNewHave.size();i++)
  417. {
  418. assert(m_vNewHave[i] < vHave.size());
  419. vHave[m_vNewHave[i]] = true;
  420. }
  421. m_vNewHave.clear();
  422. }
  423. //////////////////////////////////////////////////////////////////////////
  424. // for end game.
  426. void CSingleDownload::cancel_endgame()
  427. {
  428. assert(m_bEndgame);
  429. m_bEndgame = false;
  430. m_vActiveRequests.clear();
  431. }
  433. void CSingleDownload::make_endgame(vector<CRequestsItem>& vRequests)
  434. {
  435. assert(!m_bEndgame);
  436. m_bEndgame = true;
  438. for (int i=0; i<m_vActiveRequests.size(); i++)
  439. vRequests.push_back(m_vActiveRequests[i]);
  441. m_lHave = 0;
  442. for (i=0; i<m_vHave.size(); i++)
  443. if (m_vHave[i])
  444. m_lHave++;
  446. // ShowMessage(m_pConnection->m_pEConnection, "***************rnmake_endgame()");
  447. m_pDownloaderFeedback->ShowSocketMessage(m_lAddr, m_sPort, "***************rnmake_endgame()");
  448. }
  450. void CSingleDownload::mak_endgameflush()
  451. {
  452. if (m_bChoked)
  453. return;
  455. random_shuffle(m_pDownloader->m_vRequests.begin(), m_pDownloader->m_vRequests.end());
  457. for (int i=0; i<m_pDownloader->m_vRequests.size(); i++)
  458. {
  459. CRequestsItem& item = m_pDownloader->m_vRequests[i];
  461. bool bfind = false;
  462. for (int j=0; j<m_vActiveRequests.size(); j++)
  463. {
  464. /*if(item.m_index == m_vActiveRequests[j].m_index && 
  465. item.m_begin == m_vActiveRequests[j].m_begin && 
  466. item.m_length== m_vActiveRequests[j].m_length)
  467. //*/
  468. if (item == m_vActiveRequests[j])
  469. {
  470. bfind = true;
  471. break;
  472. }
  473. }
  474. if (bfind) continue;
  476. if (m_vHave[item.m_index])
  477. {
  478. send_request_end(item.m_index, item.m_begin, item.m_length);
  479. }
  480. }
  481. }
  483. void CSingleDownload::disconnected_end()
  484. {
  485. vector<CSingleDownload*>::iterator it = 
  486. find(m_pDownloader->m_vDownloads.begin(), m_pDownloader->m_vDownloads.end(), this);
  487. assert(it != m_pDownloader->m_vDownloads.end());
  488. m_pDownloader->m_vDownloads.erase(it);
  489. }
  491. void CSingleDownload::got_unchoke_end()
  492. {
  493. // ShowMessage(m_pConnection->m_pEConnection, "got_unchoke_end()");
  494. m_pDownloaderFeedback->ShowSocketMessage(m_lAddr, m_sPort, "got_unchoke_end()");
  496. if (!m_bChoked) return;
  497. m_bChoked = false;
  499. if (!m_bInterested) return;
  501. random_shuffle(m_pDownloader->m_vRequests.begin(), m_pDownloader->m_vRequests.end());
  502. for (int i=0; i<m_pDownloader->m_vRequests.size(); i++)
  503. {
  504. CRequestsItem& item = m_pDownloader->m_vRequests[i];
  505. if (m_vHave[item.m_index])
  506. {
  507. send_request_end(item.m_index, item.m_begin, item.m_length);
  508. }
  509. }
  510. }
  512. void CSingleDownload::got_choke_end()
  513. {
  514. // ShowMessage(m_pConnection->m_pEConnection, "got_choke_end()");
  515. m_pDownloaderFeedback->ShowSocketMessage(m_lAddr, m_sPort, "got_choke_end()");
  517. m_bChoked = true;
  518. }
  520. void CSingleDownload::send_request_end(long index, long begin, long length)
  521. {
  522. char szText[100] = {0};
  523. sprintf(szText, "send_request_end() : index = %d, begin = %d, length = %d", index, begin, length);
  524. // ShowMessage(m_pConnection->m_pEConnection, szText);
  525. m_pDownloaderFeedback->ShowSocketMessage(m_lAddr, m_sPort, szText);
  527. if (!m_bInterested)
  528. {
  529. m_bInterested = true;
  530. m_pConnection->send_interested();
  531. }
  532. m_pConnection->send_request(index, begin, length);
  533. }
  535. bool CSingleDownload::got_piece_end(long index,long begin, memstream& memPiece)
  536. {
  537. char szText[100] = {0};
  538. sprintf(szText, "got_piece_end() : index = %d, begin = %d, length = %d", index, begin, memPiece.size());
  539. // ShowMessage(m_pConnection->m_pEConnection, szText);
  540. m_pDownloaderFeedback->ShowSocketMessage(m_lAddr, m_sPort, szText);
  542. bool bfind = false;
  543. for (int i=0; i<m_pDownloader->m_vRequests.size(); i++)
  544. {
  545. CRequestsItem& item = m_pDownloader->m_vRequests[i];
  546. if (item.m_index == index && item.m_begin == begin && item.m_length == memPiece.size())
  547. {
  548. m_pDownloader->m_vRequests.erase(m_pDownloader->m_vRequests.begin() + i);
  549. bfind = true;
  550. break;
  551. }
  552. }
  553. if (!bfind)
  554. return false;
  556. //*(memPiece + 1) = 30; // test crash the piece to test data_flunk()
  558. time(&m_tLast);
  559. m_measure.update_rate(memPiece.size());
  560. m_pDownloader->m_pDownMeasure->update_rate(memPiece.size());
  561. m_pDownloader->m_pPicker->came_in(index);
  562. m_pDownloader->m_pstrorage->piece_came_in(index, memPiece, begin, memPiece.size());
  563. m_pDownloader->m_pRateMeasure->data_came_in(memPiece.size());
  565. // piece fail. rerequest.
  566. if (m_pDownloader->m_pstrorage->do_I_have_requests(index))
  567. {
  568. vector<CRequestsItem> vRequests;
  569. while (m_pDownloader->m_pstrorage->do_I_have_requests(index))
  570. {
  571. long begina = 0, lengtha = 0;
  572. m_pDownloader->m_pstrorage->new_request(index, begina, lengtha);
  573. vRequests.push_back(CRequestsItem(index, begina, lengtha));
  574. m_pDownloader->m_vRequests.push_back(CRequestsItem(index, begina, lengtha));
  575. }
  577. for (int i=0; i<m_pDownloader->m_vDownloads.size(); i++)
  578. {
  579. CSingleDownload* pd = m_pDownloader->m_vDownloads[i];
  580. if (!pd->is_choked() && pd->m_vHave[index])
  581. {
  582. random_shuffle(vRequests.begin(), vRequests.end());
  584. for (int j=0; j<vRequests.size(); j++)
  585. {
  586. // if(pd == this || vRequests[j].m_begin != begin)
  587. pd->send_request_end(vRequests[j].m_index, vRequests[j].m_begin, vRequests[j].m_length); 
  588. }
  589. }
  590. }
  591. return false;
  592. }
  594. // got the fraction of piece. cancel the fraction from other peers.
  595. for (i=0; i<m_pDownloader->m_vDownloads.size(); i++)
  596. {
  597. CSingleDownload* pd = m_pDownloader->m_vDownloads[i];
  598. pd->SendCancel(index, begin, memPiece.size(), this);
  599. /*
  600. if (!pd->is_choked() && pd->m_vHave[index] && pd != this)
  601. pd->m_pConnection->send_cancel(index, begin, memPiece.size());
  602. //*/
  603. }
  605. // if there are other fractions in requestment, don't send have message.
  606. for(i=0; i<m_pDownloader->m_vRequests.size(); i++)
  607. {
  608. if (m_pDownloader->m_vRequests[i].m_index == index)
  609. return false;
  610. }
  612. // **
  613. // have completed all the fractions of the piece.
  614. m_pDownloader->m_pPicker->complete(index);
  615. sprintf(szText, "complete endgame: index = %d", index);
  616. m_pDownloaderFeedback->ShowSocketMessage(m_lAddr, m_sPort, szText);
  619. // check all the downloads which is waiting for the piece that 
  620. // after the piece was completed, is there still active waiting.
  621. // if yes break, otherwise make it notinterested.
  622. for (i=0; i<m_pDownloader->m_vDownloads.size(); i++)
  623. {
  624. CSingleDownload* pd = m_pDownloader->m_vDownloads[i];
  625. if (pd->m_vHave[index])
  626. {
  627. bool bStillActive = false;
  628. for (int j=0; j<m_pDownloader->m_vRequests.size(); j++)
  629. {
  630. long lindexa = m_pDownloader->m_vRequests[j].m_index;
  631. if (pd->m_vHave[lindexa])
  632. {
  633. bStillActive = true;
  634. break;
  635. }
  636. }
  638. if (!bStillActive)
  639. {
  640. pd->m_bInterested = false;
  641. pd->m_pConnection->send_not_interested();
  642. }
  644. }
  645. }
  647. // check all the downloads, if the the peer of one download completed download then close the connection.
  648. if (m_pDownloader->m_vRequests.size() <= 0)
  649. {
  650. vector<CSingleDownload*> vcopy = m_pDownloader->m_vDownloads;
  651. for (i=0; i<vcopy.size(); i++)
  652. {
  653. if (vcopy[i]->m_lHave >= vcopy[i]->m_vHave.size())
  654. vcopy[i]->m_pConnection->Close();
  655. }
  656. }
  658. return true;
  659. }
  661. void CSingleDownload::got_have_end(long index)
  662. {
  663. assert(index >=0 && index <= m_vHave.size());
  665. if (m_vHave[index])
  666. return;
  668. m_vHave[index] = true;
  669. m_lHave++;
  670. assert(m_lHave <= m_vHave.size());
  671. m_pDownloader->m_pPicker->got_have(index);
  672. m_vNewHave.push_back(index);
  674. if (m_pDownloader->m_pstrorage->do_I_have(index))
  675. return;
  677. // todo:should shuffle here.
  678. random_shuffle(m_pDownloader->m_vRequests.begin(), m_pDownloader->m_vRequests.end());
  680. // if the have index is in requrements, then request all the fractions of the have piece.
  681. for (int i=0; i<m_pDownloader->m_vRequests.size(); i++)
  682. {
  683. CRequestsItem& item = m_pDownloader->m_vRequests[i];
  684. if (item.m_index == index)
  685. send_request_end(item.m_index, item.m_begin, item.m_length);
  686. }
  688. // if download completed, and peer also have all the pieces, then close the connection.
  689. if (m_pDownloader->m_vRequests.size() <= 0 && m_lHave >= m_vHave.size())
  690. {
  691. m_pConnection->Close();
  692. return;
  693. }
  696. char szText[100] = {0};
  697. sprintf(szText, "got_have_end() : index = %d, ", index);
  698. //  ShowMessage(m_pConnection->m_pEConnection, szText);
  699. m_pDownloaderFeedback->ShowSocketMessage(m_lAddr, m_sPort, szText);
  700. }
  702. void CSingleDownload::got_have_bitfield_end(vector<bool>& vHave)
  703. {
  704. assert(vHave.size() == m_pDownloader->m_lNumPieces);
  706. m_lHave = 0;
  708. for (int i=0; i<vHave.size(); i++)
  709. {
  710. m_vHave[i] = vHave[i];
  711. if (m_vHave[i])
  712. {
  713. m_lHave ++;
  714. assert(m_lHave <= m_vHave.size());
  715. m_pDownloader->m_pPicker->got_have(i);
  716. m_vNewHave.push_back(i);
  717. }
  719. }
  721. // todo:should shuffle here.
  722. random_shuffle(m_pDownloader->m_vRequests.begin(), m_pDownloader->m_vRequests.end());
  724. // if the have index is in requrements, then request all the fractions of the have piece.
  725. for (i=0; i<m_pDownloader->m_vRequests.size(); i++)
  726. {
  727. CRequestsItem& item = m_pDownloader->m_vRequests[i];
  728. if (m_vHave[item.m_index])
  729. send_request_end(item.m_index, item.m_begin, item.m_length);
  730. }
  732. // if download completed, and peer also have all the pieces, then close the connection.
  733. if (m_pDownloader->m_vRequests.size() <= 0 && m_lHave >= m_vHave.size())
  734. m_pConnection->Close();
  736. // ShowMessage(m_pConnection->m_pEConnection, "got_have_bitfield_end()");
  737. m_pDownloaderFeedback->ShowSocketMessage(m_lAddr, m_sPort, "got_have_bitfield_end()");
  738. }
  741. void CSingleDownload::SendCancel(long index, long begin, long length, CSingleDownload* pOwner)
  742. {
  743. for (int i=0; i<m_vActiveRequests.size(); i++)
  744. {
  745. CRequestsItem& item = m_vActiveRequests[i];
  746. if (item.m_index == index && 
  747. item.m_begin == begin && 
  748. item.m_length == length)
  749. {
  750. m_vActiveRequests.erase(m_vActiveRequests.begin() + i);
  751. break;
  752. }
  753. }
  755. if (!is_choked() && m_vHave[index] && pOwner!= this)
  756. m_pConnection->send_cancel(index, begin, length);
  757. }