【计算机网络】套接字编程实验—TCP多进程并发服务器程序与单进程客户端程序

最新推荐文章于 2024-05-11 15:40:57 发布
最新推荐文章于 2024-05-11 15:40:57 发布
阅读量183 收藏
点赞数 1
分类专栏： 计算机网络 文章标签： 计算机网络 tcp/ip 网络协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/spicy_chicken123/article/details/131706197
版权

该文章仅供学习交流，严禁用于任何商业或非法用途，如有侵权，请联系本人删除！

目录

实验名称

TCP多进程并发服务器与单进程客户端（简单回声）

实验内容

编写TCP多进程循环服务器程序与单进程客户端程序，实现以下主体功能：

  1. 客户端启动连接服务器之后，进入命令行交互模式。
  2. 操作人员在命令行窗口输入一行字符并回车后，客户端进程立刻从命令行（本质即 stdin）读取数据，并将该行信息发送给服务器。
  3. 服务器收到该行信息后，会将该信息原封不动的返回给客户端，即所谓消息回声（Message Echo）。
  4. 客户端收到服务器返回的消息回声后，将其打印输出至屏幕（本质即 stdout）。
  5. 客户端在从命令行收到 EXIT 指令后退出。
  6. 若服务器启动时设定 Established Queue的长度，即listen（）第二个参数backlog为2，则最多可 以有2个客户编同时连上服务器并开展交互。此时，再启动另一个客户端连接服务器，观察体验是什么现象，并尝试分析现象背后的底层逻辑。

实验要求：PDU设计与收发

本实验设定PDU具有2字节的定长头部(Header)以及变长负载(Payload)。请求报文的2字节头部携带客户端随机编号CID，该编号由客户端程序启动时从命令行获取。响应报文的2字节头部携带服务器端验证码VCD，该编号由服务器程序启动时从命令行获取。
请求报文Request PDU与响应报文Response PDU的负载数据部分均为长度不等且以\n\0结尾的字符组合。

TCP客户端、服务器可通过read( ) & write()或者send() & recv())进行收发操作。本实验要求所有套接字读写操作必须使用read() & write()，以满足在线测评指标设定。
发送PDU时，必须准备好整个PDU后执行一次性发送，仅调用一次write()。
接收PDU时，必须首先读取2字节长度的头部数据，随后再读取变长包含字符串语句的负载数据。

流程图

代码的流程图如下：
在这里插入图片描述

实验代码

  1. 服务器程序代码：

    #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <signal.h>
#include <sys/wait.h>

#define MAX_LEN 120

int sigint_flag = 0;

typedef struct Request {
	uint16_t cid;
	char msg[MAX_LEN];
} Request;

typedef struct Response {
	uint16_t vcd;
	char msg[MAX_LEN];
} Response;


void handle_sigint(int sig) {
	printf("[srv] SIGINT is coming!\n");
	sigint_flag = 1;
}

int install_sigint() {
	struct sigaction sa;
	sa.sa_flags = 0;
	sa.sa_handler = handle_sigint;
	sigemptyset(&sa.sa_mask);
	sigaction(SIGINT, &sa,NULL);
	return 0;
}


void sig_chld(int signo) {
	pid_t pid_chld;
	int stat;
	while((pid_chld = waitpid(-1, &stat, WNOHANG)) > 0);
}


int srv_biz(int connfd, int vcd) {
    Request request;
    Response response;
    // 读取客户端请求
    while(1) {		
    	if(read(connfd, &request.cid, sizeof(short)) == 0) {
    		return -1;
    	}
    	// 打印客户端请求内容
    	uint16_t cid = ntohs(request.cid);
        if (read(connfd, request.msg, MAX_LEN) == 0) {
        	perror("Read error");
        	return -1;
    	} 	
    	
    	printf("[chd](%d)[cid](%d)[ECH_RQT] %s", getpid(), cid, request.msg);
    	
		uint16_t code_network = htons(vcd); // 转换为网络字节序
		response.vcd = code_network;
		strcpy(response.msg, request.msg);
	
		int send_len = sizeof(Response);
    	// 发送回声到客户端
    	if (write(connfd, &response, send_len) < 0) {
        	perror("Write error");
        	return -1;
    	}
    	 
    	memset(&request, 0, sizeof(Request));
		memset(&response, 0, sizeof(Response));  		  
    }
    
    return 0;
}

