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

淩亂°似流年 2022-05-22 05:11 224阅读 0赞

服务器端：

#include <netdb.h>  
    #include <sys/socket.h>  
    #include <time.h>  
    #include <unistd.h>  
    #include <memory.h>  
    #include <signal.h>  
    #include <string.h>  
    #include <stdlib.h>  
    #include <stdio.h>  
    #include <arpa/inet.h>  
    #include <errno.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    #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 <unistd.h>  
    #include <netdb.h>  
    #include <sys/socket.h>  
    #include <stdlib.h>  
    #include <stdio.h>  
    #include <memory.h>  
    #include <string.h>  
    #include <arpa/inet.h>  
    #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 <unistd.h>
    #include <sys/types.h>
    #include <string.h>
    #include <memory.h>
    #include <stdio.h>
    
    /*计算校验码*/
    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;
    		
    }

测试：

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

![70][]

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

[70]: /images/20220522/87ccd950f45e4a5ea71613a6a29735c2.png