如何访问其他进程的 socket 句柄？

meee

我想访问某个特定进程的socket句柄？包括读、写、关闭等。在windows下我们可以通过HOOK或者远程线程在其他进程内启动一个线程，进而安全地使用他的文件资源，但 Linux 下是否有类似的机制？我知道通过 kernel_thread 可以启动一个共享的内核线程，可是这个线程不具有固定的进程上下文，如果用死循环判断会阻塞系统，所以不太合适，最好的办法就是启动一个用户态线程，有方法否？或者另一个办法就是共享目标进程的进程上下文，从而在我的进程里直接使用目标进程的文件句柄，能做到吗？

我试过通过复制目标进程的任务结构到当前进程，确实可以关闭目标进程的socket，但目标进程在访问socket句柄时会出错，报告句柄无效，我想可能是因为任务结构是用 memcpy 复制的，所以对资源的访问上可能有些不安全的地方。实际上我希望目标进程在访问被关闭的 socket 后象正常的断线一样的返回 0 或 -1，不知道除了远程线程外还有什么好的办法。

rickxbx

Post by meee
我知道通过 kernel_thread 可以启动一个共享的内核线程，可是这个线程不具有固定的进程上下文

什么叫"固定的进程上下文"? 你所说的"共享"又是什么意思?

我试过通过复制目标进程的任务结构到当前进程，确实可以关闭目标进程的socket，但目标进程在访问socket句柄时会出错，报告句柄无效

你都关闭了,再访问自然会出错

pointer

文件句柄隶属于进程,不同进程之间不可以简单的传送文件句柄吧?

但对于socket,可以通过创建socket文件来做到通信.

meee

Post by pointer
文件句柄隶属于进程,不同进程之间不可以简单的传送文件句柄吧?

可是我通过复制任务环境确实可以关闭文件。这也是我纳闷的地方。但我想即便可以访问，也一定还有其他要注意的地方，否则怎么会出错呢？

Post by pointer
但对于socket,可以通过创建socket文件来做到通信.

我不是要和某个SOCKET通讯，SOCKET通讯这么简单的问题没必要发贴来问了，我要从自己的进程中控制其他进程的SOCKET，包括关闭它。你明白吗？

meee

Post by rickxbx
什么叫"固定的进程上下文"? 你所说的"共享"又是什么意思?

可能是我没有表达清楚。内核的进程上下文就是随调用他的进程的上下文，在多任务环境中，内核被多个进程共享，它的进程上下文在不同的进程访问的时候当然是不一样的，所以我说不是固定的。

Post by rickxbx
你都关闭了,再访问自然会出错

实际上如果我们在同一个进程中，如果你试图读取一个已经关闭的SOCKET的时候会简单地返回 0 或 -1，而不是报告文件句柄无效。

daemeon

You can send the fd between processes over a unix-socket.
please check <<UNIX® Network Programming>> for detail.

meee

Post by daemeon
You can send the fd between processes over a unix-socket.
please check <<UNIX® Network Programming>> for detail.

I think you mean to create a socket with "F_UNIX" parameter, as I haven't the book, could you kindly introduce the theory a little more detailed?

daemeon

Recv file descriptor.

1. 
   
2. #include <sys/types.h>
   
3. #include <sys/socket.h>
   
4. #include <sys/un.h>
   
5. #include <string.h>
   
6. #include <stdio.h>
   
7. #include <stdlib.h>
   
8. 
   
9. ssize_t recv_fd(int fd, void *ptr, size_t nbytes, int *recvfd)
   
