peeperlib.cpp

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

int WINAPI PL_PaletteSize(LPBYTE lpbi)
{
   if(IS_WIN30_DIB(lpbi))
	  return (WORD)(::PL_ColorsNum(lpbi)*sizeof(RGBQUAD));
   else
	  return (WORD)(::PL_ColorsNum(lpbi)*sizeof(RGBTRIPLE));
}

HDIB WINAPI PL_BmpToDIB(HBITMAP hBitmap, HPALETTE hPal, int nBits)
{
    BITMAP              bm;
    BITMAPINFOHEADER    bi;
    LPBITMAPINFOHEADER  lpbi;
    DWORD               dwLen;
    HANDLE              hDIB, h;
    HDC                 hDC;
    WORD                biBits;

    if(!hBitmap)
        return NULL;

    if(!GetObject(hBitmap, sizeof(bm), (LPSTR)&bm))
        return NULL;
    if (hPal == NULL)
        hPal = (HPALETTE) GetStockObject(DEFAULT_PALETTE);
    biBits = bm.bmPlanes * bm.bmBitsPixel;
    if (biBits <= 1)
        biBits = 1;
    else if (biBits <= 4)
        biBits = 4;
    else if (biBits <= 8)
        biBits = 8;
    else
        biBits = 24;
	if(nBits != -1)
	{
		if(nBits == 1 || nBits == 4 || nBits == 8 || nBits == 24)
		{
			biBits = nBits;
		}
	}
    bi.biSize = sizeof(BITMAPINFOHEADER);
    bi.biWidth = bm.bmWidth;
    bi.biHeight = bm.bmHeight;
    bi.biPlanes = 1;
    bi.biBitCount = biBits;
    bi.biCompression = BI_RGB;
    bi.biSizeImage = 0;
    bi.biXPelsPerMeter = 0;
    bi.biYPelsPerMeter = 0;
    bi.biClrUsed = 0;
    bi.biClrImportant = 0;
    dwLen = bi.biSize + PL_PaletteSize((LPBYTE)&bi);

    hDC = GetDC(NULL);
    hPal = SelectPalette(hDC, hPal, FALSE);
    RealizePalette(hDC);
    hDIB = GlobalAlloc(GHND, dwLen);
    if (!hDIB)
    {
      SelectPalette(hDC, hPal, TRUE);
      RealizePalette(hDC);
      ReleaseDC(NULL, hDC);
      return NULL;
    }
    lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
    *lpbi = bi;
    GetDIBits(hDC, hBitmap, 0, (UINT)bi.biHeight, NULL, (LPBITMAPINFO)lpbi,
        DIB_RGB_COLORS);
    bi = *lpbi;
    GlobalUnlock(hDIB);

    if (bi.biSizeImage == 0)
        bi.biSizeImage = WIDTHBYTES((DWORD)bm.bmWidth * biBits) * bm.bmHeight;
    dwLen = bi.biSize + PL_PaletteSize((LPBYTE)&bi) + bi.biSizeImage;

    if (h = GlobalReAlloc(hDIB, dwLen, 0))
        hDIB = h;
    else
    {
        GlobalFree(hDIB);
        hDIB = NULL;
        SelectPalette(hDC, hPal, TRUE);
        RealizePalette(hDC);
        ReleaseDC(NULL, hDC);
        return NULL;
    }
    lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
    if (GetDIBits(hDC, hBitmap, 0, (UINT)bi.biHeight, (LPSTR)lpbi +
            (WORD)lpbi->biSize + PL_PaletteSize((LPBYTE)lpbi), (LPBITMAPINFO)lpbi,
            DIB_RGB_COLORS) == 0)
    {
        GlobalUnlock(hDIB);
        hDIB = NULL;
        SelectPalette(hDC, hPal, TRUE);
        RealizePalette(hDC);
        ReleaseDC(NULL, hDC);
        return NULL;
    }

    bi = *lpbi;
    GlobalUnlock(hDIB);
    SelectPalette(hDC, hPal, TRUE);
    RealizePalette(hDC);
    ReleaseDC(NULL, hDC);

    return (HDIB) hDIB;
}

