peeperlib.cpp

这是个soket的代码不是太实用但是对出学者还是有些帮助的 有需要的可以

///////////////////////////////////////////////////////////////////////////////
// 远程控制软件-偷窥者  开发库                                               //
// 日期:2001/10/02                                                           //
// 作者:刘东发                                                               //
// Email:[e-mail]                                                     //
// http://dongfa.yeah.net                                                    //
// OICQ:5584173  阿东                                                        //
// 作者声明:                                                                 //
//     此部分代码全是作者所写，可以随便传播，但要保持文件的完整性,有问题     //
// 或者意见请来信,谢谢!                                                      //
///////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "PeeperLib.h"
#include "PeeperZip.h"
#include "Base64.h"
#include <afxinet.h>
#pragma comment(lib, "Wininet.lib")

BOOL WINAPI PL_InitSocket()
{
#define MAJOR_VERSION 1
#define MINOR_VERSION 2

	int nStatus = 0;
	WORD wMajorVersion = MAJOR_VERSION;
	WORD wMinorVersion = MINOR_VERSION;
	WORD wVersionReqd = MAKEWORD(wMajorVersion, wMinorVersion);
	WSADATA lpmyWSAData;
	nStatus = ::WSAStartup(wVersionReqd, &lpmyWSAData);	
	if(nStatus != 0)
	{
		return FALSE;
	}
	
	return TRUE;
}

BOOL WINAPI PL_TermSocket()
{
	return (::WSACleanup() == 0)?TRUE : FALSE;
}

int WINAPI PL_SendSocketData(SOCKET s, BYTE *chData, int nLen, BYTE chFlag, UINT uFlag)
{
	int nRet = INVALID_SOCKET;
	if(s != INVALID_SOCKET)
	{
		char *chTemp = new char[nLen + 3];
		ZeroMemory(chTemp, nLen + 3);
		if(chFlag == PL_NONE) // only data
		{
			if(chData != NULL)
			{
				if(uFlag == MSG_OOB)
				{
					//实际数据大小为N,以MSG_OOB发送时数据长度要加1
					nLen += 1;
				}
				nRet = ::send(s, (char *)chData, nLen, uFlag);
			}
			else
			{
				nRet = 0;
			}
		}
		else 
		{
			chTemp[0] = chFlag;
			if(chData != NULL)
			{
				memcpy(chTemp + 1, chData, nLen);
			}
			else
			{
				nLen = 0;
			}
			if(uFlag == MSG_OOB)
			{
				//实际数据大小为N,以MSG_OOB发送时数据长度要加1
				nLen += 1;
			}
			nRet = ::send(s, chTemp, nLen+1, uFlag);
		}
		delete []chTemp;
	}

	return nRet;
}

int WINAPI PL_ReadSocketData(SOCKET s, BYTE *chData, int nLen, BYTE *chFlag, UINT uFlag)
{
	int nRet = INVALID_SOCKET;
	if(s != INVALID_SOCKET)
	{
		nRet = ::recv(s, (char *)chData, nLen, uFlag);
		if(nRet > 0)
		{
			if(chFlag != NULL)
			{
				*chFlag = chData[0];
			}
		}
	}
	return nRet;
}

