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

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

P2P编程

开发平台：

Visual C++

Download.cpp：源码内容
  1. // Download.cpp: implementation of the CDownload class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "testBT.h"
  7. #include "Download.h"
  11. #include "val.h"
  12. #include "FileTorrent.h"
  14. #include "Storage.h"
  15. #include "StorageWrapper.h"
  16. #include "Rerequester.h"
  17. #include "RawServer.h"
  18. #include "Encrypter.h"
  19. #include "Connector.h"
  20. #include "PiecePicker.h"
  21. #include "RateMeasure.h"
  22. #include "Downloader.h"
  23. #include "Upload.h"
  24. #include "choker.h"
  25. #include "DownloaderFeedback.h"
  26. #include "SetupRegister.h"
  27. #include "FileDB.h"
  31. #ifdef _DEBUG
  32. #undef THIS_FILE
  33. static char THIS_FILE[]=__FILE__;
  34. #define new DEBUG_NEW
  35. #endif
  37. //////////////////////////////////////////////////////////////////////
  38. // Construction/Destruction
  39. //////////////////////////////////////////////////////////////////////
  41. void SingleDownloadTest();
  43. CDownload::CDownload()
  44. {
  45. m_bCheckHash = true;
  47. m_hevUnPause =  CreateEvent(0, true, true, 0);
  48. m_hThreadDone = CreateEvent(0, true, true, 0);
  49. m_hevDone = CreateEvent(0, true, false, 0);
  50. m_hCompleted = CreateEvent(0, true, false, 0);
  51. m_hThreadSafe = CreateEvent(0, true, false, 0);
  53. m_pdownloader = 0;
  54. m_pconncetorget = 0;
  55. m_pRequester = 0;
  56. m_pChoker = 0;
  57. m_pEncrypter = 0;
  59. GetSetupParameter();
  61. long ltime = 0;
  62. time(&ltime);
  63. srand(ltime);
  64. m_bClosing = false;
  65. }
  67. CDownload::~CDownload()
  68. {
  69. Close();
  70. assert(IsEventSet(m_hThreadDone));
  71. CloseHandle(m_hevDone);
  72. CloseHandle(m_hCompleted);
  73. CloseHandle(m_hThreadDone);
  74. CloseHandle(m_hThreadSafe);
  75. }
  77. void CDownload::GetSetupParameter()
  78. {
  79. g_defaults["max_uploads"] = _variant_t(4L); //the maximum number of uploads to allow at once.
  80. g_defaults["keepalive_interval"] = _variant_t(120L); //number of seconds to pause between sending keepalives
  81. g_defaults["download_slice_size"] = _variant_t(pow(2, 14)); //How many bytes to query for per request.
  82. g_defaults["request_backlog"] = _variant_t(5L); //how many requests to keep in a single pipe at once.
  83. g_defaults["max_message_length"] = _variant_t(pow(2, 23)); //maximum length prefix encoding you'll accept over the wire - larger values get the connection dropped.
  84. g_defaults["ip"] = _variant_t(""); //ip to report you have to the tracker.
  85. g_defaults["minport"] = _variant_t(6881L); //minimum port to listen on, counts up if unavailable
  86. g_defaults["maxport"] = _variant_t(6999L); //maximum port to listen on
  87. g_defaults["responsefile"] = _variant_t(""); //file the server response was stored in, alternative to url
  88. g_defaults["url"] = _variant_t(""); //alternative to responsefile
  89. g_defaults["saveas"] = _variant_t(""); //local file name to save the file as, null indicates query user
  90. g_defaults["timeout"] = _variant_t(300L); //time to wait between closing sockets which nothing has been received on
  91. g_defaults["timeout_check_interval"] = _variant_t(60L); //time to wait between checking if any connections have timed out
  92. g_defaults["max_slice_length"] = _variant_t(pow(2, 17)); //maximum length slice to send to peers, larger requests are ignored
  93. g_defaults["max_rate_period"] = _variant_t(3L); //maximum amount of time to guess the current rate estimate represents
  94. g_defaults["bind"] = _variant_t(""); //ip to bind to locally
  95. g_defaults["upload_rate_fudge"] = _variant_t(1L); //time equivalent of writing to kernel-level TCP buffer, for rate adjustment
  96. g_defaults["display_interval"] = _variant_t(5L); //time between updates of displayed information
  97. g_defaults["rerequest_interval"] = _variant_t(5*60L); //time to wait between requesting more peers
  98. g_defaults["min_peers"] = _variant_t(100L); //minimum number of peers to not do rerequesting
  99. g_defaults["http_timeout"] = _variant_t(60L); //number of seconds to wait before assuming that an http connection has timed out
  100. g_defaults["max_initiate"] = _variant_t(60L); //number of peers at which to stop initiating new connections
  101. g_defaults["check_hashes"] = _variant_t(1L); //whether to check hashes on disk
  102. g_defaults["max_upload_rate"] = _variant_t(0L); //maximum kB/s to upload at, 0 means no limit
  103. g_defaults["alloc_pause"] = _variant_t(3L); //seconds to wait before displaying allocation feedback
  104. g_defaults["snub_time"] = _variant_t(60L); //seconds to wait for data to come in over a connection before assuming it's semi-permanently choked
  105. g_defaults["spew"] = _variant_t(0L); //whether to display diagnostic info to stdout
  107. g_defaults["AllocSpeed"] = _variant_t(2L); //whether to display diagnostic info to stdout
  108. g_defaults["AllocType"] = _variant_t(0L); //whether to display diagnostic info to stdout
  109. g_defaults["FileOpenMax"] = _variant_t(0L); //whether to display diagnostic info to stdout
  110. g_defaults["SuperSeed"] = _variant_t(0L); //whether to display diagnostic info to stdout
  113. m_lUploadPeerMax = 4L;
  114. m_lUploadSpeedMax = 0;
  116. m_lConnectErrorMax = 200;
  117. m_lConnectIntval = 10;
  119. m_bLockFile = true;
  120. m_bLockFileWhileReading = false;
  122. m_bDoubleCheck = false;
  123. m_bTripleCheck = false;
  124. }
  126. void CDownload::SetParameter(CSetupRegister* pSetupRegister)
  127. {
  128. assert(pSetupRegister);
  129. assert(pSetupRegister->m_lAllocSpeed > 0 && pSetupRegister->m_lAllocSpeed <= 10);
  130. assert(pSetupRegister->m_eAllocType >= CStorageWrapperEx::eAllocNormal && 
  131. pSetupRegister->m_eAllocType <= CStorageWrapperEx::eAllocBackGound);
  132. assert(pSetupRegister->m_lFileOpenMax > 0 && pSetupRegister->m_lFileOpenMax < 250);
  134. g_defaults["minport"] = pSetupRegister->m_lPortMin;
  135. g_defaults["maxport"] = pSetupRegister->m_lPortMax;
  136. g_defaults["max_initiate"] = pSetupRegister->m_lPeersMax;
  137. g_defaults["min_peers"] = pSetupRegister->m_lPeersMin;
  138. g_defaults["display_interval"] = (long)(pSetupRegister->m_lDisplayItval);
  140. g_defaults["AllocSpeed"] = pSetupRegister->m_lAllocSpeed;
  141. g_defaults["AllocType"] = (long)pSetupRegister->m_eAllocType;
  142. g_defaults["FileOpenMax"] = pSetupRegister->m_lFileOpenMax;
  143. g_defaults["SuperSeed"] = pSetupRegister->m_bSuperSeed;
  145. m_lConnectErrorMax = pSetupRegister->m_lConnectErrorMax;
  146. m_lConnectIntval = pSetupRegister->m_lConnectIntval;
  148. if (pSetupRegister->m_lSendServerIP != INADDR_NONE )
  149. {
  150. in_addr inaddress;
  151. inaddress.S_un.S_addr = pSetupRegister->m_lSendServerIP;
  152. g_defaults["ip"] = inet_ntoa(inaddress);
  153. }
  155. switch (pSetupRegister->m_eFileLock)
  156. {
  157. case CSetupRegister::eFileUnlock:
  158. {
  159. m_bLockFile = false;
  160. m_bLockFileWhileReading = false;
  161. }
  162. break;
  163. case CSetupRegister::eFileWriteLock:
  164. {
  165. m_bLockFile = true;
  166. m_bLockFileWhileReading = false;
  167. }
  168. break;
  169. case CSetupRegister::eFileLock:
  170. {
  171. m_bLockFile = true;
  172. m_bLockFileWhileReading = true;
  173. }
  174. break;
  175. }
  177. switch (pSetupRegister->m_eExtraCheck)
  178. {
  179. case CSetupRegister::eNoExtraCheck:
  180. {
  181. m_bDoubleCheck = false;
  182. m_bTripleCheck = false;
  183. }
  184. break;
  186. case CSetupRegister::eDoubleCheck:
  187. {
  188. m_bDoubleCheck = true;
  189. m_bTripleCheck = false;
  190. }
  191. break;
  193. case CSetupRegister::eTripleCheck:
  194. {
  195. m_bDoubleCheck = true;
  196. m_bTripleCheck = true;
  197. }
  198. break;
  199. }
  201. // m_bCompleteKeepSeed = pSetupRegister->m_bCompleteKeepSeed;
  203. /*
  204. if(pSetupRegister->m_lDownSpeed < CSpeedParameters::eSpeedModeAll && pSetupRegister->m_lDownSpeed >=0)
  205. {
  206. g_defaults["max_uploads"] = _variant_t(CSpeedParameters::m_lArrPeerVal[pSetupRegister->m_lDownSpeed]);
  207. g_defaults["max_upload_rate"] = _variant_t(CSpeedParameters::m_lArrSpeedVal[pSetupRegister->m_lDownSpeed]);
  208. }
  209. else
  210. assert(false);
  211. //*/
  213. }
  215. void CDownload::CloseDownload()
  216. {
  217. if (IsEventSet(m_hThreadDone))
  218. {
  219. assert(false);
  220. }
  222. m_bClosing = true;
  223. if (IsPause()) Pause(false);
  224. SetEvent(m_hevDone);
  225. return;
  226. }
  228. void CDownload::Close()
  229. {
  230. if (!IsEventSet(m_hThreadDone))
  231. {
  232. if (IsPause())
  233. Pause(false);
  235. SetEvent(m_hevDone);
  237. DWORD dwRet = WaitForSingleObject(m_hThreadDone, INFINITE);
  238. switch (dwRet)
  239. {
  240. case WAIT_OBJECT_0:
  241. break;
  242. case WAIT_TIMEOUT:
  243. break;
  244. }
  245. }
  246. }
  248. bool CDownload::CanSetRunParameters()
  249. {
  250. return IsEventSet(m_hThreadSafe);
  251. }
  253. void CDownload::SetUnNeededFilesInxs(const vector<CSize>& vUnNeededFileInxs)
  254. {
  255. bool bToPause = !IsPause();
  256. if (bToPause) Pause(true);
  258. _SetUnNeededFilesInxs(vUnNeededFileInxs);
  260. if (bToPause) Pause(false);
  261. }
  263. void CDownload::_SetUnNeededFilesInxs(const vector<CSize>& vUnNeededFileInxs)
  264. {
  265. if (!IsDownloading() || !CanSetRunParameters())
  266. {
  267. assert(false);
  268. return;
  269. }
  271. if (!IsEventSet(m_hThreadSafe))
  272. {
  273. Pause(false);
  274. return;
  275. }
  277. if (!m_pStorageWrapper)
  278. {
  279. assert(false);
  280. return;
  281. }
  282. m_pStorageWrapper->SetUnNeededFilesInxs(vUnNeededFileInxs);
  283. }
  285. void CDownload::SetRunParameters(long lMaxUploadSpeed, long lMaxUploads, 
  286.  long lCompleteKeepSeedHour, long lConnectErrorMax, 
  287.  long lConnectIntval,
  288.  long minpeers, long maxpeers)
  289. {
  290. bool bToPause = !IsPause();
  291. if (bToPause) Pause(true);
  293. ASSERT(maxpeers > minpeers);
  294. _SetRunParameters(lMaxUploadSpeed, lMaxUploads, lCompleteKeepSeedHour, lConnectErrorMax, lConnectIntval, minpeers, maxpeers);
  295. if (bToPause) Pause(false);
  296. }
  298. void CDownload::_SetRunParameters(long lMaxUploadSpeed, long lMaxUploads,
  299.   long lCompleteKeepSeedHour, long lConnectErrorMax, 
  300.   long lConnectIntval,
  301.   long minpeers, long maxpeers)
  302. {
  303. assert(lMaxUploads > 0 && lMaxUploadSpeed >= 0);
  305. if (!IsDownloading() || !CanSetRunParameters())
  306. {
  307. assert(false);
  308. return;
  309. }
  311. if (!IsEventSet(m_hThreadSafe))
  312. {
  313. Pause(false);
  314. return;
  315. }
  317. if (m_pChoker && m_pconncetorget && m_pRequester && m_pEncrypter)
  318. {
  319. m_pChoker->SetMaxUploads(lMaxUploads);
  320. m_pconncetorget->SetMaxUploadRate(lMaxUploadSpeed * 1024);
  321. m_DownloaderFeedback.SetCompleteKeepSeedHour(lCompleteKeepSeedHour);
  322. m_pRequester->SetConnectErrorMax(lConnectErrorMax, lConnectIntval, minpeers, maxpeers);
  323. m_pEncrypter->SetMaxPeers(maxpeers);
  324. }
  325. else
  326. {
  327. assert(false);
  328. }
  329. }
  331. void CDownload::Pause(bool bPause)
  332. {
  333. if (bPause == IsPause())
  334. {
  335. assert(false);
  336. return;
  337. }
  339. if (bPause)
  340. {
  341. ResetEvent(m_hevUnPause);
  342. }
  343. else
  344. {
  345. SetEvent(m_hevUnPause);
  346. }
  347. }
  349. bool CDownload::IsPause()
  350. {
  351. return !IsEventSet(m_hevUnPause);
  352. }
  354. bool CDownload::IsDownloading()
  355. {
  356. return !IsEventSet(m_hThreadDone);
  357. }
  359. bool CDownload::IsBad()
  360. {
  361. return m_DownloaderFeedback.IsBad();
  362. }
  364. void CDownload::PausePeer(CAddrPort addrPort, bool bPause)
  365. {
  366. bool bToPause = !IsPause();
  367. if (bToPause) Pause(true);
  369. _PausePeer(addrPort, bPause);
  371. if (bToPause) Pause(false);
  372. }
  374. void CDownload::_PausePeer(CAddrPort addrPort, bool bPause)
  375. {
  376. if (!IsDownloading() || !m_pconncetorget || !CanSetRunParameters())
  377. {
  378. assert(false);
  379. return;
  380. }
  382. m_pconncetorget->PausePeer(addrPort, bPause);
  383. }
  385. void CDownload::ClosePeer(CAddrPort addrPort)
  386. {
  387. bool bToPause = !IsPause();
  388. if (bToPause) Pause(true);
  390. _ClosePeer(addrPort);
  392. if (bToPause) Pause(false);
  393. }
  395. void CDownload::_ClosePeer(CAddrPort addrPort)
  396. {
  397. if (!IsDownloading() || !m_pconncetorget || !CanSetRunParameters())
  398. {
  399. assert(false);
  400. return;
  401. }
  402. m_pconncetorget->ClosePeer(addrPort);
  403. }
  405. void CDownload::PartCompleted()
  406. {
  407. // SetEvent(m_hCompleted);
  408. m_pStorage->SetReadOnly();
  409. }
  411. void CDownload::Completed()
  412. {
  413. SetEvent(m_hCompleted);
  414. m_pStorage->SetReadOnly();
  416. if (m_pRequester)
  417. m_pRequester->AnnounceEx(REQ_COMPLETED);
  419. // todo:
  420. // send http request stoped.
  421. }
  423. void CDownload::data_flunked(long lAmount)
  424. {
  425. if (!m_pratemeasure)
  426. {
  427. ASSERT(FALSE);
  428. return;
  429. }
  430. m_pratemeasure->data_rejected(lAmount);
  431. TRACE("rn**********data_flunked****************rn");
  432. // todo:
  433. // ratemeasure.data_reject();
  434. }
  436. string CDownload::GetBadMsg()
  437. {
  438. return m_DownloaderFeedback.GetBadMsg();
  439. }
  442. /******************************************************************************
  444. parameter:
  445. lUploadSpeedMax unit is k.
  447. ******************************************************************************/
  449. bool CDownload::DownloadEx(CSetupRegister* pSetupRegister, 
  450. string strTorrentFileName, string strSaveFileName, bool bCheckHash, 
  451. HTREEITEM curItem, HWND hFeedbackwnd, long lParam, const CFileDBItem* const pFileDBItem)
  452. {
  453. if (strTorrentFileName.empty() || strSaveFileName.empty())
  454. {
  455. assert(false);
  456. return false;
  457. }
  458. assert(curItem && hFeedbackwnd && pSetupRegister);
  460. /////////////////////////////////////////////////////////////
  461. // pass parameter.
  463. SetParameter(pSetupRegister);
  465. m_vUnNeededFileInxs = pFileDBItem->m_vUnneededFileInx;
  466. m_lUploadPeerMax = pFileDBItem->m_lUploadPeerMax;
  467. m_lUploadSpeedMax = pFileDBItem->m_lUploadSpeedMax * 1024;
  469. m_lConnectErrorMax = pFileDBItem->m_lConnectErrorMax;
  470. m_lConnectIntval = pFileDBItem->m_lConnectIntval;
  471. g_defaults["max_initiate"] = pFileDBItem->m_lPeersMax;
  472. g_defaults["min_peers"] = pFileDBItem->m_lPeersMin;
  474. //
  475. // CDownloaderFeedback setdownload
  476. //
  477. m_DownloaderFeedback.SetDownload(this, curItem, hFeedbackwnd, pFileDBItem->m_lCompleteKeepSeedHour, lParam);
  480. /////////////////////////////////////////////////////////////
  481. // CFileTorrent
  483. m_bCheckHash = bCheckHash;
  484. m_strSaveFileName = strSaveFileName;
  485. m_strTorrentFileName = strTorrentFileName;
  486. try
  487. {
  488. if (!m_fileTorrernt.OpenFile(m_strTorrentFileName, m_strSaveFileName))
  489. {
  490. m_DownloaderFeedback.SetBadMsg(m_fileTorrernt.GetBadMsg(), false);
  491. return false;
  492. }
  494. if (!m_fileTorrernt.CreateDir(m_strSaveFileName))
  495. {
  496. assert(false);
  497. return false;
  498. }
  499. }
  500. catch (string e)
  501. {
  502. m_DownloaderFeedback.SetBadMsg(e, false);
  503. return false;
  504. }
  506. assert(IsEventSet(m_hThreadDone));
  507. ResetEvent(m_hThreadDone);
  508. ResetEvent(m_hCompleted);
  509. ResetEvent(m_hevDone);
  511. DWORD dwThreadId = 0;
  512. ::CreateThread(0, 0, DownloadProc, this, 0, &dwThreadId);
  513. TRACE("rndownload thread = (%x)rn", dwThreadId);
  515. return true;
  516. }
  519. ///////////////////////////////////////////////////////////
  520. // download thread
  521. ///////////////////////////////////////////////////////////
  523. DWORD WINAPI CDownload::DownloadProc(void *pParam)
  524. {
  525. CDownload* pdownload = (CDownload* )pParam;
  526. pdownload->DownloadProcEx();
  527. return 0;
  528. }
  530. void CDownload::DownloadProcEx()
  531. {
  532. // init socket.
  533. WORD wVersionRequested;
  534. WSADATA wsaData;
  535. wVersionRequested = MAKEWORD( 2, 2 ); 
  536. int err = WSAStartup( wVersionRequested, &wsaData );
  537. if ( err != 0 ) 
  538. return;
  540. // _CrtMemState s1, s2, s3;
  541. // _CrtMemCheckpoint( &s1 );
  542. Download();
  544. /*
  545. _CrtMemCheckpoint( &s2 );
  547. if ( _CrtMemDifference( &s3, &s1, &s2) )
  548. {
  549. _CrtMemDumpStatistics( &s3 );
  550. TRACE("rnendrn");
  551. }
  552. //*/
  555. WSACleanup();
  557. // if (!IsEventSet(m_hevDone))
  558. m_DownloaderFeedback.QuitDownload();
  559. SetEvent(m_hThreadDone);
  560. }
  562. void CDownload::Download()
  563. {
  564. try
  565. {
  567. //
  568. // CFileTorrent 
  569. //
  570. CVal* pInfo = m_fileTorrernt.GetInfo();
  571. CVal* pResponse = m_fileTorrernt.GetResponse();
  572. if (!pResponse) 
  573. {
  574. assert(false);
  575. return;
  576. }
  577. vector<CFileInfo>& vFiles = m_fileTorrernt.GetFileInfo();
  578. memstream& memMyid = m_fileTorrernt.GetMyId();
  579. memstream& memInfohash = m_fileTorrernt.GetInfohash();
  580. vector<char*>& vPieces = m_fileTorrernt.GetPieces();
  581. long lNumPieces = vPieces.size();
  584. //
  585. // CDownloaderFeedback setdownload
  586. //
  587. // m_DownloaderFeedback.SetDownload(this);
  589. CDownloader download;
  591. //
  592. // middle layer
  593. //
  594. // CChoker choker(g_defaults["max_uploads"], m_hCompleted);
  595. CChoker choker(m_lUploadPeerMax, m_hCompleted);
  596. m_pChoker = &choker;
  598. CConnector m_connector(m_lUploadSpeedMax);
  599. m_pconncetorget = &m_connector;
  601. CRerequester requester(m_lConnectErrorMax, m_lConnectIntval, g_defaults["min_peers"], g_defaults["max_initiate"]);
  602. assert(!m_pRequester);
  603. m_pRequester = &requester;
  605. CEncrypter encrypter(g_defaults["max_initiate"]);
  606. m_pEncrypter = &encrypter;
  609. //
  610. // CStorageWrapper
  611. //
  612. CStorage storage;
  613. m_pStorage = &storage;
  614. if (!storage.Create(&m_DownloaderFeedback, vFiles, m_hevDone, g_defaults["FileOpenMax"], m_bLockFile, m_bLockFileWhileReading))
  615. return;
  617. CStorageWrapper storageWrapper(m_vUnNeededFileInxs);
  618. m_pStorageWrapper = &storageWrapper;
  620. // Make sure user can manipulate run parameter.
  621. SetEvent(m_hThreadSafe);
  623. storageWrapper.Create(&m_DownloaderFeedback, m_hevDone, m_hevUnPause, 
  624. &storage, &download, vPieces, m_bCheckHash,  (long)g_defaults["download_slice_size"], (*pInfo)["piece length"]->lVal, 
  625. (CStorageWrapperEx::eAllocType)((long)g_defaults["AllocType"]), 
  626. g_defaults["AllocSpeed"], m_bDoubleCheck, m_bTripleCheck);
  629. // notify the window check completed.
  630. if (!IsEventSet(m_hevDone))
  631. m_DownloaderFeedback.StorageCheckComplete();
  634. CPiecePicker piecepicker(lNumPieces);
  635. CMeasure upmeasure(g_defaults["max_rate_period"], g_defaults["upload_rate_fudge"]);
  636. CMeasure downmeasure(g_defaults["max_rate_period"]);
  637. CRateMeasure ratemeasure(storageWrapper.get_amount_left(), &storageWrapper);
  638. m_pratemeasure = &ratemeasure;
  640. download.Create(&m_DownloaderFeedback, &storageWrapper, &piecepicker, g_defaults["request_backlog"], 
  641. g_defaults["max_rate_period"], &downmeasure, lNumPieces, 
  642. g_defaults["snub_time"], &ratemeasure);
  643. m_pdownloader = &download;
  645. CUploader uploader(&m_DownloaderFeedback, &storageWrapper, &choker, g_defaults["max_slice_length"], 
  646. g_defaults["max_rate_period"], g_defaults["upload_rate_fudge"]);
  648. // CConnector m_connector(&download, &uploader, &choker,
  649. //  lNumPieces, &storageWrapper, g_defaults["max_upload_rate"], &upmeasure);
  650. m_connector.Create(&download, &uploader, &choker,
  651.   lNumPieces, &storageWrapper, &upmeasure);
  653. // m_connector.SetMaxUploadRate(5000);
  655. encrypter.Create(&m_DownloaderFeedback, &m_connector, 
  656. memMyid, memInfohash, g_defaults["max_message_length"], g_defaults["keepalive_interval"]);
  657. // encrypter.start_connection("", 6881, memInfohash);
  658.  // return;
  660. //
  661. // create CDownloaderFeedback
  662. //
  663. m_DownloaderFeedback.Create(&m_connector, g_defaults["display_interval"]);
  664. // throw string("test error handle");
  667. //
  668. // create raw server
  669. //
  670. CRawServer rawserver(m_hevDone, m_hevUnPause, &encrypter, &choker, &m_connector, &m_DownloaderFeedback, m_pStorageWrapper);
  671. long lport = rawserver.Bind(g_defaults["minport"], g_defaults["maxport"]);
  672. if (!lport)
  673. {
  674. m_DownloaderFeedback.errorFunc("Couldn't listen - ");
  675. return;
  676. }
  677. m_DownloaderFeedback.PutRunParameter(lport);
  679. //
  680. // CRerequester : Get infomation from track.
  681. //
  682. string strIp = (char*)((_bstr_t)g_defaults["ip"]);
  683. requester.Create(&m_DownloaderFeedback, &storageWrapper, &upmeasure
  684. ,&downmeasure, &m_connector, &encrypter,
  685. (*pResponse)["announce"]->pstrVal, lport, strIp, memMyid, memInfohash, 
  686. g_defaults["rerequest_interval"],
  687. g_defaults["http_timeout"], m_hevDone);
  690. //
  691. // listen loop
  692. //
  693. rawserver.listen_forever(&requester);
  695. //
  696. // close.
  697. //
  698. storage.Close();
  699. requester.Close();
  701. // show end message.
  702. /*
  703. if (IsEventSet(m_hevDone))
  704. m_DownloaderFeedback.ShowSystemMessage("用户取消了该下载/上传", CSystemMsg::eCmd);
  705. else
  706. m_DownloaderFeedback.SetBadMsg("unknown reason terminate download");
  707. //*/
  709. ResetEvent(m_hThreadSafe);
  710. WaitForSingleObject(m_hevUnPause, INFINITE);
  712. }
  713. catch (string &e)
  714. {
  715. m_DownloaderFeedback.SetBadMsg(e);
  716. ResetEvent(m_hThreadSafe);
  717. WaitForSingleObject(m_hevUnPause, INFINITE);
  718. }
  720. }
  724. ///////////////////////////////////////////////////////////
  725. // download display
  726. ///////////////////////////////////////////////////////////
  727. void CDownload::GetFractions(vector<long>& vFractions)
  728. {
  729. m_DownloaderFeedback.GetFractions(vFractions);
  730. }
  732. void CDownload::GetRunParameter(long& lPort, long &lPeerMin, long &lPeerMax, 
  733. long &lDisplayItval, long &lAllocType, long&lFileOpenMax)
  734. {
  735. m_DownloaderFeedback.GetRunParameter(lPort);
  737. lPeerMin = g_defaults["min_peers"];
  738. lPeerMax = g_defaults["max_initiate"];
  739. lDisplayItval = g_defaults["display_interval"];
  740. lAllocType = g_defaults["AllocType"];
  741. lFileOpenMax = g_defaults["FileOpenMax"];
  742. }
  744. CDownloaderFeedback& CDownload::GetFeedback()
  745. {
  746. return m_DownloaderFeedback;
  747. }
  748. void CDownload::GetSystemMessage(vector<CSystemMsg>& vMsg)
  749. {
  750. m_DownloaderFeedback.GetSystemMessage(vMsg);
  751. }
  753. string CDownload::GetSocketMessageAll()
  754. {
  755. if (!IsDownloading()) 
  756. {
  757. assert(false);
  758. return "not in loop";
  759. }
  760. return m_DownloaderFeedback.GetSocketMessageAll();
  761. }
  763. string CDownload::GetSocketMessage(long lAddr, short sPort)
  764. {
  765. assert(IsDownloading());
  766. return m_DownloaderFeedback.GetSocketMessage(lAddr, sPort);
  767. }
  769. vector<CConncetionData>& CDownload::GetConnections()
  770. {
  771. assert(IsDownloading());
  772. return m_DownloaderFeedback.GetData();
  773. }
  775. CStatics& CDownload::GetStatics()
  776. {
  777. assert(IsDownloading());
  778. return m_DownloaderFeedback.GetStatics();
  779. }
  781. string CDownload::getmessage()
  782. {
  783. if (!IsDownloading())
  784. {
  785. assert(false);
  786. return "not in loop";
  787. }
  789. vector<CConncetionData>& vConnectionDatas = m_DownloaderFeedback.GetData();
  791. string strRet;
  793. for (int i=0; i<vConnectionDatas.size(); i++)
  794. {
  795. CConncetionData& connectionData = vConnectionDatas[i];
  796. {
  797. in_addr inaddress;
  798. inaddress.S_un.S_addr = connectionData.m_lAddr;
  800. char szText[1024] = {0};
  801. sprintf(szText, "peer - ip:%s:%d - Local:%d - uprate:%d - downrate:%d - downcount:%d - upcount:%d - havePercent:%d",
  802. inet_ntoa(inaddress),
  803. ntohs(connectionData.m_sPort),
  804. connectionData.m_bLocallyInitiated,
  805. connectionData.m_lUpRate,
  806. connectionData.m_lDownRate,
  807. connectionData.m_lDownCount,
  808. connectionData.m_lUpCount,
  809. connectionData.m_fPeerHavePercent
  810. );
  812. strRet += szText;
  813. strRet += "rn";
  814. }
  815. }
  817. return strRet;
  819. /*
  820. char szText[100] = {0};
  821. string  strRet;
  823. long lrate = 0;
  825. lrate = m_pdownloader->m_pDownMeasure->get_rate();
  826. sprintf(szText, "global download rate : (%d)", lrate);
  827. strRet += szText;
  828. strRet += "rn";
  831. lrate = m_pconncetorget->how_many_connections();
  832. sprintf(szText, "connections size : (%d)", lrate);
  833. strRet += szText;
  834. strRet += "rn";
  836. for (int i=0; i<m_pconncetorget->m_connections.size();i++)
  837. {
  838. string strIp = m_pconncetorget->m_connections[i]->GetIP();
  839. strRet += "ip : (" + strIp + ")";
  841. lrate = m_pconncetorget->m_connections[i]->m_pDownload->get_rate();
  842. sprintf(szText, "peer -- download rate : (%d)", lrate);
  843. strRet += szText;
  845. lrate = m_pconncetorget->m_connections[i]->m_pUpload->get_rate();
  846. sprintf(szText, " -- upload rate : (%d)", lrate);
  847. strRet += szText;
  849. long lHaveCount = m_pconncetorget->m_connections[i]->m_pDownload->GetHaveCountPercent();
  850. sprintf(szText, " -- have count: (%d)", lHaveCount);
  851. strRet += szText;
  853. strRet += "rn";
  854. }
  856. lrate = m_pdownloader->m_pRateMeasure->get_size_left();
  857. sprintf(szText, "size left: (%d)", lrate);
  858. strRet += szText;
  859. strRet += "rn";
  861. lrate = m_pdownloader->m_pRateMeasure->get_time_left();
  862. tm* tt = localtime(&lrate);
  863. if (tt)
  864. sprintf(szText, "time left: (%d:%d:%d:%d)", tt->tm_mday, tt->tm_hour, tt->tm_min, tt->tm_sec);
  865. else
  866. sprintf(szText, "time left: no");
  868. strRet += szText;
  869. strRet += "rn";
  870. //*/
  872. return strRet;
  873. }
  875. /////////////////////////////////////////////////////////////////////////////////////////////
  876. //
  877. // for test
  878. //
  879. /////////////////////////////////////////////////////////////////////////////////////////////
  880. void CDownload::test()
  881. {
  882. /*
  883. CVal* pRet = 0;
  884. CBdecode dec;
  886. char buf[] = "i1000e";
  887. pRet = dec.bdecode(buf, sizeof(buf)/sizeof(char));
  888. if (pRet)
  889. delete pRet;
  891. char buf1[] = "5:hello";
  892. pRet = dec.bdecode(buf1, sizeof(buf1)/sizeof(char));
  893. if (pRet)
  894. delete pRet;
  895. //*/
  897. // ShowMessage((*pRet).data());
  899. // CVal::test();
  902. // CStorage::test();
  903. /*
  904. long ltime = 0;
  905. time(&ltime);
  906. srand(ltime);
  907. PiecePickerTest();
  908. //*/
  910. // RateMeasureTest();
  912. // SingleDownloadTest();
  915. /*
  916. char pbuf[262144] = {0};
  917. for (int i=0; i<262144; i++)
  918. {
  919. pbuf[i] = i;
  920. }
  922. for (i=0; i<3000; i++)
  923. {
  924. SHA1 sha;
  925. unsigned int shaRes[5] = {0};
  926. sha.Input(pbuf, 262144);
  927. sha.Result(shaRes);
  928. TRACE("%d, ", i/30);
  929. if (!(i %20))
  930. TRACE("rn");
  931. }
  932. //*/
  934. }