server.c

经典远程控制代码

	// 建立屏幕的高度
	memset(szMessage,'\0',sizeof(szMessage));
	sprintf(szMessage,"%d",iHeight);
	iSent = Transmit(MySocket,szMessage,strlen(szMessage));

	// 接收确认
	memset(szMessage,'\0',sizeof(szMessage));
	iRecv = recv(MySocket,szMessage,81,0);
	szMessage[iRecv] = '\0';
}

// 通过socket发送区域显示位图
int SendRegionDisplay(HWND hWnd,SOCKET MySocket)
{
	char	szMessage[81];
	DWORD	iSent,iRecv;
	int		fSend = FALSE;
	int		iUpdates;
	WORD	wTreeSize;
	DWORD	dwByteTree[768];
	DWORD	dwCodes[514];
	DWORD	dwCompLen,dwLastCompLen;
	BOOL	fTransmit;
	char	*pTempDIB;
	DWORD	dwMinCompress;

	// 指向GDI链表的起始位
	iUpdates = 0;
	pGdiNode = GdiStart.pNext;
	while (pGdiNode)
	{
		//为每个网格得到区域显示
		fSend = GetRegionDisplay(hWnd);
		// 计算需要发送的变化的显示区域的数目
		if (fSend)
			iUpdates++;
		// 移动到下一个节点
		pGdiNode = pGdiNode->pNext;
	}

	// 发送到客户端需要更新的显示区域的数目
	memset(szMessage,'\0',sizeof(szMessage));
	sprintf(szMessage,"%d",iUpdates);
	iSent = Transmit(MySocket,szMessage,strlen(szMessage));
	// 接收确认
	memset(szMessage,'\0',sizeof(szMessage));
	iRecv = recv(MySocket,szMessage,81,0);
	szMessage[iRecv] = '\0';

	if (iUpdates > 0)
	{
		// 指向GDI链表的起始位
		pGdiNode = GdiStart.pNext;
		while (pGdiNode)
		{
			// 如果桌面发生了变化，则发送DIB
			if (pGdiNode->Gdi.fChange)
			{
				int		iCompressions = 1;
				//无压缩
				if (iCompressionLevel == 0) 
				{
					pGdiNode->Gdi.pDIBCompress = (char *)malloc(pGdiNode->Gdi.dwCompress);
					memblast(pGdiNode->Gdi.pDIBCompress,pGdiNode->Gdi.pDIBChange,pGdiNode->Gdi.dwCompress);
					dwSendLen = pGdiNode->Gdi.dwCompress;
				}
				if (iCompressionLevel == 10) // 单遍霍夫曼编码压缩
				{
					pGdiNode->Gdi.pDIBCompress = (char *)malloc(pGdiNode->Gdi.dwCompress + 1536);
					// 生成霍夫曼字节树字典
					wTreeSize = HuffmanDictionary(pGdiNode->Gdi.pDIBChange,pGdiNode->Gdi.dwCompress,&dwByteTree[0],&dwCodes[0]);
					// 使用霍夫曼压缩方法压缩图片
					dwSendLen = HuffmanCompress(pGdiNode->Gdi.pDIBChange,pGdiNode->Gdi.dwCompress,wTreeSize,&dwByteTree[0],&dwCodes[0],pGdiNode->Gdi.pDIBCompress);
				}
				else if (iCompressionLevel == 11) // 多遍霍夫曼压缩编码
				{
					dwMinCompress = pGdiNode->Gdi.dwCompress + 1536;
					pGdiNode->Gdi.pDIBCompress = (char *)malloc(dwMinCompress);
					pTempDIB = (char *)malloc(pGdiNode->Gdi.dwCompress);
					memblast(pTempDIB,pGdiNode->Gdi.pDIBChange,pGdiNode->Gdi.dwCompress);
					iCompressions = 0;
					dwCompLen = pGdiNode->Gdi.dwCompress;
					dwLastCompLen = dwCompLen;
					for (;;)
					{
						// 生成霍夫曼字节树字典
						wTreeSize = HuffmanDictionary(pTempDIB,pGdiNode->Gdi.dwCompress,&dwByteTree[0],&dwCodes[0]);
						// 计算压缩长度
						dwCompLen = HuffmanCountCompress(pTempDIB,dwCompLen,wTreeSize,&dwCodes[0]);
						if (dwCompLen < dwMinCompress)
						{
							dwSendLen = HuffmanCompress(pTempDIB,dwLastCompLen,wTreeSize,&dwByteTree[0],&dwCodes[0],pGdiNode->Gdi.pDIBCompress);
							memblast(pTempDIB,pGdiNode->Gdi.pDIBCompress,dwSendLen);
							dwMinCompress = dwSendLen;
							dwLastCompLen = dwCompLen;
							iCompressions++;
						}
						else
							break;
					}
					free(pTempDIB);
				}
				else if (iCompressionLevel == 12) // Run Length编码
				{
					//为最坏的情况分配压缩空间
					pGdiNode->Gdi.pDIBCompress = (char *)malloc(pGdiNode->Gdi.dwCompress * 3 + 4);
					// Run Length编码图象
					dwSendLen = RunLengthEncode(pGdiNode->Gdi.pDIBChange,pGdiNode->Gdi.dwCompress,pGdiNode->Gdi.pDIBCompress);
				}
				else if (iCompressionLevel == 13) // Run Length&Huffman编码
				{
					pTempDIB = (char *)malloc(pGdiNode->Gdi.dwCompress * 3 + 4);
					pGdiNode->Gdi.pDIBCompress = (char *)malloc(pGdiNode->Gdi.dwCompress * 3 + 4);
					// Run Length 编码图象
					dwCompLen = RunLengthEncode(pGdiNode->Gdi.pDIBChange,pGdiNode->Gdi.dwCompress,pTempDIB);
					// 生成霍夫曼字节树的字典
					wTreeSize = HuffmanDictionary(pTempDIB,dwCompLen,&dwByteTree[0],&dwCodes[0]);
					// 使用霍夫曼压缩Run Lenght编码的图象
					dwSendLen = HuffmanCompress(pTempDIB,dwCompLen,wTreeSize,&dwByteTree[0],&dwCodes[0],pGdiNode->Gdi.pDIBCompress);
					// 释放临时的DIB
					free(pTempDIB);
				}

				// 建立位图控制消息
				memset(szMessage,'\0',sizeof(szMessage));
				sprintf(szMessage,"%d;%d;%d;%ld;%ld;%ld;",
					iCompressions,
					pGdiNode->Gdi.iGridX,pGdiNode->Gdi.iGridY,
					pGdiNode->Gdi.iStartPos,
					pGdiNode->Gdi.dwCompress,dwSendLen);
				// 发送控制消息
				iSent = Transmit(MySocket,szMessage,strlen(szMessage));

				// 接收确认
				memset(szMessage,'\0',sizeof(szMessage));
				iRecv = recv(MySocket,szMessage,81,0);
				szMessage[iRecv] = '\0';

				// 发送压缩的DIB
				fTransmit = Transmit(MySocket,pGdiNode->Gdi.pDIBCompress,dwSendLen);
				// 释放压缩的DIB
				free(pGdiNode->Gdi.pDIBCompress);
				// 接收确认
				memset(szMessage,'\0',sizeof(szMessage));
				iRecv = recv(MySocket,szMessage,81,0);
				szMessage[iRecv] = '\0';
			}
			pGdiNode = pGdiNode->pNext;
		}
	}
	return iUpdates;
}

