linux网络编程（6）基于多进程的TCP服务器与客户端编程

服务器端：

#include   
#include   
#include   
#include   
#include   
#include   
#include   
#include   
#include   
#include   
#include 
#include 
#include 
#include "msg.h"

int sockfd;

/*信号处理函数*/
void sig_handler(int signo)
{
	if (signo == SIGINT)
	{
		printf("server close!\n");
		/*关闭socket*/
		close(sockfd);
		exit(1);
	}

	if (signo == SIGCHLD)
	{
		printf("child process deaded...\n");
		
		/*回收子进程*/
		wait(0);
	}
}

/*输出客户端连接的地址信息*/
void out_addr(struct sockaddr_in *clientaddr)
{
	//将端口从网络字节序转换成主机字节序  
	int port = ntohs(clientaddr->sin_port);
	char ip[16];
	memset(ip, 0, sizeof(ip));

	//将IP地址从网络字节序转换为点分十进制  
	inet_ntop(AF_INET, &clientaddr->sin_addr.s_addr, ip, sizeof(ip));
	printf("client: %s(%d) connected\n", ip, port);
}

//服务器发送数据给客户端  
void do_service(int fd)
{
	/*与客户端进行读写操作*/
	char buff[512];
	while (1)
	{
		memset(buff, 0, sizeof(buff));
		printf("start read and write...\n");
		size_t size;
		if ((size = read_msg(fd, buff, sizeof(buff))) < 0)
		{
			perror("protocal error");
			break;
		}
		else if (0 == size)
		{
			break;
		}
		else
		{
			printf("%s\n", buff);
			if (write_msg(fd, buff, sizeof(buff)) < 0) 
			{
				//假如客户端关闭
				if (errno == EPIPE)
				{
					break;
				}
				printf("protocal error");
			}
		}
	}
}

int main(int argc, char* argv[])
{
	/*输入端口号*/
	if (argc < 2)
	{
		printf("usage: %s #port\n", argv[0]);
		exit(1);
	}

	/*注册SIFINT信号SIGINT,“ctrl + c”终止程序运行*/
	if (signal(SIGINT, sig_handler) == SIG_ERR)
	{
		perror("signal sigint error");
		exit(1);
	}

	/*注册子进程结束信号SIGCHLD*/
	if (signal(SIGCHLD, sig_handler) == SIG_ERR)
	{
		perror("signal sigchld error");
		exit(1);
	}

	/*1.创建socket
	* 注：socket创建在内核中，是一个结构体
	* AF_INET：IPV4
	* SOCK_STREAM:tcp协议
	* */
	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if (sockfd == -1)
	{
		perror("socket error");
		exit(1);
	}

	/*2.将socket和地址(ip、port)进行绑定*/
	struct sockaddr_in serveraddr;
	memset(&serveraddr, 0, sizeof(serveraddr));
	//地址中填入ip、port、internet地质族类型  
	serveraddr.sin_family = AF_INET;
	serveraddr.sin_port = htons(atoi(argv[1]));//转换为网络字节序  
	serveraddr.sin_addr.s_addr = htons(INADDR_ANY);//响应所有的网卡请求  

	if (bind(sockfd, (struct sockaddr*)(&serveraddr), sizeof(serveraddr)) < 0)//注意地址要强制转换为通用地址  
	{
		perror("bind error");
		exit(1);
	}


	/*3.调用listen函数启动监听(指定的端口监听)
	* 通知系统去接收来自客户端的连接请求
	* (将接收到的客户端的请求放置到对应的队列中)
	*第二个参数：指定队列的长度
	* */
	if (listen(sockfd, 10) < 0)
	{
		perror("listen error");
		exit(1);
	}

	/*4.调用accept函数从队列中获取一
	* 个客户端的请求连接,并返回一个新的socket描述符
	* 第二个参数：用来获取客户端的地址信息，如果不需要传入NULL
	* 注意:若没有客户端连接，调用此函数会阻塞。
	* */

	struct sockaddr_in clientaddr;
	socklen_t clientaddr_len = sizeof(clientaddr);

	while (1)
	{
		int fd = accept(sockfd, (struct sockaddr*)&clientaddr, &clientaddr_len);
		if (fd < 0)
		{
			perror("accept error");
			continue;
		}

		pid_t pid = fork();
		if (pid < 0)
		{
			continue;
		}
		else if(pid == 0)//子进程
		{
			/*调用IO函数和连接的客户端进行双向的通信*/
			out_addr(&clientaddr);
			do_service(fd);
			//关闭子进程继承来的fd
			close(fd);
			break;
		}
		else//父进程
		{
			//关闭父进程的fd,因为此fd对父进程无用
			close(fd);
		}
	}

	return 0;
}

