linux系统编程之服务器模型

最新推荐文章于 2024-05-11 20:56:30 发布

lxzlife

最新推荐文章于 2024-05-11 20:56:30 发布

阅读量87

点赞数

分类专栏： linux系统编程文章标签： linux 服务器运维

本文链接：https://blog.csdn.net/weixin_45050132/article/details/126633645

版权

linux系统编程专栏收录该内容

23 篇文章 0 订阅

订阅专栏

服务器端

server_listen.c

// 多进程服务器

#include <sys/types.h>
#include <sys/un.h>
#include <sys/socket.h>
#include <unistd.h>
#include <signal.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define CLIENT_NUM_MAX 10
#define SERVER_SOCKET_FILE "./server_socket"
#define LISTEN_N 10
#define DEAL_CONNETCT_PROCESS "./server_deal_connect"

#define DEBUG_MSG(msg) {fprintf(stdout,"[file:%s],[function:%s],[line:%d],%s\n",__FILE__,__FUNCTION__,__LINE__,msg);}

extern char **environ;

typedef int socket_fd_t;

socket_fd_t serverSocketFd = -1;
struct 
{
    socket_fd_t socketFd;
    pid_t pid;
}
clientStructArray[CLIENT_NUM_MAX];

// 初始化客户端结构数组中某个
void InitSpecificClientStructArray(int index)
{
    if ((index < 0) || (index >= CLIENT_NUM_MAX))
    {
        DEBUG_MSG("index invalid");
        exit(1);
    }
    clientStructArray[index].socketFd = -1;
    clientStructArray[index].pid = -1;
}

// 初始化客户端结构数组
void InitClientStructArray(void)
{
    for (int i = 0; i < CLIENT_NUM_MAX; i ++)
    {
        clientStructArray[i].socketFd = -1;
        clientStructArray[i].pid = -1;
    }
}

// 获取可用的客户端结构数组索引
int GetClientStructArrayIndex(void)
{
    for (int i = 0; i < CLIENT_NUM_MAX; i ++)
    {
        if (clientStructArray[i].socketFd == -1)
        {
            return(i);
        }
    }
    return(-1);
}

// 关闭指定的套接字描述符
void CloseSpecificClientSocketFd(int index)
{
    if ((index < 0) || (index >= CLIENT_NUM_MAX))
    {
        DEBUG_MSG("index invalid");
        exit(1);
    }
    if (clientStructArray[index].socketFd == -1)
    {
        DEBUG_MSG("socketFd invalid");
        exit(1);
    }
    close(clientStructArray[index].socketFd);
}

// 关闭所有客户端套接字描述符
void CloseAllClientSocketFd(void)
{
    for (int i = 0; i < CLIENT_NUM_MAX; i ++)
    {
        if (clientStructArray[i].socketFd != -1)
        {
            close(clientStructArray[i].socketFd);
        }
    }
}

// 关闭服务端套接字描述符
void CloseServerSocketFd(void)
{
    if (serverSocketFd != -1)
    {
        close(serverSocketFd);
    }
}

// 刷新客户端结构数组
void RefreshClientStructArray(void)
{
    int intRet = -1;
    for (int i = 0; i < CLIENT_NUM_MAX; i ++)
    {
        // after child process over
        if (clientStructArray[i].pid != -1)
        {
            // detect child process
            intRet = kill(clientStructArray[i].pid,0);
            // child process exist
            if (intRet == 0)
            {
                fprintf(stdout,"pid:%d exist,socketFd:%d\n",
                        clientStructArray[i].pid,
                        clientStructArray[i].socketFd);
            }
            // child process not exist
            else if (intRet == -1)
            {
                CloseSpecificClientSocketFd(i);
                clientStructArray[i].pid = -1;
            }
        }
    }
}

int main(int argc,char **argv)
{
    // 注册退出时的钩子函数
    atexit(CloseServerSocketFd);
    atexit(CloseAllClientSocketFd);

    int intRet = -1;
    intRet = remove(SERVER_SOCKET_FILE);
    if (intRet != 0)
    {
        DEBUG_MSG("remove error");
    }
    
    serverSocketFd = socket(AF_UNIX,SOCK_STREAM,0);
    if (serverSocketFd == -1)
    {
        DEBUG_MSG("socket error");
        exit(1);
    }
    fprintf(stdout,"serverSocketFd:%d\n",serverSocketFd);

    struct sockaddr_un unixSockAddr;
    memset(&unixSockAddr,0x00,sizeof(struct sockaddr_un));
    unixSockAddr.sun_family = AF_UNIX;
    strncpy(unixSockAddr.sun_path,SERVER_SOCKET_FILE,sizeof(unixSockAddr.sun_path) - 1);

    intRet = bind(serverSocketFd,(struct sockaddr*)&unixSockAddr,sizeof(struct sockaddr_un));
    if (intRet == -1)
    {
        DEBUG_MSG("bind error");
        exit(1);
    }
    // fprintf(stdout,"bind ret:%d\n",intRet);

    intRet = listen(serverSocketFd,LISTEN_N);
    if (intRet == -1)
    {
        DEBUG_MSG("listen error");
        exit(1);
    }
    // fprintf(stdout,"listen ret:%d\n",intRet);

    // 初始化客户端结构数组
    InitClientStructArray();

    int index = -1;
    socket_fd_t socketFd = -1;
    pid_t childPid = -1;
    for (;;)
    {
        // 刷新客户端结构数组
        RefreshClientStructArray();

        index = GetClientStructArrayIndex();
        if (index == -1)
        {
            DEBUG_MSG("GetClientStructArrayIndex error");
            exit(1);
        }
        fprintf(stdout,"[file:%s],[function:%s],[line:%d],index:%d\n",__FILE__,__FUNCTION__,__LINE__,index);

        socketFd = -1;
        socketFd = accept(serverSocketFd,NULL,NULL);
        if (socketFd == -1)
        {
            DEBUG_MSG("accept error");
            exit(1);
        }
        fprintf(stdout,"[file:%s],[function:%s],[line:%d],socketFd:%d\n",__FILE__,__FUNCTION__,__LINE__,socketFd);
        
        childPid = fork();
        if (childPid == -1)
        {
            DEBUG_MSG("fork error");
            exit(1);
        }
        // child process
        else if (childPid == 0)
        {
            CloseServerSocketFd();
            // clientSocketFd in string
            char fdBuf[10];
            sprintf(fdBuf,"%d",socketFd);
            char *argArr[] = {DEAL_CONNETCT_PROCESS,fdBuf,NULL};

            // for (int i = 0;;i ++)
            // {
            //     fprintf(stdout,"argArr[%d]:%s\n",i,argArr[i]);
            //     if (argArr[i] == NULL)
            //     {
            //         break;
            //     }
            // }
            
            execvp(argArr[0],argArr);
            // if execvp error
            DEBUG_MSG("execvp error");
            exit(1);
        }
        // parent process
        else if (childPid > 0)
        {
            clientStructArray[index].socketFd = socketFd;
            clientStructArray[index].pid = childPid;
        }
    }

    exit(0);
}

