關於一個開發中的程式

Lynr · August 29, 2011

不知道各位有沒有聽過虛擬區域網路

老實說我不太確定這個名詞適不適合用在我正在開發的程式上

因為我覺得在某些方面看來似乎兩者並不完全相同

有許多單機的遊戲都會提供可以在區域網路連線的功能

也出現了一些可以透過各種方式讓遊戲也可以在網際網路上連線的程式

有些模擬了一個虛擬的網路卡

有些則是Hook遊戲網路連線的API

我目前是採用Hook API的方式

或者說是我只能採用這種方式

畢竟要怎樣虛擬一個硬體裝置我是連點皮毛都不知道

目前是把它用在魔獸爭霸3上

有一款叫做garena的軟體也是有這種功能

而且它的規模似乎挺大的

或者是大陸也有許多類似的軟體

我本身就時常玩魔獸爭霸3當作悠閒

只是那些平台上的玩家的水準真令人不敢領教

惡意的謾罵或是人身攻擊幾乎是隨處可見

我又剛好對程式設計頗有興趣的

我就想試著寫寫看

我第一次知道Hook API這種東西大概是在三年前

而這一次我還是第一次把它付諸實行

看了三年的瑣碎文章都沒做出什麼來

而這次只花了一個禮拜就一口氣寫出來了

我是覺得寫的過程挺多阻礙的

說起程式語言我似乎沒有很正式的學過什麼

好像只在高一的電腦課聽了點幾乎都沒什麼幫助的東西

老師連什麼叫做型別什麼叫做變數都沒提到

同學們只是依樣畫葫蘆罷了

前些陣子我看到了這些文章

http://blog.ez2learn.com/category/chinese-articles/

我想我或許更幸運了些

畢竟我至少比他小個五六歲

或許是個更好的世代

也許是看了這篇我才在暑假的最後幾天寫了出來

其實寫的過程有很多東西我都是一知半解的

更何況C語言我其實根本不會多少

我目前只完成到可以Hook API而已

大致的作法是用CreateRemoteThread讓遊戲去呼叫LoadLibrary

把我編寫的DLL載入到遊戲的程序中

在Dllmain的地方再去修改遊戲的IAT

讓遊戲在呼叫API時先跳到我的函式在跳到API去執行

這個過程我就可以攔截到呼叫API的參數或是修改等等

我目前大致知道這遊戲是透過用255.255.255.255廣播來在區域網路散布訊息的

我想攔截這個訊息將它發送到網路網路特定的電腦上或許就可以了

只是沒有適合的方式測試

不過我想是可以的

那些部分都是用C語言寫的或許混雜一些C++的

剩下的部分我可能會想要用VB.Net

其實說了以上這麼多

我只是想說一下為什麼想寫這個程式而已

我是想要看看有沒有願意參與開發的

因為我其實真的蠻想完成它的

不過我覺得要做到真的能讓多人連線還能保證它的穩定性

不是一個人可以完成的

我前面也說了

對於程式設計我大概只能算是入門中的入門

不管會什麼語言都可以

或者說是完全不會也沒關係

任何事都會有一個開始的

更何況我覺得我需要許多意見

我目前還沒有寫過任何程式是由多人一起編寫的

我在想人多一點或許會更有趣

感覺有點像是看電影

應該很少有人會一個人去看電影的吧

其實我蠻久之前就知道有這個論壇了

只是第一次這麼仔細注意它是為了打現在這篇主題

感覺在這裡或許比較容易找到感興趣的人

雖然沒有什麼必要性

不過還是打出我目前寫的部分

寫的方式或許會有些愚蠢的部分

可能也不是相當完美

不過至少能正確執行了

以下是執行檔


#include "stdafx.h"

DWORD Fix ();
DWORD Injection (LPCTSTR, LPCTSTR, LPCTSTR, LPHANDLE, LPHANDLE);
DWORD ReadThread(LPHANDLE);

