mainframe.cpp

用PC机访问wince的远程桌面,还可以上传文件,杀进程等功能,服务端在wince,客服端在windows下

// MainFrame.cpp: implementation of the CMainFrame class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "MainFrame.h"
#include <stdio.h>
#include <shellapi.h>
#include <Tlhelp32.h>
#include "Iprtrmib.h"
#include "Iphlpapi.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

char g_szRet[MAX_UDP_PACKAGE]	= {0};
int sendbufleng = 0;

char *trim(const char *p)
{
	char *tmp	= (char *)p;
	while(*tmp == ' ' || *tmp == '\t')
		tmp++;
	return tmp;
};

CMainFrame::CMainFrame()
{
}

CMainFrame::~CMainFrame()
{
}

int CMainFrame::OnDataRecv(char *szData, int nLength, int sk, sockaddr_in saClient, int nSaLength)
{
	PReqPackHead	pRmtCtl	= (PReqPackHead)szData;
//	WriteLog("nFlag %d nsize %d\n",pRmtCtl->nFlag,pRmtCtl->nSize);
	if( nLength != pRmtCtl->nSize )
	{		
		int nlen = sizeof(ReplyPackHead);
		CreateReplyHead(pRmtCtl,nlen,ERR_REQUEST_PARAMS);		
		Send(g_szRet, nlen, sk, saClient, sizeof(saClient));
		/////////
		return 1;
	}
	DealClt[pRmtCtl->nFlag](this, sk, saClient, szData+sizeof(ReqPackHead), pRmtCtl);
	
	return 0;
}
void CMainFrame::CreateReplyHead(PReqPackHead pReq,int nSize,int nErr)
{	
	PReplyPackHead pReply = (PReplyPackHead)g_szRet;
	pReply->nFlag = pReq->nFlag+0x5000;
	pReply->nSize = nSize;
	pReply->nVerson = pReq->nVerson;
	pReply->nErrorCode = nErr;
}
void CMainFrame::OnError(int sk, sockaddr_in sa,PReqPackHead pReq,int nErr)
{
	int nlen = sizeof(ReplyPackHead);
	CreateReplyHead(pReq,nlen,nErr);	
	Send(g_szRet, nlen, sk, sa, sizeof(sa));
}
int CMainFrame::Initialize()
{
	for(int nCount = 0; nCount < 255; nCount++)
		DealClt[nCount]	= 0;
	
	DealClt[BUSINESS_SAYHELLO]		= DealHello;
	DealClt[BUSINESS_DIR]			= DealDir;
	DealClt[BUSINESS_DOWNLOADFILE]	= DealDownLoadFile;
	DealClt[BUSINESS_UPLOADFILE]	= DealUploadFile;
	DealClt[BUSINESS_DELETEFILE]    = DealDelFile;
	DealClt[BUSINESS_RUNFILE]		= DealRun;
	DealClt[BUSINESS_GETPROCESS]    = DealGetProcess;
	DealClt[BUSINESS_KILLPROCESS]   = DealKillProcess;
	DealClt[BUSINESS_PROCESSHEAP]   = DealProcessHeap;
	DealClt[BUSINESS_SCREENCOPY]    = DealCopyScreen;
	DealClt[BUSINESS_MOUSE]			= DealMouse;
	DealClt[BUSINESS_KEYBD]			= DealKeybd;
	DealClt[BUSINESS_REPLAYRENAME]	= DealReName;
	DealClt[BUSINESS_SYSTEMINFO]	= DealGetSystemInfo;
	DealClt[BUSINESS_CREATEDIRECTORY]	= DealCreateDirectory;
	
	return RunAsServer(9000);
}