server_deal_connect.c

// 多进程服务器的处理子进程

// #include <sys/types.h>
// #include <sys/un.h>
// #include <sys/socket.h>
#include <unistd.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define DEBUG_MSG(msg) {fprintf(stdout,"[file:%s],[function:%s],[line:%d],%s\n",__FILE__,__FUNCTION__,__LINE__,msg);}

#define READ_N_MAX 1024

typedef int socket_fd_t;

int main(int argc,char **argv)
{
    if (argc < 2)
    {
        DEBUG_MSG("argc too less");
        exit(1);
    }

    // for (int i = 0;;i ++)
    // {
    //     fprintf(stdout,"argv[%d]:%s\n",i,argv[i]);
    //     if (argv[i] == NULL)
    //     {
    //         break;
    //     }
    // }

    socket_fd_t clientSocketFd = -1;
    clientSocketFd = atoi(argv[1]);
    // fprintf(stdout,"clientSocketFd:%d\n",clientSocketFd);

    ssize_t readN = -1;
    char readBuf[READ_N_MAX];

    for (;;)
    {
        readN = read(clientSocketFd,readBuf,READ_N_MAX);
        if (readN < 0)
        {
            DEBUG_MSG("read error");
            exit(1);
        }
        // fprintf(stdout,"file:%s,readBuf:%s\n",__FILE__,readBuf);

        ssize_t writeN = -1;
        writeN = write(clientSocketFd,readBuf,readN);
        if (writeN != readN)
        {
            DEBUG_MSG("write error");
            exit(1);
        }

    }
    
    // fprintf(stdout,"pid:%d to exit\n",getpid());
    exit(0);
}

客户端

client.c

// 多进程服务器对应的客户端

#include <sys/un.h>
#include <sys/socket.h>
#include <unistd.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define DEBUG_MSG(msg) {fprintf(stdout,"[function:%s],[line:%d],%s\n",__FUNCTION__,__LINE__,msg);}

#define SERVER_SOCKET_FILE "./server_socket"
#define READ_NUM_MAX 1024

typedef int socket_fd_t;

int main(int argc,char **argv)
{
    socket_fd_t serverSocketFd = -1;
    serverSocketFd = socket(AF_UNIX,SOCK_STREAM,0);
    if (serverSocketFd == -1)
    {
        DEBUG_MSG("socket error");
        exit(1);
    }

    struct sockaddr_un unixSockAddr;
    unixSockAddr.sun_family = AF_UNIX;
    strncpy(unixSockAddr.sun_path,SERVER_SOCKET_FILE,sizeof(unixSockAddr.sun_path) - 1);

    int intRet = -1;
    intRet = connect(serverSocketFd,(struct sockaddr*)&unixSockAddr,sizeof(struct sockaddr_un));
    if (intRet == -1)
    {
        DEBUG_MSG("connect error");
        close(serverSocketFd);
        exit(1);
    }

    ssize_t readN = -1;
    char readBuf[READ_NUM_MAX];
    ssize_t writeN = -1;
    for (;;)
    {
        readN = read(STDIN_FILENO,readBuf,READ_NUM_MAX);
        if (readN <= 0)
        {
            DEBUG_MSG("read error");
            continue;
        }

        writeN = write(serverSocketFd,readBuf,readN);
        if (writeN != readN)
        {
            DEBUG_MSG("write error");
            close(serverSocketFd);
            exit(1);
        }

        readN = read(serverSocketFd,readBuf,writeN);
        if (readN != writeN)
        {
            DEBUG_MSG("read error");
            close(serverSocketFd);
            exit(1);
        }

        writeN = write(STDOUT_FILENO,readBuf,readN);
        if (writeN != readN)
        {
            DEBUG_MSG("write error");
            close(serverSocketFd);
            exit(1);
        }
    }
    close(serverSocketFd);
    exit(0);
}