int _tmain (int argc, _TCHAR* argv[])
{	
	DWORD Code;
	Code = Fix ();
	if (Code != 0)
	{
		return Code;
	}
	HANDLE OutputRead;
	HANDLE InputWrite;
	Code = Injection (_T("C:\\Warcraft III\\War3.exe"), _T("-window"), _T("Dll.dll"), &OutputRead, &InputWrite);
	if (Code != 0)
	{
		return Code;
	}
	SECURITY_ATTRIBUTES sa;
	HANDLE ReadThreadHandle = CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE)ReadThread, &OutputRead, 0, NULL);
	CloseHandle (ReadThreadHandle);
	while (TRUE)
	{
		Sleep(INFINITE);
	}
	return 0;
}

DWORD ReadThread (LPHANDLE OutputRead)
{
	while (TRUE)
	{
		if (PeekNamedPipe (*OutputRead, NULL, 0, NULL, NULL, NULL))
		{
			LPSTR Buffer = new CHAR[256];
			DWORD Read;
			ReadFile (*OutputRead, Buffer, 255, &Read, NULL);
			Buffer[Read] = '\0';
			printf ("%s",Buffer);
			fflush (stdout);
		}
		else
		{
			Sleep(200);
		}
	}
}

DWORD Fix()
{
	LPTSTR WorkDirectory = new TCHAR[MAX_PATH];
	DWORD WorkDirectoryBufferLength = GetModuleFileName (NULL, WorkDirectory, MAX_PATH);
	if (WorkDirectoryBufferLength == 0)
	{
		return GetLastError ();
	}
	DWORD i = WorkDirectoryBufferLength - 1;
	for (; i >= 0 ; i--)
	{
		if (WorkDirectory[i] == '\\')
		{
			WorkDirectory[i] = '\0';
			break;
		}
	}
	if (SetCurrentDirectory (WorkDirectory) == FALSE)
	{
		return GetLastError ();
	}
	return 0;
}

DWORD Injection(LPCTSTR ExeFile, LPCTSTR ExeCmd, LPCTSTR DllFile, LPHANDLE OutputRead, LPHANDLE InputWrite)
{
	DWORD ExePathBufferLength = GetFullPathName (ExeFile, 0, NULL, NULL);
	if (ExePathBufferLength == 0)
	{
		return GetLastError ();
	}
	LPTSTR ExeFilePath = new TCHAR [ExePathBufferLength];
	LPTSTR ExeFileName;
	DWORD ExePathLength = GetFullPathName (ExeFile, ExePathBufferLength, ExeFilePath, &ExeFileName);
	if (ExePathLength == 0)
	{
		return GetLastError ();
	}
	DWORD ExeDirectoryLength = ExePathLength - wcslen (ExeFileName) - 1;
	LPTSTR ExeFileDirectory = new TCHAR [ExeDirectoryLength + 1];
	wcsncpy_s (ExeFileDirectory, ExeDirectoryLength + 1, ExeFilePath, ExeDirectoryLength);
	DWORD DllPathBufferLength = GetFullPathName (DllFile, 0, NULL, NULL);
	if (DllPathBufferLength == 0)
	{
		return GetLastError ();
	}
	LPTSTR DllFilePath = new TCHAR [DllPathBufferLength];
	LPTSTR DllFileName;
	DWORD DllPathLength = GetFullPathName (DllFile, DllPathBufferLength, DllFilePath, &DllFileName);
	if (DllPathLength == 0)
	{
		return GetLastError ();
	}
	DWORD DllDirectoryLength = DllPathLength - wcslen (DllFileName) - 1;
	LPTSTR DllFileDirectory = new TCHAR [DllDirectoryLength + 1];
	wcsncpy_s (DllFileDirectory, DllDirectoryLength + 1, DllFilePath, DllDirectoryLength);
	DWORD CommandLength = ExePathLength + wcslen (ExeCmd) + 3;
	LPTSTR Command = new TCHAR [CommandLength + 1];
	wcscpy_s (Command, CommandLength + 1, _T("\""));
	wcscat_s (Command, CommandLength + 1, ExeFilePath);
	wcscat_s (Command, CommandLength + 1, _T("\" "));
	wcscat_s (Command, CommandLength + 1, ExeCmd);
	HANDLE InputRead,OutputWrite;
	SECURITY_ATTRIBUTES sa;
	sa.nLength = sizeof (SECURITY_ATTRIBUTES);
	sa.bInheritHandle = TRUE;
	sa.lpSecurityDescriptor = NULL;
	CreatePipe (&InputRead, InputWrite, &sa, 0);
	CreatePipe (OutputRead, &OutputWrite, &sa, 0);
	STARTUPINFO StarupInfo = {NULL};
	StarupInfo.cb = sizeof (STARTUPINFO);
	StarupInfo.dwFlags = STARTF_USESTDHANDLES;
	StarupInfo.hStdInput = InputRead;
	StarupInfo.hStdOutput = OutputWrite;
	StarupInfo.hStdError = OutputWrite;
	PROCESS_INFORMATION ProcessInfo;
	if (!CreateProcess (ExeFilePath, Command, NULL, NULL, TRUE, NORMAL_PRIORITY_CLASS | CREATE_SUSPENDED, NULL, ExeFileDirectory, &StarupInfo, &ProcessInfo))
	{
		return GetLastError ();
	}
	LPVOID DllPathMemory = VirtualAllocEx (ProcessInfo.hProcess, NULL, sizeof (TCHAR) * DllPathBufferLength, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
	if (DllPathMemory == NULL)
	{
		return GetLastError ();
	}
	if (!WriteProcessMemory (ProcessInfo.hProcess, DllPathMemory, DllFilePath, sizeof (TCHAR) * DllPathBufferLength, NULL))
	{
		return GetLastError ();
	}
	HANDLE RemoteThreadHandle = CreateRemoteThread (ProcessInfo.hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)GetProcAddress (GetModuleHandle (_T("kernel32.dll")), "LoadLibraryW"), DllPathMemory, 0, NULL);
	if (RemoteThreadHandle == NULL)
	{
		return GetLastError ();
	}
	if (WaitForSingleObject (RemoteThreadHandle, INFINITE) != WAIT_OBJECT_0)
	{
		return GetLastError ();
	}
	VirtualFreeEx (ProcessInfo.hProcess, DllPathMemory, sizeof (TCHAR) * DllPathBufferLength, MEM_RELEASE);
	ResumeThread (ProcessInfo.hThread);
	CloseHandle(InputRead);
	CloseHandle(OutputWrite);
	CloseHandle(RemoteThreadHandle);
	CloseHandle(ProcessInfo.hProcess);
	CloseHandle(ProcessInfo.hThread);
	return 0;
}