int CMainFrame::DealHello(LPVOID lpvoid, int sk, sockaddr_in sa, char *pInBuf,PReqPackHead pReq)
{
	CMainFrame	*pMf	= (CMainFrame *)lpvoid;
	pMf->OnError(sk,sa,pReq,0);
	return 0;
}
int FindFilesAndDirsInDirectory(LPTSTR dir)
{
	int ncc = 0;
	WIN32_FIND_DATA fd;
	HANDLE hd = FindFirstFile(dir,&fd);		
	if( hd != INVALID_HANDLE_VALUE )
	{
		do{
			if( fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )		//directory
			{
				if( (_tcscmp(fd.cFileName,_T(".")) != 0) && (_tcscmp(fd.cFileName,_T("..")) !=0) )
				{
					if( _tcslen(fd.cFileName) < DIRREPPARAMS_FILENAME )
						ncc++;
				}
			}else
			{
				if( _tcslen(fd.cFileName) < DIRREPPARAMS_FILENAME )
					ncc++;
			}			
		}while( FindNextFile(hd,&fd) );
	}
	FindClose(hd);
	return ncc;
}
static const __int64 SECS_BETWEEN_EPOCHS = 11644473600;
static const __int64 SECS_TO_100NS = 10000000; /* 10^7 */
time_t FILEFileTimeToUnixTime( FILETIME FileTime, long *nsec )
{
	__int64 UnixTime;
    /* get the full win32 value, in 100ns */
    UnixTime = ((__int64)FileTime.dwHighDateTime << 32) + 
		FileTime.dwLowDateTime; 
	/* convert to the Unix epoch */
	UnixTime -= (SECS_BETWEEN_EPOCHS * SECS_TO_100NS); 
	if ( nsec )
	{
		/* get the number of 100ns, convert to ns */
        *nsec = (UnixTime % SECS_TO_100NS) * 100;
	}
	UnixTime /= SECS_TO_100NS; /* now convert to seconds */
	return (time_t)UnixTime;
}