HGLOBAL WINAPI PL_LZ77_Zip(HGLOBAL hUnZip)
{
	int _n = ::GetTickCount();

	int nSize = ::GlobalSize(hUnZip);
	LPBYTE lpData = (LPBYTE)::GlobalLock(hUnZip);
	HGLOBAL hZip = NULL;
	if(nSize > 0 && lpData != NULL)
	{
		const int nMax = 65536;
		BYTE byTemp[nMax + 16];
		CCompressLZ77 cc;
		WORD wFlag1 = 0;
		WORD wFlag2 = 0;
		int nLast = nSize;
		int nReal = 0;
		hZip = ::GlobalAlloc(GHND, nMax+16);
		LPBYTE lpZipData = (LPBYTE)::GlobalLock(hZip);
		int nPos = 0;
		int nZipPos = 0;
		while(nLast > 0)
		{
			nReal = min(nLast, nMax);
			nLast -= nReal;
			if(nReal == nMax)
			{
				wFlag1 = 0;
			}
			else
			{
				wFlag1 = nReal;
			}
			memcpy(lpZipData + nZipPos, &wFlag1, sizeof(WORD));
			nZipPos += sizeof(WORD);
			int nRetLen = 0;
			nRetLen = cc.Compress(lpData + nPos, nReal, byTemp);
			if(nRetLen == 0)		// can't compress the block
			{
				wFlag2 = wFlag1;
				memcpy(lpZipData + nZipPos, &wFlag2, sizeof(WORD));
				nZipPos += sizeof(WORD);
				memcpy(lpZipData + nZipPos, lpData + nPos, nReal);
				nZipPos += nReal;
			}
			else
			{
				wFlag2 = (WORD)nRetLen;
				memcpy(lpZipData + nZipPos, &wFlag2, sizeof(WORD));
				nZipPos += sizeof(WORD);
				memcpy(lpZipData + nZipPos, byTemp, nRetLen);
				nZipPos += nRetLen;
			}
			nPos += nReal;
			::GlobalUnlock(hZip);
			if(nLast > 0)
			{
				hZip = ::GlobalReAlloc(hZip, nZipPos + nMax, 0);
			}
			else
			{
				hZip = ::GlobalReAlloc(hZip, nZipPos, 0);
			}

			lpZipData = (LPBYTE)::GlobalLock(hZip);
		}
		::GlobalUnlock(hZip);
	}
	TRACE(_T("PL_LZ77_Zip--Time:%d, %d-->%d.\n"),
		GetTickCount() - _n, GlobalSize(hUnZip), GlobalSize(hZip));
	return hZip;
}

HGLOBAL WINAPI PL_LZ77_UnZip(HGLOBAL hZip)
{
	int _n = ::GetTickCount();
	int nSize = ::GlobalSize(hZip);
	LPBYTE lpZipData = (LPBYTE)::GlobalLock(hZip);
	HGLOBAL hUnZip = NULL;
	if(nSize > 0 && lpZipData != NULL)
	{
		const int nMax = 65536;
		BYTE byTemp[nMax + 16];
		CCompressLZ77 cc;
		WORD wFlag1 = 0;
		WORD wFlag2 = 0;
		int nLast = nSize;
		int nReal = 0;
		hUnZip = ::GlobalAlloc(GHND, nMax+16);
		LPBYTE lpData = (LPBYTE)::GlobalLock(hUnZip);
		int nPos = 0;
		int nZipPos = 0;
		while(nLast > 0)
		{
			memcpy(&wFlag1, lpZipData + nZipPos, sizeof(WORD));
			nZipPos += sizeof(WORD);
			memcpy(&wFlag2, lpZipData + nZipPos, sizeof(WORD));
			nZipPos += sizeof(WORD);
			nLast -= 2*sizeof(WORD);
			if(wFlag1 == 0)
			{
				nReal = nMax;
			}
			else
			{
				nReal = wFlag1;
			}
			nLast -= wFlag2 ? (wFlag2) : nReal;
			if(wFlag2 == wFlag1)
			{
				memcpy(byTemp, lpZipData + nZipPos, nReal);
				nZipPos += nReal;
			}
			else
			{
//				if(AfxIsValidAddress(lpZipData + nZipPos, nReal))
				{
					if(!cc.Decompress(byTemp, nReal, lpZipData + nZipPos))
					{
						break ;
					}
				}
				nZipPos += wFlag2;
			}
			memcpy(lpData + nPos, byTemp, nReal);
			nPos += nReal;
			::GlobalUnlock(hUnZip);
			if(nLast > 0)
			{
				if((::GlobalSize(hUnZip) - nPos) < nMax)
				{
					hUnZip = ::GlobalReAlloc(hUnZip, nPos + nMax, 0);
				}
			}
			else
			{
				hUnZip = ::GlobalReAlloc(hUnZip, nPos, 0);
			}
			lpData = (LPBYTE)::GlobalLock(hUnZip);
		}
		::GlobalUnlock(hUnZip);
	}
	TRACE(_T("PL_LZ77_UnZip--Time:%d, %d-->%d.\n"),
		GetTickCount() - _n, GlobalSize(hZip), GlobalSize(hUnZip));
	return hUnZip;
}