BOOL WINAPI PL_CreateDIBPalette(HDIB hDIB, CPalette* pPal)
{
	LPLOGPALETTE lpPal = NULL;
	HANDLE hLogPal = NULL;
	HPALETTE hPal = NULL;
	int i;                   // loop index
	WORD wNumColors;         // number of colors in color table
	LPSTR lpbi;              // pointer to packed-DIB
	LPBITMAPINFO lpbmi;      // pointer to BITMAPINFO structure (Win3.0)
	LPBITMAPCOREINFO lpbmc;  // pointer to BITMAPCOREINFO structure (old)
	BOOL bWinStyleDIB;       // flag which signifies whether this is a Win3.0 DIB
	BOOL bResult = FALSE;
	
	if (hDIB == NULL)
		return FALSE;
	
	lpbi = (LPSTR) ::GlobalLock((HGLOBAL) hDIB);
	
	lpbmi = (LPBITMAPINFO)lpbi;
	
	lpbmc = (LPBITMAPCOREINFO)lpbi;
	
	wNumColors = ::PL_ColorsNum((LPBYTE)lpbi);
	
	if (wNumColors != 0)
	{
		hLogPal = ::GlobalAlloc(GHND, sizeof(LOGPALETTE)
			+ sizeof(PALETTEENTRY) * wNumColors);
		
		if (hLogPal == 0)
		{
			::GlobalUnlock((HGLOBAL) hDIB);
			return FALSE;
		}
		
		lpPal = (LPLOGPALETTE) ::GlobalLock((HGLOBAL) hLogPal);
		
		lpPal->palVersion = PALVERSION;
		lpPal->palNumEntries = (WORD)wNumColors;
		
		bWinStyleDIB = IS_WIN30_DIB(lpbi);
		for (i = 0; i < (int)wNumColors; i++)
		{
			if (bWinStyleDIB)
			{
				lpPal->palPalEntry[i].peRed = lpbmi->bmiColors[i].rgbRed;
				lpPal->palPalEntry[i].peGreen = lpbmi->bmiColors[i].rgbGreen;
				lpPal->palPalEntry[i].peBlue = lpbmi->bmiColors[i].rgbBlue;
				lpPal->palPalEntry[i].peFlags = 0;
			}
			else
			{
				lpPal->palPalEntry[i].peRed = lpbmc->bmciColors[i].rgbtRed;
				lpPal->palPalEntry[i].peGreen = lpbmc->bmciColors[i].rgbtGreen;
				lpPal->palPalEntry[i].peBlue = lpbmc->bmciColors[i].rgbtBlue;
				lpPal->palPalEntry[i].peFlags = 0;
			}
		}
		
		bResult = pPal->CreatePalette(lpPal);
		::GlobalUnlock((HGLOBAL) hLogPal);
		::GlobalFree((HGLOBAL) hLogPal);
	}
	
	::GlobalUnlock((HGLOBAL) hDIB);
	
	return bResult;
}

LPBYTE WINAPI PL_DIBBits(LPBYTE lpbi)
{
	return (lpbi + *(LPDWORD)lpbi + ::PL_PaletteSize(lpbi));
}

