高级进程间通信之传送文件描述符

在进程间传送打开的文件描述符的能力是非常有用的，可以用它对客户进程/服务器进程应用进行不同的设计。它使一个进程（一般是服务器进程）能够处理为打开一个文件所要求的一切操作（具体如将网络名翻译为网络地址、拨号调制解调器、协商文件锁等）以及向调用进程送回一描述符，该描述符可被用于以后的所有I/O函数。涉及打开文件或设备的所有细节对客户进程而言都是隐藏的。

下面进一步说明从一个进程向另一个进程“传送一打开的文件描述符”的含义。回忆http://www.cnblogs.com/nufangrensheng/p/3498509.html中的图3-2，其中显示了两个进程，它们打开了同一文件。虽然它们共享同一v节点表，但每个进程都有它自己的文件表项。

当一个进程向另一个进程传送一打开的文件描述符时，我们想要发送进程和接收进程共享同一文件表项。图17-8显示了所希望的安排。

                                   图17-8 从顶部进程传送一个打开的文件至底部进程

在技术上，发送进程实际上向接收进程传送一个指向一打开文件表项的指针。该指针被分配存放在接收进程的第一个可用描述符项中。（注意，不要造成错觉，以为发送进程和接收进程中的描述符编号是相同的，通常它们是不同的。）两个进程共享同一打开文件表项，在这一点上与fork之后，父、子进程共享打开文件表项的情况完全相同（参考http://www.cnblogs.com/nufangrensheng/p/3509492.html中图8-1所示）。

当发送进程将描述符传送给接收进程后，通常它关闭该描述符。发送进程关闭该描述符并不造成关闭该文件或设备，其原因是该描述符对应的文件仍被视为由接收者进程打开（即使接收进程尚未接收到该描述符）。

下面定义三个函数以发送和接收文件描述符。本节将会给出对于STREAMS和套接字的这三个函数的不同实现代码。

#include "apue.h"

int send_fd(int fd, int fd_to_send);

int send_err(int fd, int status, const char *errmsg);

两个函数返回值：若成功则返回0，出错则返回-1

int recv_fd(int fd, ssize_t (*userfunc)(int, const void *, size_t));

返回值：若成功则返回文件描述符，出错则返回负值

当一个进程（通常是服务器进程）希望将一个描述符传送给另一个进程时，它调用send_fd或send_err。等待接收描述符的进程（客户进程）调用recv_fd。

send_fd经由fd代表的STREAMS管道或UNIX域套接字发送描述符fd_to_send。

send_err函数用fd发送errmsg以及后随的status字节。status的值应在-1到-255之间。

客户进程调用recv_fd接收一描述符。如果一切正常（发送者调用了send_fd），则作为函数值返回非负描述符。否则，返回值是由send_err发送的status（-1到-255之间的一个值）。另外，如果服务器进程发送了一条出错消息，则客户进程调用它自己的userfunc处理该消息。userfunc的第一个参数是常量STDERR_FILENO，然后是指向出错消息的指针及其长度。userfunc函数的返回值是已写的字节数或负的出错编号值。客户进程常将userfunc指定为通常的write函数。

我们实现了用于这三个函数的我们自己指定的协议。为发送一描述符，send_fd先发送两个0字节，然后是实际描述符。为了发送一条出错消息，send_err发送errmsg，然后是1个0字节，最后是status字节的绝对值（1-255）。recv_fd读s管道（可以实现为STREAMS管道或UNIX域套接字的双向通信管道）中所有字节直至null字符。null字符之前的所有字符都传送给调用者的userfunc。recv_fd读到的下一个字节是status字节。若status字节为0，那么一个描述符已传送过来，否则表示没有描述符可接收。

send_err函数在将出错消息写到STREAMS管道后，即调用send_fd函数。如程序清单17-11所示。

程序清单17-11 send_err函数

#include "apue.h"

/*
* Used when we had planned to send an fd using send_fd(),
* but encountered an error instead. We send the error back
* using the send_fd()/recv_fd() protocol.
*/
int
send_err(int fd, int errcode, const char *msg)
{
    int    n;
    
    if((n = strlen(msg)) > 0)
        if(writen(fd, msg, n) != n)    /* send the error message */
            return(-1);

    if(errcode >= 0)
        errcode = -1;    /* must be negtive */

    if(send_fd(fd, errcode) < 0)
        return(-1);
        
    return(0);
}

