【2.5】exec函数族

exec 函数族

如果一个进程想执行另外一个程序，它就可以调用fork函数新建一个进程，然后在子进程中调用任何一个exec函数把自身替换成新的程序。函数族具体函数如下：

#include <unistd.h>

int execl(const char *pathname, const char *arg, ...);
int execv(const char *pathname, char *const argv[]);
int execle(const char *pathname, const char *arg, ..., char *const envp[]);
int execve(const char *pathname, char *const argv[], char *const envp[]);
int execlp(const char *filename, const char *arg, ...);
int execvp(const char *filename, char *const argv[]);

上述函数只有在出错的时候，才会返回给调用者，否则控制将会被传递给新程序的起点，通常就是main函数。

exec 服务端程序

接收到客户端连接之后，调用新的msg.c来处理

msg.c
将msg.c编译成名称为msg的可执行程序

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

static void do_msg_process(int accsocfd) {
    printf("do_msg_process enter!\n");
    int size = 0;
    char read_buffer[512] = {0};
    char write_buffer[1024] = {0};

    while (true) {
        memset(read_buffer, 0x00, sizeof(read_buffer));
        memset(write_buffer, 0x00, sizeof(write_buffer));

        size = read(accsocfd, read_buffer, 1024);
        if (size > 0) {
            printf("pid: %d, client say: %s\n", getpid(), read_buffer);

            snprintf(write_buffer, 1024, "%s%s", "[SERVER RECV]: ", read_buffer);
            size = write(accsocfd, write_buffer, strlen(write_buffer));
        } else {
            break;
        }
    }
    printf("do_msg_process exit!\n");
}

int main(int argc, char const *argv[]) {
    printf("msg.c enter! argc:%d\n", argc);
    for (int i = 0; i < argc; i++) {
        printf("msg.c argv[%d]:%s\n", i, argv[i]);
    }
    int accsocfd = atoi(argv[1]);
    do_msg_process(accsocfd);
    printf("msg.c exit!\n");
    return 0;
}

服务端
调用方式上注意：第一个参数填路径 / 可执行文件名，第二个参数填可执行文件名，最后一个参数为NULL，中间为正常需要传入到msg.c的参数，跟命令行参数类似。

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

static void sig_func(int arg) {
    pid_t pid;
    int stat;

    while ((pid = waitpid(-1, &stat, WNOHANG)) > 0) {
        printf("child %d terminated!\n", pid);
    }
}

int main(int argc, char const *argv[]) {
    // 调用socket函数来创建一个IPV4（AF_INET）字节流（SOCK_STREAM）套接字，返回标识符
    int socketfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (socketfd < 0) {
        perror("socket create failed!\n");
        return 0;
    }

    // 将服务器的IP地址和端口号填入sockaddr_t结构的变量中，地址族设定为AF_INET，IP地址和端口必须要是特地格式，IP地址使用INADDR_ANY表示任意IP
    struct sockaddr_in s_addr;
    memset(&s_addr, 0x00, sizeof(struct sockaddr_in));
    s_addr.sin_family = AF_INET;
    s_addr.sin_port = htons(6666);
    s_addr.sin_addr.s_addr = htonl(INADDR_ANY);

    // 调用bind函数绑定所创建的套接字
    bind(socketfd, (struct sockaddr*)&s_addr, sizeof(struct sockaddr));

    // 调用listen将套接字转换为监听套接字，这样外来连接可以通过该套接字被内核接受
    listen(socketfd, 10);

    // 监听SIGCHLD信号，通过函数sig_func来处理该信号
    signal(SIGCHLD, sig_func);

    while (true) {
        // 调用accept，服务器进入睡眠状态，等待客户的连接，完成3次握手，然后返回一个握手成功的描述符，新描述符用于与客户端通讯
        int accsocfd = accept(socketfd, NULL, NULL);

        pid_t forkpid = fork();
        if (forkpid == 0) {
            // 子进程不需要监听
            close(socketfd);
            // 处理消息
            printf("accsocfd:%d, pid:%d\n", accsocfd, getpid());
            char execl_argv[16] = {0};
            snprintf(execl_argv, sizeof(execl_argv), "%d", accsocfd);
            /* 传参解析
             * ./msg: 可执行文件的目录为当前目录，可执行文件名为msg
             * msg: 可执行文件名为msg
             * execl_argv：参数
             * NULL: 定为NULL
            */
            if (execl("./msg", "msg", &execl_argv, NULL) < 0) {
                printf("error in execl. errno:%d\n", errno);
            }
            // 子进程退出
            exit(0);
        }

        // 调由子进程处理了，父进程用close来关闭已连接的套接字
        close(accsocfd);
    }

    close(socketfd);
    return 0;
}

运行结果

可以看到msg.c中打印的pid和服务端子进程打印的pid是一致的，exec只是把当前进程的镜像替换成新的程序文件，进程ID不会改变。