记一次传递文件句柄引发的血案 （续）

继 记一次传递文件句柄引发的血案 之后，这个 demo 又引发了一次血案，现录如下。

这次我是在 linux 上测试文件句柄的传递，linux 上并没有 STREAMS 系统，

因此是采用 unix domain socket 的 sendmsg/recvmsg 中控制消息部分来传递句柄的。

代码的主要修改部分集中于发送 fd 与接收 fd 处，一开始代码是这样的，运行良好。

spipe_fd.c

#define MAXLINE 128
#define RIGHTSLEN CMSG_LEN(sizeof(int))
#define CREDSLEN CMSG_LEN(sizeof(struct CREDSTRUCT))
#define CONTROLLEN (RIGHTSLEN+CREDSLEN)

int send_fd (int fd, int fd_to_send)
{
    struct iovec iov[1]; 
    struct msghdr msg; 
    struct cmsghdr *cmptr = NULL; 
    char buf[2]; 

    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; 
        if (buf[1] == 0)
            buf[1] = 1; 
    } else {
        if ((cmptr = malloc(CONTROLLEN)) == NULL) {
            fprintf (stderr, "malloc memory failed\n"); 
            return -1; 
        }

        msg.msg_control = cmptr; 
        msg.msg_controllen = CONTROLLEN; 

        cmptr->cmsg_level = SOL_SOCKET; 
        cmptr->cmsg_type = SCM_RIGHTS; 
        cmptr->cmsg_len = CONTROLLEN; 

        *(int *) CMSG_DATA(cmptr) = fd_to_send; 
        buf[1] = 0; 
    }

    buf[0] = 0; 
    if (sendmsg(fd, &msg, 0) != 2) {
        free (cmptr); 
        return -1; 
    }

    free (cmptr); 
    return 0; 
}

 

以上是发送句柄部分，重点位于 37-39 行，设置了控制消息的类型与句柄的值。

sendmsg 中的数据消息部分，用来兼容出错的场景（出错时可以提供一个-1~-255的错误码，及一段描述信息），关键信息位于控制部分。

下面来看消息的接收：

int recv_fd (int fd, uid_t *uidptr, ssize_t (*userfunc) (int, const void*, size_t))
{
    struct cmsghdr *cmptr = NULL; 
    int newfd, nr, status; 
    char *ptr; 
    char buf[MAXLINE]; 
    struct iovec iov[1]; 
    struct msghdr msg; 

    status = -1; 
    newfd = -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 = malloc (CONTROLLEN)) == NULL) {
            fprintf (stderr, "malloc error\n"); 
            return -1; 
        }

        msg.msg_control = cmptr; 
        msg.msg_controllen = CONTROLLEN; 

        if ((nr = recvmsg (fd, &msg, 0)) < 0) { 
            fprintf (stderr, "recvmsg error\n"); 
            free (cmptr); 
            return -1; 
        } else if (nr == 0) {
            fprintf (stderr, "connection closed by server\n"); 
            free (cmptr); 
            return -1; 
        }

        for (ptr = buf; ptr < &buf[nr]; ) {
            if (*ptr ++ == 0) {
                if (ptr != &buf[nr-1]) {
                    fprintf (stderr, "message format error"); 
                    free (cmptr); 
                    return -1; 
                }

                status = *ptr & 0xff; 
                if (status == 0) {
                    if (msg.msg_controllen != CONTROLLEN) { 
                        fprintf (stderr, "status = 0 but no fd\n"); 
                        free (cmptr); 
                        return -1; 
                    }

                    newfd = *(int *) CMSG_DATA(cmptr); 
                } else { 
                    newfd = -status; 
                }

                nr -= 2; 
            }
        }

        free(cmptr); 
        if (nr > 0 && (*userfunc)(STDERR_FILENO, buf, nr) != nr)
            return -1; 

        if (status >= 0)
            return newfd; 
    }

    return -1; 
}

 

接收部分的重点位于 56 行，这里取得了对方传递过来的文件句柄（注意不是简单的值传递！参考上篇文章）

其它一些代码则用来处理出错信息，当出现错误时，调用 userfunc 打印错误信息 (用户一般传递 write) 。

另外接口中 uidptr 参数并没有用，这个是为将来扩展预留的。

 

使用之前的 demo （spipe_server.c / spipe_client.c）编译、运行，输出结果如下：

./spipe_server ./spipe_client
create pipe 3.4
3 7
create temp file /tmp/outliqA3i with fd 4
seek to head
send fd 4 to peer
recv fd 3, position 0
create temp file /tmp/inaLr30i with fd 4
source: 3 7

