Windows網路程式設計附書程式碼(簡單的伺服器與客戶端)

劉俊發表於2012-01-29
Windows程式設計伺服器客戶端
 
//程式清單6-1 迴應伺服器程式碼
// 編譯命令Compile：cl -o Server Server.c ws2_32.lib
//
// 命令列選項：
// server [-p:x] [-i:IP] [-o]
// -p:x 監聽的埠號
// -i:str 監聽的網路卡
// -o 只接收，不回顯資料
//



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

#pragma  comment(lib, "Ws2_32.lib ")

#define DEFAULT_PORT 5150
#define DEFAULT_BUFFER 4096

int iPort = DEFAULT_PORT; // 監聽客戶端的埠
BOOL bInterface = FALSE, // 在指定網路卡上監聽
bRecvOnly = FALSE; // 只接收，不回顯
char szAddress[128];



void usage() ;
void ValidateArgs(int argc, char **argv) ;
DWORD WINAPI ClientThread(LPVOID lpParam) ;


// 函式：main
// 說明：執行主執行緒、初始化Winsock、解釋命令列引數、建立監聽套接字、捆綁到本地地址、
//等待
// 客戶端連線
int main(int argc, char **argv)
{
	WSADATA wsd;

	SOCKET sListen,sClient;

	int iAddrSize;


	HANDLE hThread;

	DWORD dwThreadId;

	struct sockaddr_in local, client;

	int i = 0 ;

	printf("程式開始:\n");

//	ValidateArgs(argc, argv);

	if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
	{
		printf("Failed to load Winsock!\n");
		return 1;
	}
	// 建立監聽套接字
	sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);

	if (sListen == SOCKET_ERROR)
	{
		printf("socket() failed: %d\n", WSAGetLastError());
		return 1;
	}
	// 選擇本地網路介面卡，並且捆綁到它上面
	if (bInterface)
	{
		local.sin_addr.s_addr = inet_addr(szAddress);
		if (local.sin_addr.s_addr == INADDR_NONE)
			usage();
	}
	else
		local.sin_addr.s_addr = htonl(INADDR_ANY);


	local.sin_family = AF_INET;
	local.sin_port = htons(iPort);
	if (bind(sListen, (struct sockaddr *)&local,sizeof(local)) == SOCKET_ERROR)
	{
		printf("bind() failed: %d\n", WSAGetLastError());
		return 1;
	}
	listen(sListen, 8);

	// 迴圈等待進入的客戶端連線，一旦檢查到連線，建立執行緒並且傳遞控制程式碼
	printf("主程式迴圈前:\n");
	while (1)
	{
		printf("主程式第%d迴圈\n",i);

		iAddrSize = sizeof(client);

		sClient = accept(sListen, (struct sockaddr *)&client,&iAddrSize);   //會掛起，直到有連線

		if (sClient == INVALID_SOCKET)
		{
			printf("accept() failed: %d\n", WSAGetLastError());
			break;
		}
		printf("Accepted client: %s:%d\n",inet_ntoa(client.sin_addr), ntohs(client.sin_port));

		hThread = CreateThread(NULL, 0, ClientThread,(LPVOID)sClient, 0, &dwThreadId);  //建立處理純種

		if (hThread == NULL)
		{
			printf("CreateThread() failed: %d\n", GetLastError());
			break;
		}
		CloseHandle(hThread);

		i++ ;
	}
	closesocket(sListen);


	WSACleanup();

	printf("程式結束:\n");

	return 0;
}


