UNIX Domain Socket IPC（转）

socket API原本是为网络通讯设计的，但后来在socket的框架上发展出一种IPC机制，就是UNIX Domain Socket。虽然网络socket也可用于同一台主机的进程间通讯（通过loopback地址127.0.0.1），但是UNIX Domain Socket用于IPC更有效率：不需要经过网络协议栈，不需要打包拆包、计算校验和、维护序号和应答等，只是将应用层数据从一个进程拷贝到另一个进程。这是因为，IPC机制本质上是可靠的通讯，而网络协议是为不可靠的通讯设计的。UNIX Domain Socket也提供面向流和面向数据包两种API接口，类似于TCP和UDP，但是面向消息的UNIX Domain Socket也是可靠的，消息既不会丢失也不会顺序错乱。

    UNIX Domain Socket是全双工的，API接口语义丰富，相比其它IPC机制有明显的优越性，目前已成为使用最广泛的IPC机制，比如X Window服务器和GUI程序之间就是通过UNIX Domain Socket通讯的。

    使用UNIX Domain Socket的过程和网络socket十分相似，也要先调用socket()创建一个socket文件描述符，address family指定为AF_UNIX，type可以选择SOCK_DGRAM或SOCK_STREAM，protocol参数仍然指定为0即可。

    UNIX Domain Socket与网络socket编程最明显的不同在于地址格式不同，用结构体sockaddr_un表示，网络编程的socket地址是IP地址加端口号，而UNIX Domain Socket的地址是一个socket类型的文件在文件系统中的路径，这个socket文件由bind()调用创建，如果调用bind()时该文件已存在，则bind()错误返回。

    以下程序将UNIX Domain socket绑定到一个地址。

[cpp]  view plain copy

1. #include <stdlib.h>  
2. #include <stdio.h>  
3. #include <stddef.h>  
4. #include <sys/socket.h>  
5. #include <sys/un.h>  
6.   
7. <pre class="programlisting" name="code">#include <stdlib.h>  
8. #include <stdio.h>  
9. #include <stddef.h>  
10. #include <sys/socket.h>  
11. #include <sys/un.h>  
12.   
13. int main(void)  
14. {  
15.     int fd, size;  
16.     struct sockaddr_un un;  
17.   
18.     memset(&un, 0, sizeof(un));  
19.     un.sun_family = AF_UNIX;  
20.     strcpy(un.sun_path, "foo.socket");  
21.     if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {  
22.         perror("socket error");  
23.         exit(1);  
24.     }  
25.     size = offsetof(struct sockaddr_un, sun_path) + strlen(un.sun_path);  
26.     if (bind(fd, (struct sockaddr *)&un, size) < 0) {  
27.         perror("bind error");  
28.         exit(1);  
29.     }  
30.     printf("UNIX domain socket bound\n");  
31.     exit(0);  
32. }  
33. 注意程序中的offsetof宏，它在stddef.h头文件中定义： 
34. #define offsetof(TYPE, MEMBER) ((int)&((TYPE *)0)->MEMBER) 
35. offsetof(struct sockaddr_un, sun_path) 就是取 sockaddr_un 结构体的 sun_path 成员在结构体中的偏移，也就是从结构体的第几个字节开始是sun_path成员。想一想，这个宏是如何实现这一功能的？
36. 该程序的运行结果如下。
37. $ ./a.out  
38. UNIX domain socket bound  
39. $ ls -l foo.socket  
40. srwxrwxr-x 1 user        0 Aug 22 12:43 foo.socket  
41. $ ./a.out  
42. bind error: Address already in use  
43. $ rm foo.socket  
44. $ ./a.out  
45. UNIX domain socket bound  
46. 
    