1、经由基于STREAMS的管道传送文件描述符

文件描述符用两个ioctl命令经由STREAMS管道交换，这两个命令是：I_SENDFD和I_RECVFD。为了发送一个描述符，将ioctl的第三个参数设置为实际描述符。

程序清单17-12 STREAMS管道的send_fd函数

#include "apue.h"
#include <stropts.h>

/*
* Pass a file descriptor to another process.
* If fd < 0, then -fd is sent back instead as the error status.
*/
int 
send_fd(int fd, int fd_to_send)
{
    char     buf[2];        /* send_fd()/recv_fd() 2-byte protocol */

    buf[0] = 0;        /* null bytes flag to recv_fd() */
    if(fd_to_send < 0)
    {
        buf[1] = -fd_to_send;    /* nonzero status means error */
        if(buf[1] == 0)
            buf[1] = 1;    /* -256, etc. would screw up protocol */ 
    }
    else
    {
        buf[1] = 0;    /* zero status means OK */
    }
    
    if(write(fd, buf, 2) != 2)
        return(-1);

    if(fd_to_send >= 0)
        if(ioctl(fd, I_SENDFD, fd_to_send) < 0)
            return(-1);
    return(0);
}

当接收一个描述符时，ioctl的第三个参数是一指向strrecvfd结构的指针。

struct strrecvfd {
    int      fd;     /* new descriptor */
    uid_t    uid;    /* effective user ID of sender */
    gid_t    gid;    /* effective group ID of sender */
    char     fill[8];
};

recv_fd读STREAMS管道直到接收到双字节协议的第一个字节（null字节）。当发出I_RECVFD ioctl命令时，位于流首读队列中的下一条消息应当是一个描述符，它是由I_SENDFD发来的，或者是一条出错消息。

程序清单17-13 STREAMS管道的recv_fd函数

#include "apue.h"
#include <stropts.h>

/*
* Receive a file descirpor from another process ( a server ).
* In addition, any data received from the server is passed
* to (*userfunc)(STDERR_FILENO, buf, nbytes). We have a 
* 2-byte protocol for receiving the fd from send_fd(). 
*/
int
recv_fd(int fd, ssize_t (*userfunc)(int, const void *, size_t))
{
    itn                  newfd,    nread, flag, status;
    char                *ptr;
    char                 buf[MAXLINE];
    struct strbuf        dat;
    struct strrecvfd     recvfd;
    
    status = -1;
    for(;;)
    {
        dat.buf = buf;
        dat.maxlen = MAXLINE;
        flag = 0;
        if(getmsg(fd, NULL, &dat, &flag) < 0)
            err_sys("getmsg error");
        nread = dat.len;
        if(nread == 0)
        {
            err_ret("connection closed by server");
            return(-1);
        }
        /*
        * See if this is the final data with null & status.
        * Null must be next to last byte of buffer, status
        * byte is last byte. Zero status means there must 
        * be a file descriptor to receive.
        */
        for(ptr = buf; ptr < &buf[nread]; )
        {
            if(*ptr++ == 0)
            {
                if(ptr != &buf[nread - 1])
                    err_dump("message format error");
                status = *ptr & 0xFF;    /* prevent sign extension */
                if(status == 0)
                {
                    if(ioctl(fd, I_RECVFD, &recvfd) < 0)
                        return(-1);
                    newfd = recvfd.fd; /* new descriptor */
                }
                else
                {
                    newfd = -status;
                }
                nread -= 2;
            }
        }
        if(nread > 0)
            if((*userfunc(STDERR_FILENO, buf, nread) != nread))
                return(-1);

        if(status >= 0)    /* final data has arrived */
            return(newfd);    /* descriptor, or -status */
    }
        
}

2、经由UNIX域套接字传送文件描述符

为了用UNIX域套接字交换文件描述符，调用sendmsg（2）和recvmsg（2）函数（http://www.cnblogs.com/nufangrensheng/p/3567376.html）。这两个函数的参数中都有一个指向msghdr结构的指针，该结构包含了所有有关收发内容的信息。该结构的定义大致如下：