BOOL WINAPI PL_DrawDIB(HDC hDC, LPRECT lpDCRect, HDIB hDIB, 
					   LPRECT lpDIBRect, CPalette* pPal)
{
	LPSTR    lpDIBHdr;
	LPSTR    lpDIBBits;
	BOOL     bSuccess = FALSE;
	HPALETTE hPal = NULL;
	HPALETTE hOldPal = NULL;
	
	if(hDIB == NULL)
		return -1;
	lpDIBHdr  = (LPSTR)::GlobalLock((HGLOBAL) hDIB);
	lpDIBBits = (LPSTR)::PL_DIBBits((LPBYTE)lpDIBHdr);
	
	if(pPal != NULL)
	{
		hPal = (HPALETTE) pPal->m_hObject;
		hOldPal = ::SelectPalette(hDC, hPal, TRUE);
	}

	if(lpDIBRect == NULL)
	{
		if(lpDCRect != NULL)
		{
			::SetStretchBltMode(hDC, COLORONCOLOR);
			
			bSuccess = ::StretchDIBits(hDC, lpDCRect->left, lpDCRect->top,
				RECTWIDTH(lpDCRect), RECTHEIGHT(lpDCRect), 0, 0, 
				PL_DIBWidth((LPBYTE)lpDIBHdr), PL_DIBHeight((LPBYTE)lpDIBHdr),
				lpDIBBits, (LPBITMAPINFO)lpDIBHdr, DIB_RGB_COLORS, SRCCOPY);
		}
		else
		{
			bSuccess = ::SetDIBitsToDevice(hDC, 0, 0,
				PL_DIBWidth((LPBYTE)lpDIBHdr), PL_DIBHeight((LPBYTE)lpDIBHdr),
				0, 0, 0, PL_DIBHeight((LPBYTE)lpDIBHdr),
				lpDIBBits, (LPBITMAPINFO)lpDIBHdr, DIB_RGB_COLORS);
		}
	}
	else
	{
		if(lpDCRect != NULL)
		{
			::SetStretchBltMode(hDC, COLORONCOLOR);
	
			bSuccess = ::StretchDIBits(hDC, lpDCRect->left, lpDCRect->top,
				RECTWIDTH(lpDCRect), RECTHEIGHT(lpDCRect),
				lpDIBRect->left, lpDIBRect->top, 
				RECTWIDTH(lpDIBRect), RECTHEIGHT(lpDIBRect),
				lpDIBBits, (LPBITMAPINFO)lpDIBHdr, DIB_RGB_COLORS, SRCCOPY);

		}
		else
		{
			bSuccess = ::SetDIBitsToDevice(hDC, 0, 0,
				RECTWIDTH(lpDIBRect), RECTHEIGHT(lpDIBRect),
				0, 0, 0, RECTHEIGHT(lpDIBRect),
				lpDIBBits, (LPBITMAPINFO)lpDIBHdr, DIB_RGB_COLORS);

		}
	}

	::GlobalUnlock((HGLOBAL)hDIB);
	if (hOldPal != NULL)
	{
		::SelectPalette(hDC, hOldPal, TRUE);
	}
	
	return bSuccess;
}

SIZE WINAPI PL_GetScreenSize()
{
	SIZE sz;
	sz.cx = ::GetSystemMetrics(SM_CXSCREEN);
	sz.cy = ::GetSystemMetrics(SM_CYSCREEN);
	return sz;
}

void WINAPI PL_MouseMove(POINT point)
{
	::SetCursorPos(point.x, point.y);
}

void WINAPI PL_MouseLButtonDown(POINT point, BOOL bMove)
{
	if(bMove)
	{
		::PL_MouseMove(point);
	}
	::mouse_event(MOUSEEVENTF_LEFTDOWN, point.x, point.y, 0, 0);
}

void WINAPI PL_MouseLButtonUp(POINT point, BOOL bMove)
{
	if(bMove)
	{
		::PL_MouseMove(point);
	}
	::mouse_event(MOUSEEVENTF_LEFTUP, point.x, point.y, 0, 0);
}

void WINAPI PL_MouseRButtonDown(POINT point, BOOL bMove)
{
	if(bMove)
	{
		::PL_MouseMove(point);
	}
	::mouse_event(MOUSEEVENTF_RIGHTDOWN, point.x, point.y, 0, 0);
}

void WINAPI PL_MouseRButtonUp(POINT point, BOOL bMove)
{
	if(bMove)
	{
		::PL_MouseMove(point);
	}
	::mouse_event(MOUSEEVENTF_RIGHTUP, point.x, point.y, 0, 0);
}

