多并发服务器小程序实践-优快云博客

本文链接：https://blog.youkuaiyun.com/head555/article/details/72855879

实例：多并发服务器小程序练习：编写一个服务器，可多个客服端进行对齐同时访问。采用多进程的方法实现。
功能：服务器端打印接收的字符串长度，和字符串，客服端ip，以及使用的端口，将服务器接收到的数据会送给客服端，当接收到q时，服务器就与客服端断开连接，关闭sockfd套接字，当接收到h时，向主机发送hello linux。

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

#define MAX_BUFFER_SIZE 100
struct sockaddr_in server_ip,client_ip;


int socket_process()
{
    int socket_id;
    //创建套接字
    if((socket_id = socket(AF_INET,SOCK_STREAM,0))==-1)
    {
        printf("socket failed\n");
        return -1;
    }
    //赋值
    server_ip.sin_family = AF_INET;
    server_ip.sin_port = htons(8888);
    inet_aton("192.168.1.113",&server_ip.sin_addr);
    memset(server_ip.sin_zero,0,sizeof(server_ip.sin_zero));

    //绑定
    if(bind(socket_id,(struct sockaddr *)&server_ip,sizeof(server_ip))==-1)
    {
        printf("bind failed\n");
        return -1;
    }

    //监听端口
    listen(socket_id,5);
    return socket_id;
}


//signal_handler执行时会调用这个函数，用waitpid()回收进程结束时的资源，防止僵尸进程
int process_signal(int signo)
{
    switch(signo){
        case SIGCHLD:
            printf("连接中断\n");
            while(waitpid(-1, NULL, WNOHANG)>0);    
        break;
    }
}
//当有退出信号到达时（输入q，或者关闭客户端）
int signal_handler(void)
{
    struct sigaction act, oact;
    act.sa_handler = (void *)process_signal;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    act.sa_flags |= SA_RESTART;
    if(sigaction(SIGCHLD, &act, &oact) < 0)
    {
        return -1;
    }
        return 0;
}

int my_socket_process(int sockfd)
{
    char recv_buf[MAX_BUFFER_SIZE],send_buf[MAX_BUFFER_SIZE];//接收和发送的缓冲区
    int bytes;
    //int recv_len;
    //清空缓存
    while(1)
    {
        memset(recv_buf,0,MAX_BUFFER_SIZE);
        memset(send_buf,0,MAX_BUFFER_SIZE);
        bytes = recv(sockfd,recv_buf,MAX_BUFFER_SIZE,0);//接收客户端发来的数据存入recv_buf
        if(bytes < 0){
            printf("read err.\n");
            return -1;
        }
        if(bytes == 0){
            printf("client connection closed.\n");
            return 0;
        }
        //打印接收的字符串长度，和字符串，客服端ip，以及使用的端口
        printf("Bytes:%d\n", bytes);
        printf("recv_buf: %s \n", recv_buf);
        printf("client ip is %s \n",inet_ntoa(client_ip.sin_addr));//打印客服端ip，转换为点分十进制ip
        printf("port is %d\n",ntohs(client_ip.sin_port));//打印端口号，网络序转换为主机序
        printf("\n");
        //将接收到的数据发送回去
        send(sockfd,recv_buf,strlen(recv_buf),0);//将服务器接收到的数据会送给客服端
        if(!strcmp(recv_buf,"q"))//当接收到q时，服务器就与客服端断开连接，关闭sockfd套接字
            break;
        if(!strcmp(recv_buf,"h"))//当接收到h时，向主机发送hello linux
        {
            printf("i will send \"hello linux to client\"\n");
            sprintf(send_buf,"%s","hello linux");
            send(sockfd,send_buf,strlen(send_buf),0);
        }

    }
    close(sockfd);
    return 0;



}


int main(int argc, char const *argv[])
{
    int socket_id,sockfd;
    char buff[100];
    int addrlen;
    addrlen = sizeof(struct sockaddr);
    socket_id = socket_process();
    signal_handler();//用来处理连接的退出
    while(1)
    {
        sockfd = accept(socket_id, (struct sockaddr *)&client_ip, &addrlen);//还回一个监听套接字，原有的套接字继续用来监听新来的
        if(sockfd < 0)
        {
                perror("accept error.");
                return -1;
        }
        if(fork()==0)
        {
            close(socket_id);//子进程会继承父进程的所有文件描述符，继承后会导致套接字的计数器加一，因此要将继承的关闭
            printf("new client linking\n");
            my_socket_process(sockfd);
            exit(0);
        }
        close(sockfd);
    }

    return 0;
}