struct msghdr {
    void            *msg_name;         /* optional address */
    socklen_t        msg_namelen;      /* address size in bytes */
    struct iovec    *msg_iov;          /* array of I/O buffers */
    int              msg_iovlen;       /* number of elements in array */
    void            *msg_control;      /* ancillary data */
    socklen_t        msg_controllen;   /* number of ancillary bytes */
    int              msg_flags;        /* flags for received message */
};

其中，头两个元素通常用于在网络连接上发送数据报文，在这里，目的地址可以由每个数据报文指定。下面两个元素使我们可以指定由多个缓冲区构成的数组（散布读和聚集写），这与对readv和writev函数（http://www.cnblogs.com/nufangrensheng/p/3559304.html）的说明一样。msg_flags字段包含了说明所接收到消息的标志，这些标志摘要示于表16-9中（http://www.cnblogs.com/nufangrensheng/p/3567376.html）。

有两个参数用来处理控制信息的传送和接收：msg_control字段指向cmsghdr（控制信息首部）结构，msg_contrllen字段包含控制信息的字节数。

struct cmsghdr {
    socklen_t        cmsg_len;      /* data byte count, including header */
    int              cmsg_level;    /* originating protocol */
    int              cmsg_type;     /* protocol-specific type */
    /* followed by the actual control message data */
};

为了发送文件描述符，将cmsg_len设置为cmsghdr结构的长度加一个整型（描述符）的长度，cmsg_level字段设置为SOL_SOCKET，cmsg_type字段设置为SCM_RIGHTS，用以指明我们在传送访问权。（SCM指的是套接字级控制信息，socket_level cnotrol message。）访问权仅能通过UNIX域套接字传送。描述符紧随cmsg_type字段之后存放，用CMSG_DATA宏获得该整型量的指针。

三个宏用于访问控制数据，一个宏用于帮助计算smsg_len所使用的值。

#include <sys/socket.h>

unsigned char *CMSG_DATA(struct cmsghdr *cp);
返回值：指向与cmsghdr结构相关联的数据的指针

struct cmsghdr *CMSG_FIRSTHDR(struct msghdr *mp);
返回值：指向与msghdr结构相关联的第一个cmsghdr结构的指针，若无这样的结构则返回NULL

struct cmsghdr *CMSG_NXTHDR(struct msghdr *mp, struct cmsghdr *cp);
返回值：指向与msghdr结构相关联的下一个cmsghdr结构的指针，该msghdr结构给出了当前cmsghdr结构，若当前cmsghdr结构已是最后一个则返回NULL

unsigned int CMSG_LEN(unsigned int nbytes);
返回值：为nbytes大小的数据对象分配的长度

Single UNIX规范定义了前三个宏，但没有定义CMSG_LEN。

GMSG_LEN宏返回为存放长度为nbytes的数据对象（控制数据）所需的字节数。它先将nbytes加上cmsghdr结构（控制数据头部）的长度，然后按处理机体系结构的对齐要求进行调整，最后再向上取整。

程序清单17-14 UNIX域套接字的send_fd函数

#include "apue.h"
#include <sys/socket.h>

/* size of control buffer to send/recv one file descriptor */
#define    CONTROLLEN    CMSG_LEN(sizeof(int))

static struct cmsghdr    *cmptr = NULL;    /* malloc'ed first time */

/*
* Pass a file descriptor to another process.
* If fd < 0, then -fd is sent back instead as the error status.
*/
int send_fd(int fd, int fd_to_send)
{
    struct iovec     iov[1];
    struct msghdr    msg;
    char             buf[2];    /* send_fd()/recv_fd() 2-byte protocol */

    iov[0].iov_base     = buf;
    iov[0].iov_len      = 2;
    msg.msg_iov         = iov;
    msg.msg_iovlen      = 1;
    msg.msg_name        = NULL;
    msg.msg_namelen     = 0;
    
    if(fd_to_send < 0)
    {
        msg.msg_control    = NULL;
        msg.msg_controllen = 0;
        buf[1] = -fd_to_send;    /* nonzero status means error */
        if(buf[1] == 0)
            buf[1] = 1;    /* -256, etc. would screw up protocol */        
    }
    else
    {
        if(cmptr == NULL && (cmptr = malloc(CONTROLLEN)) == NULL)
            return(-1);
        cmptr->cmsg_level      = SOL_SOCKET;
        cmptr->cmsg_type       = SCM_RIGHTS;
        cmptr->cmsg_len        = CONTROLLEN;
        msg.msg_control        = cmptr;
        msg.msg_controllen     = CONTROLLEN;
        *(int *)CMSG_DATA(cmptr) = fd_to_send;    /* the fd to pass */
        buf[1] = 0;    /* zero status means ok */
    }
    buf[0] = 0;    /* null byte flag to recv_fd() */
    if(sendmsg(fd, &msg, 0) != 2)
        return(-1);
    return(0);
}

