linux c socket多進程服務端

server_process.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <signal.h>
#include "rd_wt_msg.h"


#define HEAD_LEN    40
typedef struct{
    int socket;
    int port;
    char ip[20];
}clnt_info_def;

int print_client_inf(clnt_info_def *p_clnt_info, struct sockaddr_in* p_clientaddr)
{
    
    if (p_clientaddr == NULL || p_clnt_info == NULL)
    {
        printf("p_clientaddr or p_clnt_info para is null ! | %s,%d %s\n",__FILE__, __LINE__, __FUNCTION__);
        return -1;
    }
    
    inet_ntop(AF_INET, &p_clientaddr->sin_addr.s_addr, p_clnt_info->ip, sizeof(p_clnt_info->ip));
    p_clnt_info->port = ntohs(p_clientaddr->sin_port);
    printf("server accept client[%s:%d] success\n", p_clnt_info->ip, p_clnt_info->port);
    
    return 0;
}


int main(int argc, char* argv[])
{
    int client_fd;
    
    int server_fd;

    int res = 0;
    int opt = 1;
    socklen_t clientaddr_len;
    struct sockaddr_in serveraddr;
    struct sockaddr_in clientaddr;
    
    if (argc < 2)
    {
        printf("usgae: %s port\n", argv[0]);
        return -1;
    }
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd < 0)
    {
        perror("socket error");
        return -1;
    }
    /* 端口重複利用 */
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, (void*)&opt, sizeof(opt));
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(atoi(argv[1]));
    serveraddr.sin_addr.s_addr = INADDR_ANY;
    
    res = bind(server_fd, (struct sockaddr*)&serveraddr, sizeof(struct sockaddr));
    if (res != 0)
    {
        perror("bind error");
        return -1;
    }
    res = listen(server_fd, 10);
    if (res != 0)
    {
        perror("listen error");
        return -1;
    }
    
    clientaddr_len = sizeof(struct sockaddr_in);
    while(1)
    {
        client_fd = accept(server_fd, (struct sockaddr*)&clientaddr, &clientaddr_len);
        if (client_fd < 0)
        {
            perror("client_fd error");
            return -1;
        }
        res = fork();
        if (res < 0)
        {
            continue;
        }
        else if (res == 0)//child process
        {
            msg_def msg;
            int read_len = 0;
            int body_len = 0;
            char tmp[4+1];
            char client_ip[20];
            int write_len = 0;
            clnt_info_def clnt_info;
            
            print_client_inf(&clnt_info, &clientaddr);
            while(1)
            {
                memset(&msg, 0x00, sizeof(msg_def));
                //接收報文頭
                read_len = msg_read(client_fd, msg.msg_buff, HEAD_LEN);
                if (read_len <=0)
                {
                    close(client_fd);
                    break;
                }
                
                memset(tmp, 0x00, sizeof(tmp));
                memcpy(tmp, msg.msg_buff+4, 4);
                body_len = atoi(tmp);
                printf("[%d] child process recv head data is[%s]\n", getpid(), msg.msg_buff);
                // 接收報文體 
                read_len = msg_read(client_fd, msg.msg_buff+HEAD_LEN, body_len);
                if (read_len <=0)
                {
                    close(client_fd);
                    break;
                }
                
                printf("[%d] child process recv body data is[%s]\n", getpid(), msg.msg_buff+HEAD_LEN);
                
                write_len = strlen(msg.msg_buff);
                write_len = msg_write(client_fd, msg.msg_buff, write_len);
                if (write_len < 0)
                {
                    close(client_fd);
                    break;
                }
            }
            close(client_fd);
        }
        else
        {
            //close(client_fd);
        }
        
        
    }
    return 0;
}

rd_wt_msg.h

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <signal.h>
#include <assert.h>
#include <errno.h>

#ifndef __RD_WT_MSG_H_
#define __RD_WT_MSG_H_

/*
    消息頭：固定長度40字節
    交易碼：4位數字
    消息長度：4位數字
    消息交易碼：32位
*/


/*
    消息：報文頭加報文體
    報文體：最大能容納1024字節
*/
typedef struct {
    char            msg_buff[1064+1];
}msg_def;


int msg_read(int socket_fd, char* read_buff, int read_len);


int msg_write(int socket_fd, char* write_buff, int write_len);


#endif

rd_wt_msg.c

#include "rd_wt_msg.h"


int msg_read(int socket_fd, char* read_buff, int read_len)
{
    int res = 0;
    if (read_buff == NULL)
    {
        printf("read_buff para is null |%s,%d %s\n", __FILE__, __LINE__, __FUNCTION__);
        return -1;
    }
    
    res = read(socket_fd, read_buff, read_len);
    if (res < 0)
    {
        printf("socket[%d] read errer, errno=%d, msg=%s! | %s,%d %s\n", socket_fd,errno, strerror(errno),__FILE__, __LINE__, __FUNCTION__);
        return -1;
    }
    else if (res == 0)
    {
        printf("socket[%d] has closed! | %s,%d %s\n", socket_fd,__FILE__, __LINE__, __FUNCTION__);
        return 0;
    }
    else if (res != read_len)
    {
        printf("socket[%d] read len [%d] not equal [%d] errer! | %s,%d %s\n", socket_fd,res, read_len, __FILE__, __LINE__, __FUNCTION__);
        return -1;
    }
    
    return res;
}


int msg_write(int socket_fd, char* write_buff, int write_len)
{
    int res = 0;
    assert(write_buff != NULL);
    res = write(socket_fd, write_buff, write_len);
    if (res < 0)
    {
        printf("socket[%d] error errno=%d, msg=%s\n", socket_fd, errno, strerror(errno));
        return -1;
    }
    else if (res == write_len)
    {
        return res;
    }
    return -1;
}

編譯
gcc -c rd_wt_msg.c -o rd_wt_msg.o
gcc server_process.c -o server_process -Iinclude rd_wt_msg.o
執行
./ server_process 8888