高级进程间通信之传送文件描述符
在进程间传送打开的文件描述符的能力是非常有用的，可以用它对客户进程/服务器进程应用进行不同的设计。它使一个进程（一般是服务器进程）能够处理为打开一个文件所要求的一切操作（具体如将网络名翻译为网络地址、拨号调制解调器、协商文件锁等）以及向调用进程送回一描述符，该描述符可被用于以后的所有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/。
