免费注册 查看新帖 |

Chinaunix

  平台 论坛 博客 文库
最近访问板块 发新帖
楼主: love2000

进程间能否传递socket [复制链接]

论坛徽章:
0
发表于 2007-04-17 10:48 |显示全部楼层
有亲属关系的进程可以。否则不可以。

论坛徽章:
0
发表于 2007-04-17 10:49 |显示全部楼层
原帖由 思一克 于 2007-4-17 10:48 发表
有亲属关系的进程可以。否则不可以。


如果是先fork一个子进程,然后接收连接,再传递给子进程处理,那也还是不行的吧,因为后来的连接不在子进程的空间内了.

论坛徽章:
0
发表于 2007-04-17 10:52 |显示全部楼层
必须先有sock fd, 然后fork.
converse 说的对。先fork了,两个独立的

论坛徽章:
0
发表于 2007-04-17 10:53 |显示全部楼层
mq110以前问过一个传递文件描述符的问题
用sendmsg可以做到
转一个网上的文章

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

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

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

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

  8. /* test_fdpass.c */
  9. #include <stdio.h>
  10. #include <string.h>
  11. #include <stdlib.h>

  12. #include <unistd.h>
  13. #include <sys/wait.h>
  14. #include <sys/types.h>
  15. #include <sys/stat.h>
  16. #include <fcntl.h>
  17. #include <errno.h>

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

  19. #define MY_LOGO         "-- Tony Bai"

  20. static int send_fd(int fd, int fd_to_send)
  21. {
  22.         struct iovec    iov[1];
  23.         struct msghdr   msg;
  24.         char            buf[1];

  25.         if (fd_to_send >= 0) {
  26.                 msg.msg_accrights       = (caddr_t)&fd_to_send;
  27.                 msg.msg_accrightslen    = sizeof(int);
  28.         } else {
  29.                 msg.msg_accrights       = (caddr_t)NULL;
  30.                 msg.msg_accrightslen    = 0;
  31.         }

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

  34.         iov[0].iov_base = buf;
  35.         iov[0].iov_len  = 1;
  36.         msg.msg_iov     = iov;
  37.         msg.msg_iovlen  = 1;

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

  42.         return 0;
  43. }

  44. static int recv_fd(int fd, int *fd_to_recv)
  45. {
  46.         struct iovec    iov[1];
  47.         struct msghdr   msg;
  48.         char            buf[1];

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

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

  53.         iov[0].iov_base = buf;
  54.         iov[0].iov_len  = 1;
  55.         msg.msg_iov     = iov;
  56.         msg.msg_iovlen  = 1;

  57.         if (recvmsg(fd, &msg, 0) < 0) {
  58.                 return errno;
  59.         }

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

  63.         return 0;
  64. }

  65. int x_sock_set_block(int sock, int on)
  66. {
  67.         int             val;
  68.         int             rv;

  69.         val = fcntl(sock, F_GETFL, 0);
  70.         if (on) {
  71.                 rv = fcntl(sock, F_SETFL, ~O_NONBLOCK&val);
  72.         } else {
  73.                 rv = fcntl(sock, F_SETFL, O_NONBLOCK|val);
  74.         }

  75.         if (rv) {
  76.                 return errno;
  77.         }

  78.         return 0;
  79. }

  80. int main() {
  81.         pid_t   pid;
  82.         int     sockpair[2];
  83.         int     rv;
  84.         char    fname[256];
  85.         int     fd;

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

  91.         pid = fork();
  92.         if (pid == 0) {
  93.                 /* in child */
  94.                 close(sockpair[1]);

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

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

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

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

  119.                 exit(0);
  120.         }

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

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

  133.                 fd = open(fname, O_RDWR | O_APPEND);
  134.                 if (fd < 0) {
  135.                         if (errno == ENOENT) {
  136.                                 printf("[PARENT]: can't find file '%s'\n", fname);
  137.                                 continue;
  138.                         }
  139.                         printf("[PARENT]: open file error, errno is %d\n", errno);
  140.                 }

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

  145.                 close(fd);
  146.         }

  147.         wait(NULL);
  148.         return 0;
  149. }

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

  152. [PARENT]: please enter filename:
  153. kk.log
  154. [CHILD]: append logo successfully
  155. [PARENT]: please enter filename:
  156. cc.log
  157. [PARENT]: can't find file 'cc.log'
  158. exit
  159. [CHILD]: child process exit normally!

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

论坛徽章:
0
发表于 2007-04-17 10:54 |显示全部楼层
无知者无畏啊,UNPV12e中有现成的例子

论坛徽章:
0
发表于 2007-04-17 11:45 |显示全部楼层
这是我平时用的描述符传递的库,可以参考一下
注: 进程间必须用流来传递,比如socketpair,不能用管道( 不是所有,但很多linux的实现管道并非基于流的 )

[ 本帖最后由 isnowran 于 2007-4-17 11:49 编辑 ]

transfd.tar.gz

702 Bytes, 下载次数: 214

论坛徽章:
0
发表于 2007-04-17 12:41 |显示全部楼层
to 1998 and 市长:
受教了,我回头看看,UNP第14章还没有看过~~

论坛徽章:
0
发表于 2007-04-17 13:22 |显示全部楼层
原来根本不知道可以这样使用。学习了。谢谢

论坛徽章:
0
发表于 2007-04-17 13:27 |显示全部楼层
原帖由 converse 于 2007-4-17 12:41 发表
to 1998 and 市长:
受教了,我回头看看,UNP第14章还没有看过~~

第三版的UNP是15章,15.7节

论坛徽章:
0
发表于 2007-04-29 15:22 |显示全部楼层
你如果使用fork的話,socket會復制一份到子進程中,這樣就有兩個socket了,它們是各自獨立工作的,關掉其中一個,另一個并不會被關掉
...
sock_client = accept(sock_listen, NULL, NULL);
if (fork() == 0)
{
    close(sock_listen); //子進程中不用監聽的話就關掉子進程中的監聽套接字
    ... //在子進程中操作客戶連接
    exit(0);
}
close(sock_client); //在父進程中不用處理客戶連接就關閉客戶連接套接字
...
您需要登录后才可以回帖 登录 | 注册

本版积分规则 发表回复

  

北京盛拓优讯信息技术有限公司. 版权所有 京ICP备16024965号-6 北京市公安局海淀分局网监中心备案编号:11010802020122 niuxiaotong@pcpop.com 17352615567
未成年举报专区
中国互联网协会会员  联系我们:huangweiwei@itpub.net
感谢所有关心和支持过ChinaUnix的朋友们 转载本站内容请注明原作者名及出处

清除 Cookies - ChinaUnix - Archiver - WAP - TOP