//传输数据到客户端
BOOL Transmit(SOCKET MySocket,char *pData,DWORD dwLength)
{
	WSAOVERLAPPED	olSend;
	WSAEVENT	gheventOlSock;
	WSAEVENT	eventArray[2];
	WSABUF		buffSend;
	DWORD		dwRet,dwNumBytes,dwFlags;
	int			nWSAError;
	char		szError[81];

	// 为发送完成创建一个信号事件
	gheventOlSock = WSACreateEvent();
	eventArray[0] = gheventOlSock;

	// 初始化重叠发送的结构
	ZeroMemory(&olSend, sizeof(WSAOVERLAPPED));
	// 为发送重叠结构创建一个信号时间
	olSend.hEvent= gheventOlSock;
	buffSend.len = dwLength;
	buffSend.buf = pData;
	// 持续发送，直到dwSendLen个字节被发送完成
	while (TRUE)
	{
		if ((dwRet = WSASend(MySocket,&buffSend,1,&dwNumBytes,0,&olSend,NULL)) == SOCKET_ERROR)
		{
			nWSAError= WSAGetLastError();
			if (nWSAError != ERROR_IO_PENDING)
			{
				sprintf(szError,"WSASend failed with error %d\n",nWSAError);
				MessageBox(NULL,szError,"Server",MB_OK);
			}
		}
	
		if (WSAWaitForMultipleEvents(1,eventArray,FALSE,WSA_INFINITE,FALSE) == WSA_WAIT_FAILED)
		{
			sprintf(szError,"WSAWaitForMultipleEvents failed %d\n", WSAGetLastError());
			MessageBox(NULL,szError,"Server",MB_OK);
		} 
		// 重置gheventOlSock
		WSAResetEvent(eventArray[0]);
		if (WSAGetOverlappedResult(MySocket,&olSend,&dwNumBytes,FALSE,&dwFlags) == FALSE)
		{
			sprintf(szError,"WSAGetOverlappedResult failed with error %d\n", WSAGetLastError());
			MessageBox(NULL,szError,"Server",MB_OK);
		}
		buffSend.len -= dwNumBytes;
		if (buffSend.len == 0) 
			break;
		else 
			buffSend.buf += dwNumBytes;
	}

	// 关闭信号事件
	WSACloseEvent(gheventOlSock);
	return TRUE;
}