HGLOBAL WINAPI PL_LZSS_Zip(HGLOBAL hUnZip)
{
	int _n = ::GetTickCount();

	HGLOBAL hZip = NULL;

	LPBYTE lpData = (LPBYTE)::GlobalLock(hUnZip);
	if(lpData != NULL)
	{
		int nLen = ::GlobalSize(hUnZip);
		C_LZSS lz;
		hZip = lz.Encode((char *)lpData, nLen);
		::GlobalUnlock(hUnZip);
	}
	TRACE(_T("PL_LZSS_Zip--Time:%d, %d-->%d.\n"),
		GetTickCount() - _n, GlobalSize(hUnZip), GlobalSize(hZip));
	return hZip;
}

HGLOBAL WINAPI PL_LZSS_UnZip(HGLOBAL hZip)
{
	int _n = ::GetTickCount();

	HGLOBAL hUnZip = NULL;
	LPBYTE lpData = (LPBYTE)::GlobalLock(hZip);
	if(lpData != NULL)
	{
		int nLen = ::GlobalSize(hZip);
		C_LZSS lz;
		hUnZip = lz.Decode((char *)lpData, nLen);
		::GlobalUnlock(hZip);
	}

	TRACE(_T("PL_LZSS_UnZip--Time:%d, %d-->%d.\n"),
		GetTickCount() - _n, GlobalSize(hZip), GlobalSize(hUnZip));

	return hUnZip;
}

HGLOBAL WINAPI PL_ARI_Zip(HGLOBAL hUnZip)
{
	int _n = ::GetTickCount();
	HGLOBAL hZip = NULL;

	LPBYTE lpData = (LPBYTE)::GlobalLock(hUnZip);
	if(lpData != NULL)
	{
		int nLen = ::GlobalSize(hUnZip);
		C_ARI lz;
		hZip = lz.Encode((char *)lpData, nLen);
		::GlobalUnlock(hUnZip);
	}
	TRACE(_T("PL_ARI_Zip--Time:%d, %d-->%d.\n"),
		GetTickCount() - _n, GlobalSize(hUnZip), GlobalSize(hZip));

	return hZip;
}

HGLOBAL WINAPI PL_ARI_UnZip(HGLOBAL hZip)
{
	int _n = ::GetTickCount();

	HGLOBAL hUnZip = NULL;
	LPBYTE lpData = (LPBYTE)::GlobalLock(hZip);
	if(lpData != NULL)
	{
		int nLen = ::GlobalSize(hZip);
		C_ARI lz;
		hUnZip = lz.Decode((char *)lpData, nLen);
		::GlobalUnlock(hZip);
	}

	TRACE(_T("PL_ARI_UnZip--Time:%d, %d-->%d.\n"),
		GetTickCount() - _n, GlobalSize(hZip), GlobalSize(hUnZip));

	return hUnZip;
}

HGLOBAL WINAPI PL_LZW_Zip(HGLOBAL hUnZip)
{
	int _n = ::GetTickCount();
	HGLOBAL hZip = NULL;

	LPBYTE lpData = (LPBYTE)::GlobalLock(hUnZip);
	if(lpData != NULL)
	{
		int nLen = ::GlobalSize(hUnZip);
		C_LZW lz;
		hZip = lz.Encode((char *)lpData, nLen);
		::GlobalUnlock(hUnZip);
	}
	TRACE(_T("PL_LZW_Zip--Time:%d, %d-->%d.\n"),
		GetTickCount() - _n, GlobalSize(hUnZip), GlobalSize(hZip));

	return hZip;
}

HGLOBAL WINAPI PL_LZW_UnZip(HGLOBAL hZip)
{
	int _n = ::GetTickCount();

	HGLOBAL hUnZip = NULL;
	LPBYTE lpData = (LPBYTE)::GlobalLock(hZip);
	if(lpData != NULL)
	{
		int nLen = ::GlobalSize(hZip);
		C_LZW lz;
		hUnZip = lz.Decode((char *)lpData, nLen);
		::GlobalUnlock(hZip);
	}

	TRACE(_T("PL_LZW_UnZip--Time:%d, %d-->%d.\n"),
		GetTickCount() - _n, GlobalSize(hZip), GlobalSize(hUnZip));

	return hUnZip;
}