// 函式：ClientThread
// 說明：函式以執行緒方式呼叫，並且處理給定客戶端連線，傳遞引數為從accept()呼叫中返回
//的套接
// 字控制程式碼，該函式從客戶端讀取資料，並且將讀到的資料寫回去
DWORD WINAPI ClientThread(LPVOID lpParam)
{
	SOCKET sock=(SOCKET)lpParam;
	char szBuff[DEFAULT_BUFFER];
	int ret,
		nLeft,
		idx;

	printf("Client開始:\n");

	while(1)
	{
		// 阻塞recv()呼叫

		printf("recv開始:\n");

		ret = recv(sock, szBuff, DEFAULT_BUFFER, 0);
		if (ret == 0) // 常規關閉
			break;
		else if (ret == SOCKET_ERROR)
		{
			printf("recv() failed: %d\n", WSAGetLastError());
			break;
		}
		szBuff[ret] = '\0';
		printf("RECV: '%s'\n", szBuff);
		//
		// 選擇回顯資料
		if (!bRecvOnly)
		{
			nLeft = ret;
			idx = 0;
			// 確保寫所有資料
			while(nLeft > 0)
			{
				ret = send(sock, &szBuff[idx], nLeft, 0);
				if (ret == 0)
					break;
				else if (ret == SOCKET_ERROR)
					
				{
					printf("send() failed: %d\n",
						WSAGetLastError());
					break;
				}
				nLeft -= ret;
				idx += ret;
			}
		}

	}

	printf("Client結束:\n");

	return 0;
}



// 監聽客戶端的網路卡
// 函式：usage
// 說明：列印使用資訊，並且退出


void usage()
{
	printf("usage: server [-p:x] [-i:IP] [-o]\n\n");
	printf(" -p:x 監聽的埠號\n");
	printf(" -i:str 監聽的網路卡\n");
	printf(" -o 只接收，不回顯資料\n\n");
	ExitProcess(1);
}
// 函式：ValidateArgs
// 說明：解釋命令列引數，設定指示操作如何進行的全域性變數
void ValidateArgs(int argc, char **argv)
{
	int i;


	printf("解釋命令列引數程式開始:\n");
	for(i = 1; i < argc; i++)
	{
		if ((argv[i][0] == '-') || (argv[i][0] == '/'))
		{
			switch (tolower(argv[i][1]))
			{
			case 'p':
				iPort = atoi(&argv[i][3]);
				break;
			case 'i':
				
					bInterface = TRUE;
				if (strlen(argv[i]) > 3)
					strcpy(szAddress, &argv[i][3]);
				break;
			case 'o':
				bRecvOnly = TRUE;
				break;
			default:
				usage();
				break;
			}
		}
	}
	printf("解釋命令列引數程式結束:\n");
}


 

 

/*

程式清單6-2 是客戶端程式碼，客戶端建立一個套接字，並對投入應用的伺服器名進行解析，然後
與伺服器建立連線。連線一旦建成，就可傳送大量的訊息了。每次傳送資料之後，客戶端都會等待服
務器發回的迴應。客戶端把得自套接字的資料列印出來。
迴應客戶端和伺服器不能完全說明TCP 協議的流式傳輸。這是因為讀取操作是在寫操作之後進行
的，至少客戶端這一端是這樣的。當然，對伺服器來說，還有另一種方式。因此，伺服器每次呼叫讀
取函式，一般都會返回客戶端發出的整條訊息。但不要誤會，如果客戶端的訊息大到超過了TCP 的最
大傳輸單元，線上上，它會被分成幾個小的資料包，這種情況下，接收端需要多次執行接收呼叫，才
能收完整條訊息。為了更好地說明流式傳輸，執行客戶端和伺服器時帶上-O 選項即可。這樣，客戶端
便只管傳送資料，接收端只管讀取資料。

		  
			
伺服器如下執行：
server -p:5150 -o
而客戶端如下執行：
client -p:5150 -s:IP -n:10 -o
大家最可能見到的是客戶端進行了10 次send 呼叫，而伺服器在一次或兩次recv 呼叫中，就讀
取了10 條訊息。


*/



//程式清單6-2 迴應客戶端程式碼


// 說明：回顯客戶端，連線TCP 伺服器，傳送資料，並且讀伺服器返回的資料
// 編譯命令：cl -o Client Client.c ws2_32.lib
//
// 命令列引數：
// client [-p:x] [-s:IP] [-n:x] [-o]
// -p:x 傳送的遠端埠
// -s:IP 伺服器IP 地址或主機名
// -n:x 傳送訊息次數
// -o 只傳送訊息，不接收
//

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

#pragma  comment(lib, "Ws2_32.lib ")

#define DEFAULT_COUNT 1000
#define DEFAULT_PORT 5150
#define DEFAULT_BUFFER 2048
#define DEFAULT_MESSAGE "This is a test of the emergency \
broadcasting system"


