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

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

P2P编程

开发平台：

Visual C++

Storage.cpp：源码内容
  1. // StorageEx.cpp: implementation of the CStorageEx class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "testbt.h"
  7. #include "Storage.h"
  9. #include "FileBase.h"
  10. #include <sys/stat.h> 
  11. #include <sys/types.h>
  12. #include <sys/locking.h>
  14. #include "DownloaderFeedback.h"
  17. #ifdef _DEBUG
  18. #undef THIS_FILE
  19. static char THIS_FILE[]=__FILE__;
  20. #define new DEBUG_NEW
  21. #endif
  23. //////////////////////////////////////////////////////////////////////
  24. // Construction/Destruction
  25. //////////////////////////////////////////////////////////////////////
  27. CStorageEx::CStorageEx()
  28. {
  29. m_pMain = 0;
  30. m_hevDone = 0;
  31. m_lTotalLength = 0;
  32. m_lMaxFilesOpen = 0;
  33. m_bLockWhileReading = false;
  34. m_bLockFiles = false;
  35. }
  37. CStorageEx::~CStorageEx()
  38. {
  39. Close();
  40. }
  43. void CStorageEx::Close()
  44. {
  45. for (map<string, FILE*>::iterator i=m_mHandles.begin(); i != m_mHandles.end(); i++)
  46. {
  47. string strFileName = (*i).first;
  48. FILE* pfile = (*i).second;
  49. assert(pfile);
  51. if (m_bLockWhileReading || 
  52. m_mWHandles.find(strFileName) != m_mWHandles.end())
  53. {
  54. _unlock_file(strFileName, pfile);
  55. }
  57. int iRet = fclose(pfile);
  58. assert(!iRet);
  59. ferror(pfile);
  60. }
  62. m_vHandleBuffer.clear();
  63. m_mHandles.clear();
  64. m_mWHandles.clear();
  65. m_mSizes.clear();
  66. m_mTimes.clear();
  67. m_vRange.clear();
  68. }
  70. bool CStorageEx::Create(CDownloaderFeedback* pMain, vector<CFileInfo>& vFiles, 
  71. HANDLE hevDone, long lMaxFilesOpen, bool bLockFiles, bool bLockWhileReading)
  72. {
  73. // assert(pMain && hevDone);
  75. m_pMain = pMain;
  76. m_hevDone = hevDone;
  77. m_lMaxFilesOpen = lMaxFilesOpen;
  78. m_bLockWhileReading = bLockWhileReading;
  79. m_bLockFiles = bLockFiles;
  82. try
  83. {
  84. BLONG lTotalLength = 0;
  85. long lNumFiles = 0;
  87. for (int i=0; i<vFiles.size(); i++)
  88. {
  89. if (IsEventSet(m_hevDone))
  90. return true;
  92. if (vFiles[i].m_lFileLength != 0)
  93. {
  94. m_vRange.push_back(CRange(lTotalLength, 
  95. lTotalLength + vFiles[i].m_lFileLength, vFiles[i].m_strFilePath));
  97. lNumFiles ++;
  98. lTotalLength += vFiles[i].m_lFileLength;
  100. BLONG lsize = 0;
  102. if (!_access(vFiles[i].m_strFilePath.data(), 0))
  103. {
  104. lsize = GetFileSize(vFiles[i].m_strFilePath.data());
  106. if (lsize > vFiles[i].m_lFileLength)
  107. {
  108. lsize = vFiles[i].m_lFileLength;
  110. FILE* pfile = fopen(vFiles[i].m_strFilePath.data(), "rb+");
  111. if (!pfile)
  112. {
  113. assert(pfile);
  114. return false; // throw string("truncate file(") + vFiles[i].m_strFilePath + ") error";
  115. }
  117. int fh = _fileno(pfile);
  118. int iRet = chsize(fh, vFiles[i].m_lFileLength);
  119. assert(iRet == 0);
  120. fclose(pfile);
  121. }
  123. }
  124. else // not exist.
  125. {
  126. lsize = 0;
  127. FILE* pfile = fopen(vFiles[i].m_strFilePath.data(), "wb+");
  128. if (!pfile)
  129. {
  130. assert(false);
  131. return false; // throw string("create file(") + vFiles[i].m_strFilePath + ") error";
  132. }
  133. fclose(pfile);
  134. }
  136. m_mTops[vFiles[i].m_strFilePath] = lsize;
  137. m_mSizes[vFiles[i].m_strFilePath] = vFiles[i].m_lFileLength;
  138. m_mTimes[vFiles[i].m_strFilePath] = getfiletime(vFiles[i].m_strFilePath);
  139. }
  140. else // file length = 0.
  141. {
  142. if (!_access(vFiles[i].m_strFilePath.data(), 0))
  143. {
  144. BLONG lsize = GetFileSize(vFiles[i].m_strFilePath.data());
  145. if (lsize > 0)
  146. throw string("file exist length too large, should be zero");
  147. }
  148. else
  149. {
  150. }
  151. }
  152. } // end for
  154. // for (i =0; i<m_vRange.size(); i++)
  155. // m_vBegins.push_back(m_vRange[i].m_lbeg);
  157. m_lTotalLength = lTotalLength;
  158. m_bMaxFilesOpen = (m_lMaxFilesOpen > 0 && (lNumFiles > m_lMaxFilesOpen));
  161. } // end try
  162. catch (string e)
  163. {
  164. throw e;
  165. }
  167. return true;
  168. }
  170. bool CStorageEx::GetFilesRange(vector<long>& vRangeHoles, vector<long>& vFileOffset, long lPieceLen)
  171. {
  172. if (!lPieceLen)
  173. return false;
  175. vRangeHoles.clear();
  176. vFileOffset.clear();
  177. vRangeHoles.push_back(0);
  178. vFileOffset.push_back(0);
  180. BLONG lbeg = 0, lend = 0;
  182. for (int i=0; i<m_vRange.size(); i++)
  183. {
  184. lbeg = m_vRange[i].m_lbeg;
  185. if ((lbeg - lend) > lPieceLen)
  186. {
  187. vFileOffset.push_back(lbeg % lPieceLen);
  188. vRangeHoles.push_back(lbeg / lPieceLen);
  189. lend = lbeg;
  190. }
  191. }
  193. #ifdef _DEBUG
  194. TRACE("rn**vRangeHolesIndex : {rn");
  195. for (i=0; i<vRangeHoles.size();i++)
  196. {
  197. TRACE("%d, ", vRangeHoles[i]);
  198. }
  199. TRACE("}rn");
  200. #endif
  201. return true;
  202. }
  204. void CStorageEx::GetUnNeededRanges(const vector<CSize>& vUnNeededFileInxs, vector<CSizeEx>& vUnNeededRanges) const
  205. {
  206. vUnNeededRanges.clear();
  208. for (int i=0; i<vUnNeededFileInxs.size(); i++)
  209. {
  210. assert(vUnNeededFileInxs[i].cy > vUnNeededFileInxs[i].cx);
  211. assert(vUnNeededFileInxs[i].cx >= 0);
  213. if((vUnNeededFileInxs[i].cy - 1) >= m_vRange.size())
  214. {
  215. /*
  216. CSize lData[1000] = {CSize(0, 0)};
  217. for (int j=0; j<vUnNeededFileInxs.size(); j++)
  218. {
  219. lData[j] = vUnNeededFileInxs[j];
  220. }
  222. long lsize  = vUnNeededFileInxs.size();
  223. int iCount = m_vRange.size();
  224. //*/
  225. assert(false);
  226. return;
  227. }
  228. long x = vUnNeededFileInxs[i].cx;
  229. long y = vUnNeededFileInxs[i].cy - 1;
  231. BLONG cx = m_vRange[x].m_lbeg;
  232. BLONG cy = m_vRange[y].m_lend;
  234. if (vUnNeededRanges.size() > 0 && (cx == vUnNeededRanges[vUnNeededRanges.size() - 1].cy))
  235. {
  236. vUnNeededRanges[vUnNeededRanges.size() - 1].cy = cy;
  237. }
  238. else
  239. {
  240. vUnNeededRanges.push_back(CSizeEx(cx, cy));
  241. }
  242. }
  244. // int iCount = vUnNeededRanges.size();
  245. }
  247. BLONG CStorageEx::GetTotalLength()
  248. {
  249. return m_lTotalLength;
  250. }
  252. void CStorageEx::SetReadOnly()
  253. {
  254. vector<string> vKeys;
  255. for (map<string, bool>::iterator it = m_mWHandles.begin(); it != m_mWHandles.end(); it ++)
  256. vKeys.push_back((*it).first);
  258. for (int i=0; i<vKeys.size(); i++)
  259. {
  260. string strFileName = vKeys[i];
  261. assert(!strFileName.empty());
  263. _close(strFileName);
  265. vector<string>::iterator iter = 
  266. find(m_vHandleBuffer.begin(), m_vHandleBuffer.end(), strFileName);
  267. if (iter != m_vHandleBuffer.end())
  268. m_vHandleBuffer.erase(iter);
  269. }
  270. }
  272. void CStorageEx::top_off()
  273. {
  274. for (int i=0; i<m_vRange.size(); i++)
  275. {
  276. int lLength = m_vRange[i].m_lend - m_vRange[i].m_lbeg;
  277. if (lLength > m_mTops[m_vRange[i].m_strFileName])
  278. {
  279. FILE* pfile = _get_file_handle(m_vRange[i].m_strFileName, true);
  280. if (!pfile)
  281. {
  282. assert(false);
  283. continue;
  284. }
  286. int iRet = fseek(pfile, lLength-1, SEEK_SET);
  287. assert(!iRet);
  289. unsigned char cEnd = 0xff;
  290. iRet = fwrite(&cEnd, sizeof(char), 1, pfile);
  291. if (iRet != 1)
  292. {
  293. assert(false);
  294. return;
  295. }
  296. }
  297. }
  298. }
  300. bool CStorageEx::flush()
  301. {
  302. for (map<string, bool>::iterator iter = m_mWHandles.begin(); iter != m_mWHandles.end(); iter ++)
  303. {
  304. assert(m_mHandles.find((*iter).first) != m_mHandles.end());
  305. int iRet = fflush(m_mHandles[(*iter).first]);
  306. if (iRet)
  307. {
  308. assert(false);
  309. return false;
  310. }
  311. }
  312. return true;
  313. }
  315. bool CStorageEx::was_preallocated(BLONG lPos, BLONG lLength)
  316. {
  317. assert(lPos >= 0 && lLength >= 0);
  319. vector<CRange> v;
  320. _intervals(lPos, lLength, v);
  322. for (int i=0; i<v.size(); i++)
  323. {
  324. if (m_mTops[v[i].m_strFileName] < v[i].m_lend)
  325. return false;
  326. }
  328. return true;
  329. }
  331. bool CStorageEx::write(char *pBuf, BLONG lPos, BLONG lAmount)
  332. {
  333. assert((lAmount + lPos) <= m_lTotalLength && lPos >= 0 && lAmount >= 0);
  335. BLONG lwrite = 0;
  336. vector<CRange> v;
  337. _intervals(lPos, lAmount, v);
  339. for (int i=0; i<v.size(); i++)
  340. {
  341. FILE* pfile = _get_file_handle(v[i].m_strFileName, true);
  342. if (!pfile)
  343. {
  344. assert(false);
  345. return false;
  346. }
  348. int iRet = fseek(pfile, v[i].m_lbeg, SEEK_SET);
  349. assert(!iRet);
  351. BLONG lLen = v[i].m_lend - v[i].m_lbeg;
  352. iRet = fwrite(pBuf + lwrite, sizeof(char), lLen, pfile);
  353. if (iRet != lLen)
  354. {
  355. if (ENOSPC == errno)
  356. {
  357. m_pMain->SetBadMsg("No space left on device");
  358. return false;
  359. }
  360. int i = errno;
  361. assert(false);
  362. return false;
  363. }
  364. lwrite += lLen;
  365. }
  366. assert(lwrite == lAmount);
  367. return true;
  368. }
  370. bool CStorageEx::read(char *pBuf, BLONG lPos, BLONG lAmount, bool bFlushFirst)
  371. {
  372. //*
  373. assert((lAmount + lPos) <= m_lTotalLength && lPos >= 0 && lAmount >= 0);
  375. BLONG lread = 0;
  376. vector<CRange> v;
  377. _intervals(lPos, lAmount, v);
  379. for (int i=0; i<v.size(); i++)
  380. {
  381. FILE* pfile = _get_file_handle(v[i].m_strFileName, false);
  382. if (!pfile)
  383. {
  384. assert(false);
  385. return false;
  386. }
  388. if (bFlushFirst && m_mWHandles.find(v[i].m_strFileName) != m_mWHandles.end())
  389. {
  390. int iRet = fflush(pfile);
  391. if (iRet)
  392. {
  393. assert(false);
  394. return false;
  395. }
  396. }
  398. int iRet = fseek(pfile, v[i].m_lbeg, SEEK_SET);
  399. assert(!iRet);
  401. BLONG lLen = v[i].m_lend - v[i].m_lbeg;
  402. iRet = fread(pBuf+lread, sizeof(char), lLen, pfile);
  403. if (iRet != lLen)
  404. {
  405. TRACE("%d, %d", v[i].m_lend, v[i].m_lbeg);
  406. assert(iRet == lLen);
  407. return false;
  408. }
  409. lread+= lLen;
  410. }
  412. assert(lread == lAmount);
  413. return true;
  414. }
  417. bool CStorageEx::_intervals(BLONG lPos, BLONG lAmount, vector<CStorageEx::CRange>& v)
  418. {
  419. assert(lPos >= 0 && lAmount >= 0 && v.empty());
  421. BLONG lbeg = 0, lend = 0;
  422. BLONG lstop = lPos + lAmount;
  424. for (int i=0; i<m_vRange.size(); i++)
  425. {
  426. lend = lbeg + (m_vRange[i].m_lend - m_vRange[i].m_lbeg);
  428. if (lend <= lPos)
  429. {
  430. lbeg = lend;
  431. continue;
  432. }
  433. if (lbeg >= lstop)
  434. break;
  436. v.push_back(CRange(max(lPos, lbeg) - lbeg, min(lend, lstop) - lbeg, m_vRange[i].m_strFileName));
  438. lbeg = lend;
  439. }
  441. #ifdef _DEBUG
  442. BLONG lread = 0;
  443. // TRACE("rn{");
  444. for (i=0; i<v.size(); i++)
  445. {
  446. lread += v[i].m_lend - v[i].m_lbeg;
  447. // TRACE("(%d, %d)",  v[i].m_lbeg, v[i].m_lend);
  448. }
  449. // TRACE("}rn");
  450. assert(lread  == lAmount);
  451. #endif
  452. return true;
  453. }
  456. void CStorageEx::_lock_file(string strFileName, FILE* pfile)
  457. {
  458. if (!m_bLockFiles)
  459. return;
  461. assert(m_mSizes.find(strFileName) != m_mSizes.end());
  463. BLONG lLength = m_mSizes[strFileName];
  464. assert(lLength >= 0);
  466. int iRet = fseek(pfile, 0, SEEK_SET);
  467. assert(!iRet);
  469. iRet = _locking(fileno(pfile), _LK_LOCK, lLength);
  470. assert(iRet != -1);
  472. /*
  473. for (int i=0; i<lLength;)
  474. {
  475. int iRet = fseek(pfile, i, SEEK_SET);
  476. assert(!iRet);  
  477. }
  478. //*/
  479. }
  482. void CStorageEx::_unlock_file(string strFileName, FILE* pfile)
  483. {
  484. if (!m_bLockFiles)
  485. return;
  487. assert(m_mSizes.find(strFileName) != m_mSizes.end());
  489. BLONG lLength = m_mSizes[strFileName];
  490. assert(lLength >= 0);
  492. int iRet = fseek(pfile, 0, SEEK_SET);
  493. assert(!iRet);
  495. iRet = _locking(fileno(pfile), _LK_UNLCK, lLength);
  496. int iErr = errno;
  497. assert(iRet != -1);
  498. }
  500. FILE* CStorageEx::_get_file_handle(string strFileName, bool bForWrite)
  501. {
  502. if (m_mHandles.find(strFileName) != m_mHandles.end())
  503. {
  504. if (bForWrite && m_mWHandles.find(strFileName) == m_mWHandles.end())
  505. {
  506. _close(strFileName);
  507. FILE* pfile = _open(strFileName, "rb+");
  508. if (!pfile)
  509. {
  510. assert(false);
  511. return 0;
  512. }
  514. m_mHandles[strFileName] = pfile;
  515. m_mWHandles[strFileName] = 1;
  516. _lock_file(strFileName, pfile);
  517. }
  519. if (m_bMaxFilesOpen)
  520. {
  521. vector<string>::iterator iter = 
  522. find(m_vHandleBuffer.begin(), m_vHandleBuffer.end(), strFileName);
  524. if (iter != m_vHandleBuffer.end())
  525. m_vHandleBuffer.erase(iter);
  527. m_vHandleBuffer.push_back(strFileName);
  528. }
  529. }
  530. else
  531. {
  532. if (bForWrite)
  533. {
  534. FILE* pfile = _open(strFileName, "rb+");
  535. if (!pfile)
  536. {
  537. assert(false);
  538. return 0;
  539. }
  540. m_mHandles[strFileName] = pfile;
  541. m_mWHandles[strFileName] = 1;
  542. _lock_file(strFileName, pfile);
  543. }
  544. else
  545. {
  546. FILE* pfile = _open(strFileName, "rb");
  547. if (!pfile)
  548. {
  549. assert(false);
  550. return 0;
  551. }
  553. m_mHandles[strFileName] = pfile;
  554. if (m_bLockWhileReading)
  555. _lock_file(strFileName, pfile);
  556. }
  558. if (m_bMaxFilesOpen)
  559. {
  560. m_vHandleBuffer.push_back(strFileName);
  562. if (m_vHandleBuffer.size() > m_lMaxFilesOpen)
  563. {
  564. _close(*m_vHandleBuffer.begin());
  565. m_vHandleBuffer.erase(m_vHandleBuffer.begin());
  566. }
  567. }
  569. }
  571. return m_mHandles[strFileName];
  572. }
  574. FILE* CStorageEx::_open(string strFileName, string strMode)
  575. {
  576. assert(m_mTops.find(strFileName) != m_mTops.end() && 
  577. m_mTimes.find(strFileName)!= m_mTimes.end());
  579. if (m_bMaxFilesOpen)
  580. {
  581. if (GetFileSize(strFileName) != m_mTops[strFileName] ||
  582. getfiletime(strFileName) > (m_mTimes[strFileName] + 1))
  583. {
  584. assert(false);
  585. throw string("file (" + strFileName + ") modified by user during downloading");
  586. return 0;
  587. }
  588. }
  590. return fopen(strFileName.data(), strMode.data());
  591. }
  593. void CStorageEx::_close(string strFileName)
  594. {
  595. assert(m_mHandles.find(strFileName) != m_mHandles.end());
  597. FILE* pfile = m_mHandles[strFileName];
  598. m_mHandles.erase(strFileName);
  600. if (m_mWHandles.find(strFileName) != m_mWHandles.end())
  601. {
  602. m_mWHandles.erase(strFileName);
  603. _unlock_file(strFileName, pfile);
  604. m_mTops[strFileName] = GetFileSize(strFileName);
  605. fclose(pfile);
  606. m_mTimes[strFileName] = getfiletime(strFileName);
  607. }
  608. else
  609. {
  610. if (m_bLockWhileReading)
  611. _unlock_file(strFileName, pfile);
  613. fclose(pfile);
  614. }
  616. }
  618. time_t CStorageEx::getfiletime(string strFileName)
  619. {
  620. FILE* pfile = fopen(strFileName.data(), "rb");
  621. if (!pfile)
  622. {
  623. assert(false);
  624. return 0; // throw string("truncate file(") + vFiles[i].m_strFilePath + ") error";
  625. }
  627. int fh = _fileno(pfile);
  628. struct _stat buf;
  629. int result = _fstat( fh, &buf );
  630. if( result != 0 )
  631. {
  632. assert(false);
  633. return 0;
  634. }
  636. time_t tRet = buf.st_mtime;
  637. fclose(pfile);
  638. return tRet;
  639. }