void WINAPI PL_MouseLButtonDblClk(POINT point, BOOL bMove)
{
	if(bMove)
	{
		::PL_MouseMove(point);
	}
	::PL_MouseLButtonDown(point);
	::PL_MouseLButtonUp(point);
	::PL_MouseLButtonDown(point);
	::PL_MouseLButtonUp(point);
}

void WINAPI PL_MouseRButtonDblClk(POINT point, BOOL bMove)
{
	if(bMove)
	{
		::PL_MouseMove(point);
	}
	::PL_MouseRButtonDown(point);
	::PL_MouseRButtonUp(point);
	::PL_MouseRButtonDown(point);
	::PL_MouseRButtonUp(point);
}

void WINAPI PL_KeyDown(UINT uChar, UINT uFlag)
{
	::keybd_event((BYTE)uChar, (BYTE)uChar, 0, 0);
}

void WINAPI PL_KeyUp(UINT uChar, UINT uFlag)
{
	::keybd_event((BYTE)uChar, (BYTE)uChar, KEYEVENTF_KEYUP, 0);
}

BOOL WINAPI PL_GetHostName(char *chIP, char *chName)
{
	BOOL bRet = FALSE;
	char chTemp[256];
	hostent* pEnt = NULL;
	ZeroMemory(chTemp, 256);
	int nRet = ::gethostname(chTemp, 256);
	if(nRet == 0)
	{
		if(AfxIsValidAddress(chName, strlen(chTemp)))
		{
			strcpy(chName, chTemp);
			bRet = TRUE;
		}
		if(AfxIsValidAddress(chIP, 16))
		{
			pEnt = ::gethostbyname(chTemp);
			if(pEnt)
			{
				sprintf(chIP, "%d.%d.%d.%d", 
					BYTE(pEnt->h_addr_list[0][0]), BYTE(pEnt->h_addr_list[0][1]),
					BYTE(pEnt->h_addr_list[0][2]), BYTE(pEnt->h_addr_list[0][3]));
				bRet = TRUE;
			}
			else
			{
				bRet = FALSE;
			}
		}
	}
	return bRet;
}

int WINAPI PL_ExecuteCommand(char *chCommandLine)
{
	return ::WinExec(chCommandLine, SW_NORMAL);
}

void WINAPI PL_LockDesktop(BOOL bLock)
{
	::ShowCursor(!bLock);
	::SystemParametersInfo(SPI_SETFASTTASKSWITCH, (int)(!bLock), NULL, 0);
	::SystemParametersInfo(SPI_SCREENSAVERRUNNING, (int)bLock, NULL, 0);
	::EnableWindow(::GetDesktopWindow(), !bLock);
}

BOOL WINAPI PL_ExitWindow(UINT uFlag)
{
	HANDLE hToken = NULL;
	TOKEN_PRIVILEGES tkp;
	BOOL fResult = FALSE;
	if(OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
	{
		if(LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, &tkp.Privileges[0].Luid))
		{
			tkp.PrivilegeCount = 1;
			tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; 
			if(AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES) NULL, 0))
			{
				return ::ExitWindowsEx(uFlag, 0);
			}
		}
	}
	
	return ::ExitWindowsEx(uFlag, 0);
}

void WINAPI PL_Send_CtrlAltDel()
{
	::PL_KeyDown(VK_CONTROL, 0);
	::PL_KeyDown(VK_MENU, 0);
	::PL_KeyDown(VK_DELETE, 0);
	::Sleep(2000);
	::PL_KeyUp(VK_CONTROL, 0);
	::PL_KeyUp(VK_MENU, 0);
	::PL_KeyUp(VK_DELETE, 0);
}