在sendmsg调用中，发送双字节协议数据（null和status字节）和描述符。

为了接收文件描述符，我们为cmsghdr结构和描述符分配足够大的空间，将msg_control指向该存储空间，然后调用recvmsg。我们使用MSG_LEN宏计算所需空间的总量。

我们从UNIX域套接字读入，直至读到null字节，它位于最后的status字节之前。null字节之前是一条来自发送者的出错消息。

程序清单17-15 UNIX域套接字的recv_fd函数

#include "apue.h"
#include <sys/socket.h>    /* struct msghdr */

/* size of control buffer to send/recv one file descriptor */
#define CONTOLLEN    CMSG_LEN(sizeof(int))

static struct cmsghdr    *cmptr = NULL;    /* malloc'ed first time */

/*
* Receive a file descriptor from a server process. Also, any data
* received is passed to (*userfunc)(STDERR_FILENO, buf, nbytes).
* We have a 2-byte protocol for receiving the fd from send_fd().
*/
int
recv_fd(int fd, ssize_t (*userfunc)(int, const void *, size_t))
{
    int              newfd,    nr, status;
    char            *ptr;
    char             buf[MAXLINE];
    struct iovec     iov[1];
    struct msghdr    msg;
    status = -1;
    for(;;)
    {
        iov[0].iov_base   = buf;
        iov[0].iov_len    = sizeof(buf);
        msg.msg_iov       = iov;    
        msg.msg_iovlen    = 1;
        msg.msg_name      = NULL;
        msg.msg_namelen   = 0;
        
        if(cmptr == NULL && (cmptr = malloc(CONTROLLEN)) == NULL)
            return(-1);
        msg.msg_control        = cmptr;
        msg.msg_controllen     = CONTROLLEN;
        if((nr = recvmsg(fd, &msg, 0)) < 0)
        {
            err_sys("recvmsg error");    
        }
        else if(nr == 0)
        {
            err_ret("connection close by server");
            return(-1);    
        }

        /*
        * See if this is the final data with null & status. Null
        * is next to last byte to buffer; status byte is last byte.
        * Zero status means there is a file descriptor to receive. 
        */
        for(ptr = buf; ptr < &buf[nr];)
        {
            if(*ptr++ == 0)
            {
                if(ptr != &buf[nr - 1])
                {
                    err_dump("message format error");
                }
                status = *ptr & 0xFF;    /* prevent sign extension */
                if(status == 0)
                {
                    if(msg.msg_controllen != CONTROLLEN)
                    {
                        err_dump("status = 0 but no fd");
                    }
                    newfd = *(int *)CMSG_DATA(cmptr);
                }
                else
                {
                    newfd = -status;
                }
                nr -= 2;
            }
        }
        if(nr > 0 && (*userfunc)(STDERR_FILENO, buf, nr) != nr)
            return(-1);
        if(status >= 0)    /* final data has arrived */
            return(newfd);    /* descriptor, or -status */
    }
}

注意，该程序总是准备接收一描述符（在每次调用recvmsg之前，设置msg_control和msg_controllen），但是仅当在返回时，msg_controllen非0，才确实接收到一描述符。

在传送文件描述符方面，UNIX域套接字和STREAMS管道之间的一个区别是，用STREAMS管道时我们得到发送进程的身份。

FreeBSD 5.2.1和Linux 2.4.22支持在UNIX域套接字上发送凭证，但实现方式不同。

