IPC 传递文件描述符-CSDN博客

本文链接：https://blog.csdn.net/fromair/article/details/144640851

fork创建的进程直接复制文件描述符

在 Linux 中，fork 系统调用会创建一个子进程，该子进程是父进程的副本。父进程的文件描述符会被复制到子进程中，因此子进程可以访问父进程已打开的文件或套接字。也就是说，在通过 fork 创建的子进程中，文件描述符是共享的。

然而，有一些细节需要注意：

文件描述符复制： 通过 fork 创建的子进程会继承父进程的文件描述符表的副本，这意味着它们会指向相同的文件描述符。文件描述符指向的文件或套接字的状态和文件偏移量（对于文件而言）在父子进程之间是共享的。
不同进程间的文件描述符共享： 如果父子进程在 fork 后对文件描述符进行了操作（例如，读写文件或改变文件偏移量），这些操作会影响另一个进程。也就是说，父进程和子进程中的文件描述符是独立的，但它们指向同一个内核对象，因此它们会共享文件状态（如文件偏移量）。
文件描述符继承： 子进程继承父进程的文件描述符表项，但并不意味着父进程的文件描述符会自动在所有新创建的进程之间共享。如果需要不同进程间共享文件描述符，通常是通过某些 IPC 机制，如 管道（pipe）、消息队列（message queue）、共享内存（shared memory） 或 套接字（socket） 等。
套接字共享： 如果父进程通过 socket() 创建了一个套接字并且 fork 了子进程，那么子进程能够共享这个套接字，父进程和子进程可以通过该套接字进行通信。这种套接字是继承的，但套接字的操作（如读写）是独立的。

总结一下，fork 可以让父子进程共享文件描述符，但这仅限于通过 fork 创建的进程。如果需要在其他进程间共享文件描述符，则需要借助其他 IPC 机制。

不同进程共享文件描述符

通过 IPC 机制在不同进程间共享文件描述符的方式，的确不是直接通过简单的传递整数（文件描述符的值）来完成的，因为文件描述符本身是进程特定的，它在不同进程中的含义是不同的。要实现不同进程之间共享文件描述符，通常会利用以下几种方法：

1. Unix 域套接字（Unix Domain Socket）

Unix 域套接字允许不同进程间通过套接字进行通信，而且支持一种特殊的功能，即通过 sendmsg() 和 recvmsg() 系统调用发送和接收文件描述符。这个过程叫做“文件描述符传递”。具体步骤如下：

父进程或其他进程将一个打开的文件描述符通过套接字发送给另一个进程。
接收进程通过套接字接收文件描述符，并将其作为文件描述符传递给其自己的文件描述符表。

这种方法的好处是，Unix 域套接字本身就是设计来允许进程间通信的，而且内核会处理文件描述符的转移。

示例：

假设父进程通过 Unix 域套接字将文件描述符发送给子进程：

父进程：

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

int main() {
    int sockfd, newfd;
    struct sockaddr_un addr;
    char *socket_path = "/tmp/my_socket";

    // 创建 Unix 域套接字
    sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (sockfd == -1) {
        perror("socket");
        return 1;
    }

    // 设置套接字地址
    memset(&addr, 0, sizeof(addr));
    addr.sun_family = AF_UNIX;
    strcpy(addr.sun_path, socket_path);
    
    // 绑定套接字
    if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
        perror("bind");
        return 1;
    }

    // 打开一个文件
    newfd = open("somefile.txt", O_RDWR);
    if (newfd == -1) {
        perror("open");
        return 1;
    }

    // 发送文件描述符
    struct msghdr msg = {0};
    struct iovec io = {0};
    char buf[1];  // 作为消息内容
    msg.msg_iov = &io;
    msg.msg_iovlen = 1;
    io.iov_base = buf;
    io.iov_len = sizeof(buf);

    struct cmsghdr *cmsg;
    char cmsgbuf[CMSG_SPACE(sizeof(int))];

    msg.msg_control = cmsgbuf;
    msg.msg_controllen = sizeof(cmsgbuf);

    cmsg = CMSG_FIRSTHDR(&msg);
    cmsg->cmsg_level = SOL_SOCKET;
    cmsg->cmsg_type = SCM_RIGHTS;
    cmsg->cmsg_len = CMSG_LEN(sizeof(int));
    *(int *)CMSG_DATA(cmsg) = newfd;

    if (sendmsg(sockfd, &msg, 0) == -1) {
        perror("sendmsg");
        return 1;
    }

    // 关闭文件描述符
    close(newfd);
    close(sockfd);
    return 0;
}

子进程：

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

int main() {
    int sockfd;
    struct sockaddr_un addr;
    char *socket_path = "/tmp/my_socket";
    char buf[1];
    struct msghdr msg = {0};
    struct iovec io = {0};
    struct cmsghdr *cmsg;
    char cmsgbuf[CMSG_SPACE(sizeof(int))];
    
    // 创建套接字
    sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (sockfd == -1) {
        perror("socket");
        return 1;
    }

    // 连接到父进程的套接字
    memset(&addr, 0, sizeof(addr));
    addr.sun_family = AF_UNIX;
    strcpy(addr.sun_path, socket_path);
    if (connect(sockfd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
        perror("connect");
        return 1;
    }

    // 接收文件描述符
    msg.msg_iov = &io;
    msg.msg_iovlen = 1;
    io.iov_base = buf;
    io.iov_len = sizeof(buf);

    msg.msg_control = cmsgbuf;
    msg.msg_controllen = sizeof(cmsgbuf);

    if (recvmsg(sockfd, &msg, 0) == -1) {
        perror("recvmsg");
        return 1;
    }

    cmsg = CMSG_FIRSTHDR(&msg);
    if (cmsg && cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
        int received_fd = *(int *)CMSG_DATA(cmsg);
        printf("Received file descriptor: %d\n", received_fd);
        // 可以使用该文件描述符进行操作
    }

    close(sockfd);
    return 0;
}