BOOL WINAPI PL_CopyFileClient(CString strIP, UINT uPort, char *chSrc, 
							  BOOL bSend, HWND hNotifyWnd)
{
	BOOL bRet = FALSE;
	CSocket sckClient;
	CFile file;
	do
	{
		if(bSend)
		{
			bRet = file.Open(chSrc, CFile::modeRead);
		}
		else
		{
			bRet = file.Open(chSrc, CFile::modeCreate | CFile::modeWrite);
		}
		if(!bRet)
		{
			break ;
		}
		bRet = sckClient.Create();
		if(!bRet)
		{
			break ;
		}
		bRet = sckClient.Connect(strIP, uPort);
		if(!bRet)
		{
			break ;
		}
		BYTE *chFileData = new BYTE[PL_SOCKET_MAXBYTES+1];
		char chData[10];
		int nSize = 0;
		if(bSend)
		{
			nSize = file.GetLength();
			int nRead = nSize;
			ZeroMemory(chData, 10);
			memcpy(chData, &nSize, sizeof(int));
			int nRet = sckClient.Send(chData, sizeof(int));
			if(nRet <= 0)
			{
				bRet = FALSE;
				break ;
			}
			while(nRead > 0)
			{
				int n1 = min(nRead, PL_SOCKET_MAXBYTES);
				int n2 = file.Read(chFileData, n1);
				nRead -= n2;
				nRet = sckClient.Send(chFileData, n2);
				if(nRet <= 0)
				{
					bRet = FALSE;
					break ;
				}
				if(hNotifyWnd != NULL)
				{
					int nProgress = (int)(((float)(nSize - nRead))*100.0f/((float)nSize));
					::PostMessage(hNotifyWnd, PL_PEEPER_NOTIFY_COPYFILE, 
						(WPARAM)nProgress, NULL);
				}
				bRet = TRUE;
			}
		}
		else
		{
			char chData[10];
			ZeroMemory(chData, 10);
			nSize = 0;
			int nRet = sckClient.Receive(chData, 10);//读文件大小
			if(nRet <= 0)
			{
				bRet = FALSE;
				break ;
			}
			nSize = *((int*)(chData));
			if(nSize <= 0)
			{
				bRet = FALSE;
				break ;
			}
			BYTE *chFileData = new BYTE[PL_SOCKET_MAXBYTES+1];
			int nWrite = 0;
			while(nWrite < nSize)
			{
				nRet = sckClient.Receive(chFileData, PL_SOCKET_MAXBYTES);
				if(nRet <= 0)
				{
					bRet = FALSE;
					break ;
				}
				file.Write(chFileData, nRet);
				nWrite += nRet;
				if(hNotifyWnd != NULL)
				{
					int nProgress = (int)(((float)nWrite)*100.0f/((float)nSize));
					::PostMessage(hNotifyWnd, PL_PEEPER_NOTIFY_COPYFILE, 
						(WPARAM)nProgress, NULL);
				}
				bRet = TRUE;
			}
		}
		delete []chFileData;
		if(!bRet) // 送文件数据出错.
		{
			break ;
		}
	}while(0);
	if(sckClient.m_hSocket !=	INVALID_SOCKET)
	{
		sckClient.Close();
	}
	if(file.m_hFile != CFile::hFileNull)
	{
		file.Close();
	}

	return bRet;
}

BOOL WINAPI PL_CopyFileServer(UINT uPort, char *chDes, BOOL bSend, HWND hNotifyWnd)
{
	BOOL bRet = FALSE;
	CFile file;
	CSocket sckServer;
	CSocket sckClient;
	do
	{
		if(!bSend)
		{
			bRet = file.Open(chDes, CFile::modeCreate | CFile::modeWrite);
		}
		else
		{
			bRet = file.Open(chDes, CFile::modeRead);
		}
		if(!bRet)
		{
			break ;
		}
		bRet = sckServer.Create(uPort);
		if(!bRet)
		{
			break ;
		}
		bRet = sckServer.Listen();
		if(!bRet)
		{
			break ;
		}
		bRet = sckServer.Accept(sckClient);
		if(!bRet)
		{
			break ;
		}
		char chData[10];
		BYTE *chFileData = new BYTE[PL_SOCKET_MAXBYTES+1];
		int nSize = 0;
		if(!bSend)
		{
			ZeroMemory(chData, 10);
			int nRet = sckClient.Receive(chData, 10);//读文件大小