在FreeBSD，将凭证作为cmsgcred结构传送。

#define    CMGROUP_MAX    16

struct cmsgcred {
    pid_t    cmcred_pid;                     /* sender's process ID */
    uid_t    cmcred_uid;                     /* sender's real UID */
    uid_t    cmcred_euid;                    /* sender's effective UID */
    gid_t    cmcred_gid;                     /* sender's read GID */
    short    cmcred_ngroups;                 /* number of groups */
    gid_t    cmcred_groups[CMGROUP_MAX];     /* groups */
};

当传送凭证时，仅需为cmsgcred结构保留存储空间。内核将填充该结构以防止应用程序伪装成具有另一种身份。

在Linux中，将凭证作为ucred结构传送。

struct ucred {
    uint32_t    pid;    /* sender's process ID */
    uint32_t    uid;    /* sender's user ID */
    uint32_t    gid;    /* sender's group ID */
};

不同于FreeBSD的是，Linux要求在传送前先将结构初始化。内核将确保应用程序使用对应于调用程序的值，或具有适当的权限使用其他值。

程序清单17-16 在UNIX域套接字上发送凭证

#include "apue.h"
#include <sys/socket.h>

#if define(SCM_CRED)    /* BSD interface */
#define CREDSTRUCT    cmsgcred
#define SCM_CREDTYPE    SCM_CREDS
#elif define(SCM_CREDENTIALS)    /* Linux interface */
#define CREDSTRUCT    ucred
#define    SCM_CREDTYPE    SCM_CREDENTIALS
#else
#error passing credentials is unsupported!
#endif

/* size of control buffer to send/recv one file descriptor */
#define    CONTROLLEN    CMSG_LEN(sizeof(int))

static struct cmsghdr    *cmptr = NULL;    /* malloc'ed first time */

/*
* Pass a file descriptor to another process.
* If fd < 0, then -fd is sent back instead as the error status.
*/
int send_fd(int fd, int fd_to_send)
{
    struct CREDSTRUCT    *credp;
    struct cmsghdr        *cmp;
    struct iovec        iov[1];
    struct msghdr        msg;
    char            buf[2];    /* send_fd()/recv_fd() 2-byte protocol */

    iov[0].iov_base     = buf;
    iov[0].iov_len     = 2;
    msg.msg_iov     = iov;
    msg.msg_iovlen     = 1;
    msg.msg_name     = NULL;
    msg.msg_namelen     = 0;
    msg.msg_flags = 0;

    if(fd_to_send < 0)
    {
        msg.msg_control    = NULL;
        msg.msg_controllen = 0;
        buf[1] = -fd_to_send;    /* nonzero status means error */
        if(buf[1] == 0)
            buf[1] = 1;    /* -256, etc. would screw up protocol */        
    }
    else
    {
        if(cmptr == NULL && (cmptr = malloc(CONTROLLEN)) == NULL)
            return(-1);
        msg.msg_control        = cmptr;
        msg.msg_controllen    = CONTROLLEN;
        cmp = cmptr;
        cmp->cmsg_level        = SOL_SOCKET;
        cmp->cmsg_type        = SCM_RIGHTS;
        cmp->cmsg_len        = RIGHTSLEN;
        *(int *)CMSG_DATA(cmp) = fd_to_send;    /* the fd to pass */
        
        cmp = CMSG_NXTHDR(&msg, cmp);
        cmp->cmsg_level =SOL_SOCKET;
        cmp->cmsg_type    = SCM_CREDTYPE;
        cmp->cmsg_len    = CREADSLEN;
        credp = (struct CREADSTRUCT *)CMSG_DATA(cmp);
#if defined(SCM_CREDENTIALS)
        credp->uid = geteuid();
        credp->gid = getegid();
        credp->pid = getpid();
#endif
        buf[1] = 0;    /* zero status means ok */
    }
    buf[0] = 0;    /* null byte flag to recv_fd() */
    if(sendmsg(fd, &msg, 0) != 2)
        return(-1);
    return(0);
}

注意，只是Linux上才需要初始化凭证结构。

程序清单17-17 在UNIX域套接字上接收凭证

#include "apue.h"
#include <sys/socket.h>    /* struct msghdr */


**************************************

