多进程自定义协议的通信
2022-12-02 本文已影响0人
arkliu
自定义协议
msg.h
#ifndef __MSG_H__
#define __MSG_H__
#include<sys/types.h>
typedef struct {
//协议头部
char head[10];
char checknum;//校验码
//协议体部
char buf[512]; // 数据
}Msg;
/**
* 发送一个基于自定义协议的message
* 发送的数据存放在buff中
*/
extern int write_msg(int sockfd, char *buf, size_t len);
/**
* 读取一个基于自定义协议的mssage
* 读取的数据存放在buff中
*/
extern int read_msg(int sockfd, char *buf, size_t len);
#endif
msg.c
#include "msg.h"
#include <unistd.h>
#include<string.h>
#include <memory.h>
#include<sys/types.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->buf); i++) {
s += message->buf[i];
}
return s;
}
/**
* 发送一个基于自定义协议的message
* 发送的数据存放在buff中
*/
int write_msg(int sockfd, char *buf, size_t len) {
Msg message;
memset(&message, 0, sizeof(message));
strcpy(message.head, "hello");
memcpy(message.buf, buf, len);
message.checknum = msg_check(&message);
if(write(sockfd, &message, sizeof(message)) != sizeof(message)) {
return -1;
}
}
/**
* 读取一个基于自定义协议的mssage
* 读取的数据存放在buff中
*/
int read_msg(int sockfd, char *buf, size_t len) {
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;
}
//进行校验码验证，判断接收到的message是否完整
unsigned char s = msg_check(&message);
if((s == (unsigned char)message.checknum && (!strcmp("hello", message.head)))) {
memcpy(buf, message.buf, len);
return sizeof(message);
}
return -1;
}
1669865807774.png
多进程模型服务器端
echo_server.c
#include <arpa/inet.h>
#include <netdb.h>
#include<sys/socket.h>
#include<unistd.h>
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<memory.h>
#include<signal.h>
#include<errno.h>
#include<time.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");
/*步骤6：关闭服务器端的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 buf[512];
while (1){
memset(buf, 0, sizeof(buf));
printf("start read and write...\n");
size_t size;
if((size = read_msg(fd, buf, sizeof(buf))) < 0) {
perror("protocal error");
break;
} else if(size == 0) { //客户端已经断开连接，读取到的size大小为0
break;
} else {
printf("%s\n", buf);
if(write_msg(fd, buf, sizeof(buf)) < 0) {
if(errno == EPIPE) { //客户端读端关闭
break;
}
perror("protocal error");
}
}
}
}
int main(int argc, char *argv[]) {
if (argc < 2){
printf("usage:%s #port\n",argv[0]);
exit(1);
}
if (signal(SIGINT, sig_handler) == SIG_ERR){
perror("signal sigint error");
exit(1);
}
if (signal(SIGCHLD, sig_handler) == SIG_ERR){
perror("signal sigchld error");
exit(1);
}
/*步骤1：创建socket套接字*/
sockfd = socket(AF_INET, SOCK_STREAM, 0);
/*步骤2：调用bind将socket和地址绑定(包括ip，port)*/
struct sockaddr_in serveraddr;
memset(&serveraddr, 0, sizeof(serveraddr));
serveraddr.sin_family = AF_INET; //IPV4
serveraddr.sin_port = htons(atoi(argv[1]));
serveraddr.sin_addr.s_addr = INADDR_ANY;
if(bind(sockfd, (struct sockaddr *)&serveraddr,sizeof(serveraddr)) < 0) {
perror("bind error");
exit(1);
}
/*步骤3：调用listen函数启动监听(指定port监听)*/
if(listen(sockfd,10) < 0) {
perror("listen error");
exit(1);
}
/*步骤4：调用accept函数从队列中获得一个客户端的请求连接
注意：若没有客户端连接，调用accept函数将阻塞，直到货到衣蛾客户端连接
*/
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;
}
/**
* 步骤5：启动子进程调用IO函数(read/write)和连接的客户端进行双向的通信
*/
pid_t pid = fork();
if(pid < 0) {
continue;
} else if(pid ==0) { //child process
out_addr(&clientaddr);
do_service(fd);
/*步骤6：关闭客户端的socket*/
close(fd);
break; // 跳出循环，子进程终止，产生SIG_CHLD信号
} else { // parent process
close(fd);
}
}
return 0;
}
编译服务器端：
gcc -o bin/echo_server -Iinclude obj/msg.o src/echo_server.c
多进程模型客户端
echo_client.c
#include <arpa/inet.h>
#include <netdb.h>
#include<sys/socket.h>
#include<unistd.h>
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<memory.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]));
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函数(read/write)和服务器端双向通信*/
char buff[512];
size_t size;
char *prompt = ">";
while(1) {
memset(buff, 0, sizeof(buff));
write(STDOUT_FILENO, prompt, 1);
size = read(STDIN_FILENO, buff, sizeof(buff));
if(size < 0) continue;
buff[size-1] = '\0';
if(write_msg(sockfd, buff, sizeof(buff)) < 0) {
perror("write msg error");
continue;
} else {
if(read_msg(sockfd, buff, sizeof(buff)) <0) {
perror("read msg error");
continue;
} else {
printf("%s\n", buff);
}
}
}
/*步骤4：关闭socket*/
close(sockfd);
return 0;
}
编译客户端
gcc -o bin/echo_client -Iinclude obj/msg.o src/echo_client.c
测试
- 启动服务器端
- 开启多个客户端，发送数据并从服务器端接收数据
- 关闭一个客户端，不影响其他客户端