//返回本机安装的所有的有XP1_GUARANTEED_DELIVERY and XP1_GUARANTEED_ORDER标志的协议和协议链
int SelectProtocols(DWORD dwSetFlags,DWORD dwNotSetFlags,LPWSAPROTOCOL_INFO lpProtocolBuffer,LPDWORD lpdwBufferLength,WSAPROTOCOL_INFO *pProtocol)
{
	LPBYTE				pBuf;
	LPWSAPROTOCOL_INFO	pInfo;
	DWORD				dwNeededLen;
	LPWSAPROTOCOL_INFO	pRetInfo;
	DWORD				dwRetLen;
	int					nCount;
	int					nMatchCount;
	int					nRet;

	// 决定需要的缓冲区大小
	dwNeededLen = 0;
	nRet = WSAEnumProtocols(NULL, NULL, &dwNeededLen);
	if (nRet == SOCKET_ERROR)
	{
		if (WSAGetLastError() != WSAENOBUFS)
			return SOCKET_ERROR;
	}
	// 分配大小
	pBuf = malloc(dwNeededLen);
	if (pBuf == NULL)
	{
		WSASetLastError(WSAENOBUFS);
		return SOCKET_ERROR;
	}

	nRet = WSAEnumProtocols(NULL,(LPWSAPROTOCOL_INFO)pBuf,&dwNeededLen);
	if (nRet == SOCKET_ERROR)
	{
		free(pBuf);
		return SOCKET_ERROR;
	}

	#define REJECTSET(f) \
	    ((dwSetFlags & f) && !(pInfo->dwServiceFlags1 & f))
	#define REJECTNOTSET(f) \
	    ((dwNotSetFlags &f) && (pInfo->dwServiceFlags1 & f))
	#define REJECTEDBY(f) (REJECTSET(f) || REJECTNOTSET(f))

	pInfo = (LPWSAPROTOCOL_INFO)pBuf;	
	pRetInfo = lpProtocolBuffer;
	dwRetLen = 0;
	nMatchCount = 0;
	for(nCount = 0; nCount < nRet; nCount++)
	{
		while(1)
		{
			if (REJECTEDBY(XP1_CONNECTIONLESS))
				break;
			if (REJECTEDBY(XP1_GUARANTEED_DELIVERY))
				break;
			if (REJECTEDBY(XP1_GUARANTEED_ORDER))
				break;
			if (REJECTEDBY(XP1_MESSAGE_ORIENTED))
				break;
			if (REJECTEDBY(XP1_PSEUDO_STREAM))
				break;
			if (REJECTEDBY(XP1_GRACEFUL_CLOSE))
				break;
			if (REJECTEDBY(XP1_EXPEDITED_DATA))
				break;
			if (REJECTEDBY(XP1_CONNECT_DATA))
				break;
			if (REJECTEDBY(XP1_DISCONNECT_DATA))
				break;
			if (REJECTEDBY(XP1_SUPPORT_BROADCAST)) 
				break;
			if (REJECTEDBY(XP1_SUPPORT_MULTIPOINT))
				break;
			if (REJECTEDBY(XP1_MULTIPOINT_DATA_PLANE))
				break;
			if (REJECTEDBY(XP1_QOS_SUPPORTED))
				break;
			if (REJECTEDBY(XP1_UNI_SEND))
				break;
			if (REJECTEDBY(XP1_UNI_RECV))
				break;
			if (REJECTEDBY(XP1_IFS_HANDLES))
				break;
			if (REJECTEDBY(XP1_PARTIAL_MESSAGE))
				break;

			dwRetLen += sizeof(WSAPROTOCOL_INFO);

			if (dwRetLen > *lpdwBufferLength)
			{
				WSASetLastError(WSAENOBUFS);
				*lpdwBufferLength = dwNeededLen;
				free(pBuf);
				return SOCKET_ERROR;
			}
			nMatchCount++;
			// 拷贝协议到调用者的buffer里
			memblast(pRetInfo,pInfo,sizeof(WSAPROTOCOL_INFO));
			if (strcmp(pInfo->szProtocol,"MSAFD Tcpip [TCP/IP]") == 0)
				memblast(pProtocol,pInfo,sizeof(WSAPROTOCOL_INFO));
			pRetInfo++;
			break;
		}
		pInfo++;
	}
	free(pBuf);
	*lpdwBufferLength = dwRetLen;
	return(nMatchCount);
}