以下是DLL


#include "stdafx.h"

void Hook (LPCWSTR, LPCWSTR, LPCSTR, PROC);

HMODULE WINAPI MyLoadLibraryA (__in LPCSTR);

BOOL APIENTRY DllMain (HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
{
	switch (ul_reason_for_call)
	{
	case DLL_PROCESS_ATTACH:
		printf("HOOK\n");
		fflush(stdout);
		Hook (NULL, _T("kernel32.dll"), "LoadLibraryA", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "MyLoadLibraryA"));
		break;
	case DLL_THREAD_ATTACH:
	case DLL_THREAD_DETACH:
	case DLL_PROCESS_DETACH:
		break;
	}
	return TRUE;
}

void Hook (LPCWSTR module, LPCWSTR dll, LPCSTR proc, PROC m)
{
	HMODULE hModule = GetModuleHandle (module);
	ULONG Size;
	PIMAGE_IMPORT_DESCRIPTOR pid = (PIMAGE_IMPORT_DESCRIPTOR)ImageDirectoryEntryToData (hModule, TRUE, IMAGE_DIRECTORY_ENTRY_IMPORT, &Size);
	while (pid->Name)
	{
		LPTSTR hd = new TCHAR[256];
		MultiByteToWideChar (CP_ACP,0,(LPCSTR)((LPBYTE)hModule+pid->Name),-1,hd,256);
		if (lstrcmpi (hd, dll) == 0)
		{
			PIMAGE_THUNK_DATA ptd = (PIMAGE_THUNK_DATA)((LPBYTE)hModule + pid->FirstThunk);
			while (ptd->u1.Function)
			{
				PROC *fe = (PROC*)&(ptd->u1.Function);
				if (*fe == GetProcAddress (GetModuleHandle (dll), proc))
				{
					MEMORY_BASIC_INFORMATION mi;
					VirtualQuery (fe, &mi,sizeof (mi));
					VirtualProtect (mi.BaseAddress, mi.RegionSize, PAGE_READWRITE, &mi.Protect);
					WriteProcessMemory (GetCurrentProcess(), fe, &m, sizeof(PROC*), NULL);
					VirtualProtect (mi.BaseAddress, mi.RegionSize, mi.Protect, &mi.Protect);
				}
				ptd++;	
			}
		}
		pid++;
	}
}