BOOL WINAPI PL_Bmp2Gry(HBITMAP hBmp, LPBYTE *lpGryData, SIZE *szGrySize)
{
	//目前只支持256色
	LPBYTE	lpBitsData = NULL;
	int		nBmpSize = 0;
	
	BITMAPINFO *pInfo = NULL;
	BITMAP  bm;
	GetObject(hBmp, sizeof(BITMAP), &bm);
	if(bm.bmBitsPixel != 8)
	{
		return FALSE;
	}
	
	szGrySize->cx = bm.bmWidth; szGrySize->cy = bm.bmHeight;
	
	nBmpSize = ((((bm.bmWidth * bm.bmBitsPixel) + 31) & ~31) >> 3) * bm.bmHeight;
	lpBitsData = new BYTE[nBmpSize];
	memset(lpBitsData, 0, nBmpSize);
	
	pInfo = (BITMAPINFO*)new BYTE[sizeof(BITMAPINFOHEADER) + 256*sizeof(RGBQUAD)];
	pInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	pInfo->bmiHeader.biWidth = bm.bmWidth;
	pInfo->bmiHeader.biHeight = bm.bmHeight;
	pInfo->bmiHeader.biPlanes = bm.bmPlanes;
	pInfo->bmiHeader.biBitCount = bm.bmBitsPixel;
	pInfo->bmiHeader.biCompression = BI_RGB;
	pInfo->bmiHeader.biSizeImage = nBmpSize;
	pInfo->bmiHeader.biXPelsPerMeter = 0;
	pInfo->bmiHeader.biYPelsPerMeter = 0;
	pInfo->bmiHeader.biClrUsed = 0;
	pInfo->bmiHeader.biClrImportant = 0;
	
	HDC           hMemDC;
	HBITMAP       hOldBitmap;
	RGBQUAD       rgb[256];
	
	memset(rgb, 0, 256);
	hMemDC = CreateCompatibleDC(NULL);
	hOldBitmap = (HBITMAP)SelectObject(hMemDC, hBmp);
	// Get the DIBSection's color table
	GetDIBColorTable(hMemDC, 0, 256, rgb);
	// Populate BITMAPINFO header info
	// Now actually get the bits
	CClientDC cdc( CWnd::GetDesktopWindow() );
	::GetDIBits(cdc.GetSafeHdc(), hBmp,
		0, (WORD)bm.bmHeight, lpBitsData, pInfo, DIB_RGB_COLORS);
	
	*lpGryData = new BYTE[nBmpSize];
	memset(*lpGryData, 0, nBmpSize);
	for(int i = 0; i < nBmpSize; i ++)
	{
		int nIndex = lpBitsData[i];
		double r = (double)(rgb[nIndex].rgbRed);
		double g = (double)(rgb[nIndex].rgbGreen);
		double b = (double)(rgb[nIndex].rgbBlue);
		BYTE c = (BYTE)(r*0.29900 + g*0.58700 + b*0.11400);
		int pos = ((bm.bmHeight - (i/bm.bmWidth) - 1)*bm.bmWidth) + (i % bm.bmWidth);
		(*lpGryData)[pos] = c;
	}
	SelectObject(hMemDC, hOldBitmap);
	DeleteDC(hMemDC);
	
	delete []lpBitsData;
	lpBitsData = NULL;

	return TRUE;
}

BOOL WINAPI PL_DrawGry(HDC hDC, LPBYTE lpGryData, SIZE szGrySize)
{
	//暂不实现
	return TRUE;
}

