我们知道父进程在子进程被fork出来之前打开的文件描述符是能被子进程继承下来的，但是一旦子进程已经创建后，父进程打开的文件描述符要怎样才能传递给子进程呢？Unix提供相应的技术来满足这一需求，这就是同一台主机上进程间的文件描述符传递，很美妙而且强大的技术。

想象一下我们试图实现一个服务器，接收多个客户端的连接，我们欲采用多个子进程并发的形式来处理多客户端的同时连接，这时候我们可能有两种想法：
1、客户端每建立一条连接，我们fork出一个子进程负责处理该连接；
2、预先创建一个进程池，客户端每建立一条链接，服务器就从该池中选出一个空闲(Idle)子进程来处理该连接。
后者显然更高效，因为减少了子进程创建的性能损耗，反应的及时性大大增强。这里恰恰就出现了我们前面提到的问题，所有子进程都是在服务器Listen到一条连接以前就已经fork出来了，也就是说新的连接描述符子进程是不知道的，需要父进程传递给它，它接收到相应的连接描述符后，才能与相应的客户端进行通信处理。这里我们就可以使用’传递文件描述符’的方式来实现。

在’UNIX网络编程第1卷’的14.7小节中对这种技术有详细的阐述，实际上这种技术就是利用sendmsg和recvmsg在一定的UNIX域套接口(或者是某种管道)上发送和接收一种特殊的消息，这种消息可以承载’文件描述符’罢了，当然操作系统内核对这种消息作了特殊的处理。在具体一点儿’文件描述符’是作为辅助数据(Ancillary Data)通过msghdr结构中的成员msg_control(老版本中称为msg_accrights)发送和接收的。值得一提的是发送进程在将’文件描述符’发送出去后，即使立即关闭该文件描述符，该文件描述符对应的文件设备也没有被真正的关闭，其引用计数仍然大于一，直到接收进程成功接收后，再关闭该文件描述符，如果这时文件设备的引用计数为0，那么才真正关闭该文件设备。

OK，下面是一个简单的文件描述符传递的例子，该例子实现这样一个功能：即子进程负责在父进程传递给它的文件描述符对应的文件尾加上特定的’LOGO’字符串。例子环境为Solaris 9 + GCC 3.2

/* test_fdpass.c */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

#include <sys/socket.h> /* for socketpair */

#define MY_LOGO         "– Tony Bai"

static int send_fd(int fd, int fd_to_send)
{
        struct iovec    iov[1];
        struct msghdr   msg;
        char            buf[1];

        if (fd_to_send >= 0) {
                msg.msg_accrights       = (caddr_t)&fd_to_send;
                msg.msg_accrightslen    = sizeof(int);
        } else {
                msg.msg_accrights       = (caddr_t)NULL;
                msg.msg_accrightslen    = 0;
        }

        msg.msg_name    = NULL;
        msg.msg_namelen = 0;

        iov[0].iov_base = buf;
        iov[0].iov_len  = 1;
        msg.msg_iov     = iov;
        msg.msg_iovlen  = 1;

        if(sendmsg(fd, &msg, 0) < 0) {
                printf("sendmsg error, errno is %d\n", errno);
                return errno;
        }

        return 0;
}

static int recv_fd(int fd, int *fd_to_recv)
{
        struct iovec    iov[1];
        struct msghdr   msg;
        char            buf[1];

        msg.msg_accrights       = (caddr_t)fd_to_recv;
        msg.msg_accrightslen    = sizeof(int);

        msg.msg_name    = NULL;
        msg.msg_namelen = 0;

        iov[0].iov_base = buf;
        iov[0].iov_len  = 1;
        msg.msg_iov     = iov;
        msg.msg_iovlen  = 1;

        if (recvmsg(fd, &msg, 0) < 0) {
                return errno;
        }

        if(msg.msg_accrightslen != sizeof(int)) {
                *fd_to_recv = -1;
        }

        return 0;
}

int x_sock_set_block(int sock, int on)
{
        int             val;
        int             rv;

        val = fcntl(sock, F_GETFL, 0);
        if (on) {
                rv = fcntl(sock, F_SETFL, ~O_NONBLOCK&val);
        } else {
                rv = fcntl(sock, F_SETFL, O_NONBLOCK|val);
        }

        if (rv) {
                return errno;
        }

        return 0;
}