HMODULE WINAPI MyLoadLibraryA (__in LPCSTR lpLibFileName)
{
	HMODULE Dll = LoadLibraryA (lpLibFileName);
	if (lstrcmpiA (lpLibFileName, "Game.dll") == 0)
	{
		Hook (_T("Game.dll"), _T("wsock32.dll"), "accept", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "Myaccept"));//連入
		Hook (_T("Game.dll"), _T("wsock32.dll"), "bind", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "Mybind"));//綁定
		//Hook (_T("Game.dll"), _T("wsock32.dll"), "closesocket", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "Myclosesocket"));
		Hook (_T("Game.dll"), _T("wsock32.dll"), "connect", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "Myconnect"));//連接
		//Hook (_T("Game.dll"), _T("wsock32.dll"), "getpeername", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "Mygetpeername"));
		//Hook (_T("Game.dll"), _T("wsock32.dll"), "getsockname", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "Mygetsockname"));
		//Hook (_T("Game.dll"), _T("wsock32.dll"), "htons", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "Myhtons"));
		//Hook (_T("Game.dll"), _T("wsock32.dll"), "inet_addr", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "Myinet_addr"));
		//Hook (_T("Game.dll"), _T("wsock32.dll"), "inet_ntoa", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "Myinet_ntoa"));
		Hook (_T("Game.dll"), _T("wsock32.dll"), "ioctlsocket", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "Myioctlsocket"));//設定
		Hook (_T("Game.dll"), _T("wsock32.dll"), "listen", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "Mylisten"));//接聽
		//Hook (_T("Game.dll"), _T("wsock32.dll"), "ntohl", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "Myntohl"));
		//Hook (_T("Game.dll"), _T("wsock32.dll"), "ntohs", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "Myntohs"));
		Hook (_T("Game.dll"), _T("wsock32.dll"), "recv", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "Myrecv"));//接收
		Hook (_T("Game.dll"), _T("wsock32.dll"), "recvfrom", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "Myrecvfrom"));//接收
		Hook (_T("Game.dll"), _T("wsock32.dll"), "select", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "Myselect"));//非同步
		Hook (_T("Game.dll"), _T("wsock32.dll"), "send", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "Mysend"));//發送
		Hook (_T("Game.dll"), _T("wsock32.dll"), "sendto", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "Mysendto"));//發送
		Hook (_T("Game.dll"), _T("wsock32.dll"), "setsockopt", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "Mysetsockopt"));//設定
		Hook (_T("Game.dll"), _T("wsock32.dll"), "socket", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "Mysocket"));//建立
		//Hook (_T("Game.dll"), _T("wsock32.dll"), "gethostbyname", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "Mygethostbyname"));
		//Hook (_T("Game.dll"), _T("wsock32.dll"), "gethostname", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "Mygethostname"));
		//Hook (_T("Game.dll"), _T("wsock32.dll"), "WSAGetLastError", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "MyWSAGetLastError"));
		//Hook (_T("Game.dll"), _T("wsock32.dll"), "WSAStartup", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "MyWSAStartup"));
		//Hook (_T("Game.dll"), _T("wsock32.dll"), "WSACleanup", GetProcAddress (GetModuleHandle (_T("DLL.dll")), "MyWSACleanup"));
	}
	return Dll;
}

以下是DLL的匯出函式


#include "stdafx.h"

//接受
SOCKET PASCAL FAR Myaccept (__in SOCKET s, __out_bcount_opt(*addrlen) struct sockaddr FAR *addr, __inout_opt int FAR *addrlen)
{
	printf("Call accept\n Socket:%x\n", s);
	fflush(stdout);
	SOCKET r = accept (s, addr, addrlen);
	printf(" Socket:%x\n Addr:%s\n Port:%d\n", r, inet_ntoa(((sockaddr_in*)addr)->sin_addr), ((sockaddr_in*)addr)->sin_port);
	fflush(stdout);
	return r;
}