47.     以下是服务器的listen模块，与网络socket编程类似，在bind之后要listen，表示通过bind的地址（也就是socket文件）提供服务。
48. #include <stddef.h>  
49. #include <sys/socket.h>  
50. #include <sys/un.h>  
51. #include <errno.h>  
52.   
53. #define QLEN 10  
54.   
55. /* 
56.  * Create a server endpoint of a connection. 
57.  * Returns fd if all OK, <0 on error. 
58.  */  
59. int serv_listen(const char *name)  
60. {  
61.     int                 fd, len, err, rval;  
62.     struct sockaddr_un  un;  
63.   
64.     /* create a UNIX domain stream socket */  
65.     if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)  
66.         return(-1);  
67.     unlink(name);   /* in case it already exists */  
68.   
69.     /* fill in socket address structure */  
70.     memset(&un, 0, sizeof(un));  
71.     un.sun_family = AF_UNIX;  
72.     strcpy(un.sun_path, name);  
73.     len = offsetof(struct sockaddr_un, sun_path) + strlen(name);  
74.   
75.     /* bind the name to the descriptor */  
76.     if (bind(fd, (struct sockaddr *)&un, len) < 0) {  
77.         rval = -2;  
78.         goto errout;  
79.     }  
80.     if (listen(fd, QLEN) < 0) { /* tell kernel we're a server */  
81.         rval = -3;  
82.         goto errout;  
83.     }  
84.     return(fd);  
85.   
86. errout:  
87.     err = errno;  
88.     close(fd);  
89.     errno = err;  
90.     return(rval);  
91. }
92.     以下是服务器的accept模块，通过accept得到客户端地址也应该是一个socket文件，如果不是socket文件就返回错误码，如果是socket文件，在建立连接后这个文件就没有用了，调用unlink把它删掉，通过传出参数uidptr返回客户端程序的user id。
93. #include <stddef.h>  
94. #include <sys/stat.h>  
95. #include <sys/socket.h>  
96. #include <sys/un.h>  
97. #include <errno.h>  
98.   
99. int serv_accept(int listenfd, uid_t *uidptr)  
100. {  
101.     int                 clifd, len, err, rval;  
102.     time_t              staletime;  
103.     struct sockaddr_un  un;  
104.     struct stat         statbuf;  
105.   
106.     len = sizeof(un);  
107.     if ((clifd = accept(listenfd, (struct sockaddr *)&un, &len)) < 0)  
108.         return(-1);     /* often errno=EINTR, if signal caught */  
109.   
110.     /* obtain the client's uid from its calling address */  
111.     len -= offsetof(struct sockaddr_un, sun_path); /* len of pathname */  
112.     un.sun_path[len] = 0;           /* null terminate */  
113.   
114.     if (stat(un.sun_path, &statbuf) < 0) {  
115.         rval = -2;  
116.         goto errout;  
117.     }  
118.   
119.     if (S_ISSOCK(statbuf.st_mode) == 0) {  
120.         rval = -3;      /* not a socket */  
121.         goto errout;  
122.     }  
123.   
124.     if (uidptr != NULL)  
125.         *uidptr = statbuf.st_uid;   /* return uid of caller */  
126.     unlink(un.sun_path);        /* we're done with pathname now */  
127.     return(clifd);  
128.   
129. errout:  
130.     err = errno;  
131.     close(clifd);  
132.     errno = err;  
133.     return(rval);  
134. } 
135.     以下是客户端的connect模块，与网络socket编程不同的是，UNIX Domain Socket客户端一般要显式调用bind函数，而不依赖系统自动分配的地址。客户端bind一个自己指定的socket文件名的好处是，该文件名可以包含客户端的pid以便服务器区分不同的客户端。
136. #include <stdio.h>  
137. #include <stddef.h>  
138. #include <sys/stat.h>  
139. #include <sys/socket.h>  
140. #include <sys/un.h>  
141. #include <errno.h>  
142.   
143. #define CLI_PATH    "/var/tmp/"      /* +5 for pid = 14 chars */  
144.   
145. /* 
146.  * Create a client endpoint and connect to a server. 
147.  * Returns fd if all OK, <0 on error. 
148.  */  
149. int cli_conn(const char *name)  
150. {  
151.     int                fd, len, err, rval;  
152.     struct sockaddr_un un;  
153.   
154.     /* create a UNIX domain stream socket */  
155.     if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)  
156.         return(-1);  
157.   
158.     /* fill socket address structure with our address */  
159.     memset(&un, 0, sizeof(un));  
160.     un.sun_family = AF_UNIX;  
161.     sprintf(un.sun_path, "%s%05d", CLI_PATH, getpid());  
162.     len = offsetof(struct sockaddr_un, sun_path) + strlen(un.sun_path);  
163.   
164.     unlink(un.sun_path);        /* in case it already exists */  
165.     if (bind(fd, (struct sockaddr *)&un, len) < 0) {  
166.         rval = -2;  
167.         goto errout;  
168.     }  
169.   
170.     /* fill socket address structure with server's address */  
171.     memset(&un, 0, sizeof(un));  
172.     un.sun_family = AF_UNIX;  
173.     strcpy(un.sun_path, name);  
174.     len = offsetof(struct sockaddr_un, sun_path) + strlen(name);  
175.     if (connect(fd, (struct sockaddr *)&un, len) < 0) {  
176.         rval = -4;  
177.         goto errout;  
178.     }  
179.     return(fd);  
180.   
181. errout:  
182.     err = errno;  
183.     close(fd);  
184.     errno = err;  
185.     return(rval);  
186. }