seek to head
send fd 4
recv fd 5 from peer, position 0
10

 

可以看到通过新的方式传递的文件句柄值也发生了变化（从 4 变为 3），且也需要对文件偏移进行重置，否则还会掉到之前文章说的那个坑里。

 

问题出现在增加一些代码来传递发送进程凭证（如uid）时，此时发送方需要传递两个控制子消息（分别表示句柄与凭证），接收方也需要处理两个子消息。

新的发送代码如下：

#define MAXLINE 128
#if defined(SCM_CREDS) // on BSD
#define CREDSTRUCT cmsgcred
#define CR_UID cmcred_uid
#define CREDOPT LOCAL_PEERCRED
#define SCM_CREDTYPE SCM_CREDS
#elif defined(SCM_CREDENTIALS)  // on linux
#define CREDSTRUCT ucred
#define CR_UID uid
#define CREDOPT SO_PASSCRED
#define SCM_CREDTYPE SCM_CREDENTIALS
#else
#error passing credentials is unsupported!
#endif

#define RIGHTSLEN CMSG_LEN(sizeof(int))
#define CREDSLEN CMSG_LEN(sizeof(struct CREDSTRUCT))
#define CONTROLLEN (RIGHTSLEN+CREDSLEN)


int send_fd (int fd, int fd_to_send)
{
    struct iovec iov[1]; 
    struct msghdr msg; 
    struct cmsghdr *cmptr = NULL; 
    char buf[2]; 
    struct CREDSTRUCT *credp; 
    struct cmsghdr *cmp; 

    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; 
        if (buf[1] == 0)
            buf[1] = 1; 
    } else {
        if ((cmptr = malloc(CONTROLLEN)) == NULL) {
            fprintf (stderr, "malloc memory failed\n"); 
            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; 

        cmp = CMSG_NXTHDR(&msg, cmp); 
        cmp->cmsg_level = SOL_SOCKET; 
        cmp->cmsg_type = SCM_CREDTYPE; 
        cmp->cmsg_len = CREDSLEN; 
        credp = (struct CREDSTRUCT *) CMSG_DATA(cmp); 

#  if defined(SCM_CREDENTIALS)
        // only linux need to set members of this struct !
        credp->uid = getuid (); 
        credp->gid = getegid (); 
        credp->pid = getpid (); 
#  endif
        buf[1] = 0; 
    }

    buf[0] = 0; 
    if (sendmsg(fd, &msg, 0) != 2) {
        free (cmptr); 
        return -1; 
    }

    free (cmptr); 
    return 0; 
}

 

最开始的一些宏定义，是用来区分 linux 与 bsd 上一些细节，重点在 55-64 行，这两段代码分别设置了句柄与凭证。

然后控制消息的大小 CONTROLLEN 由两部分消息的长度（RIGHTSLEN 与 CREDSLEN）累加得到，分配的内存也是这么大。

再来看接收部分：

int recv_fd (int fd, uid_t *uidptr, ssize_t (*userfunc) (int, const void*, size_t))
{
    struct cmsghdr *cmptr = NULL; 

    int newfd, nr, status; 
    char *ptr; 
    char buf[MAXLINE]; 
    struct iovec iov[1]; 
    struct msghdr msg; 

    status = -1; 
    newfd = -1; 

    const int on = -1; 
    struct cmsghdr *cmp; 
    struct CREDSTRUCT *credp; 
    if (setsockopt (fd, SOL_SOCKET, CREDOPT, &on, sizeof(int)) < 0) {
        fprintf (stderr, "setsockopt for %d failed\n", CREDOPT); 
        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 = malloc (CONTROLLEN)) == NULL) {
            fprintf (stderr, "malloc error\n"); 
            return -1; 
        }

        msg.msg_control = cmptr; 
        msg.msg_controllen = CONTROLLEN; 

        if ((nr = recvmsg (fd, &msg, 0)) < 0) { 
            fprintf (stderr, "recvmsg error\n"); 
            free (cmptr); 
            return -1; 
        } else if (nr == 0) {
            fprintf (stderr, "connection closed by server\n"); 
            free (cmptr); 
            return -1; 
        }

        for (ptr = buf; ptr < &buf[nr]; ) {
            if (*ptr ++ == 0) {
                if (ptr != &buf[nr-1]) {
                    fprintf (stderr, "message format error"); 
                    free (cmptr); 
                    return -1; 
                }

                status = *ptr & 0xff; 
                if (status == 0) {
                    if (msg.msg_controllen != CONTROLLEN) { 
                        fprintf (stderr, "status = 0 but no fd\n"); 
                        free (cmptr); 
                        return -1; 
                    }

                    for (cmp = CMSG_FIRSTHDR(&msg); cmp != NULL; cmp = CMSG_NXTHDR(&msg, cmp)) { 
                        if (cmp->cmsg_level != SOL_SOCKET) {
                            fprintf (stderr, "ignore unknown socket level %d\n", cmp->cmsg_level); 
                            continue; 
                        }

                        switch (cmp->cmsg_type) {
                            case SCM_RIGHTS:
                                newfd = *(int *) CMSG_DATA(cmp); 
                                break; 
                            case SCM_CREDTYPE:
                                credp = (struct CREDSTRUCT *) CMSG_DATA(cmp); 
                                *uidptr = credp->CR_UID; 
                                break; 
                            default:
                                fprintf (stderr, "ignore unknown msg type %d\n", cmp->cmsg_type); 
                                break; 
                        }
                    }
                } else { 
                    newfd = -status; 
                }

                nr -= 2; 
            }
        }

        free(cmptr); 
        if (nr > 0 && (*userfunc)(STDERR_FILENO, buf, nr) != nr)
            return -1; 

        if (status >= 0)
            return newfd; 
    }

    return -1; 
}

 