//綁定
int PASCAL FAR Mybind (__in SOCKET s, __in_bcount(namelen) const struct sockaddr FAR *addr, __in int namelen)
{
	printf("Call bind\n Socket:%x\n Addr:%s\n Port:%d\n", s, inet_ntoa(((sockaddr_in*)addr)->sin_addr), ((sockaddr_in*)addr)->sin_port);
	fflush(stdout);
	int r = bind (s, addr, namelen);
	printf(" bind返回:%d\n", r);
	fflush(stdout);
	return r;
}

//int PASCAL FAR Myclosesocket (IN SOCKET s)
//{
//	printf ("Call closesocket\n");
//	return closesocket (s);
//}

//連接
int PASCAL FAR Myconnect (__in SOCKET s, __in_bcount(namelen) const struct sockaddr FAR *name, __in int namelen)
{
	printf("Call connect\n Socket:%x\n Addr:%s\n Port:%d\n", s, inet_ntoa(((sockaddr_in*)name)->sin_addr), ((sockaddr_in*)name)->sin_port);
	fflush(stdout);
	int r = connect (s, name, namelen);
	printf(" connect返回:%d\n", r);
	fflush(stdout);
	return r;
}

//int PASCAL FAR Mygetpeername (__in SOCKET s, __out_bcount_part(*namelen, *namelen) struct sockaddr FAR *name, __inout int FAR * namelen)
//{
//	printf("Call getpeername\n");
//	printf("Socket:%x 長度:%d\n", s, namelen);
//	int r = getpeername (s, name, namelen);
//	return r;
//}
//
//int PASCAL FAR Mygetsockname (__in SOCKET s, __out_bcount_part(*namelen, *namelen) struct sockaddr FAR *name, __inout int FAR * namelen)
//{
//	printf("Call getsockname\n");
//	printf("Socket:%x 長度:%d\n", s, namelen);
//	int r = getsockname (s, name, namelen);
//	return r;
//}

//u_short PASCAL FAR Myhtons (__in u_short hostshort)
//{
//	printf("Call htons\n");
//	u_short r = htons (hostshort);
//	printf("%d %d\n", hostshort, r);
//	return r;
//}

//unsigned long PASCAL FAR Myinet_addr (__in const char FAR * cp)
//{
//	printf("Call inet_addr\n");
//	return inet_addr (cp);
//}

//char FAR * PASCAL FAR Myinet_ntoa (__in struct in_addr in)
//{
//	printf("Call inet_ntoa\n");
//	return inet_ntoa (in);
//}

//設置Socket
int PASCAL FAR Myioctlsocket (__in SOCKET s, __in long cmd, __inout u_long FAR *argp)
{
	printf("Call ioctlsocket\n Socket:%x\n Cmd:%x\n Before Argp:%d\n", s, cmd, *argp);
	fflush(stdout);
	int r = ioctlsocket (s, cmd, argp);
	printf(" After Argp:%d\n ioctlsocket返回:%d\n", *argp, r);
	fflush(stdout);
	return r;
}

//接聽
int PASCAL FAR Mylisten (__in SOCKET s, __in int backlog)
{
	printf("Call listen\n Socket:%x\n Backlog:%d\n", s, backlog);
	fflush(stdout);
	int r = listen (s, backlog);
	printf(" listen返回:%d\n", r);
	fflush(stdout);
	return r;
}

//u_long PASCAL FAR Myntohl (__in u_long netlong)
//{
//	printf("Call ntohl\n");
//	return ntohl (netlong);
//}

//u_short PASCAL FAR Myntohs (__in u_short netshort)
//{
//	printf("Call ntohs\n");
//	return ntohs (netshort);
//}

//接收
int PASCAL FAR Myrecv (__in SOCKET s, __out_bcount_part(len, return) __out_data_source(NETWORK) char FAR * buf, __in int len, __in int flags)
{
	printf("Call recv\n");
	fflush(stdout);
	int r = recv (s, buf, len, flags);
	printf(" Socket:%x\n Flags:%d\n Data:%s\n recvfrom返回:%d\n", s, flags, buf, r);
	fflush(stdout);
	return r;
}