#if define(SCM_CRED)    /* BSD interface */
#define CREDSTRUCT    cmsgcred
#define CR_UID        cmcred_uid
#define CREDOPT        LOCAL_PEERCRED
#define SCM_CREDTYPE    SCM_CREDS
#elif define(SCM_CREDENTIALS)    /* Linux interface */
#define CREDSTRUCT    ucred
#define    CR_UID        uid
#define    CREDOPT        SO_PASSCRED
#define    SCM_CREDTYPE    SCM_CREDENTIALS
#else
#error passing credentials is unsupported!
#endif

/* size of control buffer to send/recv one file descriptor */
#define RIGHTSLEN    CMSG_LEN(sizeof(int))
#define CREDSLEN    CMSG_LEN(sizeof(struct CREDSTRUCT))
#define    CONTROLLEN    (RIGHTSLEN + CREDSLEN)

static struct cmsghdr    *cmptr = NULL;    /* malloc'ed first time */

/*
* Receive a file descriptor from a server process. Also, any data
* received is passed to (*userfunc)(STDERR_FILENO, buf, nbytes).
* We have a 2-byte protocol for receiving the fd from send_fd().
*/
int
recv_fd(int fd, uid_t *uidptr, ssize_t (*userfunc)(int, const void *, size_t))
{
    struct cmsghdr        *cmp;    
    struct CREDSTRUCT     *credp;
    int                    newfd,    nr, status;
    char                  *ptr;
    char                   buf[MAXLINE];
    struct iovec           iov[1];
    struct msghdr          msg;
    const int              on = 1;

    status = -1;
    newfd = -1;
    if(setsockopt(fd, SOL_SOCKET, CREDOPT, &on, sizeof(int)) < 0)
    {
        err_ret("setsockopt failed");
        return(-1);
    }
    for(;;)
    {
        iov[0].iov_base   = buf;
        iov[0].iov_len    = sizeof(buf);
        msg.msg_iov       = iov;    
        msg.msg_iovlen    = 1;
        msg.msg_name      = NULL;
        msg.msg_namelen   = 0;
        
        if(cmptr == NULL && (cmptr = malloc(CONTROLLEN)) == NULL)
            return(-1);
        msg.msg_control        = cmptr;
        msg.msg_controllen     = CONTROLLEN;
        if((nr = recvmsg(fd, &msg, 0)) < 0)
        {
            err_sys("recvmsg error");    
        }
        else if(nr == 0)
        {
            err_ret("connection close by server");
            return(-1);    
        }

        /*
        * See if this is the final data with null & status. Null
        * is next to last byte to buffer; status byte is last byte.
        * Zero status means there is a file descriptor to receive. 
        */
        for(ptr = buf; ptr < &buf[nr];)
        {
            if(*ptr++ == 0)
            {
                if(ptr != &buf[nr - 1])
                {
                    err_dump("message format error");
                }
                status = *ptr & 0xFF;    /* prevent sign extension */
                if(status == 0)
                {
                    if(msg.msg_controllen != CONTROLLEN)
                    {
                        err_dump("status = 0 but no fd");
                    }
                    
                    /* process the control data */
                    for(cmp = CMSG_FIRSTHDR(&msg); cmp != NULL; cmp = CMSG_NXTHDR(&msg, cmp))
                    {
                        if(cmp->cmsg_level != SOL_SOCKET)
                            continue;
                        switch(cmp->cmsg_type)
                        {
                            case SCM_RIGHTS:
                                newfd = *(int *)CMSG_DATA(cmptr);    
                                break;
                            case SCM_CREDTYPE:
                                credp = (struct CREDSTRUCT *)CMSG_DATA(cmp);
                                *uidptr = credp->CR_UID;
                                
                        }
                    }
                }
                else
                {
                    newfd = -status;
                }
                nr -= 2;
            }
        }
        if(nr > 0 && (*userfunc)(STDERR_FILENO, buf, nr) != nr)
            return(-1);
        if(status >= 0)    /* final data has arrived */
            return(newfd);    /* descriptor, or -status */
    }
}

本篇博文内容摘自《UNIX环境高级编程》（第二版），仅作个人学习记录所用。关于本书可参考：http://www.apuebook.com/。