10. {
    
11.         struct msghdr msg;
    
12.         struct iovec iov[1];
    
13.         ssize_t n;
    
14. 
    
15.         union {
    
16.                 struct cmsghdr cm;
    
17.                 char     control[CMSG_SPACE(sizeof (int))];
    
18.         } control_un;
    
19.         struct cmsghdr  *cmptr;
    
20.         msg.msg_control  = control_un.control;
    
21.         msg.msg_controllen = sizeof(control_un.control);
    
22. 
    
23.         msg.msg_name = NULL;
    
24.         msg.msg_namelen = 0;
    
25.         iov[0].iov_base = ptr;
    
26.         iov[0].iov_len = nbytes;
    
27.         msg.msg_iov = iov;
    
28.         msg.msg_iovlen = 1;
    
29.         if ((n = recvmsg(fd, &msg, 0)) <= 0)
    
30.                 return -1;
    
31. 
    
32.         if ((cmptr = CMSG_FIRSTHDR(&msg)) != NULL &&
    
33.                         cmptr->cmsg_len == CMSG_LEN(sizeof(int))) {
    
34.                 if (cmptr->cmsg_level != SOL_SOCKET)  
    
35.                         return -1;
    
36.                 if (cmptr->cmsg_type != SCM_RIGHTS)
    
37.                         return -1;
    
38.                 *recvfd = *((int *) CMSG_DATA(cmptr));
    
39.         } else {
    
40.                 *recvfd = -1;
    
41.         }
    
42.         return (n);
    
43. }
    
44. 
    
45. int main(int argc, char *argv[]) {
    
46.         char c;
    
47.         int fd, newfd;
    
48.         struct sockaddr_un addr;
    
49. 
    
50.         fd = socket(PF_UNIX, SOCK_STREAM, 0);
    
51.         bzero(&addr, sizeof(addr));
    
52.         addr.sun_family = PF_UNIX;
    
53.         strcpy(addr.sun_path, "/tmp/fd.socket");
    
54. 
    
55.         unlink("/tmp/fd.socket");
    
56.         bind(fd, (struct sockaddr *)&addr, sizeof(addr));
    
57. 
    
58.         listen(fd, 10);
    
59.         while((newfd = accept(fd, NULL, 0)) >= 0) {
    
60.                 int recvfd;
    
61.                 recv_fd(newfd, &c, 1, &recvfd);
    
62.                 close(newfd);
    
63.                 /* Now, we get the file descriptor. */
    
64.         }
    
65. }
    

复制代码

Send file descriptor.

1. 
   
2. #include <sys/types.h>
   
3. #include <sys/socket.h>
   
4. #include <sys/stat.h>
   
5. #include <sys/un.h>
   
6. #include <fcntl.h>
   
7. #include <string.h>
   
8. #include <stdio.h>
   
9. #include <stdlib.h>
   
10. 
    
11. ssize_t send_fd(int fd, void *ptr, size_t nbytes, int sendfd)
    
12. {
    
13.         struct msghdr msg;
    
14.         struct iovec iov[1];
    
15. 
    
16.         union {
    
17.                 struct cmsghdr cm;
    
18.                 char    control[CMSG_SPACE(sizeof(int))];
    
19.         } control_un;
    
20.         struct cmsghdr *cmptr;
    
21.         msg.msg_control = control_un.control;
    
22.         msg.msg_controllen = sizeof(control_un.control);
    
23.         cmptr = CMSG_FIRSTHDR(&msg);
    
24.         cmptr->cmsg_len = CMSG_LEN(sizeof(int));
    
25.         cmptr->cmsg_level = SOL_SOCKET;
    
26.         cmptr->cmsg_type = SCM_RIGHTS;
    
27.         *((int *) CMSG_DATA(cmptr)) = sendfd;
    
28. 
    
29.         msg.msg_name = NULL;
    
30.         msg.msg_namelen = 0;
    
31.         iov[0].iov_base = ptr;
    
32.         iov[0].iov_len = nbytes;
    
33.         msg.msg_iov = iov;
    
34.         msg.msg_iovlen = 1;
    
35.         return (sendmsg(fd, &msg, 0));
    
36. }
    
37. 
    
38. int main(int argc, char *argv[]) {
    
39.         int fd, sendfd;
    
40.         struct sockaddr_un addr;
    
41.         fd = socket (PF_UNIX, SOCK_STREAM, 0);
    
42.         bzero(&addr, sizeof(addr));
    
43.         addr.sun_family = PF_UNIX;
    
44.         strcpy(addr.sun_path, "/tmp/fd.socket");
    
45. 
    
46.         connect(fd, (struct sockaddr *)&addr, sizeof(addr));
    
47. 
    
48.         sendfd = open("/etc/inittab", O_RDONLY);
    
49.         /* send a file descriptor. */
    
50.         send_fd(fd, "", 1, sendfd);       
    
51.         return 0;
    
52. }
    

复制代码