//接收
int PASCAL FAR Myrecvfrom (__in SOCKET s, __out_bcount_part(len, return) __out_data_source(NETWORK) char FAR * buf, __in int len, __in int flags, __out_bcount_opt(*fromlen) struct sockaddr FAR * from, __inout_opt int FAR * fromlen)
{
	printf("Call recvfrom\n");
	fflush(stdout);
	int r = recvfrom (s, buf, len, flags, from, fromlen);
	printf(" Socket:%x\n Flags:%d\n Addr:%s\n Port:%d\n Data:%s\n recvfrom返回:%d\n", s, flags, inet_ntoa(((sockaddr_in*)from)->sin_addr), ((sockaddr_in*)from)->sin_port, buf, r);
	fflush(stdout);
	return r;
}

//非同步
int PASCAL FAR Myselect (__in int nfds, __inout_opt fd_set FAR *readfds, __inout_opt fd_set FAR *writefds, __inout_opt fd_set FAR *exceptfds, __in_opt  const struct timeval FAR *timeout)
{
	printf("Call select\n");
	fflush(stdout);
	int r = select (nfds, readfds, writefds, exceptfds, 0);
	printf(" select返回:%d\n", r);
	fflush(stdout);
	return r;
}

//發送
int PASCAL FAR Mysend (__in SOCKET s, __in_bcount(len) const char FAR * buf, __in int len, __in int flags)
{
	printf("Call send\n Socket:%x\n Flags:%d\n Data:%s\n", s, flags, buf);
	fflush(stdout);
	int r = send (s, buf, len, flags);
	printf(" send返回:%d\n", r);
	fflush(stdout);
	return r;
}

//發送
int PASCAL FAR Mysendto (__in SOCKET s, __in_bcount(len) const char FAR * buf, __in int len, __in int flags, __in_bcount_opt(tolen) const struct sockaddr FAR *to, __in int tolen)
{
	printf("Call sendto\n Socket:%x\n Flags:%d\n Addr:%s\n Port:%d\n Data:%s\n", s, flags, inet_ntoa(((sockaddr_in*)to)->sin_addr), ((sockaddr_in*)to)->sin_port, buf);
	fflush(stdout);
	//sockaddr_in *a = (sockaddr_in*) to;
	//a->sin_addr.S_un.S_addr = inet_addr("123.195.128.247");
	int r = sendto (s, buf, len, flags, (sockaddr*)to, tolen);
	printf(" sendto返回:%d\n", r);
	fflush(stdout);
	return r;
}

//設定Socket選項
int PASCAL FAR Mysetsockopt (__in SOCKET s, __in int level, __in int optname, __in_bcount_opt(optlen) const char FAR * optval, __in int optlen)
{	
	printf("Call setsockopt\n Socket:%x\n Level:%x\n", s, level);
	fflush(stdout);
	switch (optname)
	{
	case SO_BROADCAST:
		printf (" Option Name:廣播\n");
		fflush(stdout);
		break;
	case SO_REUSEADDR:
		printf (" Option Name:重用\n");
		fflush(stdout);
		break;
	default:
		printf(" Option Name:%d\n", optname);
		fflush(stdout);
	}
	printf(" Option Value:%d\n", *optval);
	fflush(stdout);
	int r = setsockopt (s,  level,  optname,  optval,  optlen);
	printf(" setsockopt返回:%d\n", r);
	fflush(stdout);
	return r;
}