int main() {
        pid_t   pid;
        int     sockpair[2];
        int     rv;
        char    fname[256];
        int     fd;

        rv = socketpair(AF_UNIX, SOCK_STREAM, 0, sockpair);
        if (rv < 0) {
                printf("Call socketpair error, errno is %d\n", errno);
                return errno;
        }

        pid = fork();
        if (pid == 0) {
                /* in child */
                close(sockpair[1]);

                for ( ; ; ) {
                        rv = x_sock_set_block(sockpair[0], 1);
                        if (rv != 0) {
                                printf("[CHILD]: x_sock_set_block error, errno is %d\n", rv);
                                break;
                        }

                        rv = recv_fd(sockpair[0], &fd);
                        if (rv < 0) {
                                printf("[CHILD]: recv_fd error, errno is %d\n", rv);
                                break;
                        }

                        if (fd < 0) {
                                printf("[CHILD]: child process exit normally!\n");
                                break;
                        }

                       /* 处理fd描述符对应的文件 */
                        rv = write(fd, MY_LOGO, strlen(MY_LOGO));
                        if (rv < 0) {
                                printf("[CHILD]: write error, errno is %d\n", rv);
                        } else {
                                printf("[CHILD]: append logo successfully\n");
                        }
                        close(fd);
                }

          
      exit(0);
        }

        /* in parent */
        for ( ; ; ) {
                memset(fname, 0, sizeof(fname));
                printf("[PARENT]: please enter filename:\n");
                scanf("%s", fname);

                if (strcmp(fname, "exit") == 0) {
                        rv = send_fd(sockpair[1], -1);
                        if (rv < 0) {
                                printf("[PARENT]: send_fd error, errno is %d\n", rv);
                        }
                        break;
                }

                fd = open(fname, O_RDWR | O_APPEND);
                if (fd < 0) {
                        if (errno == ENOENT) {
                                printf("[PARENT]: can’t find file ‘%s’\n", fname);
                                continue;
                        }
                        printf("[PARENT]: open file error, errno is %d\n", errno);
                }

                rv = send_fd(sockpair[1], fd);
                if (rv != 0) {
                        printf("[PARENT]: send_fd error, errno is %d\n", rv);
                }

                close(fd);
        }

        wait(NULL);
        return 0;
}

编译：gcc -o test_fdpass -lsocket -lnsl test_fdpass.c
执行：test_fdpass(事先在同一目录下创建一个文件kk.log)

[PARENT]: please enter filename:
kk.log
[CHILD]: append logo successfully
[PARENT]: please enter filename:
cc.log
[PARENT]: can’t find file ‘cc.log’
exit
[CHILD]: child process exit normally!

你可以发现kk.log内容的末尾已经加上了我的独特LOGO ‘– Tony Bai’。^_^
关于文件描述符传递的更多细节， W. Richard Stevens的’UNIX网络编程第1卷’和’UNIX环境高级编程’两本书中都有详细说明，参读即可。

第一次看《C专家编程》一书时关于其采用的'优先级规则'分析C复杂声明时看得很糊涂，在理解'right-left'规则分析C复杂声明后，再回过头来看'优先级规则'，居然发现它们的异曲同工之妙^_^。

其实'优先级规则'的分析过程极其类似'right-left'规则，下面首先摘录'优先级规则'的'口诀'，然后再'一招一式'的细致讲解^_^。

[优先级规则'口诀']
A 声明从它的名字开始读取，然后按照优先级顺序依次读取。
B 优先级从高到低依次是：
B. 1 声明中被括号括起来的那部分
B. 2 后缀操作符：
括号() 表示这是个函数，而
方括号[]表示这是个数组。
B. 3 前缀操作符：星号*表示'指向…的指针'。
C 如果const和(或)volatile关键字的后面紧跟类型说明符(如int, long等)，那么它作用于类型说明符(说明是常量数据)。在其他情况下，const和(或)volatile关键字作用于其左边紧邻的指针星号(说明是常量指针)。

[一招一式练口诀]
其实'优先级规则'对分析过程中的界限的说明不是很好，而其分析界限又恰恰和'right-left'规则是一致的。