重点分为两个部分：

14-20 行，设置 unix domain socket 可以接收凭证信息；

65-83 行，分别读取控制消息中的句柄与凭证信息，这里我们取了发送进程的 uid 信息作为凭证返回给上层调用者；

与发送消息类似，这里使用系统提供的 CMSG_FIRSTHDR、CMSG_NXTHDR 在控制消息中遍历各个子部分。

 

重新编译、运行 demo，却发现出错了：

./spipe_server ./spipe_client
create pipe 3.4
3 7
create temp file /tmp/outgQY1Y4 with fd 4
seek to head
send fd 4 to peer
recv fd 3, uid 500, position 0
create temp file /tmp/invVgKW4 with fd 4
source: 3 7

seek to head
connection closed by server
recv fd from peer failed, error -1

 

从输出日志看，第一次从 server 发往 client 的句柄及凭证是可以的（line 7），再之后 client 处理完消息回传时，就出错了。

首先定位出错代码位置，在 client 回传这里 (send_fd)，加入一些日志：

 

        if ((cmptr = malloc(CONTROLLEN)) == NULL) {
            fprintf (stderr, "malloc memory failed\n"); 
            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; 
        fprintf (stderr, "add fd with len %d\n", RIGHTSLEN); 

        cmp = CMSG_NXTHDR(&msg, cmp); 
        cmp->cmsg_level = SOL_SOCKET; 
        cmp->cmsg_type = SCM_CREDTYPE; 
        cmp->cmsg_len = CREDSLEN; 
        credp = (struct CREDSTRUCT *) CMSG_DATA(cmp); 
        fprintf (stderr, "add credential with len %d\n", CREDSLEN); 

#  if defined(SCM_CREDENTIALS)
        // only linux need to set members of this struct !
        credp->uid = getuid (); 
        credp->gid = getegid (); 
        credp->pid = getpid (); 
        fprintf (stderr, "set uid %d, gid %d, pid %d\n", credp->uid, credp->gid, credp->pid);
#  endif
        buf[1] = 0; 

 

标黄的是新加入的输出日志，再次编译运行：

./spipe_server ./spipe_client
create pipe 3.4
3 7
create temp file /tmp/outivt2Og with fd 4
seek to head
add fd with len 16
add credential with len 24
set uid 500, gid 500, pid 12071
send fd 4 to peer
recv fd 3, uid 500, position 0
create temp file /tmp/inHqRwMg with fd 4
source: 3 7

seek to head
add fd with len 16
connection closed by server
recv fd from peer failed, error -1

 

可以看到，第一次传递时，这三条日志全都正确输出了，而回传时，只输出了第一条日志。

所以明显是在第一条日志与第二条日志之间的代码出了问题。左看右看，看不出这块有什么问题，难道系统提供的 CMSG_NXTHDR 会出错?

这边再加两条日志：

        if ((cmptr = malloc(CONTROLLEN)) == NULL) {
            fprintf (stderr, "malloc memory failed\n"); 
            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; 
        fprintf (stderr, "add fd with len %d\n", RIGHTSLEN); 
        fprintf (stderr, "cmsghdr = %d, cmsglen = %d, after align = %d, control len = %d\n", sizeof(struct cmsghdr), CREDSLEN, CMSG_ALIGN(CREDSLEN), CONTROLLEN); 

        cmp = CMSG_NXTHDR(&msg, cmp); 
        fprintf (stderr, "cmp = %p\n", cmp); 
        cmp->cmsg_level = SOL_SOCKET; 
        cmp->cmsg_type = SCM_CREDTYPE; 
        cmp->cmsg_len = CREDSLEN; 
        credp = (struct CREDSTRUCT *) CMSG_DATA(cmp); 
        fprintf (stderr, "add credential with len %d\n", CREDSLEN); 

#  if defined(SCM_CREDENTIALS)
        // only linux need to set members of this struct !
        credp->uid = getuid (); 
        credp->gid = getegid (); 
        credp->pid = getpid (); 
        fprintf (stderr, "set uid %d, gid %d, pid %d\n", credp->uid, credp->gid, credp->pid);
#  endif
        buf[1] = 0; 

 

第二条日志是主要怀疑的地方，看指针是否为空；第一条日志则是怀疑块大小计算有误，导致分配的内存不够大，指针递增时出现了范围错误，所以这里打印各种长度做验证。

再次运行后，又多了一些输出：

./spipe_server ./spipe_client
create pipe 3.4
3 7
create temp file /tmp/out7UgSYZ with fd 4
seek to head
add fd with len 16
cmsghdr = 12, cmsglen = 24, after align = 24, control len = 40
cmp = 0x9ded018
add credential with len 24
set uid 500, gid 500, pid 12100
send fd 4 to peer
recv fd 3, uid 500, position 0
create temp file /tmp/inC3nyWZ with fd 4
source: 3 7

seek to head
add fd with len 16
cmsghdr = 12, cmsglen = 24, after align = 24, control len = 40
cmp = (nil)
connection closed by server
recv fd from peer failed, error -1

 

神奇的地方出现了，同样的代码，相同的尺寸，第一次指针正常；第二次就为空了！

崩溃点找到了，但是还是一头雾水，看起来数据块都对齐了，计算也没毛病，难道是这个系统提供的宏 (CMSG_NXTHDR) 出问题了吗？

翻看头文件，找到这一段的定义 (我所在的系统，位于 /usr/include/bits/socket.h (L311))：

__EXTERN_INLINE struct cmsghdr *
__NTH (__cmsg_nxthdr (struct msghdr *__mhdr, struct cmsghdr *__cmsg))
{
  if ((size_t) __cmsg->cmsg_len < sizeof (struct cmsghdr))
    /* The kernel header does this so there may be a reason.  */
    return 0;

  __cmsg = (struct cmsghdr *) ((unsigned char *) __cmsg
                   + CMSG_ALIGN (__cmsg->cmsg_len));
  if ((unsigned char *) (__cmsg + 1) > ((unsigned char *) __mhdr->msg_control
                    + __mhdr->msg_controllen)
      || ((unsigned char *) __cmsg + CMSG_ALIGN (__cmsg->cmsg_len)
      > ((unsigned char *) __mhdr->msg_control + __mhdr->msg_controllen)))
    /* No more entries.  */
    return 0;
  return __cmsg;
}

 

这段 INLINE 函数主要包含三个判断，

1）子消息长度小于消息头长度，返回 null；

2）下一个子消息的消息头超出消息尾部，返回null；

3）下一个子消息的消息体超出消息尾部，返回null；

直接修改系统代码不方便，将这个函数拷贝到本地并重全名为 my_cmsg_nxthdr，在各个判断下面添加日志输出：

struct cmsghdr *my_cmsg_nxthdr (struct msghdr *__mhdr, struct cmsghdr *__cmsg)
{
  if ((size_t) __cmsg->cmsg_len < sizeof (struct cmsghdr)) {
    /* The kernel header does this so there may be a reason.  */
    fprintf (stderr, "in step1\n"); 
    return 0;
  }

  fprintf (stderr, "%p: cmsg_len %u, cmsg_level %d, cmsg_type %d\n", __cmsg, __cmsg->cmsg_len, __cmsg->cmsg_level, __cmsg->cmsg_type); 
  __cmsg = (struct cmsghdr *) ((unsigned char *) __cmsg + CMSG_ALIGN (__cmsg->cmsg_len));
  if ((unsigned char *) (__cmsg + 1) > ((unsigned char *) __mhdr->msg_control + __mhdr->msg_controllen)) {
      fprintf (stderr, "in step2\n"); 
      return 0; 
  }

  fprintf (stderr, "%p: cmsg_len %u, cmsg_level %d, cmsg_type %d\n", __cmsg, __cmsg->cmsg_len, __cmsg->cmsg_level, __cmsg->cmsg_type); 
  if (((unsigned char *) __cmsg + CMSG_ALIGN (__cmsg->cmsg_len) > ((unsigned char *) __mhdr->msg_control + __mhdr->msg_controllen))) {
    /* No more entries.  */
      fprintf (stderr, "in step3\n"); 
      fprintf (stderr, "msg len %d, after align %d, msg control %d\n", __cmsg->cmsg_len, CMSG_ALIGN(__cmsg->cmsg_len), __mhdr->msg_controllen); 
    return 0;
  }

  fprintf (stderr, "in final step\n"); 
  return __cmsg;
}

 

为了便于根据不同的判断条件输出日志，这里对判断条件进行了拆分。

再次运行 demo，输出如下：

./spipe_server ./spipe_client
create pipe 3.4
3 7
create temp file /tmp/outh7NhIs with fd 4
seek to head
add fd with len 16
cmsghdr = 12, cmsglen = 24, after align = 24, control len = 40
0x9336008: cmsg_len 16, cmsg_level 1, cmsg_type 1
0x9336018: cmsg_len 0, cmsg_level 0, cmsg_type 0
in final step
cmp = 0x9336018
add credential with len 24
set uid 500, gid 500, pid 12171
send fd 4 to peer
recv fd 3, uid 500, position 0
create temp file /tmp/inoJMmKs with fd 4
source: 3 7

seek to head
add fd with len 16
cmsghdr = 12, cmsglen = 24, after align = 24, control len = 40
0x904d008: cmsg_len 16, cmsg_level 1, cmsg_type 1
0x904d018: cmsg_len 500, cmsg_level 500, cmsg_type 16
in step3
msg len 500, after align 500, msg control 40
cmp = (nil)
connection closed by server
recv fd from peer failed, error -1

 

原来是第三个判断出现了问题(Line 24)！

消息总长度是 16 + 24 = 40，而这里的第二个子消息单个的长度达到 500，明显越界了。

但是第二个子消息的长度明明是 24 呀，哪里跑出来的 500 呢？

而且它的其它字段也明显不对，例如消息 level 也是 500，消息类型是 16 ！

 

初步可以确定是这块内存被弄乱了，而从前面打印的消息指针(0x904d008 与 0x904d018)看，分配的大小是没问题的，因此内存越界问题先排除掉；

其次是我们设置好的内容……等等……我们好像还没有设置第二个子消息的内容！！

……

malloc 之后没有清空的垃圾数据！

……

这也是第一次调用没问题而第二次掉坑里的原因，随着系统内存的分配回收而存在一定的随机性！

 

找到原因之后，修改就简单了，可以将 malloc 替换为 calloc，或者简单的加一句 memset 来清空内存：

        if ((cmptr = malloc(CONTROLLEN)) == NULL) {
            fprintf (stderr, "malloc memory failed\n"); 
            return -1; 
        }

        // important on linux, garbage data may mess cmsg_len fields, 
        // and cause CMSG_NXTHDR return null on protection.
        memset (cmptr, 0, CONTROLLEN); 
        msg.msg_control = cmptr; 
        msg.msg_controllen = CONTROLLEN; 

 

再次运行 demo，一切正常：

./spipe_server ./spipe_client
create pipe 3.4
3 7
create temp file /tmp/outqsTYkp with fd 4
seek to head
add fd with len 16
cmsghdr = 12, cmsglen = 24, after align = 24, control len = 40
0x814c008: cmsg_len 16, cmsg_level 1, cmsg_type 1
0x814c018: cmsg_len 0, cmsg_level 0, cmsg_type 0
in final step
cmp = 0x814c018
add credential with len 24
set uid 500, gid 500, pid 12207
send fd 4 to peer
recv fd 3, uid 500, position 0
create temp file /tmp/in3ntkip with fd 4
source: 3 7

seek to head
add fd with len 16
cmsghdr = 12, cmsglen = 24, after align = 24, control len = 40
0x8389008: cmsg_len 16, cmsg_level 1, cmsg_type 1
0x8389018: cmsg_len 0, cmsg_level 0, cmsg_type 0
in final step
cmp = 0x8389018
add credential with len 24
set uid 500, gid 500, pid 12208
send fd 4
recv fd 5, uid 500 from peer, position 0
10

 

通过这次 debug，找到了经典的 APUE 例子中的一个瑕疵 (随机性比较大，大师刚好没有遇到而已，可能你的机器也不复现)。

不过回过头来看这个场景，也不能全算在 coder 身上，我感觉系统提供的这个 CMSG_NXTHDR 宏也颇成问题：

如果我调用这个之前还没有设置下一个子消息，难道还不准我使用了么? 过多的检查反而弄巧成拙，总之一句话：差评！ 哈哈~