Category

Development Platform
Home > SourceCode/Document > Internet-Socket-Network > Remote Control > View Code
PeeperLib.cpp
Package: TOUKUI-1.5.zip　[view]
Upload User: xztxsm
Upload Date: 2007-02-12
Package Size: 150k
Code Size: 42k
Category:

Remote Control

Development Platform:

Visual C++

PeeperLib.cpp：Code Content
  1. ///////////////////////////////////////////////////////////////////////////////
  2. // 远程控制软件-偷窥者  开发库                                               //
  3. // 日期:2001/10/02                                                           //
  4. // 作者:刘东发                                                               //
  5. // Email:dongfa@yeah.net                                                     //
  6. // http://dongfa.yeah.net                                                    //
  7. // OICQ:5584173  阿东                                                        //
  8. // 作者声明:                                                                 //
  9. //     此部分代码全是作者所写，可以随便传播，但要保持文件的完整性,有问题     //
  10. // 或者意见请来信,谢谢!                                                      //
  11. ///////////////////////////////////////////////////////////////////////////////
  13. #include "stdafx.h"
  14. #include "PeeperLib.h"
  15. #include "PeeperZip.h"
  16. #include "Base64.h"
  17. #include <afxinet.h>
  18. #pragma comment(lib, "Wininet.lib")
  20. BOOL WINAPI PL_InitSocket()
  21. {
  22. #define MAJOR_VERSION 1
  23. #define MINOR_VERSION 2
  25. int nStatus = 0;
  26. WORD wMajorVersion = MAJOR_VERSION;
  27. WORD wMinorVersion = MINOR_VERSION;
  28. WORD wVersionReqd = MAKEWORD(wMajorVersion, wMinorVersion);
  29. WSADATA lpmyWSAData;
  30. nStatus = ::WSAStartup(wVersionReqd, &lpmyWSAData);
  31. if(nStatus != 0)
  32. {
  33. return FALSE;
  34. }
  36. return TRUE;
  37. }
  39. BOOL WINAPI PL_TermSocket()
  40. {
  41. return (::WSACleanup() == 0)?TRUE : FALSE;
  42. }
  44. int WINAPI PL_SendSocketData(SOCKET s, BYTE *chData, int nLen, BYTE chFlag, UINT uFlag)
  45. {
  46. int nRet = INVALID_SOCKET;
  47. if(s != INVALID_SOCKET)
  48. {
  49. char *chTemp = new char[nLen + 3];
  50. ZeroMemory(chTemp, nLen + 3);
  51. if(chFlag == PL_NONE) // only data
  52. {
  53. if(chData != NULL)
  54. {
  55. if(uFlag == MSG_OOB)
  56. {
  57. //实际数据大小为N,以MSG_OOB发送时数据长度要加1
  58. nLen += 1;
  59. }
  60. nRet = ::send(s, (char *)chData, nLen, uFlag);
  61. }
  62. else
  63. {
  64. nRet = 0;
  65. }
  66. }
  67. else 
  68. {
  69. chTemp[0] = chFlag;
  70. if(chData != NULL)
  71. {
  72. memcpy(chTemp + 1, chData, nLen);
  73. }
  74. else
  75. {
  76. nLen = 0;
  77. }
  78. if(uFlag == MSG_OOB)
  79. {
  80. //实际数据大小为N,以MSG_OOB发送时数据长度要加1
  81. nLen += 1;
  82. }
  83. nRet = ::send(s, chTemp, nLen+1, uFlag);
  84. }
  85. delete []chTemp;
  86. }
  88. return nRet;
  89. }
  91. int WINAPI PL_ReadSocketData(SOCKET s, BYTE *chData, int nLen, BYTE *chFlag, UINT uFlag)
  92. {
  93. int nRet = INVALID_SOCKET;
  94. if(s != INVALID_SOCKET)
  95. {
  96. nRet = ::recv(s, (char *)chData, nLen, uFlag);
  97. if(nRet > 0)
  98. {
  99. if(chFlag != NULL)
  100. {
  101. *chFlag = chData[0];
  102. }
  103. }
  104. }
  105. return nRet;
  106. }
  108. HGLOBAL WINAPI PL_LZ77_Zip(HGLOBAL hUnZip)
  109. {
  110. int _n = ::GetTickCount();
  112. int nSize = ::GlobalSize(hUnZip);
  113. LPBYTE lpData = (LPBYTE)::GlobalLock(hUnZip);
  114. HGLOBAL hZip = NULL;
  115. if(nSize > 0 && lpData != NULL)
  116. {
  117. const int nMax = 65536;
  118. BYTE byTemp[nMax + 16];
  119. CCompressLZ77 cc;
  120. WORD wFlag1 = 0;
  121. WORD wFlag2 = 0;
  122. int nLast = nSize;
  123. int nReal = 0;
  124. hZip = ::GlobalAlloc(GHND, nMax+16);
  125. LPBYTE lpZipData = (LPBYTE)::GlobalLock(hZip);
  126. int nPos = 0;
  127. int nZipPos = 0;
  128. while(nLast > 0)
  129. {
  130. nReal = min(nLast, nMax);
  131. nLast -= nReal;
  132. if(nReal == nMax)
  133. {
  134. wFlag1 = 0;
  135. }
  136. else
  137. {
  138. wFlag1 = nReal;
  139. }
  140. memcpy(lpZipData + nZipPos, &wFlag1, sizeof(WORD));
  141. nZipPos += sizeof(WORD);
  142. int nRetLen = 0;
  143. nRetLen = cc.Compress(lpData + nPos, nReal, byTemp);
  144. if(nRetLen == 0) // can't compress the block
  145. {
  146. wFlag2 = wFlag1;
  147. memcpy(lpZipData + nZipPos, &wFlag2, sizeof(WORD));
  148. nZipPos += sizeof(WORD);
  149. memcpy(lpZipData + nZipPos, lpData + nPos, nReal);
  150. nZipPos += nReal;
  151. }
  152. else
  153. {
  154. wFlag2 = (WORD)nRetLen;
  155. memcpy(lpZipData + nZipPos, &wFlag2, sizeof(WORD));
  156. nZipPos += sizeof(WORD);
  157. memcpy(lpZipData + nZipPos, byTemp, nRetLen);
  158. nZipPos += nRetLen;
  159. }
  160. nPos += nReal;
  161. ::GlobalUnlock(hZip);
  162. if(nLast > 0)
  163. {
  164. hZip = ::GlobalReAlloc(hZip, nZipPos + nMax, 0);
  165. }
  166. else
  167. {
  168. hZip = ::GlobalReAlloc(hZip, nZipPos, 0);
  169. }
  171. lpZipData = (LPBYTE)::GlobalLock(hZip);
  172. }
  173. ::GlobalUnlock(hZip);
  174. }
  175. TRACE(_T("PL_LZ77_Zip--Time:%d, %d-->%d.n"),
  176. GetTickCount() - _n, GlobalSize(hUnZip), GlobalSize(hZip));
  177. return hZip;
  178. }
  180. HGLOBAL WINAPI PL_LZ77_UnZip(HGLOBAL hZip)
  181. {
  182. int _n = ::GetTickCount();
  183. int nSize = ::GlobalSize(hZip);
  184. LPBYTE lpZipData = (LPBYTE)::GlobalLock(hZip);
  185. HGLOBAL hUnZip = NULL;
  186. if(nSize > 0 && lpZipData != NULL)
  187. {
  188. const int nMax = 65536;
  189. BYTE byTemp[nMax + 16];
  190. CCompressLZ77 cc;
  191. WORD wFlag1 = 0;
  192. WORD wFlag2 = 0;
  193. int nLast = nSize;
  194. int nReal = 0;
  195. hUnZip = ::GlobalAlloc(GHND, nMax+16);
  196. LPBYTE lpData = (LPBYTE)::GlobalLock(hUnZip);
  197. int nPos = 0;
  198. int nZipPos = 0;
  199. while(nLast > 0)
  200. {
  201. memcpy(&wFlag1, lpZipData + nZipPos, sizeof(WORD));
  202. nZipPos += sizeof(WORD);
  203. memcpy(&wFlag2, lpZipData + nZipPos, sizeof(WORD));
  204. nZipPos += sizeof(WORD);
  205. nLast -= 2*sizeof(WORD);
  206. if(wFlag1 == 0)
  207. {
  208. nReal = nMax;
  209. }
  210. else
  211. {
  212. nReal = wFlag1;
  213. }
  214. nLast -= wFlag2 ? (wFlag2) : nReal;
  215. if(wFlag2 == wFlag1)
  216. {
  217. memcpy(byTemp, lpZipData + nZipPos, nReal);
  218. nZipPos += nReal;
  219. }
  220. else
  221. {
  222. // if(AfxIsValidAddress(lpZipData + nZipPos, nReal))
  223. {
  224. if(!cc.Decompress(byTemp, nReal, lpZipData + nZipPos))
  225. {
  226. break ;
  227. }
  228. }
  229. nZipPos += wFlag2;
  230. }
  231. memcpy(lpData + nPos, byTemp, nReal);
  232. nPos += nReal;
  233. ::GlobalUnlock(hUnZip);
  234. if(nLast > 0)
  235. {
  236. if((::GlobalSize(hUnZip) - nPos) < nMax)
  237. {
  238. hUnZip = ::GlobalReAlloc(hUnZip, nPos + nMax, 0);
  239. }
  240. }
  241. else
  242. {
  243. hUnZip = ::GlobalReAlloc(hUnZip, nPos, 0);
  244. }
  245. lpData = (LPBYTE)::GlobalLock(hUnZip);
  246. }
  247. ::GlobalUnlock(hUnZip);
  248. }
  249. TRACE(_T("PL_LZ77_UnZip--Time:%d, %d-->%d.n"),
  250. GetTickCount() - _n, GlobalSize(hZip), GlobalSize(hUnZip));
  251. return hUnZip;
  252. }
  254. HGLOBAL WINAPI PL_LZSS_Zip(HGLOBAL hUnZip)
  255. {
  256. int _n = ::GetTickCount();
  258. HGLOBAL hZip = NULL;
  260. LPBYTE lpData = (LPBYTE)::GlobalLock(hUnZip);
  261. if(lpData != NULL)
  262. {
  263. int nLen = ::GlobalSize(hUnZip);
  264. C_LZSS lz;
  265. hZip = lz.Encode((char *)lpData, nLen);
  266. ::GlobalUnlock(hUnZip);
  267. }
  268. TRACE(_T("PL_LZSS_Zip--Time:%d, %d-->%d.n"),
  269. GetTickCount() - _n, GlobalSize(hUnZip), GlobalSize(hZip));
  270. return hZip;
  271. }
  273. HGLOBAL WINAPI PL_LZSS_UnZip(HGLOBAL hZip)
  274. {
  275. int _n = ::GetTickCount();
  277. HGLOBAL hUnZip = NULL;
  278. LPBYTE lpData = (LPBYTE)::GlobalLock(hZip);
  279. if(lpData != NULL)
  280. {
  281. int nLen = ::GlobalSize(hZip);
  282. C_LZSS lz;
  283. hUnZip = lz.Decode((char *)lpData, nLen);
  284. ::GlobalUnlock(hZip);
  285. }
  287. TRACE(_T("PL_LZSS_UnZip--Time:%d, %d-->%d.n"),
  288. GetTickCount() - _n, GlobalSize(hZip), GlobalSize(hUnZip));
  290. return hUnZip;
  291. }
  293. HGLOBAL WINAPI PL_ARI_Zip(HGLOBAL hUnZip)
  294. {
  295. int _n = ::GetTickCount();
  296. HGLOBAL hZip = NULL;
  298. LPBYTE lpData = (LPBYTE)::GlobalLock(hUnZip);
  299. if(lpData != NULL)
  300. {
  301. int nLen = ::GlobalSize(hUnZip);
  302. C_ARI lz;
  303. hZip = lz.Encode((char *)lpData, nLen);
  304. ::GlobalUnlock(hUnZip);
  305. }
  306. TRACE(_T("PL_ARI_Zip--Time:%d, %d-->%d.n"),
  307. GetTickCount() - _n, GlobalSize(hUnZip), GlobalSize(hZip));
  309. return hZip;
  310. }
  312. HGLOBAL WINAPI PL_ARI_UnZip(HGLOBAL hZip)
  313. {
  314. int _n = ::GetTickCount();
  316. HGLOBAL hUnZip = NULL;
  317. LPBYTE lpData = (LPBYTE)::GlobalLock(hZip);
  318. if(lpData != NULL)
  319. {
  320. int nLen = ::GlobalSize(hZip);
  321. C_ARI lz;
  322. hUnZip = lz.Decode((char *)lpData, nLen);
  323. ::GlobalUnlock(hZip);
  324. }
  326. TRACE(_T("PL_ARI_UnZip--Time:%d, %d-->%d.n"),
  327. GetTickCount() - _n, GlobalSize(hZip), GlobalSize(hUnZip));
  329. return hUnZip;
  330. }
  332. HGLOBAL WINAPI PL_LZW_Zip(HGLOBAL hUnZip)
  333. {
  334. int _n = ::GetTickCount();
  335. HGLOBAL hZip = NULL;
  337. LPBYTE lpData = (LPBYTE)::GlobalLock(hUnZip);
  338. if(lpData != NULL)
  339. {
  340. int nLen = ::GlobalSize(hUnZip);
  341. C_LZW lz;
  342. hZip = lz.Encode((char *)lpData, nLen);
  343. ::GlobalUnlock(hUnZip);
  344. }
  345. TRACE(_T("PL_LZW_Zip--Time:%d, %d-->%d.n"),
  346. GetTickCount() - _n, GlobalSize(hUnZip), GlobalSize(hZip));
  348. return hZip;
  349. }
  351. HGLOBAL WINAPI PL_LZW_UnZip(HGLOBAL hZip)
  352. {
  353. int _n = ::GetTickCount();
  355. HGLOBAL hUnZip = NULL;
  356. LPBYTE lpData = (LPBYTE)::GlobalLock(hZip);
  357. if(lpData != NULL)
  358. {
  359. int nLen = ::GlobalSize(hZip);
  360. C_LZW lz;
  361. hUnZip = lz.Decode((char *)lpData, nLen);
  362. ::GlobalUnlock(hZip);
  363. }
  365. TRACE(_T("PL_LZW_UnZip--Time:%d, %d-->%d.n"),
  366. GetTickCount() - _n, GlobalSize(hZip), GlobalSize(hUnZip));
  368. return hUnZip;
  369. }
  371. BOOL WINAPI PL_Bmp2Gry(HBITMAP hBmp, LPBYTE *lpGryData, SIZE *szGrySize)
  372. {
  373. //目前只支持256色
  374. LPBYTE lpBitsData = NULL;
  375. int nBmpSize = 0;
  377. BITMAPINFO *pInfo = NULL;
  378. BITMAP  bm;
  379. GetObject(hBmp, sizeof(BITMAP), &bm);
  380. if(bm.bmBitsPixel != 8)
  381. {
  382. return FALSE;
  383. }
  385. szGrySize->cx = bm.bmWidth; szGrySize->cy = bm.bmHeight;
  387. nBmpSize = ((((bm.bmWidth * bm.bmBitsPixel) + 31) & ~31) >> 3) * bm.bmHeight;
  388. lpBitsData = new BYTE[nBmpSize];
  389. memset(lpBitsData, 0, nBmpSize);
  391. pInfo = (BITMAPINFO*)new BYTE[sizeof(BITMAPINFOHEADER) + 256*sizeof(RGBQUAD)];
  392. pInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  393. pInfo->bmiHeader.biWidth = bm.bmWidth;
  394. pInfo->bmiHeader.biHeight = bm.bmHeight;
  395. pInfo->bmiHeader.biPlanes = bm.bmPlanes;
  396. pInfo->bmiHeader.biBitCount = bm.bmBitsPixel;
  397. pInfo->bmiHeader.biCompression = BI_RGB;
  398. pInfo->bmiHeader.biSizeImage = nBmpSize;
  399. pInfo->bmiHeader.biXPelsPerMeter = 0;
  400. pInfo->bmiHeader.biYPelsPerMeter = 0;
  401. pInfo->bmiHeader.biClrUsed = 0;
  402. pInfo->bmiHeader.biClrImportant = 0;
  404. HDC           hMemDC;
  405. HBITMAP       hOldBitmap;
  406. RGBQUAD       rgb[256];
  408. memset(rgb, 0, 256);
  409. hMemDC = CreateCompatibleDC(NULL);
  410. hOldBitmap = (HBITMAP)SelectObject(hMemDC, hBmp);
  411. // Get the DIBSection's color table
  412. GetDIBColorTable(hMemDC, 0, 256, rgb);
  413. // Populate BITMAPINFO header info
  414. // Now actually get the bits
  415. CClientDC cdc( CWnd::GetDesktopWindow() );
  416. ::GetDIBits(cdc.GetSafeHdc(), hBmp,
  417. 0, (WORD)bm.bmHeight, lpBitsData, pInfo, DIB_RGB_COLORS);
  419. *lpGryData = new BYTE[nBmpSize];
  420. memset(*lpGryData, 0, nBmpSize);
  421. for(int i = 0; i < nBmpSize; i ++)
  422. {
  423. int nIndex = lpBitsData[i];
  424. double r = (double)(rgb[nIndex].rgbRed);
  425. double g = (double)(rgb[nIndex].rgbGreen);
  426. double b = (double)(rgb[nIndex].rgbBlue);
  427. BYTE c = (BYTE)(r*0.29900 + g*0.58700 + b*0.11400);
  428. int pos = ((bm.bmHeight - (i/bm.bmWidth) - 1)*bm.bmWidth) + (i % bm.bmWidth);
  429. (*lpGryData)[pos] = c;
  430. }
  431. SelectObject(hMemDC, hOldBitmap);
  432. DeleteDC(hMemDC);
  434. delete []lpBitsData;
  435. lpBitsData = NULL;
  437. return TRUE;
  438. }
  440. BOOL WINAPI PL_DrawGry(HDC hDC, LPBYTE lpGryData, SIZE szGrySize)
  441. {
  442. //暂不实现
  443. return TRUE;
  444. }
  446. HBITMAP WINAPI PL_GetBitmap(HWND hWnd)
  447. {
  448. HDC hWndDC = NULL;
  449. HDC hMemDC = NULL;
  450. HBITMAP hMemBmp = NULL;
  451. HBITMAP hOldBmp = NULL;
  452. RECT rect;
  453. int w = 0, h = 0;
  455. if(hWnd == NULL)
  456. {
  457. hWnd = ::GetDesktopWindow();
  458. }
  459. hWndDC = ::GetWindowDC(hWnd);
  460. hMemDC = ::CreateCompatibleDC(hWndDC);
  461. ::GetWindowRect(hWnd, &rect);
  462. w = rect.right - rect.left;
  463. h = rect.bottom - rect.top;
  465. hMemBmp = ::CreateCompatibleBitmap(hWndDC, w, h);
  467. hOldBmp = (HBITMAP)::SelectObject(hMemDC, hMemBmp);
  468. ::BitBlt(hMemDC, 0, 0, w, h, hWndDC, 0, 0, SRCCOPY);
  470. // Why???
  471. hMemBmp = (HBITMAP)::SelectObject(hMemDC, hOldBmp);
  473. ::DeleteObject(hOldBmp);
  474. ::ReleaseDC(NULL, hMemDC);
  475. ::ReleaseDC(NULL, hWndDC);
  477. return hMemBmp;
  478. }
  480. BOOL WINAPI PL_DrawBmp(HDC hDC, LPRECT lpDCRect, HBITMAP hBmp, LPRECT lpBmpRect, CPalette* pPal)
  481. {
  482. HDC hMemDC = NULL;
  483. BITMAP bm;
  485. hMemDC = ::CreateCompatibleDC(hDC);
  486. ::GetObject(hBmp, sizeof(bm), &bm);
  487. ::SelectObject(hMemDC, hBmp);
  489. if(lpBmpRect == NULL)
  490. {
  491. if(lpDCRect != NULL)
  492. {
  493. ::SetStretchBltMode(hDC, COLORONCOLOR);
  494. ::StretchBlt(hDC, lpDCRect->left, lpDCRect->top, RECTWIDTH(lpDCRect), RECTHEIGHT(lpDCRect),
  495. hMemDC, 0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY);
  496. }
  497. else
  498. {
  499. ::BitBlt(hDC, 0, 0, bm.bmWidth, bm.bmHeight, hMemDC, 0, 0, SRCCOPY);
  500. }
  501. }
  502. else
  503. {
  504. if(lpDCRect != NULL)
  505. {
  506. ::SetStretchBltMode(hDC, COLORONCOLOR);
  507. ::StretchBlt(hDC, lpDCRect->left, lpDCRect->top, RECTWIDTH(lpDCRect), RECTHEIGHT(lpDCRect), 
  508. hMemDC, lpBmpRect->left, lpBmpRect->top, RECTWIDTH(lpBmpRect), RECTHEIGHT(lpBmpRect), SRCCOPY);
  509. }
  510. else
  511. {
  512. ::BitBlt(hDC, 0, 0, RECTWIDTH(lpBmpRect), RECTHEIGHT(lpBmpRect), 
  513. hMemDC, lpDCRect->left, lpDCRect->top, SRCCOPY);
  514. }
  515. }
  516. ::ReleaseDC(NULL, hMemDC);
  518. return TRUE;
  519. }
  521. int WINAPI PL_ColorsNum(LPBYTE lpbi)
  522. {
  523. WORD wBitCount = 0;
  524. if(IS_WIN30_DIB(lpbi))
  525. {
  526. DWORD dwClrUsed = ((LPBITMAPINFOHEADER)lpbi)->biClrUsed;
  527. if(dwClrUsed != 0)
  528. return dwClrUsed;
  529. }
  530. if(IS_WIN30_DIB(lpbi))
  531. wBitCount = ((LPBITMAPINFOHEADER)lpbi)->biBitCount;
  532. else
  533. wBitCount = ((LPBITMAPCOREHEADER)lpbi)->bcBitCount;
  535. switch (wBitCount)
  536. {
  537. case 1:
  538. return 2;
  540. case 4:
  541. return 16;
  543. case 8:
  544. return 256;
  546. default:
  547. return 0;
  548. }
  549. }
  551. int WINAPI PL_DIBWidth(LPBYTE lpDIB)
  552. {
  553. LPBITMAPINFOHEADER lpbmi;
  554. LPBITMAPCOREHEADER lpbmc;
  556. lpbmi = (LPBITMAPINFOHEADER)lpDIB;
  557. lpbmc = (LPBITMAPCOREHEADER)lpDIB;
  559. if (IS_WIN30_DIB(lpDIB))
  560. return lpbmi->biWidth;
  561. else
  562. return lpbmc->bcWidth;
  563. }
  565. int WINAPI PL_DIBHeight(LPBYTE lpDIB)
  566. {
  567. LPBITMAPINFOHEADER lpbmi;
  568. LPBITMAPCOREHEADER lpbmc;
  570. lpbmi = (LPBITMAPINFOHEADER)lpDIB;
  571. lpbmc = (LPBITMAPCOREHEADER)lpDIB;
  573. if (IS_WIN30_DIB(lpDIB))
  574. return lpbmi->biHeight;
  575. else
  576. return lpbmc->bcHeight;
  577. }
  579. int WINAPI PL_PaletteSize(LPBYTE lpbi)
  580. {
  581.    if(IS_WIN30_DIB(lpbi))
  582.   return (WORD)(::PL_ColorsNum(lpbi)*sizeof(RGBQUAD));
  583.    else
  584.   return (WORD)(::PL_ColorsNum(lpbi)*sizeof(RGBTRIPLE));
  585. }
  587. HDIB WINAPI PL_BmpToDIB(HBITMAP hBitmap, HPALETTE hPal, int nBits)
  588. {
  589.     BITMAP              bm;
  590.     BITMAPINFOHEADER    bi;
  591.     LPBITMAPINFOHEADER  lpbi;
  592.     DWORD               dwLen;
  593.     HANDLE              hDIB, h;
  594.     HDC                 hDC;
  595.     WORD                biBits;
  597.     if(!hBitmap)
  598.         return NULL;
  600.     if(!GetObject(hBitmap, sizeof(bm), (LPSTR)&bm))
  601.         return NULL;
  602.     if (hPal == NULL)
  603.         hPal = (HPALETTE) GetStockObject(DEFAULT_PALETTE);
  604.     biBits = bm.bmPlanes * bm.bmBitsPixel;
  605.     if (biBits <= 1)
  606.         biBits = 1;
  607.     else if (biBits <= 4)
  608.         biBits = 4;
  609.     else if (biBits <= 8)
  610.         biBits = 8;
  611.     else
  612.         biBits = 24;
  613. if(nBits != -1)
  614. {
  615. if(nBits == 1 || nBits == 4 || nBits == 8 || nBits == 24)
  616. {
  617. biBits = nBits;
  618. }
  619. }
  620.     bi.biSize = sizeof(BITMAPINFOHEADER);
  621.     bi.biWidth = bm.bmWidth;
  622.     bi.biHeight = bm.bmHeight;
  623.     bi.biPlanes = 1;
  624.     bi.biBitCount = biBits;
  625.     bi.biCompression = BI_RGB;
  626.     bi.biSizeImage = 0;
  627.     bi.biXPelsPerMeter = 0;
  628.     bi.biYPelsPerMeter = 0;
  629.     bi.biClrUsed = 0;
  630.     bi.biClrImportant = 0;
  631.     dwLen = bi.biSize + PL_PaletteSize((LPBYTE)&bi);
  633.     hDC = GetDC(NULL);
  634.     hPal = SelectPalette(hDC, hPal, FALSE);
  635.     RealizePalette(hDC);
  636.     hDIB = GlobalAlloc(GHND, dwLen);
  637.     if (!hDIB)
  638.     {
  639.       SelectPalette(hDC, hPal, TRUE);
  640.       RealizePalette(hDC);
  641.       ReleaseDC(NULL, hDC);
  642.       return NULL;
  643.     }
  644.     lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  645.     *lpbi = bi;
  646.     GetDIBits(hDC, hBitmap, 0, (UINT)bi.biHeight, NULL, (LPBITMAPINFO)lpbi,
  647.         DIB_RGB_COLORS);
  648.     bi = *lpbi;
  649.     GlobalUnlock(hDIB);
  651.     if (bi.biSizeImage == 0)
  652.         bi.biSizeImage = WIDTHBYTES((DWORD)bm.bmWidth * biBits) * bm.bmHeight;
  653.     dwLen = bi.biSize + PL_PaletteSize((LPBYTE)&bi) + bi.biSizeImage;
  655.     if (h = GlobalReAlloc(hDIB, dwLen, 0))
  656.         hDIB = h;
  657.     else
  658.     {
  659.         GlobalFree(hDIB);
  660.         hDIB = NULL;
  661.         SelectPalette(hDC, hPal, TRUE);
  662.         RealizePalette(hDC);
  663.         ReleaseDC(NULL, hDC);
  664.         return NULL;
  665.     }
  666.     lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  667.     if (GetDIBits(hDC, hBitmap, 0, (UINT)bi.biHeight, (LPSTR)lpbi +
  668.             (WORD)lpbi->biSize + PL_PaletteSize((LPBYTE)lpbi), (LPBITMAPINFO)lpbi,
  669.             DIB_RGB_COLORS) == 0)
  670.     {
  671.         GlobalUnlock(hDIB);
  672.         hDIB = NULL;
  673.         SelectPalette(hDC, hPal, TRUE);
  674.         RealizePalette(hDC);
  675.         ReleaseDC(NULL, hDC);
  676.         return NULL;
  677.     }
  679.     bi = *lpbi;
  680.     GlobalUnlock(hDIB);
  681.     SelectPalette(hDC, hPal, TRUE);
  682.     RealizePalette(hDC);
  683.     ReleaseDC(NULL, hDC);
  685.     return (HDIB) hDIB;
  686. }
  688. BOOL WINAPI PL_CreateDIBPalette(HDIB hDIB, CPalette* pPal)
  689. {
  690. LPLOGPALETTE lpPal = NULL;
  691. HANDLE hLogPal = NULL;
  692. HPALETTE hPal = NULL;
  693. int i;                   // loop index
  694. WORD wNumColors;         // number of colors in color table
  695. LPSTR lpbi;              // pointer to packed-DIB
  696. LPBITMAPINFO lpbmi;      // pointer to BITMAPINFO structure (Win3.0)
  697. LPBITMAPCOREINFO lpbmc;  // pointer to BITMAPCOREINFO structure (old)
  698. BOOL bWinStyleDIB;       // flag which signifies whether this is a Win3.0 DIB
  699. BOOL bResult = FALSE;
  701. if (hDIB == NULL)
  702. return FALSE;
  704. lpbi = (LPSTR) ::GlobalLock((HGLOBAL) hDIB);
  706. lpbmi = (LPBITMAPINFO)lpbi;
  708. lpbmc = (LPBITMAPCOREINFO)lpbi;
  710. wNumColors = ::PL_ColorsNum((LPBYTE)lpbi);
  712. if (wNumColors != 0)
  713. {
  714. hLogPal = ::GlobalAlloc(GHND, sizeof(LOGPALETTE)
  715. + sizeof(PALETTEENTRY) * wNumColors);
  717. if (hLogPal == 0)
  718. {
  719. ::GlobalUnlock((HGLOBAL) hDIB);
  720. return FALSE;
  721. }
  723. lpPal = (LPLOGPALETTE) ::GlobalLock((HGLOBAL) hLogPal);
  725. lpPal->palVersion = PALVERSION;
  726. lpPal->palNumEntries = (WORD)wNumColors;
  728. bWinStyleDIB = IS_WIN30_DIB(lpbi);
  729. for (i = 0; i < (int)wNumColors; i++)
  730. {
  731. if (bWinStyleDIB)
  732. {
  733. lpPal->palPalEntry[i].peRed = lpbmi->bmiColors[i].rgbRed;
  734. lpPal->palPalEntry[i].peGreen = lpbmi->bmiColors[i].rgbGreen;
  735. lpPal->palPalEntry[i].peBlue = lpbmi->bmiColors[i].rgbBlue;
  736. lpPal->palPalEntry[i].peFlags = 0;
  737. }
  738. else
  739. {
  740. lpPal->palPalEntry[i].peRed = lpbmc->bmciColors[i].rgbtRed;
  741. lpPal->palPalEntry[i].peGreen = lpbmc->bmciColors[i].rgbtGreen;
  742. lpPal->palPalEntry[i].peBlue = lpbmc->bmciColors[i].rgbtBlue;
  743. lpPal->palPalEntry[i].peFlags = 0;
  744. }
  745. }
  747. bResult = pPal->CreatePalette(lpPal);
  748. ::GlobalUnlock((HGLOBAL) hLogPal);
  749. ::GlobalFree((HGLOBAL) hLogPal);
  750. }
  752. ::GlobalUnlock((HGLOBAL) hDIB);
  754. return bResult;
  755. }
  757. LPBYTE WINAPI PL_DIBBits(LPBYTE lpbi)
  758. {
  759. return (lpbi + *(LPDWORD)lpbi + ::PL_PaletteSize(lpbi));
  760. }
  762. BOOL WINAPI PL_DrawDIB(HDC hDC, LPRECT lpDCRect, HDIB hDIB, 
  763.    LPRECT lpDIBRect, CPalette* pPal)
  764. {
  765. LPSTR    lpDIBHdr;
  766. LPSTR    lpDIBBits;
  767. BOOL     bSuccess = FALSE;
  768. HPALETTE hPal = NULL;
  769. HPALETTE hOldPal = NULL;
  771. if(hDIB == NULL)
  772. return -1;
  773. lpDIBHdr  = (LPSTR)::GlobalLock((HGLOBAL) hDIB);
  774. lpDIBBits = (LPSTR)::PL_DIBBits((LPBYTE)lpDIBHdr);
  776. if(pPal != NULL)
  777. {
  778. hPal = (HPALETTE) pPal->m_hObject;
  779. hOldPal = ::SelectPalette(hDC, hPal, TRUE);
  780. }
  782. if(lpDIBRect == NULL)
  783. {
  784. if(lpDCRect != NULL)
  785. {
  786. ::SetStretchBltMode(hDC, COLORONCOLOR);
  788. bSuccess = ::StretchDIBits(hDC, lpDCRect->left, lpDCRect->top,
  789. RECTWIDTH(lpDCRect), RECTHEIGHT(lpDCRect), 0, 0, 
  790. PL_DIBWidth((LPBYTE)lpDIBHdr), PL_DIBHeight((LPBYTE)lpDIBHdr),
  791. lpDIBBits, (LPBITMAPINFO)lpDIBHdr, DIB_RGB_COLORS, SRCCOPY);
  792. }
  793. else
  794. {
  795. bSuccess = ::SetDIBitsToDevice(hDC, 0, 0,
  796. PL_DIBWidth((LPBYTE)lpDIBHdr), PL_DIBHeight((LPBYTE)lpDIBHdr),
  797. 0, 0, 0, PL_DIBHeight((LPBYTE)lpDIBHdr),
  798. lpDIBBits, (LPBITMAPINFO)lpDIBHdr, DIB_RGB_COLORS);
  799. }
  800. }
  801. else
  802. {
  803. if(lpDCRect != NULL)
  804. {
  805. ::SetStretchBltMode(hDC, COLORONCOLOR);
  807. bSuccess = ::StretchDIBits(hDC, lpDCRect->left, lpDCRect->top,
  808. RECTWIDTH(lpDCRect), RECTHEIGHT(lpDCRect),
  809. lpDIBRect->left, lpDIBRect->top, 
  810. RECTWIDTH(lpDIBRect), RECTHEIGHT(lpDIBRect),
  811. lpDIBBits, (LPBITMAPINFO)lpDIBHdr, DIB_RGB_COLORS, SRCCOPY);
  813. }
  814. else
  815. {
  816. bSuccess = ::SetDIBitsToDevice(hDC, 0, 0,
  817. RECTWIDTH(lpDIBRect), RECTHEIGHT(lpDIBRect),
  818. 0, 0, 0, RECTHEIGHT(lpDIBRect),
  819. lpDIBBits, (LPBITMAPINFO)lpDIBHdr, DIB_RGB_COLORS);
  821. }
  822. }
  824. ::GlobalUnlock((HGLOBAL)hDIB);
  825. if (hOldPal != NULL)
  826. {
  827. ::SelectPalette(hDC, hOldPal, TRUE);
  828. }
  830. return bSuccess;
  831. }
  833. SIZE WINAPI PL_GetScreenSize()
  834. {
  835. SIZE sz;
  836. sz.cx = ::GetSystemMetrics(SM_CXSCREEN);
  837. sz.cy = ::GetSystemMetrics(SM_CYSCREEN);
  838. return sz;
  839. }
  841. void WINAPI PL_MouseMove(POINT point)
  842. {
  843. ::SetCursorPos(point.x, point.y);
  844. }
  846. void WINAPI PL_MouseLButtonDown(POINT point, BOOL bMove)
  847. {
  848. if(bMove)
  849. {
  850. ::PL_MouseMove(point);
  851. }
  852. ::mouse_event(MOUSEEVENTF_LEFTDOWN, point.x, point.y, 0, 0);
  853. }
  855. void WINAPI PL_MouseLButtonUp(POINT point, BOOL bMove)
  856. {
  857. if(bMove)
  858. {
  859. ::PL_MouseMove(point);
  860. }
  861. ::mouse_event(MOUSEEVENTF_LEFTUP, point.x, point.y, 0, 0);
  862. }
  864. void WINAPI PL_MouseRButtonDown(POINT point, BOOL bMove)
  865. {
  866. if(bMove)
  867. {
  868. ::PL_MouseMove(point);
  869. }
  870. ::mouse_event(MOUSEEVENTF_RIGHTDOWN, point.x, point.y, 0, 0);
  871. }
  873. void WINAPI PL_MouseRButtonUp(POINT point, BOOL bMove)
  874. {
  875. if(bMove)
  876. {
  877. ::PL_MouseMove(point);
  878. }
  879. ::mouse_event(MOUSEEVENTF_RIGHTUP, point.x, point.y, 0, 0);
  880. }
  882. void WINAPI PL_MouseLButtonDblClk(POINT point, BOOL bMove)
  883. {
  884. if(bMove)
  885. {
  886. ::PL_MouseMove(point);
  887. }
  888. ::PL_MouseLButtonDown(point);
  889. ::PL_MouseLButtonUp(point);
  890. ::PL_MouseLButtonDown(point);
  891. ::PL_MouseLButtonUp(point);
  892. }
  894. void WINAPI PL_MouseRButtonDblClk(POINT point, BOOL bMove)
  895. {
  896. if(bMove)
  897. {
  898. ::PL_MouseMove(point);
  899. }
  900. ::PL_MouseRButtonDown(point);
  901. ::PL_MouseRButtonUp(point);
  902. ::PL_MouseRButtonDown(point);
  903. ::PL_MouseRButtonUp(point);
  904. }
  906. void WINAPI PL_KeyDown(UINT uChar, UINT uFlag)
  907. {
  908. ::keybd_event((BYTE)uChar, (BYTE)uChar, 0, 0);
  909. }
  911. void WINAPI PL_KeyUp(UINT uChar, UINT uFlag)
  912. {
  913. ::keybd_event((BYTE)uChar, (BYTE)uChar, KEYEVENTF_KEYUP, 0);
  914. }
  916. BOOL WINAPI PL_GetHostName(char *chIP, char *chName)
  917. {
  918. BOOL bRet = FALSE;
  919. char chTemp[256];
  920. hostent* pEnt = NULL;
  921. ZeroMemory(chTemp, 256);
  922. int nRet = ::gethostname(chTemp, 256);
  923. if(nRet == 0)
  924. {
  925. if(AfxIsValidAddress(chName, strlen(chTemp)))
  926. {
  927. strcpy(chName, chTemp);
  928. bRet = TRUE;
  929. }
  930. if(AfxIsValidAddress(chIP, 16))
  931. {
  932. pEnt = ::gethostbyname(chTemp);
  933. if(pEnt)
  934. {
  935. sprintf(chIP, "%d.%d.%d.%d", 
  936. BYTE(pEnt->h_addr_list[0][0]), BYTE(pEnt->h_addr_list[0][1]),
  937. BYTE(pEnt->h_addr_list[0][2]), BYTE(pEnt->h_addr_list[0][3]));
  938. bRet = TRUE;
  939. }
  940. else
  941. {
  942. bRet = FALSE;
  943. }
  944. }
  945. }
  946. return bRet;
  947. }
  949. int WINAPI PL_ExecuteCommand(char *chCommandLine)
  950. {
  951. return ::WinExec(chCommandLine, SW_NORMAL);
  952. }
  954. void WINAPI PL_LockDesktop(BOOL bLock)
  955. {
  956. ::ShowCursor(!bLock);
  957. ::SystemParametersInfo(SPI_SETFASTTASKSWITCH, (int)(!bLock), NULL, 0);
  958. ::SystemParametersInfo(SPI_SCREENSAVERRUNNING, (int)bLock, NULL, 0);
  959. ::EnableWindow(::GetDesktopWindow(), !bLock);
  960. }
  962. BOOL WINAPI PL_ExitWindow(UINT uFlag)
  963. {
  964. HANDLE hToken = NULL;
  965. TOKEN_PRIVILEGES tkp;
  966. BOOL fResult = FALSE;
  967. if(OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
  968. {
  969. if(LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, &tkp.Privileges[0].Luid))
  970. {
  971. tkp.PrivilegeCount = 1;
  972. tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; 
  973. if(AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES) NULL, 0))
  974. {
  975. return ::ExitWindowsEx(uFlag, 0);
  976. }
  977. }
  978. }
  980. return ::ExitWindowsEx(uFlag, 0);
  981. }
  983. void WINAPI PL_Send_CtrlAltDel()
  984. {
  985. ::PL_KeyDown(VK_CONTROL, 0);
  986. ::PL_KeyDown(VK_MENU, 0);
  987. ::PL_KeyDown(VK_DELETE, 0);
  988. ::Sleep(2000);
  989. ::PL_KeyUp(VK_CONTROL, 0);
  990. ::PL_KeyUp(VK_MENU, 0);
  991. ::PL_KeyUp(VK_DELETE, 0);
  992. }
  994. BOOL WINAPI PL_CopyFileClient(CString strIP, UINT uPort, char *chSrc, 
  995.   BOOL bSend, HWND hNotifyWnd)
  996. {
  997. BOOL bRet = FALSE;
  998. CSocket sckClient;
  999. CFile file;
  1000. do
  1001. {
  1002. if(bSend)
  1003. {
  1004. bRet = file.Open(chSrc, CFile::modeRead);
  1005. }
  1006. else
  1007. {
  1008. bRet = file.Open(chSrc, CFile::modeCreate | CFile::modeWrite);
  1009. }
  1010. if(!bRet)
  1011. {
  1012. break ;
  1013. }
  1014. bRet = sckClient.Create();
  1015. if(!bRet)
  1016. {
  1017. break ;
  1018. }
  1019. bRet = sckClient.Connect(strIP, uPort);
  1020. if(!bRet)
  1021. {
  1022. break ;
  1023. }
  1024. BYTE *chFileData = new BYTE[PL_SOCKET_MAXBYTES+1];
  1025. char chData[10];
  1026. int nSize = 0;
  1027. if(bSend)
  1028. {
  1029. nSize = file.GetLength();
  1030. int nRead = nSize;
  1031. ZeroMemory(chData, 10);
  1032. memcpy(chData, &nSize, sizeof(int));
  1033. int nRet = sckClient.Send(chData, sizeof(int));
  1034. if(nRet <= 0)
  1035. {
  1036. bRet = FALSE;
  1037. break ;
  1038. }
  1039. while(nRead > 0)
  1040. {
  1041. int n1 = min(nRead, PL_SOCKET_MAXBYTES);
  1042. int n2 = file.Read(chFileData, n1);
  1043. nRead -= n2;
  1044. nRet = sckClient.Send(chFileData, n2);
  1045. if(nRet <= 0)
  1046. {
  1047. bRet = FALSE;
  1048. break ;
  1049. }
  1050. if(hNotifyWnd != NULL)
  1051. {
  1052. int nProgress = (int)(((float)(nSize - nRead))*100.0f/((float)nSize));
  1053. ::PostMessage(hNotifyWnd, PL_PEEPER_NOTIFY_COPYFILE, 
  1054. (WPARAM)nProgress, NULL);
  1055. }
  1056. bRet = TRUE;
  1057. }
  1058. }
  1059. else
  1060. {
  1061. char chData[10];
  1062. ZeroMemory(chData, 10);
  1063. nSize = 0;
  1064. int nRet = sckClient.Receive(chData, 10);//读文件大小
  1065. if(nRet <= 0)
  1066. {
  1067. bRet = FALSE;
  1068. break ;
  1069. }
  1070. nSize = *((int*)(chData));
  1071. if(nSize <= 0)
  1072. {
  1073. bRet = FALSE;
  1074. break ;
  1075. }
  1076. BYTE *chFileData = new BYTE[PL_SOCKET_MAXBYTES+1];
  1077. int nWrite = 0;
  1078. while(nWrite < nSize)
  1079. {
  1080. nRet = sckClient.Receive(chFileData, PL_SOCKET_MAXBYTES);
  1081. if(nRet <= 0)
  1082. {
  1083. bRet = FALSE;
  1084. break ;
  1085. }
  1086. file.Write(chFileData, nRet);
  1087. nWrite += nRet;
  1088. if(hNotifyWnd != NULL)
  1089. {
  1090. int nProgress = (int)(((float)nWrite)*100.0f/((float)nSize));
  1091. ::PostMessage(hNotifyWnd, PL_PEEPER_NOTIFY_COPYFILE, 
  1092. (WPARAM)nProgress, NULL);
  1093. }
  1094. bRet = TRUE;
  1095. }
  1096. }
  1097. delete []chFileData;
  1098. if(!bRet) // 送文件数据出错.
  1099. {
  1100. break ;
  1101. }
  1102. }while(0);
  1103. if(sckClient.m_hSocket != INVALID_SOCKET)
  1104. {
  1105. sckClient.Close();
  1106. }
  1107. if(file.m_hFile != CFile::hFileNull)
  1108. {
  1109. file.Close();
  1110. }
  1112. return bRet;
  1113. }
  1115. BOOL WINAPI PL_CopyFileServer(UINT uPort, char *chDes, BOOL bSend, HWND hNotifyWnd)
  1116. {
  1117. BOOL bRet = FALSE;
  1118. CFile file;
  1119. CSocket sckServer;
  1120. CSocket sckClient;
  1121. do
  1122. {
  1123. if(!bSend)
  1124. {
  1125. bRet = file.Open(chDes, CFile::modeCreate | CFile::modeWrite);
  1126. }
  1127. else
  1128. {
  1129. bRet = file.Open(chDes, CFile::modeRead);
  1130. }
  1131. if(!bRet)
  1132. {
  1133. break ;
  1134. }
  1135. bRet = sckServer.Create(uPort);
  1136. if(!bRet)
  1137. {
  1138. break ;
  1139. }
  1140. bRet = sckServer.Listen();
  1141. if(!bRet)
  1142. {
  1143. break ;
  1144. }
  1145. bRet = sckServer.Accept(sckClient);
  1146. if(!bRet)
  1147. {
  1148. break ;
  1149. }
  1150. char chData[10];
  1151. BYTE *chFileData = new BYTE[PL_SOCKET_MAXBYTES+1];
  1152. int nSize = 0;
  1153. if(!bSend)
  1154. {
  1155. ZeroMemory(chData, 10);
  1156. int nRet = sckClient.Receive(chData, 10);//读文件大小
  1157. if(nRet <= 0)
  1158. {
  1159. bRet = FALSE;
  1160. break ;
  1161. }
  1162. nSize = *((int*)(chData));
  1163. if(nSize <= 0)
  1164. {
  1165. bRet = FALSE;
  1166. break ;
  1167. }
  1168. int nWrite = 0;
  1169. while(nWrite < nSize)
  1170. {
  1171. nRet = sckClient.Receive(chFileData, PL_SOCKET_MAXBYTES);
  1172. if(nRet <= 0)
  1173. {
  1174. bRet = FALSE;
  1175. break ;
  1176. }
  1177. file.Write(chFileData, nRet);
  1178. nWrite += nRet;
  1179. if(hNotifyWnd != NULL)
  1180. {
  1181. int nProgress = (int)(((float)nWrite)*100.0f/((float)nSize));
  1182. ::PostMessage(hNotifyWnd, PL_PEEPER_NOTIFY_COPYFILE, 
  1183. (WPARAM)nProgress, NULL);
  1184. }
  1185. bRet = TRUE;
  1186. }
  1187. }
  1188. else
  1189. {
  1190. nSize = file.GetLength();
  1191. int nRead = nSize;
  1192. ZeroMemory(chData, 10);
  1193. memcpy(chData, &nSize, sizeof(int));
  1194. int nRet = sckClient.Send(chData, sizeof(int));
  1195. if(nRet <= 0)
  1196. {
  1197. bRet = FALSE;
  1198. break ;
  1199. }
  1200. while(nRead > 0)
  1201. {
  1202. int n1 = min(nRead, PL_SOCKET_MAXBYTES);
  1203. int n2 = file.Read(chFileData, n1);
  1204. nRead -= n2;
  1205. nRet = sckClient.Send(chFileData, n2);
  1206. if(nRet <= 0)
  1207. {
  1208. bRet = FALSE;
  1209. break ;
  1210. }
  1211. if(hNotifyWnd != NULL)
  1212. {
  1213. int nProgress = (int)(((float)(nSize - nRead))*100.0f/((float)nSize));
  1214. ::PostMessage(hNotifyWnd, PL_PEEPER_NOTIFY_COPYFILE, 
  1215. (WPARAM)nProgress, NULL);
  1216. }
  1217. bRet = TRUE;
  1218. }
  1219. }
  1220. delete []chFileData;
  1221. }while(0);
  1222. if(sckClient.m_hSocket != INVALID_SOCKET)
  1223. {
  1224. sckClient.Close();
  1225. }
  1226. if(sckServer.m_hSocket != INVALID_SOCKET)
  1227. {
  1228. sckServer.Close();
  1229. }
  1230. if(file.m_hFile != CFile::hFileNull)
  1231. {
  1232. file.Close();
  1233. }
  1235. return bRet;
  1236. }
  1238. BOOL WINAPI PL_DeleteFile(char *chFileName)
  1239. {
  1240. BOOL bRet = FALSE;
  1241. DWORD dwFlag = ::SetFileAttributes(chFileName, FILE_ATTRIBUTE_NORMAL);
  1242. if(dwFlag != 0xFFFFFFFF)
  1243. {
  1244. bRet = ::DeleteFile(chFileName);
  1245. }
  1247. return bRet;
  1248. }
  1250. BOOL WINAPI PL_MoveFile(char *chSrcFileName, char *chDesFileName)
  1251. {
  1252. BOOL bRet = FALSE;
  1253. DWORD dwFlag = ::SetFileAttributes(chSrcFileName, FILE_ATTRIBUTE_NORMAL);
  1254. if(dwFlag != 0xFFFFFFFF)
  1255. {
  1256. bRet = ::MoveFile(chSrcFileName, chDesFileName);
  1257. }
  1259. return bRet;
  1260. }
  1262. BOOL WINAPI PL_SendMail(CString strSMTP, CString strFrom, 
  1263. CString strTo, CString strSubject, CString strBody)
  1264. {
  1265. BOOL bRet = FALSE;
  1266. CSocket sckSmtp;
  1267. if(sckSmtp.Create())
  1268. {
  1269. char chMonth[][12] = { "JAN", "FEB", "MAR", "APR", "MAY", "JUN", 
  1270. "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"};
  1271. SYSTEMTIME sm;
  1272. ::GetLocalTime(&sm);
  1273. CString strDate;
  1274. //                  日  月  年    时  分  秒  
  1275. strDate.Format(_T("%02d %s %02d %02d:%02d:%02d"), 
  1276. sm.wDay, chMonth[sm.wMonth-1], sm.wYear%100, 
  1277. sm.wHour, sm.wMinute, sm.wSecond);
  1278. char chTemp[1024];
  1280. int nRet = -1;
  1281. if(sckSmtp.Connect(strSMTP, 25))
  1282. {
  1283. do
  1284. {
  1285. //接收信息
  1286. ZeroMemory(chTemp, 1024);
  1287. nRet = sckSmtp.Receive(chTemp, 1024);
  1288. if(nRet < 0)
  1289. break ;
  1290. if(strncmp(chTemp, "220", 3) != 0 &&
  1291.    strncmp(chTemp, "250", 3) != 0 &&
  1292.    strncmp(chTemp, "354", 3) != 0 &&
  1293.    strncmp(chTemp, "221", 3) != 0) // 220, 250, 354, 221成功
  1294. break ;
  1295. //欢迎用户
  1297. TCHAR local_host[80];
  1298. ZeroMemory(local_host, 80*sizeof(TCHAR));
  1299. ::gethostname(local_host, 80);
  1300. CString strUser = CString(local_host);
  1302. ZeroMemory(chTemp, 1024);
  1303. sprintf(chTemp, "HELO %srn", strUser);
  1304. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1305. if(nRet < 0)
  1306. break ;
  1307. //接收信息
  1308. ZeroMemory(chTemp, 1024);
  1309. nRet = sckSmtp.Receive(chTemp, 1024);
  1310. if(nRet < 0)
  1311. break ;
  1312. if(strncmp(chTemp, "220", 3) != 0 &&
  1313.    strncmp(chTemp, "250", 3) != 0 &&
  1314.    strncmp(chTemp, "354", 3) != 0 &&
  1315.    strncmp(chTemp, "221", 3) != 0) // 220, 250, 354, 221成功
  1316. break ;
  1317. //mail from
  1318. ZeroMemory(chTemp, 1024);
  1319. sprintf(chTemp, "MAIL FROM: <%s>rn", strFrom);
  1320. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1321. if(nRet < 0)
  1322. break ;
  1323. //接收信息
  1324. ZeroMemory(chTemp, 1024);
  1325. nRet = sckSmtp.Receive(chTemp, 1024);
  1326. if(nRet < 0)
  1327. break ;
  1328. if(strncmp(chTemp, "220", 3) != 0 &&
  1329.    strncmp(chTemp, "250", 3) != 0 &&
  1330.    strncmp(chTemp, "354", 3) != 0 &&
  1331.    strncmp(chTemp, "221", 3) != 0) // 220, 250, 354, 221成功
  1332. break ;
  1333. //rcpt to
  1334. ZeroMemory(chTemp, 1024);
  1335. sprintf(chTemp, "RCPT TO: <%s>rn", strTo);
  1336. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1337. if(nRet < 0)
  1338. break ;
  1339. //接收信息
  1340. ZeroMemory(chTemp, 1024);
  1341. nRet = sckSmtp.Receive(chTemp, 1024);
  1342. if(nRet < 0)
  1343. break ;
  1344. if(strncmp(chTemp, "220", 3) != 0 &&
  1345.    strncmp(chTemp, "250", 3) != 0 &&
  1346.    strncmp(chTemp, "354", 3) != 0 &&
  1347.    strncmp(chTemp, "221", 3) != 0) // 220, 250, 354, 221成功
  1348. break ;
  1349. //Data
  1350. ZeroMemory(chTemp, 1024);
  1351. sprintf(chTemp, "DATArn");
  1352. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1353. if(nRet < 0)
  1354. break ;
  1355. //接收信息
  1356. ZeroMemory(chTemp, 1024);
  1357. nRet = sckSmtp.Receive(chTemp, 1024);
  1358. if(nRet < 0)
  1359. break ;
  1360. if(strncmp(chTemp, "220", 3) != 0 &&
  1361.    strncmp(chTemp, "250", 3) != 0 &&
  1362.    strncmp(chTemp, "354", 3) != 0 &&
  1363.    strncmp(chTemp, "221", 3) != 0) // 220, 250, 354, 221成功
  1364. break ;
  1365. //信件内容
  1366. //时间
  1367. ZeroMemory(chTemp, 1024);
  1368. sprintf(chTemp, "Date: %srn", strDate);
  1369. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1370. if(nRet < 0)
  1371. break ;
  1372. //From
  1373. ZeroMemory(chTemp, 1024);
  1374. sprintf(chTemp, "From:%srn", strFrom);
  1375. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1376. if(nRet < 0)
  1377. break ;
  1378. //To
  1379. ZeroMemory(chTemp, 1024);
  1380. sprintf(chTemp, "To:%srn", strTo);
  1381. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1382. if(nRet < 0)
  1383. break ;
  1384. //CC
  1385. // ZeroMemory(chTemp, 1024);
  1386. // sprintf(chTemp, "CC:%srn", strCC);
  1387. // sckSmtp.Send(chTemp, strlen(chTemp));
  1388. //Subject
  1389. ZeroMemory(chTemp, 1024);
  1390. sprintf(chTemp, "Subject:%srn", strSubject);
  1391. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1392. if(nRet < 0)
  1393. break ;
  1394. //内容
  1395. int nLen = strBody.GetLength() + 5;
  1396. char *chBody = new char[nLen];
  1397. ZeroMemory(chBody, nLen);
  1398. sprintf(chBody, "%srn", strBody);
  1399. nRet = sckSmtp.Send(chBody, strlen(chBody));
  1400. delete []chBody;
  1401. if(nRet < 0)
  1402. break ;
  1403. //结束
  1404. ZeroMemory(chTemp, 1024);
  1405. sprintf(chTemp, ".rn");
  1406. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1407. if(nRet < 0)
  1408. break ;
  1409. //接收信息
  1410. ZeroMemory(chTemp, 1024);
  1411. nRet = sckSmtp.Receive(chTemp, 1024);
  1412. if(nRet < 0)
  1413. break ;
  1414. if(strncmp(chTemp, "220", 3) != 0 &&
  1415.    strncmp(chTemp, "250", 3) != 0 &&
  1416.    strncmp(chTemp, "354", 3) != 0 &&
  1417.    strncmp(chTemp, "221", 3) != 0) // 220, 250, 354, 221成功
  1418. break ;
  1419. //退出
  1420. ZeroMemory(chTemp, 1024);
  1421. sprintf(chTemp, "QUITrn");
  1422. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1423. if(nRet < 0)
  1424. break ;
  1425. bRet = TRUE;
  1426. }while(0);
  1427. }
  1428. sckSmtp.Close();
  1429. }
  1431. return bRet;
  1432. }
  1434. BOOL WINAPI PL_SendMail2(CString strSMTP, CString strFrom, CString strAuth, 
  1435.   CString strPass, CString strTo, CString strSubject, 
  1436.   CString strBody)
  1437. {
  1438. BOOL bRet = FALSE;
  1439. CSocket sckSmtp;
  1440. if(sckSmtp.Create())
  1441. {
  1442. char chMonth[][12] = { "JAN", "FEB", "MAR", "APR", "MAY", "JUN", 
  1443. "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"};
  1444. SYSTEMTIME sm;
  1445. ::GetLocalTime(&sm);
  1446. CString strDate;
  1447. //                  日  月  年    时  分  秒  
  1448. strDate.Format(_T("%02d %s %02d %02d:%02d:%02d"), 
  1449. sm.wDay, chMonth[sm.wMonth-1], sm.wYear%100, 
  1450. sm.wHour, sm.wMinute, sm.wSecond);
  1451. char chTemp[1024];
  1453. int nRet = -1;
  1454. if(sckSmtp.Connect(strSMTP, 25))
  1455. {
  1456. do
  1457. {
  1458. //接收信息
  1459. ZeroMemory(chTemp, 1024);
  1460. nRet = sckSmtp.Receive(chTemp, 1024);
  1461. if(nRet < 0)
  1462. break ;
  1463. if(strncmp(chTemp, "220", 3) != 0 &&
  1464.    strncmp(chTemp, "250", 3) != 0 &&
  1465.    strncmp(chTemp, "334", 3) != 0 &&
  1466.    strncmp(chTemp, "235", 3) != 0 &&
  1467.    strncmp(chTemp, "354", 3) != 0 &&
  1468.    strncmp(chTemp, "221", 3) != 0) // 220, 250, 354, 221成功
  1469. break ;
  1470. //欢迎用户
  1472. char local_host[80];
  1473. ZeroMemory(local_host, 80);
  1474. DWORD dwLen = 80;
  1475. GetUserName(local_host, &dwLen);
  1477. ZeroMemory(chTemp, 1024);
  1478. sprintf(chTemp, "EHLO %srn", local_host);
  1479. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1480. if(nRet < 0)
  1481. break ;
  1482. //接收信息
  1483. ZeroMemory(chTemp, 1024);
  1484. nRet = sckSmtp.Receive(chTemp, 1024);
  1485. if(nRet < 0)
  1486. break ;
  1487. if(strncmp(chTemp, "220", 3) != 0 &&
  1488.    strncmp(chTemp, "250", 3) != 0 &&
  1489.    strncmp(chTemp, "334", 3) != 0 &&
  1490.    strncmp(chTemp, "235", 3) != 0 &&
  1491.    strncmp(chTemp, "354", 3) != 0 &&
  1492.    strncmp(chTemp, "221", 3) != 0) // 220, 250, 354, 221成功
  1493. break ;
  1494. // auto login
  1495. ZeroMemory(chTemp, 1024);
  1496. sprintf(chTemp, "AUTH LOGINrn");
  1497. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1498. if(nRet < 0)
  1499. break ;
  1500. ZeroMemory(chTemp, 1024);
  1501. nRet = sckSmtp.Receive(chTemp, 1024);
  1502. if(nRet < 0)
  1503. break ;
  1504. if(strncmp(chTemp, "220", 3) != 0 &&
  1505.    strncmp(chTemp, "250", 3) != 0 &&
  1506.    strncmp(chTemp, "334", 3) != 0 &&
  1507.    strncmp(chTemp, "235", 3) != 0 &&
  1508.    strncmp(chTemp, "354", 3) != 0 &&
  1509.    strncmp(chTemp, "221", 3) != 0) // 220, 250, 354, 221成功
  1510. break ;
  1511. // verify user(Base64)
  1512. CBase64 cb;
  1513. ZeroMemory(chTemp, 1024);
  1514. sprintf(chTemp, "%srn", cb.Encode(strAuth.GetBuffer(0), strAuth.GetLength()));
  1515. strAuth.ReleaseBuffer();
  1516. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1517. if(nRet < 0)
  1518. break ;
  1519. ZeroMemory(chTemp, 1024);
  1520. nRet = sckSmtp.Receive(chTemp, 1024);
  1521. if(nRet < 0)
  1522. break ;
  1524. if(strncmp(chTemp, "220", 3) != 0 &&
  1525.    strncmp(chTemp, "250", 3) != 0 &&
  1526.    strncmp(chTemp, "334", 3) != 0 &&
  1527.    strncmp(chTemp, "235", 3) != 0 &&
  1528.    strncmp(chTemp, "354", 3) != 0 &&
  1529.    strncmp(chTemp, "221", 3) != 0) // 220, 250, 354, 221成功
  1530. break ;
  1531. // verify password
  1532. ZeroMemory(chTemp, 1024);
  1533. sprintf(chTemp, "%srn", cb.Encode(strPass.GetBuffer(0), strPass.GetLength()));
  1534. strPass.ReleaseBuffer();
  1535. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1536. if(nRet < 0)
  1537. break ;
  1538. ZeroMemory(chTemp, 1024);
  1539. nRet = sckSmtp.Receive(chTemp, 1024);
  1540. if(nRet < 0)
  1541. break ;
  1543. if(strncmp(chTemp, "220", 3) != 0 &&
  1544.    strncmp(chTemp, "250", 3) != 0 &&
  1545.    strncmp(chTemp, "334", 3) != 0 &&
  1546.    strncmp(chTemp, "235", 3) != 0 &&
  1547.    strncmp(chTemp, "354", 3) != 0 &&
  1548.    strncmp(chTemp, "221", 3) != 0) // 220, 250, 354, 221成功
  1549. break ;
  1551. //mail from
  1552. ZeroMemory(chTemp, 1024);
  1553. sprintf(chTemp, "MAIL FROM: <%s>rn", strFrom);
  1554. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1555. if(nRet < 0)
  1556. break ;
  1557. //接收信息
  1558. ZeroMemory(chTemp, 1024);
  1559. nRet = sckSmtp.Receive(chTemp, 1024);
  1560. if(nRet < 0)
  1561. break ;
  1562. if(strncmp(chTemp, "220", 3) != 0 &&
  1563.    strncmp(chTemp, "250", 3) != 0 &&
  1564.    strncmp(chTemp, "334", 3) != 0 &&
  1565.    strncmp(chTemp, "235", 3) != 0 &&
  1566.    strncmp(chTemp, "354", 3) != 0 &&
  1567.    strncmp(chTemp, "221", 3) != 0) // 220, 250, 354, 221成功
  1568. break ;
  1569. //rcpt to
  1570. ZeroMemory(chTemp, 1024);
  1571. sprintf(chTemp, "RCPT TO: <%s>rn", strTo);
  1572. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1573. if(nRet < 0)
  1574. break ;
  1575. //接收信息
  1576. ZeroMemory(chTemp, 1024);
  1577. nRet = sckSmtp.Receive(chTemp, 1024);
  1578. if(nRet < 0)
  1579. break ;
  1580. if(strncmp(chTemp, "220", 3) != 0 &&
  1581.    strncmp(chTemp, "250", 3) != 0 &&
  1582.    strncmp(chTemp, "334", 3) != 0 &&
  1583.    strncmp(chTemp, "235", 3) != 0 &&
  1584.    strncmp(chTemp, "354", 3) != 0 &&
  1585.    strncmp(chTemp, "221", 3) != 0) // 220, 250, 354, 221成功
  1586. break ;
  1587. //Data
  1588. ZeroMemory(chTemp, 1024);
  1589. sprintf(chTemp, "DATArn");
  1590. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1591. if(nRet < 0)
  1592. break ;
  1593. //接收信息
  1594. ZeroMemory(chTemp, 1024);
  1595. nRet = sckSmtp.Receive(chTemp, 1024);
  1596. if(nRet < 0)
  1597. break ;
  1598. if(strncmp(chTemp, "220", 3) != 0 &&
  1599.    strncmp(chTemp, "250", 3) != 0 &&
  1600.    strncmp(chTemp, "334", 3) != 0 &&
  1601.    strncmp(chTemp, "235", 3) != 0 &&
  1602.    strncmp(chTemp, "354", 3) != 0 &&
  1603.    strncmp(chTemp, "221", 3) != 0) // 220, 250, 354, 221成功
  1604. break ;
  1605. //信件内容
  1606. //时间
  1607. ZeroMemory(chTemp, 1024);
  1608. sprintf(chTemp, "Date: %srn", strDate);
  1609. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1610. if(nRet < 0)
  1611. break ;
  1612. //From
  1613. ZeroMemory(chTemp, 1024);
  1614. sprintf(chTemp, "From:%srn", strFrom);
  1615. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1616. if(nRet < 0)
  1617. break ;
  1618. //To
  1619. ZeroMemory(chTemp, 1024);
  1620. sprintf(chTemp, "To:%srn", strTo);
  1621. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1622. if(nRet < 0)
  1623. break ;
  1624. //CC
  1625. // ZeroMemory(chTemp, 1024);
  1626. // sprintf(chTemp, "CC:%srn", strCC);
  1627. // sckSmtp.Send(chTemp, strlen(chTemp));
  1628. //Subject
  1629. ZeroMemory(chTemp, 1024);
  1630. sprintf(chTemp, "Subject:%srn", strSubject);
  1631. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1632. if(nRet < 0)
  1633. break ;
  1634. //内容
  1635. int nLen = strBody.GetLength() + 5;
  1636. char *chBody = new char[nLen];
  1637. ZeroMemory(chBody, nLen);
  1638. sprintf(chBody, "%srn", strBody);
  1639. nRet = sckSmtp.Send(chBody, strlen(chBody));
  1640. delete []chBody;
  1641. if(nRet < 0)
  1642. break ;
  1643. //结束
  1644. ZeroMemory(chTemp, 1024);
  1645. sprintf(chTemp, ".rn");
  1646. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1647. if(nRet < 0)
  1648. break ;
  1649. //接收信息
  1650. ZeroMemory(chTemp, 1024);
  1651. nRet = sckSmtp.Receive(chTemp, 1024);
  1652. if(nRet < 0)
  1653. break ;
  1654. if(strncmp(chTemp, "220", 3) != 0 &&
  1655.    strncmp(chTemp, "250", 3) != 0 &&
  1656.    strncmp(chTemp, "334", 3) != 0 &&
  1657.    strncmp(chTemp, "235", 3) != 0 &&
  1658.    strncmp(chTemp, "354", 3) != 0 &&
  1659.    strncmp(chTemp, "221", 3) != 0) // 220, 250, 354, 221成功
  1660. break ;
  1661. //退出
  1662. ZeroMemory(chTemp, 1024);
  1663. sprintf(chTemp, "QUITrn");
  1664. nRet = sckSmtp.Send(chTemp, strlen(chTemp));
  1665. if(nRet < 0)
  1666. break ;
  1667. bRet = TRUE;
  1668. }while(0);
  1669. }
  1670. sckSmtp.Close();
  1671. }
  1673. return bRet;
  1674. }
  1676. BOOL WINAPI PL_DetectInternetConnect(CString strHTTP)
  1677. {
  1678. BOOL bRet = FALSE;
  1679. HINTERNET hSession = NULL;
  1680. hSession = ::InternetOpen(_T("peeper"), PRE_CONFIG_INTERNET_ACCESS, NULL, NULL, 0);
  1681. if(hSession)
  1682. {
  1683. HINTERNET hHTTPSession = ::InternetOpenUrl(hSession,
  1684. strHTTP, NULL, 0, INTERNET_FLAG_RELOAD, 0);
  1685. if(hHTTPSession)
  1686. {
  1687. bRet = TRUE;
  1688. ::InternetCloseHandle(hHTTPSession);
  1689. }
  1690. ::InternetCloseHandle(hSession);
  1691. }
  1692. return bRet;
  1693. }
  1695. HGLOBAL WINAPI PL_ReadDataFromFile(CString strFile)
  1696. {
  1697. HGLOBAL hData = NULL;
  1698. CFile file;
  1699. if(file.Open(strFile, CFile::modeRead))
  1700. {
  1701. int nLen = file.GetLength();
  1702. hData = ::GlobalAlloc(GHND, nLen);
  1703. if(hData != NULL)
  1704. {
  1705. LPVOID lpData = ::GlobalLock(hData);
  1706. file.ReadHuge(lpData, nLen);
  1707. GlobalUnlock(hData);
  1708. }
  1709. file.Close();
  1710. }
  1711. return hData;
  1712. }
  1714. BOOL WINAPI PL_WriteDataToFile(CString strFile, HGLOBAL hData)
  1715. {
  1716. BOOL bRet = FALSE;
  1717. CFile file;
  1718. if(file.Open(strFile, CFile::modeCreate | CFile::modeWrite))
  1719. {
  1720. if(hData != NULL)
  1721. {
  1722. int nLen = ::GlobalSize(hData);
  1723. LPVOID lpData = ::GlobalLock(hData);
  1724. file.WriteHuge(lpData, nLen);
  1725. GlobalUnlock(hData);
  1726. bRet = TRUE;
  1727. }
  1728. file.Close();
  1729. }
  1730. return bRet;
  1731. }