例子1
int (*p)[20];
(1) 我们从名字p开始；
(2) 在遇到后缀操作符之前我们遇到了')'，这样我们就不能看后缀操作符了，要去看优先级低一些的前缀操作符，我们发现了'*'，我们得到结论p是一个指向…的指针；
(3) 出了包围p的那个'()'，我们继续看后缀操作符，发现一个'[]'，我们知道p这个指针是指向一个数组，而且这个数组有20个某类型的元素，但如果我们遇到'()'，那p指向的就是一个函数了；
(4) 那这是一个什么样的数组呢？那我们的继续分析前缀操作符才能得知，在p的左面我们只发现了int类型说明符，我们知道该数组是一个int类型的拥有20个元素的数组，至此分析完毕。
(5) 最后得出结论：p是一个指向一个整型数组的指针，该数组拥有20个元素。

例子2
char * const *(*p)();
(1) 我们依然从名字p开始；
(2) 在遇到后缀操作符之前我们遇到了')'，这样我们就不能看后缀操作符了，要去看优先级低一些的前缀操作符，我们发现了'*'，我们得到结论p是一个指向…的指针；
(3) 出了包围p的那个'()'，我们继续看后缀操作符，发现一个'()'，我们得知p是一个指向函数的指针；
(4) 那么这是一个什么样的函数呢？那我们的继续分析前缀操作符才能得知，而此时前缀应该表示该函数的返回类型了，这是个什么返回类型呢？我们看到了'*'，说明这个返回类型是一个指针；
(5) 那么返回类型是什么样的指针呢？继续向左，我们看到了char * const，根据规则最后一条，我们得知这是一个指向字符类型的常量指针；
(6) 最后得出结论：p是一个函数指针，这个函数没有参数，其返回类型为一个指向字符类型的常量指针的指针。

通过上面的例子我们可以得出这样的'经验'：
(1) 名字的'紧邻括号'范围内，是对名字的说明，名字无非有两种情况：指针和非指针。
(*p) — 说明p是一个指针；例如：int (*p)[20];
(p) or p — 说明p不是一个指针，例如：int *p[20] int *(p)[20]; 我们在分析的时候即使p没有'紧邻括号'，我们也可以加一个'紧邻括号'帮助分析。

(2) 如果名字是个指针(非指针情况较简单)，那么跳出名字'紧邻括号'后根据后缀不同也有两种情况：
该名字一个指针数组：后缀为[]，例如 int *p[20]；
该名字一个函数指针；后缀为()，例如 int *p()；

(3) 再得知该名字的含义后，其前缀感觉就不是用来说明该名字本身了，而是用来说明名字所指的那个对象了，这里也有两种情况：
说明是什么样的数组：当说明数组时，前缀的含义就是表明数组是什么类型的了；
说明是什么样的函数：当说明函数时，前缀的含义就是表明函数的返回类型是什么了。

以上的这三点也可以说是对'优先级规则'的再理解了^_^。

[额外收获]
'优先级规则'的最后一条则可以总结const(or volatile)的用法，关于const的不同'变型'在网络上有太多的说法，而这里一句即将之概括了，这也是我看到的最好理解的一种理解方法。我们可以应用该口诀对下面三种const的'变型'进行解释：
const int * p — const直接作用于后面的类型说明符，说明p是一个指向整型常量的指针；
int * const p — const后面没有类型说明符，则const作用其左边紧跟的int*类型指针，所以p本身是一个整型常量指针，其值在第一次赋值后就不能再改变了。
int const * p — 这是个不规则的特例，按照'优先级规则'的说法它不符合任何一种情况，const后面既没有类型说明符，其左面也没有*号，这里其实我们不妨扩展规则如下：'如果const和(或)volatile关键字的后面紧跟类型说明符(如int, long等)，那么它作用于类型说明符。在其他情况下，const和(或)volatile关键字作用于其左边紧邻的指针星号，如果左面没有星号，则直接作用于其左边的紧邻的类型说明符'。按照这种扩展(不保证这种扩展的正确性哟^_^)，我们可以得出这里的p是一个指向整型常量的指针。

不知道说到这，大家体会到'异曲同工'之妙没有!^_^