客户端：

#include   
#include   
#include   
#include   
#include   
#include   
#include   
#include   
#include "msg.h"

int main(int argc, char *argv[])
{
	if (argc < 3)
	{
		printf("usage: %s ip port \n", argv[0]);
		exit(1);
	}

	/*1.创建socket*/
	int sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if (sockfd < 0)
	{
		perror("socket error");
		exit(1);
	}

	/*向serveraddr中填入服务器端ip、port和地址族类型(IPV4)*/
	struct sockaddr_in serveraddr;
	memset(&serveraddr, 0, sizeof(serveraddr));
	serveraddr.sin_family = AF_INET;
	serveraddr.sin_port = htons(atoi(argv[2]));
	//将IP地址转换成网络字节序后填入serveraddr中  
	inet_pton(AF_INET, argv[1], &serveraddr.sin_addr.s_addr);

	/*2.客户端调用connect函数连接到服务器端*/
	if (connect(sockfd, (struct sockaddr*)&serveraddr, sizeof(serveraddr)) < 0)
	{
		perror("connect error");
		exit(1);
	}

	/*3.调用IO函数与服务器端进行通信*/
	char buf[512];
	size_t size;
	char *prompt = ">";

	while (1)
	{
		memset(buf, 0, sizeof(buf));
		/*提示符*/
		write(STDOUT_FILENO, prompt, 1);
		/*从终端读取数据*/
		size = read(STDIN_FILENO, buf, sizeof(buf));
		if (size < 0)
		{
			/*假如读取有误，继续读取*/
			perror("read msg error");
			continue;
		}
		/*读完后加结束符*/
		buf[size - 1] = '\0';
		/*将终端中输入的数据发送至服务器*/
		if (size = write_msg(sockfd, buf, sizeof(buf)) < 0)
		{
			perror("write msg error");
			continue;
		}
		else
		{
			/*读取服务器端发送来的信息*/
			if (read_msg(sockfd, buf, sizeof(buf)) < 0)
			{
				perror("read msg error");
				continue;
			}
			else
			{
				/*将读取的服务器信息输出*/
				printf("%s\n", buf);
			}
		}
	}
	
	close(sockfd);

	return 0;
}

通信协议：

msg.h

#ifndef __MSG_H__
#define __MSG_H__

/*自定义协议*/
typedef struct 
{
	//协议头部
	char head[10];
	//校验码
	char checknum;
	//协议体部,数据
	char buff[512];

}Msg;

/*发送一个基于自定义协议的message,发送的数据放在buf中*/
extern int write_msg(int sockfd, char *buf, int len);

/*读取一个基于自定义协议的message，读取的数据放在buf中*/
extern int read_msg(int sockfd, char *buf, int len);

#endif 

msg.c

#include "msg.h"
#include 
#include 
#include 
#include 
#include 

/*计算校验码*/
static unsigned char msg_check(Msg *message)
{
	unsigned char s = 0;
	int i;
	for (i = 0; i < sizeof(message->head); i++)
	{
		s += message->head[i];
	}

	for (i = 0; i < sizeof(message->buff); i++)
	{
		s += message->buff[i];
	}
	
	return s;
}


int write_msg(int sockfd, char *buf, int len)
{
	Msg message;
	memset(&message, 0, sizeof(message));
	strcpy(message.head, "socklinux");
	memcpy(message.buff, buf, len);
	message.checknum = msg_check(&message);

	if ( write(sockfd, &message, sizeof(message)) != sizeof(message))
	{
		return -1;
	}

	return 0;
}

int read_msg(int sockfd, char *buf, int len)
{
	int ret = 0;
	Msg message;
	memset(&message, 0, sizeof(message));
	size_t size;
	
	if ((size = read(sockfd, &message, sizeof(message))) < 0)
	{
		return -1;
	}
	else if (size == 0)
	{
		return 0;
	}
	
	/*校验码验证*/
	unsigned char s = msg_check(&message);
	if ((s == (unsigned char)message.checknum) && (!strcmp("socklinux", message.head)))
	{
		memcpy(buf, message.buff, len);
		return sizeof(message);
	}
		
	return -1;
		
}

测试：

开启了两个终端，上面的终端运行服务器程序，下面的终端运行客户端程序。

可以看到，分别启动了服务器与客户端程序，在客户端输入字符信息后，服务器接收到了客户端的信息，并打印到终端上；当客户端断开与服务器的连接后，服务器结束子进程，并进行回收。