void FindFilesAndDirsInDirectory(LPTSTR dir,PFileAttr pRet)
{
	PFileAttr pp = pRet;
	WIN32_FIND_DATA fd;
	HANDLE hd = FindFirstFile(dir,&fd);		
	if( hd != INVALID_HANDLE_VALUE )
	{
		do{
			if( fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )		//directory
			{
				if( (_tcscmp(fd.cFileName,_T(".")) != 0) && (_tcscmp(fd.cFileName,_T("..")) !=0) )
				{
					if( _tcslen(fd.cFileName) < DIRREPPARAMS_FILENAME )
					{						
						WideCharToMultiByte(CP_ACP, 0, fd.cFileName, -1, 
							pp->szFileName, sizeof(pp->szFileName), NULL, FALSE);
						pp->cFlag = 0;
						pp->nSize = fd.nFileSizeLow;
//						FILETIME time1,time2;						
				/*		SYSTEMTIME systime;
						time1 = fd.ftLastWriteTime;
						WriteLog("%4d/%2d/%2d %2d:%2d\n",systime.wYear,systime.wMonth,systime.wDay,systime.wHour,systime.wMinute);
						FileTimeToLocalFileTime(&time1,&time2);
						FileTimeToSystemTime(&time2,&systime);
						WriteLog("%4d/%2d/%2d %2d:%2d\n",systime.wYear,systime.wMonth,systime.wDay,systime.wHour,systime.wMinute);
					*/	pp->nCreateTimeH = fd.ftLastWriteTime.dwHighDateTime;
						pp->nCreateTimeL = fd.ftLastWriteTime.dwLowDateTime;
						pp++;
					}
				}
			}else
			{
				if( _tcslen(fd.cFileName) < DIRREPPARAMS_FILENAME )
				{
					WideCharToMultiByte(CP_ACP, 0, fd.cFileName, -1, 
						pp->szFileName, sizeof(pp->szFileName), NULL, FALSE);
					pp->cFlag = 1;
					pp->nSize = fd.nFileSizeLow;
					//					pp->nCreateTime = FILEFileTimeToUnixTime(fd.ftLastWriteTime,0);
					pp->nCreateTimeH = fd.ftLastWriteTime.dwHighDateTime;
					pp->nCreateTimeL = fd.ftLastWriteTime.dwLowDateTime;
					pp++;
				}
			}			
		}while( FindNextFile(hd,&fd) );
	}
	FindClose(hd);
}
int CMainFrame::DealDir(LPVOID lpvoid, int sk, sockaddr_in sa, char *pInBuf,PReqPackHead pReq)
{
	CMainFrame	*pMf	= (CMainFrame *)lpvoid;
	TCHAR szPath[200]={0};
	PDirParams pIn = (PDirParams)pInBuf;
	MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED,pIn->szPath,-1,
		szPath,sizeof(szPath));
	wcscat(szPath,_T("*.*"));
	//	printf("%s",szPath);
	
	int nTot = FindFilesAndDirsInDirectory(szPath);
	if( nTot <= 0 )
	{
		pMf->OnError(sk,sa,pReq,ERR_DIR_EMPTY);
		return 0;
	}
	PFileAttr pFiles = new FileAttr[nTot];
	int nFrameCount = (MAX_UDP_PACKAGE-sizeof(ReplyPackHead)-sizeof(DirRepParams))/sizeof(FileAttr);
	FindFilesAndDirsInDirectory(szPath,pFiles);	
	PFileAttr pTmpFiles = pFiles;
	while( nTot > 0 )
	{
		int nnn = nFrameCount;
		if( nTot - nnn < 0 ) nnn = nTot;
		nTot -= nnn;
		DirRepParams dirs;
		dirs.nCount = nnn;	
		dirs.nNextCount = nTot;
		int nlen = sizeof(ReplyPackHead)+sizeof(DirRepParams)+nnn*sizeof(FileAttr);
		pMf->CreateReplyHead(pReq,nlen);
		char* pData = g_szRet + sizeof(ReplyPackHead);
		memcpy(pData,&dirs,sizeof(DirRepParams));
		pData += sizeof(DirRepParams);
		memcpy(pData,pTmpFiles,nnn*sizeof(FileAttr));
		pMf->Send(g_szRet, nlen, sk, sa, sizeof(sa));
		pTmpFiles += nnn;
	}
	delete[] pFiles;
	return 0;
}
//下载文件
int CMainFrame::DealDownLoadFile(LPVOID lpvoid, int sk, sockaddr_in sa, char *pInBuf,PReqPackHead pReq)
{
	CMainFrame	*pMf	= (CMainFrame *)lpvoid;
	PDFileParams pIn = (PDFileParams)pInBuf;
	FILE*fp=fopen(pIn->szFileName,"rb");
	if( 0 == fp )
	{
		pMf->OnError(sk,sa,pReq,ERR_FILE_OPEN);
		return 1;
	}
	fseek(fp,0,SEEK_END);
	int nTotSize = ftell(fp);
	fseek(fp,0,SEEK_SET);
	int nHeadLen = sizeof(ReplyPackHead)+sizeof(DFileRepParams);
	int nPackSize = MAX_UDP_PACKAGE-nHeadLen;	
	DFileRepParams head={pIn->nSession,nTotSize,0,0};
	while( nTotSize > 0 )
	{
		int nlen = nPackSize;
		if( nTotSize - nPackSize < 0 ) nlen = nTotSize;
		nTotSize -= nlen;
		pMf->CreateReplyHead(pReq,nlen+nHeadLen);
		char* pBuf = g_szRet + sizeof(ReplyPackHead);
		memcpy(pBuf,&head,sizeof(DFileRepParams));
		pBuf += sizeof(DFileRepParams);
		int ntmp = fread(pBuf,1,nlen,fp);
		//error
		if( ntmp != nlen )
		{
			fclose(fp);			
			pMf->OnError(sk,sa,pReq,ERR_FILE_READ);
			return 1;
		}
		pMf->Send(g_szRet, nlen+nHeadLen, sk, sa, sizeof(sa));
		head.nPos += nlen;
	}	
	fclose(fp);
	return 0;
}
/*
int CMainFrame::DealRunDos(LPVOID lpvoid, int sk, sockaddr_in sa, char *pInBuf, int nLength)
{
CMainFrame	*pMf	= (CMainFrame *)lpvoid;

  WCHAR	wzExec[1024]	= {0};
  WCHAR	wzParam[1024]	= {0};
  
	MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, pInBuf, -1,wzExec, 1024);
	
	  DeleteFile(L"RMC.RET");
	  
		wsprintf(wzParam, L"/c %s>RMC.RET", wzExec);
		
		  SHELLEXECUTEINFO	info;
		  info.cbSize	= sizeof(SHELLEXECUTEINFO);
		  info.fMask	= SEE_MASK_FLAG_NO_UI|SEE_MASK_NOCLOSEPROCESS;
		  info.hwnd	= NULL;
		  info.lpVerb = NULL;
		  info.lpFile = L"\\Windows\\cmd.exe";//"1.ppt"
		  info.lpParameters	= wzParam;
		  info.lpDirectory	= L"\\";// "C:\Bin";
		  info.nShow			= SW_HIDE;
		  info.hInstApp		= NULL;
		  
			ShellExecuteEx(&info);
			
			  WaitForSingleObject(info.hProcess, 1000 * 10);
			  CloseHandle(info.hProcess);
			  
				FILE	*fp	= NULL;
				if(NULL == (fp	= fopen("RMC.RET", "r")))
				{
				sprintf(g_szRet, "Error Dos Cmd\n");
				pMf->Send(g_szRet, sizeof(g_szRet), sk, sa, sizeof(sa));
				g_szRet[0]	= 0;
				pMf->Send(g_szRet, 1, sk, sa, sizeof(sa));
				return 0;
				}
				
				  while(!feof(fp))
				  {
				  g_szRet[0]	= fgetc(fp);
				  pMf->Send(g_szRet, 1, sk, sa, sizeof(sa));
				  }
				  fclose(fp);
				  
					g_szRet[0]	= 0;
					pMf->Send(g_szRet, 1, sk, sa, sizeof(sa));
					return 0;
					}
*/
int CMainFrame::DealRun(LPVOID lpvoid, int sk, sockaddr_in sa, char *pInBuf, PReqPackHead pReq)
{
	CMainFrame	*pMf	= (CMainFrame *)lpvoid;
	PDFileRun pIn = (PDFileRun)pInBuf;
	
	WCHAR	wzExec[1024]	= {0};
	WCHAR	wzParam[1024]	= {0};
	
	WriteLog("FileName :%s  CmdParam :%s\n",pIn->szFileName,pIn->szCmdParam);
	MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, pIn->szFileName, -1,wzExec, 1024);
	MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, pIn->szCmdParam, -1,wzParam, 1024);
	
	SHELLEXECUTEINFO	info;
	ZeroMemory(&info, sizeof(info));
	info.cbSize	= sizeof(SHELLEXECUTEINFO);
	info.fMask	= SEE_MASK_FLAG_NO_UI;//SEE_MASK_NOCLOSEPROCESS
	info.hwnd	= NULL;
	info.lpVerb = _T("open");
	info.lpFile = wzExec;//"1.ppt"
	info.lpParameters	= wzParam;
	info.lpDirectory	= L"\\";// "C:\Bin";
	info.nShow			= SW_SHOW;
	info.hInstApp		= NULL;
	
	BOOL nRes = ShellExecuteEx(&info);
	
	WriteLog(g_szRet,"exec res:%d\n",nRes);
	int nHeadLen = sizeof(ReplyPackHead);
	pMf->CreateReplyHead(pReq,nHeadLen);
	pMf->Send(g_szRet, nHeadLen, sk,sa, sizeof(sa));
	return 0;
}
#pragma comment(lib,"ws2")
void WriteLog1(char* sfmt,...)
{
	static SOCKET hsock1=0;
	char szMes[4096]={0};
	char* p = szMes;
	p += strlen(p);
	va_list ap;
	va_start(ap, ,sfmt);
	vsprintf (p, sfmt, ap);
	va_end(ap);
	
	if( 0 == hsock1 )
	{
		unsigned int addr;
		addr = inet_addr("192.168.0.163");
		if( addr == INADDR_NONE )
		{
			return;
		}
		hsock1 = socket(AF_INET,SOCK_DGRAM,0);
		SOCKADDR_IN server;
		server.sin_addr.s_addr = addr;
		server.sin_family = AF_INET;
		server.sin_port = htons(8774);
		if( connect(hsock1,(struct sockaddr*)&server,sizeof(server)) )
		{  
			closesocket(hsock1);
			return;
		}
	}
	int nsend = send(hsock1,(const char*)szMes,strlen(szMes),0);
	// closesocket(hsock);
	
}
void CMainFrame::WriteLog2(char* sfmt,...)
{
	static SOCKET hsock1=0;
	char szMes[4096]={0};
	char* p = szMes;
	p += strlen(p);
	va_list ap;
	va_start(ap, ,sfmt);
	vsprintf (p, sfmt, ap);
	va_end(ap);
	
	if( 0 == hsock1 )
	{
		unsigned int addr;
		addr = inet_addr("192.168.0.160");
		if( addr == INADDR_NONE )
		{
			return;
		}
		hsock1 = socket(AF_INET,SOCK_DGRAM,0);
		SOCKADDR_IN server;
		server.sin_addr.s_addr = addr;
		server.sin_family = AF_INET;
		server.sin_port = htons(8774);
		if( connect(hsock1,(struct sockaddr*)&server,sizeof(server)) )
		{  
			closesocket(hsock1);
			return;
		}
	}
	int nsend = send(hsock1,(const char*)szMes,strlen(szMes),0);
	// closesocket(hsock);
	
}