char szServer[128], // 連線的伺服器

szMessage[1024]; // 傳送給伺服器的訊息

int iPort = DEFAULT_PORT; // 連線到伺服器的埠

DWORD dwCount = DEFAULT_COUNT; // 傳送訊息次數

BOOL bSendOnly = FALSE; // 只傳送資料，不接收


 void usage() ;
 void ValidateArgs(int argc, char **argv) ;

// 函式：main
// 說明：執行主執行緒，初始化Winsock，解釋命令列引數，建立套接字，連線伺服器，然後傳送
//和接
// 收資料
int main(int argc, char **argv)
{
	WSADATA wsd;
	SOCKET sClient;
	char szBuffer[DEFAULT_BUFFER];
	int ret,i;

	struct sockaddr_in server;

	struct hostent *host = NULL;

	// 解釋命令列並且載入Winsock
	ValidateArgs(argc, argv);

	if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
	{
		printf("Failed to load Winsock library!\n");
		return 1;
	}
	strcpy(szMessage, DEFAULT_MESSAGE);
	// 建立套接字，並且嘗試連線伺服器
	sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (sClient == INVALID_SOCKET)
	{
		printf("socket() failed: %d\n", WSAGetLastError());
		return 1;
	}
	server.sin_family = AF_INET;
	server.sin_port = htons(iPort);
	server.sin_addr.s_addr = inet_addr(szServer);
	
		// 如果提供的伺服器地址不是形如"aaa.bbb.ccc.ddd"，則為主機名，嘗試解析它
		if (server.sin_addr.s_addr == INADDR_NONE)
		{
			host = gethostbyname(szServer);
			if (host == NULL)
			{
				printf("Unable to resolve server: %s\n", szServer);
				return 1;
			}

			CopyMemory(&server.sin_addr, host->h_addr_list[0],
				host->h_length);
		}
		if (connect(sClient, (struct sockaddr *)&server,sizeof(server)) == SOCKET_ERROR)
		{
			printf("connect() failed: %d\n", WSAGetLastError());
			return 1;
		}

		// 傳送和接收資料
		for(i = 0; i < dwCount; i++)
		{
			ret = send(sClient, szMessage, strlen(szMessage), 0);
			if (ret == 0)
				break;
			else if (ret == SOCKET_ERROR)
			{
				printf("send() failed: %d\n", WSAGetLastError());
				break;
			}
			printf("Send %d bytes\n", ret);
			if (!bSendOnly)
			{
				ret = recv(sClient, szBuffer, DEFAULT_BUFFER, 0);
				if (ret == 0) // Graceful close
					break;
				else if (ret == SOCKET_ERROR)
				{
					printf("recv() failed: %d\n", WSAGetLastError());
					break;
				}
				szBuffer[ret] = '\0';
				printf("RECV [%d bytes]: '%s'\n", ret, szBuffer);
			}
		}
		closesocket(sClient);
		WSACleanup();
		return 0;
}




 void usage()
{
	printf("usage: client [-p:x] [-s:IP] [-n:x] [-o]\n\n");
	printf(" -p:x Remote port to send to\n");
	printf(" -s:IP Server's IP address or hostname\n");
	printf(" -n:x Number of times to send message\n");
	printf(" -o Send messages only; don't receive\n");
	ExitProcess(1);
}


// 函式：ValidateArgs
// 說明：解釋命令列引數，設定全域性變數
void ValidateArgs(int argc, char **argv)
{
	int i;
	for(i = 1; i < argc; i++)
	{
		if ((argv[i][0] == '-') || (argv[i][0] == '/'))
		{
			switch (tolower(argv[i][1]))
			{
			case 'p': // Remote port
				if (strlen(argv[i]) > 3)
					iPort = atoi(&argv[i][3]);
				break;
				
			case 's': // Server
				if (strlen(argv[i]) > 3)
					strcpy(szServer, &argv[i][3]);
				break;
			case 'n': // Number of times to send message
				if (strlen(argv[i]) > 3)
					dwCount = atol(&argv[i][3]);
				break;
			case 'o': // Only send message; don't receive
				bSendOnly = TRUE;
				break;
			default:
				usage();
				break;
			}
		}
	}
}


 

相關文章