Linux下的IPC－UNIX Domain Socket【转】

本文转载自：http://blog.csdn.net/guxch/article/details/7041052

一、 概述

UNIX Domain Socket是在socket架构上发展起来的用于同一台主机的进程间通讯（IPC），它不需要经过网络协议栈，不需要打包拆包、计算校验和、维护序号和应答等，只是将应用层数据从一个进程拷贝到另一个进程。UNIX Domain Socket有SOCK_DGRAM或SOCK_STREAM两种工作模式，类似于UDP和TCP，但是面向消息的UNIX Domain Socket也是可靠的，消息既不会丢失也不会顺序错乱。

UNIX Domain Socket可用于两个没有亲缘关系的进程，是全双工的，是目前使用最广泛的IPC机制，比如X Window服务器和GUI程序之间就是通过UNIX Domain Socket通讯的。

二、工作流程

UNIX Domain socket与网络socket类似，可以与网络socket对比应用。

上述二者编程的不同如下：

• address family为AF_UNIX
• 因为应用于IPC，所以UNIXDomain socket不需要IP和端口，取而代之的是文件路径来表示“网络地址”。这点体现在下面两个方面。
• 地址格式不同，UNIXDomain socket用结构体sockaddr_un表示，是一个socket类型的文件在文件系统中的路径，这个socket文件由bind()调用创建，如果调用bind()时该文件已存在，则bind()错误返回。
• UNIX Domain Socket客户端一般要显式调用bind函数，而不象网络socket一样依赖系统自动分配的地址。客户端bind的socket文件名可以包含客户端的pid，这样服务器就可以区分不同的客户端。

UNIX Domain socket的工作流程简述如下（与网络socket相同）。

服务器端：创建socket—绑定文件（端口）—监听—接受客户端连接—接收/发送数据—…—关闭

客户端：创建socket—绑定文件（端口）—连接—发送/接收数据—…—关闭

三、阻塞和非阻塞（SOCK_STREAM方式）

读写操作有两种操作方式：阻塞和非阻塞。

1.阻塞模式下

阻塞模式下，发送数据方和接收数据方的表现情况如同命名管道，参见本人文章“Linux下的IPC－命名管道的使用（http://blog.csdn.NET/guxch/article/details/6828452）”

2.非阻塞模式

在send或recv函数的标志参数中设置MSG_DONTWAIT，则发送和接收都会返回。如果没有成功，则返回值为-1，errno为EAGAIN 或 EWOULDBLOCK。

四、测试代码

 服务器端