int ll = 0;
int listLen = 0;
DWORD idthread;
pMDataList2 Listhead,dataList,tmpList;
HANDLE g_eventKill = ::CreateEvent(NULL,0,0,0);
HANDLE g_eventlist = ::CreateEvent(NULL,0,TRUE,0);
DWORD WINAPI WriteFileThread(LPVOID pParam)
{
	pMDataList2 tmpData1,tmpList1;
	char *pBuf;	
	int cou = 0;
	if(Listhead != NULL)
		tmpData1 = Listhead;
	int end = 0;
	int errf = 0;
	FILE*fp;
	fp = fopen((char *)pParam,"wb");
	DWORD dtime = 0;
	dtime = GetTickCount();
//	while(ll == 1)
	{
		do 
		{
			if(::WaitForSingleObject(g_eventKill,0) == WAIT_OBJECT_0)
				end = 1;
			WaitForSingleObject(g_eventlist, INFINITE); 
			if(listLen == 1)
			{
				Sleep(1000);
			}
			else
			{
				listLen--;
			}
			SetEvent(g_eventlist);
			while(tmpData1->next == NULL)
			{
				if(GetTickCount() - dtime > 1000)
					break;
				if(::WaitForSingleObject(g_eventKill,0) == WAIT_OBJECT_0 || (end == 1))
					break;
			}
			dtime = GetTickCount();
			pBuf=tmpData1->data;
			tmpList1 = tmpData1;
			tmpData1 = tmpData1->next;
			if(errf != -1)
			{
				if(fwrite(tmpList1->data,1,tmpList1->size,fp) != tmpList1->size)
				{
					fclose(fp);
					errf = -1;
					WriteLog1("cou %d  ---------------\n",cou);
				}
			}
			
			cou += tmpList1->size;
			delete[] tmpList1->data;
			delete tmpList1;
			WriteLog1("del %d\n",cou);
		} while(tmpData1 != NULL);
	}
	Listhead = NULL;
	WriteLog1("cou %d\n",cou);
	int j = fclose(fp);
	WriteLog1("fp %d\n",j);
	return 1;
}

int CMainFrame::DealUploadFile(LPVOID lpvoid, int sk, sockaddr_in sa, char *pInBuf, PReqPackHead pReq)
{
	
	CMainFrame	*pMf	= (CMainFrame *)lpvoid;
	PDFileUp pIn = (PDFileUp)pInBuf;
	pMf->WriteLog2("\n");
	//	FILE*fp;
	int pos = pIn->nPos;
	if(pos == 0)
	{
		ll = 1;
		::CreateThread(0,0,WriteFileThread,pIn->szFileName,0,&idthread);
/*		if(fp != 0)
		{
			fclose(fp);
			WriteLog("file no close\n");
		}*/
//		fp = fopen(pIn->szFileName,"wb");
		sendbufleng = 0;
		Listhead = NULL;
	}
	int nsize = pReq->nSize;
	int nLen;
	nLen = nsize - sizeof(DFileUp) - sizeof(ReqPackHead);

	dataList = new MDataList2;
	dataList->next = NULL;
	dataList->data = new char[nLen];
	memset(dataList->data,0,nLen);