IPC——基于STREAMS的管道

1. 概述

基于 STREAMS 的管道有三个特点：

全双工
可以传递文件描述符
可以用文件命名

2. socketpair

       #include <sys/types.h>          /* See NOTES */
       #include <sys/socket.h>
       int socketpair(int domain, int type, int protocol, int sv[2]);

创建互相连接的 unix 套接字。

由于unix套接字只复制数据，没有报文封装等操作，所以高效，且可以用套接字相关api。

3. 基于unix域套接字的服务端客户端

unix套接字编程和tcp套接字编程类似，只是bind的是文件名

服务端

#include <stdio.h>
#include <stddef.h>
#include <string.h>
#include <unistd.h>
#include <sys/un.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

int
main ()
{
        int fd, cnt, cfd;
        size_t size;
        char buf[200];
        struct sockaddr_un peer, un;

        fd = socket(AF_UNIX, SOCK_STREAM, 0);

        un.sun_family = AF_UNIX;
        strcpy(un.sun_path, "hello.socket");
        unlink(un.sun_path); // 若已存在同名文件，则先删除
        // bind 成功后会创建 socket 文件
        if (bind(fd, (struct sockaddr *)&un, sizeof(un)) < 0) {
                perror("bind");
                return -1;
        }
        // 不能删除socket文件，因为客户端需要利用文件系统连接套接字

        // 将套接字转成 监听套接字
        if (listen(fd, 10) < 0) {
                perror("listen");
                return -1;
        }

        while ((cfd = accept(fd, (struct sockaddr *)&peer, &size))) {

                if ((cnt = read(cfd, buf, sizeof(buf))) < 0) {
                        perror("read");
                        return -1;
                }

                buf[cnt] = 0;
                printf("read : %s\n", buf);
                write(cfd, "world", 5);
                close(cfd);
        }
        close(fd);

        return 0;
}

客户端

#include <stdio.h>
#include <stddef.h>
#include <string.h>
#include <unistd.h>
#include <sys/un.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

int
main ()
{
        int fd, cnt;
        struct sockaddr_un un;
        char buf[200];

        fd = socket(AF_UNIX, SOCK_STREAM, 0);

        un.sun_family = AF_UNIX;
        strcpy(un.sun_path, "hello.socket");
        if (connect(fd, (struct sockaddr *)&un, sizeof(un)) < 0) {
                perror("connect");
                return -1;
        }

        if ((cnt = write(fd, "hello", 5)) < 0) {
                perror("write");
                return -1;
        }

        if ((cnt = read(fd, buf, sizeof(buf))) < 0) {
                perror("read");
                return -1;
        }
        buf[cnt] = 0;
        printf("child read %s\n", buf);

        close(fd);

        return 0;
}

4. 进程间传递文件描述符

#include <stdio.h>
#include <stdlib.h>
#include <alloca.h>
#include <sys/ioctl.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

void parent();
void child();
int p[2];

int main()
{
        // 1. 进程之间用 unix域 套接字传递文件描述符
    socketpair(AF_UNIX, SOCK_STREAM, 0, p);

        if (fork())  {
                parent();
        }
        else {
                child();
        }

        return 0;
}

void send_fd(int sockfd, int fd_to_send)
{
        struct msghdr msg;
        struct cmsghdr *cmsg;
#define CONTRLEN        CMSG_LEN(sizeof(int))

        char buf[1];
        struct iovec iov;
        iov.iov_base = buf;
        iov.iov_len = 1;
        buf[0] = 'a';
        msg.msg_iov = &iov; // 聚合写，不能为空
        msg.msg_iovlen = 1;
        msg.msg_name = NULL;
        msg.msg_namelen = 0;
        msg.msg_flags = 0;

        // 控制信息
        cmsg = alloca(CONTRLEN);
        cmsg->cmsg_level = SOL_SOCKET;
        cmsg->cmsg_type = SCM_RIGHTS; // 用于指明传输访问权限
        cmsg->cmsg_len = CONTRLEN;
        *(int *)CMSG_DATA(cmsg) = fd_to_send; // 控制信息最后域追加 需要传递的文件描述符
        msg.msg_control = cmsg;
        msg.msg_controllen = CONTRLEN;

        if (sendmsg(sockfd, &msg, 0) < 0)  {
                perror("sendmsg");
        }
}

void recv_fd(int sockfd, int *fd_to_recv)
{
        struct msghdr msg = {0};
        struct cmsghdr *cmsg;

        struct iovec iov;
        char buf[2] = {0};
        iov.iov_base = buf;
        iov.iov_len = 2;
        msg.msg_iov = &iov;
        msg.msg_iovlen = 1;
        cmsg = alloca(CONTRLEN);
        msg.msg_control = cmsg;
        msg.msg_controllen = CONTRLEN;

        if (recvmsg(sockfd, &msg, 0) < 0) {
                perror("recvmsg");
        }

        cmsg = msg.msg_control;
        *fd_to_recv = *(int *)CMSG_DATA(cmsg);
}

void parent()
{
        int fd;

        close(p[0]);
        fd = open("./tmp", O_CREAT | O_RDWR, 0644);
        send_fd(p[1], fd);
}

void child()
{
        int fd;
        close(p[1]);
        recv_fd(p[0], &fd);
        if (write(fd, "hello world", strlen("hello world")) < 0) {
                perror("write");
        }

}

unix传输文件描述符，使用 sendmsg, recvmsg，这两个函数都有一个msghdr指针

           struct msghdr {
               void         *msg_name;       /* optional address */
               socklen_t     msg_namelen;    /* size of address */
               struct iovec *msg_iov;        /* scatter/gather array */
               size_t        msg_iovlen;     /* # elements in msg_iov */
               void         *msg_control;    /* ancillary data, see below */
               socklen_t     msg_controllen; /* ancillary data buffer len */
               int           msg_flags;      /* flags on received message */
           };

msg_name 和 msg_namelen 通常用于网络连接发送报文时，指定目的地址
msg_iov 和 msg_iovlen 用于分散读/聚合写和 readv writev一样
msg_flags 指定非阻塞等特性
msg_control 和 msg_controllen 处理控制信息的接受和发送，msg_control 指向 cmsghdr(控制信息头部)结构，

struct cmsghdr {
   socklen_t cmsg_len;  /* 整个 cmsghdr 的长度,字节为单位 */
   int cmsg_level;
   int cmsg_type;
   /* 紧接着是真实的控制信息数据 */
};

使用下面宏访问cmsghdr

// 返回关联控制信息数据的指针
unsigned char *CMSG_DATA(struct cmsghdr *cp);

// 若 控制信息数据的大小为 nbytes， 则返回对应 整个 cmsghdr 的大小
unsigned int CMSG_LEN(unsigned int nbytes);