1. #include <stdio.h>
2. #include <sys/stat.h>
3. #include <sys/socket.h>
4. #include <sys/un.h>
5. #include <errno.h>
6. #include <stddef.h>
7. #include <string.h>
8. // the max connection number of the server
9. #define MAX_CONNECTION_NUMBER 5
10. /* * Create a server endpoint of a connection. * Returns fd if all OK, <0 on error. */
11. int unix_socket_listen(const char *servername)
12. {
13. int fd;
14. struct sockaddr_un un;
15. if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
16. {
17. return(-1);
18. }
19. int len, rval;
20. unlink(servername);               /* in case it already exists */
21. memset(&un, 0, sizeof(un));
22. un.sun_family = AF_UNIX;
23. strcpy(un.sun_path, servername);
24. len = offsetof(struct sockaddr_un, sun_path) + strlen(servername);
25. /* bind the name to the descriptor */
26. if (bind(fd, (struct sockaddr *)&un, len) < 0)
27. {
28. rval = -2;
29. }
30. else
31. {
32. if (listen(fd, MAX_CONNECTION_NUMBER) < 0)
33. {
34. rval =  -3;
35. }
36. else
37. {
38. return fd;
39. }
40. }
41. int err;
42. err = errno;
43. close(fd);
44. errno = err;
45. return rval;
46. }
47. int unix_socket_accept(int listenfd, uid_t *uidptr)
48. {
49. int clifd, len, rval;
50. time_t staletime;
51. struct sockaddr_un un;
52. struct stat statbuf;
53. len = sizeof(un);
54. if ((clifd = accept(listenfd, (struct sockaddr *)&un, &len)) < 0)
55. {
56. return(-1);
57. }
58. /* obtain the client's uid from its calling address */
59. len -= offsetof(struct sockaddr_un, sun_path);  /* len of pathname */
60. un.sun_path[len] = 0; /* null terminate */
61. if (stat(un.sun_path, &statbuf) < 0)
62. {
63. rval = -2;
64. }
65. else
66. {
67. if (S_ISSOCK(statbuf.st_mode) )
68. {
69. if (uidptr != NULL) *uidptr = statbuf.st_uid;    /* return uid of caller */
70. unlink(un.sun_path);       /* we're done with pathname now */
71. return clifd;
72. }
73. else
74. {
75. rval = -3;     /* not a socket */
76. }
77. }
78. int err;
79. err = errno;
80. close(clifd);
81. errno = err;
82. return(rval);
83. }
84. void unix_socket_close(int fd)
85. {
86. close(fd);
87. }
88. int main(void)
89. {
90. int listenfd,connfd;
91. listenfd = unix_socket_listen("foo.sock");
92. if(listenfd<0)
93. {
94. printf("Error[%d] when listening...\n",errno);
95. return 0;
96. }
97. printf("Finished listening...\n",errno);
98. uid_t uid;
99. connfd = unix_socket_accept(listenfd, &uid);
100. unix_socket_close(listenfd);
101. if(connfd<0)
102. {
103. printf("Error[%d] when accepting...\n",errno);
104. return 0;
105. }
106. printf("Begin to recv/send...\n");
107. int i,n,size;
108. char rvbuf[2048];
109. for(i=0;i<2;i++)
110. {
111. //===========接收==============
112. size = recv(connfd, rvbuf, 804, 0);
113. if(size>=0)
114. {
115. // rvbuf[size]='\0';
116. printf("Recieved Data[%d]:%c...%c\n",size,rvbuf[0],rvbuf[size-1]);
117. }
118. if(size==-1)
119. {
120. printf("Error[%d] when recieving Data:%s.\n",errno,strerror(errno));
121. break;
122. }
123. /*
124. //===========发送==============
125. memset(rvbuf, 'c', 2048);
126. size = send(connfd, rvbuf, 2048, 0);
127. if(size>=0)
128. {
129. printf("Data[%d] Sended.\n",size);
130. }
131. if(size==-1)
132. {
133. printf("Error[%d] when Sending Data.\n",errno);
134. break;
135. }
136. */
137. sleep(30);
138. }
139. unix_socket_close(connfd);
140. printf("Server exited.\n");
141. }

客户端代码