void memblast(void* dest,void* src,DWORD count)
{
	DWORD	iCount;

	__asm
	{
		MOV		ECX,count
		SHR		ECX,2
		SHL		ECX,2
		MOV		iCount,ECX

		MOV		ESI,src
		MOV		EDI,dest
		MOV		ECX,iCount
		SHR		ECX,2	
		REP		MOVSD	

		MOV		ECX,count
		MOV		EAX,iCount
		SUB		ECX,EAX

		JZ		Exit

		MOV		ESI,src	
		ADD		ESI,EAX	
		MOV		EDI,dest	
		ADD		EDI,EAX		
		REP		MOVSB		
		Exit:
	}
}
/*
int GetLocalHostName(char* sHostName)	//获得本地计算机名称
{
	char szHostName[256];
	int nRetCode;
	nRetCode=gethostname(szHostName,sizeof(szHostName));
	if(nRetCode!=0)
	{
		//产生错误
		strcpy(sHostName,"没有取得");
		return GetLastError();
	}
	strcpy(sHostName,szHostName);
	return 0;
}
int GetIpAddress(char *sHostName, BYTE *f0,BYTE *f1,BYTE *f2,BYTE *f3)//获得本地IP
{
	struct hostent FAR * lpHostEnt=gethostbyname(sHostName);
	if(lpHostEnt==NULL)
	{
		//产生错误
		f0=f1=f2=f3=0;
		return GetLastError();
	}
	//获取IP
	if(lpHostEnt->h_addr_list[0])
	{
		struct in_addr inAddr;
		memmove(&inAddr,lpHostEnt->h_addr_list[0],4);
		*f0=inAddr.S_un.S_un_b.s_b1;
		*f1=inAddr.S_un.S_un_b.s_b2;
		*f2=inAddr.S_un.S_un_b.s_b3;
		*f3=inAddr.S_un.S_un_b.s_b4;
	}
	return 0;
}
*/