HBITMAP WINAPI PL_GetBitmap(HWND hWnd)
{
	HDC hWndDC = NULL;
	HDC hMemDC = NULL;
	HBITMAP hMemBmp = NULL;
	HBITMAP hOldBmp = NULL;
	RECT rect;
	int w = 0, h = 0;

	if(hWnd == NULL)
	{
		hWnd = ::GetDesktopWindow();
	}
	hWndDC = ::GetWindowDC(hWnd);
	hMemDC = ::CreateCompatibleDC(hWndDC);
	::GetWindowRect(hWnd, &rect);
	w = rect.right - rect.left;
	h = rect.bottom - rect.top;

	hMemBmp = ::CreateCompatibleBitmap(hWndDC, w, h);

	hOldBmp = (HBITMAP)::SelectObject(hMemDC, hMemBmp);
	::BitBlt(hMemDC, 0, 0, w, h, hWndDC, 0, 0, SRCCOPY);

	// Why???
	hMemBmp = (HBITMAP)::SelectObject(hMemDC, hOldBmp);

	::DeleteObject(hOldBmp);
	::ReleaseDC(NULL, hMemDC);
	::ReleaseDC(NULL, hWndDC);

	return hMemBmp;
}

BOOL WINAPI PL_DrawBmp(HDC hDC, LPRECT lpDCRect, HBITMAP hBmp, LPRECT lpBmpRect, CPalette* pPal)
{
	HDC hMemDC = NULL;
	BITMAP bm;

	hMemDC = ::CreateCompatibleDC(hDC);
	::GetObject(hBmp, sizeof(bm), &bm);
	::SelectObject(hMemDC, hBmp);

	if(lpBmpRect == NULL)
	{
		if(lpDCRect != NULL)
		{
			::SetStretchBltMode(hDC, COLORONCOLOR);
			::StretchBlt(hDC, lpDCRect->left, lpDCRect->top, RECTWIDTH(lpDCRect), RECTHEIGHT(lpDCRect),
				hMemDC, 0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY);
		}
		else
		{
			::BitBlt(hDC, 0, 0, bm.bmWidth, bm.bmHeight, hMemDC, 0, 0, SRCCOPY);
		}
	}
	else
	{
		if(lpDCRect != NULL)
		{
			::SetStretchBltMode(hDC, COLORONCOLOR);
			::StretchBlt(hDC, lpDCRect->left, lpDCRect->top, RECTWIDTH(lpDCRect), RECTHEIGHT(lpDCRect), 
				hMemDC, lpBmpRect->left, lpBmpRect->top, RECTWIDTH(lpBmpRect), RECTHEIGHT(lpBmpRect), SRCCOPY);
		}
		else
		{
			::BitBlt(hDC, 0, 0, RECTWIDTH(lpBmpRect), RECTHEIGHT(lpBmpRect), 
				hMemDC, lpDCRect->left, lpDCRect->top, SRCCOPY);
		}
	}
	::ReleaseDC(NULL, hMemDC);

	return TRUE;
}

int WINAPI PL_ColorsNum(LPBYTE lpbi)
{
	WORD wBitCount = 0;
	if(IS_WIN30_DIB(lpbi))
	{
		DWORD dwClrUsed = ((LPBITMAPINFOHEADER)lpbi)->biClrUsed;
		if(dwClrUsed != 0)
			return dwClrUsed;
	}
	if(IS_WIN30_DIB(lpbi))
		wBitCount = ((LPBITMAPINFOHEADER)lpbi)->biBitCount;
	else
		wBitCount = ((LPBITMAPCOREHEADER)lpbi)->bcBitCount;

	switch (wBitCount)
	{
		case 1:
			return 2;

		case 4:
			return 16;

		case 8:
			return 256;

		default:
			return 0;
	}
}

int WINAPI PL_DIBWidth(LPBYTE lpDIB)
{
	LPBITMAPINFOHEADER lpbmi;
	LPBITMAPCOREHEADER lpbmc;

	lpbmi = (LPBITMAPINFOHEADER)lpDIB;
	lpbmc = (LPBITMAPCOREHEADER)lpDIB;

	if (IS_WIN30_DIB(lpDIB))
		return lpbmi->biWidth;
	else
		return lpbmc->bcWidth;
}

int WINAPI PL_DIBHeight(LPBYTE lpDIB)
{
	LPBITMAPINFOHEADER lpbmi;
	LPBITMAPCOREHEADER lpbmc;

	lpbmi = (LPBITMAPINFOHEADER)lpDIB;
	lpbmc = (LPBITMAPCOREHEADER)lpDIB;

	if (IS_WIN30_DIB(lpDIB))
		return lpbmi->biHeight;
	else
		return lpbmc->bcHeight;
}