int main(int argc, char *argv[]) {
    if (argc < 4) {
        printf("Usage: %s <ip_address> <port> <veri_code>\n", argv[0]);
        return 1;
    }
    char *ip_address = argv[1];
    int port = atoi(argv[2]);
    int vcd = atoi(argv[3]);
    
    struct sigaction sigchld;
    sigchld.sa_flags = 0;
    sigchld.sa_handler = sig_chld;
    sigemptyset(&sigchld.sa_mask);
    sigaction(SIGCHLD, &sigchld, NULL);
    
    install_sigint();
    
    int listenfd, connfd;
    struct sockaddr_in servaddr, cliaddr;
    int clilen; 

    // 创建监听套接字
    listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (listenfd < 0) {
        perror("Socket error");
        return 1;
    }	

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = inet_addr(ip_address);
    servaddr.sin_port = htons(port);

    // 绑定监听套接字
    if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
        perror("Bind error");
        return 1;
    }

    if (listen(listenfd, 2) < 0) {
        perror("Listen error");
        return 1;
    }
    clilen = sizeof(struct sockaddr_in);

    printf("[srv](%d)[srv_sa](%s:%d)[vcd](%d) Server has initialized!\n", getpid(), ip_address, port, vcd);

    while (!sigint_flag) {
        if ((connfd = accept(listenfd, (struct sockaddr*) &cliaddr, &clilen)) < 0) {
        	if(errno == EINTR) 
                continue;
            else {
                perror("accept error");
                exit(1);
            }
        }
        
        printf("[srv](%d)[cli_sa](%s:%d) Client is accepted!\n", getpid(), inet_ntoa(cliaddr.sin_addr), cliaddr.sin_port);
        
        // 创建子进程接受客户端请求
        pid_t childpid = fork();
        if (childpid < 0) {
            perror("Fork error");
            continue;
        } else if (childpid == 0) {	        
            printf("[chd](%d)[ppid](%d) Child process is created!\n", getpid(), getppid());
            close(listenfd);  // 关闭子进程监听套接字
            
            srv_biz(connfd, vcd);  // 处理客户端请求
            
            printf("[chd](%d)[ppid](%d)[cli_sa](%s:%d) Client is closed!\n", getpid(), getppid(), inet_ntoa(cliaddr.sin_addr), cliaddr.sin_port);
            
            close(connfd);          
            printf("[chd](%d)[ppid](%d) connfd is closed!\n", getpid(), getppid());
            printf("[chd](%d)[ppid](%d) Child process is to return!\n", getpid(), getppid());
    	    
            return 0;         
        }

        close(connfd);  // 关闭父进程连接
    }

    close(listenfd);	
    printf("[srv](%d) Server is shutting down...\n", getpid());	
    return 0;
}

  2. 客户端程序代码：

    #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#define MAX_LEN 120

typedef struct Request {
	uint16_t cid;
	char msg[MAX_LEN];
} Request;

typedef struct Response {
	uint16_t vcd;
	char msg[MAX_LEN];
} Response;