1. #include <stdio.h>
2. #include <stddef.h>
3. #include <sys/stat.h>
4. #include <sys/socket.h>
5. #include <sys/un.h>
6. #include <errno.h>
7. #include <string.h>
8. /* Create a client endpoint and connect to a server.   Returns fd if all OK, <0 on error. */
9. int unix_socket_conn(const char *servername)
10. {
11. int fd;
12. if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)    /* create a UNIX domain stream socket */
13. {
14. return(-1);
15. }
16. int len, rval;
17. struct sockaddr_un un;
18. memset(&un, 0, sizeof(un));            /* fill socket address structure with our address */
19. un.sun_family = AF_UNIX;
20. sprintf(un.sun_path, "scktmp%05d", getpid());
21. len = offsetof(struct sockaddr_un, sun_path) + strlen(un.sun_path);
22. unlink(un.sun_path);               /* in case it already exists */
23. if (bind(fd, (struct sockaddr *)&un, len) < 0)
24. {
25. rval=  -2;
26. }
27. else
28. {
29. /* fill socket address structure with server's address */
30. memset(&un, 0, sizeof(un));
31. un.sun_family = AF_UNIX;
32. strcpy(un.sun_path, servername);
33. len = offsetof(struct sockaddr_un, sun_path) + strlen(servername);
34. if (connect(fd, (struct sockaddr *)&un, len) < 0)
35. {
36. rval= -4;
37. }
38. else
39. {
40. return (fd);
41. }
42. }
43. int err;
44. err = errno;
45. close(fd);
46. errno = err;
47. return rval;
48. }
49. void unix_socket_close(int fd)
50. {
51. close(fd);
52. }
53. int main(void)
54. {
55. srand((int)time(0));
56. int connfd;
57. connfd = unix_socket_conn("foo.sock");
58. if(connfd<0)
59. {
60. printf("Error[%d] when connecting...",errno);
61. return 0;
62. }
63. printf("Begin to recv/send...\n");
64. int i,n,size;
65. char rvbuf[4096];
66. for(i=0;i<10;i++)
67. {
68. /*
69. //=========接收=====================
70. size = recv(connfd, rvbuf, 800, 0);   //MSG_DONTWAIT
71. if(size>=0)
72. {
73. printf("Recieved Data[%d]:%c...%c\n",size,rvbuf[0],rvbuf[size-1]);
74. }
75. if(size==-1)
76. {
77. printf("Error[%d] when recieving Data.\n",errno);
78. break;
79. }
80. if(size < 800) break;
81. */
82. //=========发送======================
83. memset(rvbuf,'a',2048);
84. rvbuf[2047]='b';
85. size = send(connfd, rvbuf, 2048, 0);
86. if(size>=0)
87. {
88. printf("Data[%d] Sended:%c.\n",size,rvbuf[0]);
89. }
90. if(size==-1)
91. {
92. printf("Error[%d] when Sending Data:%s.\n",errno,strerror(errno));
93. break;
94. }
95. sleep(1);
96. }
97. unix_socket_close(connfd);
98. printf("Client exited.\n");
99. }

五、 讨论

通过实际测试，发现UNIXDomain Socket与命名管道在表现上有很大的相似性，例如，UNIX Domain Socket也会在磁盘上创建一个socket类型文件；如果读端进程关闭了，写端进程“写数据”时，有可能使进程异常退出，等等。查阅有关文档，摘录如下：

Send函数
当调用该函数时，send先比较待发送数据的长度len和套接字s的发送缓冲的 长度，如果len大于s的发送缓冲区的长度，该函数返回SOCKET_ERROR；如果len小于或者等于s的发送缓冲区的长度，那么send先检查协议是否正在发送s的发送缓冲中的数据，如果是就等待协议把数据发送完，如果协议还没有开始发送s的发送缓冲中的数据或者s的发送缓冲中没有数据，那么 send就比较s的发送缓冲区的剩余空间和len，如果len大于剩余空间大小send就一直等待协议把s的发送缓冲中的数据发送完，如果len小于剩余空间大小send就仅仅把buf中的数据copy到剩余空间里（注意并不是send把s的发送缓冲中的数据传到连接的另一端的，而是协议传的，send仅仅是把buf中的数据copy到s的发送缓冲区的剩余空间里）。如果send函数copy数据成功，就返回实际copy的字节数，如果send在copy数据时出现错误，那么send就返回SOCKET_ERROR；如果send在等待协议传送数据时网络断开的话，那么send函数也返回SOCKET_ERROR。
要注意send函数把buf中的数据成功copy到s的发送缓冲的剩余空间里后它就返回了，但是此时这些数据并不一定马上被传到连接的另一端。如果协议在后续的传送过程中出现网络错误的话，那么下一个Socket函数就会返回SOCKET_ERROR。（每一个除send外的Socket函数在执行的最开始总要先等待套接字的发送缓冲中的数据被协议传送完毕才能继续，如果在等待时出现网络错误，那么该Socket函数就返回 SOCKET_ERROR）
注意：在Unix系统下，如果send在等待协议传送数据时网络断开的话，调用send的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。

Recv函数与send类似，看样子系统在实现各种IPC时，有些地方是复用的。