Windows网络编程附书代码(简单的服务器与客户端)

 

//程序清单6-1 回应服务器代码
// 编译命令Compile：cl -o Server Server.c ws2_32.lib
//
// 命令行选项：
// server [-p:x] [-i:IP] [-o]
// -p:x 监听的端口号
// -i:str 监听的网卡
// -o 只接收，不回显数据
//



#include 
#include 
#include 

#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 
#include 
#include 

#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;
			}
		}
	}
}