//建立Socket
SOCKET PASCAL FAR Mysocket (__in int af, __in int type, __in int protocol)
{
	//AF 1 IPv4
	//Type 1 TCP
	//Type 2 UDP
	//Protocol 6 TCP
	//Protocol 17 UDP
	printf("Call socket\n");
	fflush(stdout);
	switch (af)
	{
	case AF_INET:
		printf (" Address Family:IPv4\n");
		fflush(stdout);
		break;
	default:
		printf(" Address Family:%d\n", af);
		fflush(stdout);
	}
	switch (type)
	{
	case SOCK_STREAM:
		printf (" Type:TCP\n");
		fflush(stdout);
		break;
	case SOCK_DGRAM:
		printf (" Type:UDP\n");
		fflush(stdout);
		break;
	default:
		printf("Type:%d\n", type);
		fflush(stdout);
	}
	switch (protocol)
	{
	case IPPROTO_TCP:
		printf (" Protocol:TCP\n");
		fflush(stdout);
		break;
	case IPPROTO_UDP:
		printf (" Protocol:UDP\n");
		fflush(stdout);
		break;
	default:
		printf(" Protocol:%d\n", type);
		fflush(stdout);
	}	
	SOCKET r = socket (af,  type,  protocol);
	printf(" Socket:%x\n", r);
	fflush(stdout);
	return r;
}

//struct hostent FAR * PASCAL FAR Mygethostbyname (__in_z const char FAR * name)
//{
//	printf ("Call gethostbyname\n");
//	printf ("名稱:%s\n", name);
//
//	hostent *r = gethostbyname (name);
//	if (r == 0)
//	{
//		printf ("錯誤\n");
//	}
//	else
//	{
//	printf ("域名:%s\n", r->h_name);
//	printf ("備用域名:%s\n", *r->h_aliases);
//	printf ("類型:%d\n", r->h_addrtype);
//	printf ("長度:%d\n", r->h_length);
//	printf ("地址:%s\n", *r->h_addr_list);
//	}
//	return r;
//}
//
//int PASCAL FAR Mygethostname (__out_bcount_part(namelen, return) char FAR * name, __in int namelen)
//{
//	printf("Call gethostname\n");
//	return gethostname (name, namelen);
//}

//int PASCAL FAR MyWSAStartup (__in WORD wVersionRequired, __out LPWSADATA lpWSAData)
//{
//	printf ("Call WSAStartup\n");
//	printf ("要求版本:%x.%x\n", LOBYTE (wVersionRequired), HIBYTE (wVersionRequired));
//	int r = WSAStartup (wVersionRequired, lpWSAData);
//	printf ("目前版本:%x.%x\n", LOBYTE (lpWSAData->wVersion), HIBYTE (lpWSAData->wVersion));
//	printf ("最高版本:%x.%x\n", LOBYTE (lpWSAData->wHighVersion), HIBYTE (lpWSAData->wHighVersion));
//	printf ("描述:%s\n", lpWSAData->szDescription);
//	printf ("狀態:%s\n", lpWSAData->szSystemStatus);
//	printf ("MaxSockets:%d\n", lpWSAData->iMaxSockets);
//	printf ("MaxUdpDg:%d\n", lpWSAData->iMaxUdpDg);
//	printf ("VendorInfo:%s\n", lpWSAData->lpVendorInfo);
//	printf ("WSAStartup返回:%d\n", r);
//	return r;
//}

//int PASCAL FAR MyWSACleanup ()
//{
//	printf ("Call WSACleanup\n");
//	int r = WSACleanup ();
//	printf ("WSACleanup返回:%d\n", r);
//	return r;
//}

//int PASCAL FAR MyWSAGetLastError ()
//{
//	printf ("Call WSAGetLastError\n");
//	int r = WSAGetLastError ();
//	printf ("錯誤碼:%d\n", r);
//	return r;
//}

一些標頭



// stdafx.h : 可在此標頭檔中包含標準的系統 Include 檔，
// 或是經常使用卻很少變更的
// 專案專用 Include 檔案
//

#pragma once

#include "targetver.h"

#define WIN32_LEAN_AND_MEAN             // 從 Windows 標頭排除不常使用的成員
// Windows 標頭檔:
#include <windows.h>

#include <tchar.h>
#include <stdio.h>
#include <stdlib.h>

#pragma comment(lib,"Dbghelp.lib")
#include <Dbghelp.h>

#pragma comment(lib,"wsock32.lib")
#include <WinSock.h>

// TODO: 在此參考您的程式所需要的其他標頭

登入

關於一個開發中的程式

Recommended Posts

Lynr 10

鏈接文章

分享到其他網站

請登入後來留意見

瀏覽

動態