int main(int argc, char *argv[]) {
    if (argc < 4) {
        printf("Usage: %s <ip_address> <port> <cid>\n", argv[0]);
        return 1;
    }

    char *ip_address = argv[1];
    int port = atoi(argv[2]);
    int cid = atoi(argv[3]);

    int sockfd;
    struct sockaddr_in servaddr;

    int nbytes;

    // 创建套接字
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        perror("Socket error");
        return 1;
    }

	memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = inet_addr(ip_address);
    servaddr.sin_port = htons(port);

    // 连接服务器
    if (connect(sockfd, (struct sockaddr *)&servaddr, sizeof(struct sockaddr)) < 0) {
        perror("Connect error");
        return 1;
    }

    printf("[cli](%d)[srv_sa](%s:%d) Server is connected!\n", getpid(), ip_address, port);
    
    char send_msg[MAX_LEN];
    Request request;
    Response response;

    while (1) {
    	memset(send_msg, 0, sizeof(send_msg));
    	memset(&request, 0, sizeof(Request)); 
    	memset(&response, 0, sizeof(Response));
       
        fgets(send_msg, sizeof(send_msg), stdin);
        
        if (strcmp(send_msg, "EXIT\n") == 0) {
            printf("[cli](%d) connfd is closed!\n", getpid());
            break;
        }
        printf("[cli](%d)[cid](%d)[ECH_RQT] %s", getpid(), cid, send_msg);
        
		uint16_t cid_network = htons(cid); // 转换为网络字节序
   	 	request.cid = cid_network;	
		send_msg[strlen(send_msg)] = '\0';
		strcpy(request.msg, send_msg);
        
        // 发送消息至服务器
        if (write(sockfd, &request, strlen(send_msg) + sizeof(short)) < 0) {
            perror("Write error");
            break;
        }
	
		uint16_t vcd_network; // 网络字节序的VCD
		read(sockfd, &vcd_network, sizeof(vcd_network));
		uint16_t vcd = ntohs(vcd_network); // 转换为主机字节序
			        
        nbytes = read(sockfd, response.msg, MAX_LEN);
        if (nbytes <= 0) {
            perror("Read error");
            break;
        }
        printf("[cli](%d)[vcd](%d)[ECH_REP] %s", getpid(), vcd, response.msg);  
         		
    }

   	close(sockfd);		
    printf("[cli](%d) client is to return!\n", getpid());
    return 0;
}
明月出天山_
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python实现多线程/多进程的TCP服务器
12-25
多线程的TCP服务器，供大家参考，具体内容如下 背景：同学公司的传感器设备需要将收集的数据发到服务器上，前期想写一个简单的服务器来测试下使用效果，设备收集的数据非常的重要，所以考虑使用TCP协议来实现。 因为...
服务器客户端-socket（进程线程）
10-13
服务器客户端-socket（进程线程），包括套接字，多线程，多进程，单进程，并发，互斥锁，tcp/ip,udp等
（计算机网络课程实验）Socket TCP编程实现客户端与服务器通信
热门推荐
ccnuacmhdu的博客
10-05 1万+
一、实验目的 认识Socket TCP编程 二、实验内容 （1）命令行界面要可以带多个参数（出程序名之外至少有2个参数，一个是选项，另一个是选项作用的对象。参看ping，netstat等命令） （2）如何实现多个用户连接同一个服务器 （3）如何实现异步的TCP连接（待实现） 三、实验过程及实验结果 （1）客户端命令行操作：ping_client ping www.baidu.com 三个参数分别...
服务端和客户端通信-TCP(含完整源代码)
qq_51782199的博客
03-14 3244
一、是TCP流式套接字(SOCK_STREAM)提供了一个面向连接、可靠的数据传输服务，数据无差错、无重复地发送，且按发送顺序接收。Af--------指定通信发生的区域：AF_UNIX、AF_INET、AF_NS等，而DOS、WINDOWS中仅支持AF_INET，它是网际网区域。如果没有错误发生，accept()返回一个SOCKET类型的值，表示接收到的套接字的描述符。listen()在执行调用过程中可为没有调用过bind()的套接字s完成所必须的连接，并建立长度为backlog的请求连接队列。
TCP套接字编程
写博客记录分享学习笔记
04-13 853
Linux操作系统下TCP套接字编程
计算机网络（三）——TCP套接字编程
qq_52145272的博客
07-18 1478
tcp套接字实现
计算机网络-基础编程实验(JAVA\Python3)
04-28 1590
计算机网络实验二
简单的TCP网络程序·单进程(后端服务器)
weixin_67595436的博客
06-11 1276
简单的TCP网络程序·单进程
【计算机网络】套接字编程实验—TCP单进程循环服务器程序与单进程客户端程序
spicy_chicken123的博客
07-13 271
TCP单进程循环服务器与单进程客户端（简单回声）
基于并发服务器几种实现方法(总结)
12-24
今天主题是实现并发服务器，实现方法有多种版本，先从简单的单进程代码实现到多进程，多线程的实现，最终引入一些高级模块来实现并发TCP服务器。 说到TCP，想起吐槽大会有个段子提到三次握手，也只有程序猿(媛)能get...
《计算机 网络》实验一套接字网络编程
12-31
在本实验中，将学习Python中TCP连接的套接字编程的基础知识：如何创建套接字，将其绑定到特定的地址和端口，以及发送和接收HTTP数据包。你还将学习一些HTTP首部格式的基础知识。 你将开发一个处理一个HTTP请求的Web服务器。你的Web服务器应该接受并解析HTTP请求，然后从服务器的文件系统获取所请求的文件，创建一个由响应文件组成的HTTP响应消息，前面是首部行，然后将响应直接发送给客户端。如果请求的文件不存在于服务器中，则服务器应该向客户端发送“404 Not Found”差错报文。
TCP和UDP套接字_简单的客户/服务器
06-10
设计简单的客户/服务器，服务器实现并发同时响应客户的UDP通信要求，也能响应客户端发过来的TCP通信要求。
tcp并发服务器
10-22
tcp并发服务器
二十、socket套接字编程（二）——TCP
weixin_54447296的博客
06-29 783
如果手动传./serverTcpd 8080 0，IP地址传的是0，此时inet_aton(0, &local.sin_addr) 即inet_aton第一个参数传的就是0，把值为0的本地字符串风格IP转网络4字节IP存入local.sin_addr中；总结：inet_aton(ip_.c_str(), &local.sin_addr) ip_为0时，inet_aton(0, &local.sin_addr) 等于 local.sin_addr.s_addr = INADDR_ANY。
【网络编程】网络编程套接字（三）TCP网络程序
weixin_61654591的博客
07-18 1359
TCP网络程序|服务器|客户端
网络编程：单客户端单进程统一accpet TCP并发服务器（简单时间服务器）
weixin_45730130的博客
04-29 1146
网络编程：单客户端单进程统一accpet TCP并发服务器（简单时间服务器） 写在前面的话 由主进程统一的处理客户端连接，当客户端连接到来时才fork()子进程来处理客户端请求。参考教材：Linux网络编程。 题目（功能） 服务端：接收客户端时间请求，返回本地时间 客户端：发送时间请求，接收客户端返回的时间并打印 服务端代码 #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #
TCP IP网络编程(四) 基于TCP的服务器端、客户端
m0_63743577的博客
09-06 1558
TCP/IP网络编程，TCP、UDP传输协议
【网络】网络编程——带你手搓简易TCP服务端（echo服务器）+客户端（四种版本）
You don't have the guts to be what you wanna be.
10-11 900
本篇主要讲解套接字编程，以TCP服务端和客户端为主，提供以下版本： 1. 单线程循环版 2. 多进程版（两个小版本） 3. 多线程版 4. 线程池版
无线通信模块通过TCP/IP协议实现与PC端的数据传输
最新发布
成都亿佰特的博客
05-11 576
在传输层，接收方会先将TCP首部和TCP数据分离，然后根据TCP协议的规定进行数据的校验、排序和重传等操作，以确保数据的完整性和可靠性。在当今的信息时代，无线通信技术的发展日新月异，为我们的工作和生活带来了极大的便利。在QT平台下，我们可以利用QT的网络编程接口和WIFI模块的驱动程序，实现基于TCP/IP协议的WIFI数据无线传输。无线通信模块通过TCP/IP协议向PC端传送数据是一种稳定、可靠的数据传输方式。在实际应用中，我们可以根据具体的需求和场景选择合适的无线通信模块和TCP/IP协议的实现方式。
用python做套接字编程实验
03-27
以下是一个简单的套接字编程实验，使用Python语言。 1. 创建一个简单的服务器 ```python import socket # 创建一个TCP套接字 server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 绑定IP地址和端口号 server_socket.bind(('localhost', 8000)) # 监听客户端连接 server_socket.listen(5) # 等待客户端连接 client_socket, client_address = server_socket.accept() # 接收客户端发送的消息 message = client_socket.recv(1024) # 发送消息给客户端 client_socket.sendall(b'Hello, Client!') # 关闭套接字 client_socket.close() server_socket.close() ``` 2. 创建一个简单的客户端 ```python import socket # 创建一个TCP套接字 client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 连接服务器 client_socket.connect(('localhost', 8000)) # 发送消息给服务器 client_socket.sendall(b'Hello, Server!') # 接收服务器发送的消息 message = client_socket.recv(1024) # 打印服务器发送的消息 print(message) # 关闭套接字 client_socket.close() ``` 注意：在运行服务器之前，需要先运行客户端，否则服务器会一直等待客户端连接。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

明月出天山_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值