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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > P2P编程 > 查看源码
BufferMgr.cpp
资源名称：p2p_vod.rar　[点击查看]
上传用户：liguizhu
上传日期：2015-11-01
资源大小：2422k
文件大小：11k
源码类别：

P2P编程

开发平台：

Visual C++

BufferMgr.cpp：源码内容
  1. /*
  2.  *  Openmysee
  3.  *
  4.  *  This program is free software; you can redistribute it and/or modify
  5.  *  it under the terms of the GNU General Public License as published by
  6.  *  the Free Software Foundation; either version 2 of the License, or
  7.  *  (at your option) any later version.
  8.  *
  9.  *  This program is distributed in the hope that it will be useful,
  10.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  *  GNU General Public License for more details.
  13.  *
  14.  *  You should have received a copy of the GNU General Public License
  15.  *  along with this program; if not, write to the Free Software
  16.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17.  *
  18.  */
  19. // BufferMgr.cpp: implementation of the BufferMgr class.
  20. //
  21. //////////////////////////////////////////////////////////////////////
  23. #include "stdafx.h"
  24. #include "BufferMgr.h"
  25. #include <tlhelp32.h> 
  27. namespace NPLayer1 {
  29. //////////////////////////////////////////////////////////////////////
  30. // Construction/Destruction
  31. //////////////////////////////////////////////////////////////////////
  33. BufferMgr::BufferMgr() : blockArray(NULL), blockNum(0), hBufferFile(NULL) {
  34. }
  36. BufferMgr::~BufferMgr() {
  37. if(hBufferFile) {
  38. // 删除文件
  39. CloseHandle(hBufferFile);
  40. hBufferFile = NULL;
  41. }
  42. ::DeleteFile(bufferFileName.data());
  44. delete [] blockArray;
  45. blockArray = NULL;
  46. blockNum = 0;
  47. }
  49. P2P_RETURN_TYPE BufferMgr::Init(string fullPath, bool& bufFileModified, UINT randNum, UINT bufferSize) {
  50. bufFileModified = false;
  51. // 只能初始化一次，如果已经初始化了，就返回错误
  52. if(blockArray)
  53. return PRT_DUP_INIT;
  55. // 如果没有给出缓冲文件的全路径，则在缓冲文件夹建立一个缓冲文件
  56. GENERATE_FILENAME:if(fullPath.empty()) {
  57. // Filter文件所在的路径
  58. char buf[MAX_PATH_EX];
  59. if(!GetSelfModulePath(buf, MAX_PATH_EX))
  60. return PRT_SYS;
  61. bufferFileName = buf;
  62. bufferFileName.append("GB");
  63. itoa(randNum, buf, 10);
  64. bufferFileName.append(buf);
  65. bufferFileName.append(".tmp");
  66. }
  67. else
  68. bufferFileName = fullPath;
  70. // 缓冲文件的最大长度
  71. bufferFileSize = bufferSize;
  73. // 查找缓冲文件, 如果没有找到，则创建一个
  74. WIN32_FIND_DATA fileData;
  75. HANDLE hFind = FindFirstFile(bufferFileName.data(), &fileData);
  76. if(hFind == INVALID_HANDLE_VALUE) {
  77. for(;;) {
  78. // 创建缓冲文件
  79. if(!ExCreateFile(hBufferFile, bufferFileName.data(), CREATE_ALWAYS)) {
  80. int err = GetLastError();
  81. if(err == 3) { 
  82. // 创建文件失败,因为有不存在的中间目录,需要首先创建中间目录
  83. int index = 0;
  84. string temp;
  85. do {
  86. int offset = bufferFileName.find_first_of('\', index);
  87. if(offset == -1)
  88. break;
  89. temp = bufferFileName.substr(0, offset);
  90. index = offset+1;
  91. if(!CreateDirectory(temp.data(), NULL)) {
  92. int ret = GetLastError();
  93. if(ret == ERROR_ALREADY_EXISTS || ret == ERROR_ACCESS_DENIED)
  94. continue;
  95. break;
  96. }
  97. }while(1);
  98. // Create Again
  99. continue;
  100. }
  101. else
  102. return PRT_SYS;
  103. }
  104. // 成功创建文件
  105. bufFileModified = true;
  106. break;
  107. }
  108. // 将缓冲文件长度设为0
  109. ExSetFileSize(hBufferFile, 0);
  110. }
  111. else if(fullPath.empty()) {
  112. // 如果是随机生成的文件名,结果发现重名,则把randnum+1，再次尝试
  113. randNum++;
  114. goto GENERATE_FILENAME;
  115. }
  116. else {
  117. FindClose(hFind);
  118. // 打开缓冲文件
  119. if(!ExCreateFile(hBufferFile, bufferFileName.data(), OPEN_EXISTING)) {
  120. //assert(0);
  121. if(!ExCreateFile(hBufferFile, bufferFileName.data(), CREATE_ALWAYS)) {
  122. //assert(0);
  123. return PRT_CANNOT_OPEN_BUF;
  124. }
  125. bufFileModified = true;
  126. }
  127. }
  129. // 如果存在的文件大小超过目标文件大小，则将其大小设置为目标文件大小
  130. UINT realBufSize = ::GetFileSize(hBufferFile, NULL);
  131. if(realBufSize == INVALID_FILE_SIZE)
  132. return PRT_SYS;
  133. if(realBufSize > bufferFileSize) {
  134. // 将缓冲文件长度设为目标文件大小
  135. ExSetFileSize(hBufferFile, bufferFileSize);
  136. realBufSize = bufferFileSize;
  137. bufFileModified = true;
  138. }
  140. // 检查磁盘空间是否足够
  141. ULARGE_INTEGER availableBytes, totalBytes;
  142. string purepath = bufferFileName;
  143. int index = purepath.find_last_of('\');
  144. if(index != -1)
  145. purepath.resize(index);
  146. else
  147. return PRT_SYS;
  148. if(!GetDiskFreeSpaceEx(purepath.data(), &availableBytes, &totalBytes, NULL)) {
  149. return PRT_SYS;
  150. }
  151. else {
  152. if(availableBytes.QuadPart < bufferFileSize-realBufSize) {
  153. // not enough space on disk
  154. return PRT_DISK_FULL;
  155. }
  156. }
  158. // 计算数组大小, 如果不能整除,则加一
  159. blockNum = bufferFileSize/BLOCK_SIZE;
  160. if(bufferFileSize%BLOCK_SIZE != 0)
  161. blockNum++;
  162. // 初始化数组
  163. blockArray = new bool[blockNum];
  164. if(!blockArray)
  165. return PRT_ALLOC;
  166. // 将所有成员置为false, 即标记所有快为未使用
  167. fill(blockArray, blockArray+blockNum, false);
  169. return PRT_OK;
  170. }
  172. UINT BufferMgr::GetEmptyIndex(UINT randNum) {
  173. // 如果尚未初始化，则返回错误
  174. if(!blockArray)
  175. return UINT_MAX;
  177. // 使用随机数选择缓冲区中的空位，这是为了防止有人Hook我们的缓冲区
  178. // 如果我们是顺序存储的，那么很容易就从新建缓冲区中按顺序读出数据
  179. // 所以要使用随即的存储位置
  181. // 1. 根据随机数，确定随机位置
  182. UINT randPos = randNum%blockNum;
  183. // 2. 将遍历用的iterator移动到该随机位置
  184. UINT i = randPos;
  185. // 3. 设定第一轮循环的开始结束位置，从随机位置到hash_map尾
  186. UINT start = i;
  187. UINT end = blockNum;
  188. for(; ;++i) {
  189. if(i == end) {
  190. if(end == blockNum) {
  191. // 4. 第一轮循环结束，开始第二轮，从头到随机位置
  192. i = 0;
  193. end = start;
  195. // 如果两者相等说明只有一个元素，而且第一轮已经比较过了，所以跳出循环
  196. if(i == end) {
  197. break;
  198. }
  199. }
  200. else {
  201. // 5. 第二轮循环结束，跳出循环
  202. break;
  203. }
  204. }
  206. // 如果发现一个未使用的块,则标记为已使用,并返回数组下标
  207. if(!blockArray[i]) {
  208. blockArray[i] = true;
  209. return i;
  210. }
  211. }
  212. return UINT_MAX;
  213. }
  215. void BufferMgr::EraseIndex(UINT index) {
  216. // 如果尚未初始化，则返回
  217. if(!blockArray)
  218. return;
  219. // 下标越界
  220. if(index >= blockNum)
  221. return;
  222. // 将此块标记为未使用
  223. blockArray[index] = false;
  224. }
  226. // 获取剩余空间大小
  227. UINT BufferMgr::GetEmptySpace() {
  228. return BLOCK_SIZE*count(blockArray, blockArray+blockNum, false);
  229. }
  231. P2P_RETURN_TYPE BufferMgr::GetIndexData(UINT index, UINT offset, LPVOID data, UINT size) {
  232. // 如果参数错误或者尚未初始化，则返回错误
  233. if(!data || !blockArray)
  234. return PRT_WRONG_ARG;
  235. // 如果超过边界,则返回错误
  236. if(index >= blockNum)
  237. return PRT_WRONG_ARG;
  238. // 如果要求的数据过大,则返回错误
  239. if(offset+size > BLOCK_SIZE)
  240. return PRT_WRONG_ARG;
  241. // 如果要求的是最后一块，但是数据长度过大，则返回错误
  242. if(index == blockNum-1 && offset+size > bufferFileSize-index*BLOCK_SIZE)
  243. return PRT_WRONG_ARG;
  244. // 如果此块不存在,则返回出错
  245. //if(!blockArray[index])
  246. // return PRT_WRONG_ARG;
  247. // 移动文件指针到偏移位置
  248. if(!ExSetFilePointer(hBufferFile, index*BLOCK_SIZE+offset))
  249. return PRT_SYS;
  250. // 如果读到的数据长度不等于需要的数据长度,则返回错误
  251. if(ExReadFile(hBufferFile, data, size) != size)
  252. return PRT_SYS;
  253. return PRT_OK;
  254. }
  256. P2P_RETURN_TYPE BufferMgr::PutIndexData(UINT index, LPVOID data, UINT size) {
  257. // 如果参数错误或者尚未初始化，则返回错误
  258. if(!data || !blockArray)
  259. return PRT_WRONG_ARG;
  260. // 如果超过边界,则返回错误
  261. if(index >= blockNum)
  262. return PRT_WRONG_ARG;
  263. // 如果数据过大,则返回错误
  264. if(size > BLOCK_SIZE)
  265. return PRT_WRONG_ARG;
  266. // 如果是最后一块，但是数据长度过大，则返回错误
  267. if(index == blockNum-1 && size > bufferFileSize-index*BLOCK_SIZE)
  268. return PRT_WRONG_ARG;
  269. /*
  270. // 在GetEmptyIndex里已经把这里划分出去了！
  271. // 如果此块已经存在,则返回出错
  272. if(blockArray[index])
  273. return FALSE;
  274. */
  275. // 移动文件指针到偏移位置
  276. if(!ExSetFilePointer(hBufferFile, index*BLOCK_SIZE))
  277. return PRT_SYS;
  278. // 如果写入的数据长度不等于实际的数据长度,则返回错误
  279. if(ExWriteFile(hBufferFile, data, size) != size)
  280. return PRT_SYS;
  281. return PRT_OK;
  282. }
  284. BOOL BufferMgr::ExSetFileSize(HANDLE handle, UINT size) {
  285. BOOL ret = TRUE;
  286. if(!ExSetFilePointer(handle, size))
  287. ret = FALSE;
  288. else if(0 == SetEndOfFile(handle)) {
  289. ret = FALSE;
  290. }
  291. return ret;
  292. }
  294. UINT BufferMgr::ExReadFile(HANDLE handle, LPVOID buf, UINT toBeRead) {
  295. UINT readCount = 0;
  296. DWORD tmpRead;
  297. while(readCount < toBeRead) {
  298. BOOL success = ReadFile(
  299. handle, // file handler
  300. (char*)buf+readCount, // current buffer position
  301. toBeRead - readCount, // remaining bytes to be read
  302. &tmpRead, // read bytes
  303. NULL); // not overlaped
  304. if(!success)
  305. return 0;
  306. if(tmpRead == 0) // no more data
  307. return 0;
  308. readCount += tmpRead;
  309. }
  310. return readCount;
  311. }
  313. UINT BufferMgr::ExWriteFile(HANDLE handle, LPCVOID buf, UINT toBeWrite) {
  314. UINT writeCount = 0;
  315. DWORD tmpWrite;
  316. while(writeCount < toBeWrite) {
  317. BOOL success = WriteFile(
  318. handle, // file handler
  319. (char*)buf+writeCount, // current buffer position
  320. toBeWrite-writeCount, // remaining bytes to be read
  321. &tmpWrite, // written bytes
  322. NULL); // not overlaped
  323. if(!success) {
  324. return FALSE;
  325. }
  326. writeCount += tmpWrite;
  327. }
  328. return writeCount;
  329. }
  331. BOOL BufferMgr::ExSetFilePointer(HANDLE handle, UINT offset) {
  332. if(-1 == SetFilePointer(handle, 
  333. offset, 
  334. NULL, 
  335. FILE_BEGIN)) {
  336. return FALSE;
  337. }
  338. return TRUE;
  339. }
  341. BOOL BufferMgr::ExCreateFile(HANDLE& handle,
  342. LPCTSTR lpFileName,
  343. DWORD dwDesiredAccess,
  344. DWORD dwShareMode,
  345. LPSECURITY_ATTRIBUTES lpSecurityAttributes,
  346. DWORD dwCreationDisposition,
  347. DWORD dwFlagsAndAttributes,
  348. HANDLE hTemplateFile) {
  349. handle = CreateFile(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, 
  350. dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
  351. if(handle == INVALID_HANDLE_VALUE) {
  352. return FALSE;
  353. }
  354. return TRUE;
  355. }
  357. BOOL BufferMgr::ExCreateFile(HANDLE& handle, LPCTSTR lpFileName, DWORD dwCreationDisposition) {
  358. handle = CreateFile(lpFileName, 
  359. GENERIC_WRITE | GENERIC_READ, 
  360. 0, 
  361. NULL, 
  362. dwCreationDisposition, 
  363. FILE_ATTRIBUTE_NORMAL, 
  364. NULL);
  365. if(handle == INVALID_HANDLE_VALUE) {
  366. return FALSE; 
  367. }
  368. return TRUE;
  369. }
  371. BOOL BufferMgr::GetSelfModulePath(LPTSTR buf, DWORD nSize) {
  372. HANDLE hModuleSnap = INVALID_HANDLE_VALUE; 
  373. MODULEENTRY32 me32; 
  375. //  Take a snapshot of all modules in the specified process. 
  376. hModuleSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, GetCurrentProcessId()); 
  377. if(hModuleSnap == INVALID_HANDLE_VALUE) 
  378. return FALSE; 
  380. //  Set the size of the structure before using it. 
  381. me32.dwSize = sizeof(MODULEENTRY32); 
  383. //  Retrieve information about the first module, 
  384. //  and exit if unsuccessful 
  385. if(!Module32First(hModuleSnap, &me32)) { 
  386. CloseHandle(hModuleSnap);     // Must clean up the snapshot object! 
  387. return FALSE; 
  388. } 
  390. //  Now walk the module list of the process, 
  391. //  and display information about each module 
  392. do 
  393. {
  394. _tcsupr(me32.szModule);
  395. if( _tcsncmp(me32.szModule, _T("LAYER1.DLL"), _tcslen(_T("LAYER1.DLL"))) != NULL || 
  396. _tcsncmp(me32.szModule, _T("LAYER1D.DLL"), _tcslen(_T("LAYER1D.DLL"))) != NULL) {
  397. if(_tcslen(me32.szExePath) >= nSize)
  398. return FALSE;
  399. _tcscpy(buf, me32.szExePath);
  400. char* index = _tcsrchr(buf, _T('\'));
  401. if(index == 0)
  402. return FALSE;
  403. index[1] = 0;
  404. return TRUE;  // Find target module name
  405. }
  406. } while(Module32Next(hModuleSnap, &me32)); 
  408. //  Do not forget to clean up the snapshot object. 
  409. CloseHandle(hModuleSnap);
  410. return FALSE;
  411. }
  413. }