第十四章 unix域套接字

- 日理万妓 2022-08-04 12:43 193阅读 0赞

unix域套接字实际上不是一个实际的协议，他只是在同一台主机上客户和服务器之间通信时，使用与在不同主机上客户和服务器间通信时相同的API

unix域套接字分为两种：字节流套接字和数据报套接字

unix域套接字的好处：

1 在同一台主机上进行通信时，是不同主机间通信的两倍

2 unix域套接口可以在同一台主机上，不同进程之间传递套接字描述符

3 unix域套接字可以向服务器提供客户的凭证（用户id或者用户组id）

unix域套接字使用的地址通常是文件系统中一个文件路径（套接口文件：APUE中的4.3节文件类型，是以s开头的），这些文件不是不同的文件，只能作为域套接字通信，不能读写

![0_1321156193Kl7A.gif][]

并且是以s开头的文件

unix域套接字的**地址结构**是：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **struct** sockaddr\_un  
2.  \{  
3.      uint8\_t sun\_len;  
4.      sa\_family\_sun\_family;//AF\_LOCAL  
5.      **char** sun\_path\[104\];//必须是以空结尾的字符串（路径+文件名）  
6.  \}

**int socketpair(int family, int type, intprotocol, int sockfd\[2\]);**

这个函数创建两个互相连接的套接字（socketfd\[2\]）family 是AF\_LOCAL, type可以是SOCK\_STREAM （字节流）或者SOCK\_DGRAM（数据报），协议是0，之后就能够或者两个互相连接的套接字

以SOCK\_STREAM调用的socketpair函数得到的套接字叫做流管道（stream pipe），是全双工的，就是这两个套接字是可读可写的

※

1在unix域套接字进行bind的时候建立套接口文件，其默认的权限值是0777，并被当前的umask修改，看上图就知道，umask是0022 的到的文件权限是0755

2关于bind创建文件中地址参数 sockaddr\_un 中的sun\_path需要是绝对路径，这样才能不用考虑相对的概念。防止客户端程序也用相对路径，但是和服务器不在同一个目录的考虑

3 connect中的地址中的路径名必须是套接口文件，而且已经被服务端绑定的，以下情况会出错：1 文件路径存在但是不是套接口文件2 路径名存在且是套接口文件，但是没有和该文件绑定的套接口3 就是type必须和服务器相同

4 connect连接unix套接口的时候的权限检查和open函数一样的

5 unix域字节流套接口和TCP一样都给进程提供一个无记录边界的字节流接口

6 unix域套接口connect发现等待队列满了，就直接返回ECONNREFUSRD错误，说连接拒绝错误

7 unix域数据报套接口和UDP一样提供一个保留记录边界的不可靠数据报服务

unix域套接字的客户端：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  \#include <sys/un.h>  
2.  \#include <stdio.h>  
3.  \#include <errno.h>  
4.  \#include <stdlib.h>  
5.  \#include <sys/types.h>  
6.  \#include <sys/socket.h>  
7.    
8.  \#define MAX\_SEND 1025  
9.  \#define UNIX\_PATH "/tmp/sinfor"  
10.   
11. **void** dump\_unix(**int** sock\_fd)  
12. \{  
13.     **char** tmp\[MAX\_SEND\] = \{0\};  
14.     **char** recv\[MAX\_SEND\] = \{0\};  
15.     **while**(fgets(tmp, MAX\_SEND, stdin) != NULL)  
16.     \{  
17.         write(sock\_fd, tmp, strlen(tmp));  
18.         read(sock\_fd, recv, MAX\_SEND);  
19.         printf("data : %s\\n", recv);  
20.         bzero(tmp,MAX\_SEND);  
21.         bzero(recv, MAX\_SEND);  
22.     \}  
23. \}  
24. **int** main(**int** argc, **char**\*\* argv)  
25. \{  
26.     **int** conn\_sock = socket(AF\_LOCAL, SOCK\_STREAM, 0);  
27.     **if**(conn\_sock == -1)  
28.     \{  
29.         perror("socket fail ");  
30.         **return** -1;  
31.     \}  
32.     **struct** sockaddr\_un addr;  
33.     bzero(&addr, **sizeof**(addr));  
34.     addr.sun\_family = AF\_LOCAL;  
35.     strcpy((**void**\*)&addr.sun\_path, UNIX\_PATH);  
36.     **if**(connect(conn\_sock, (**struct** sockaddr\*)&addr, **sizeof**(addr)) < 0)  
37.     \{  
38.         perror("connect fail ");  
39.         **return** -1;  
40.     \}  
41.     dump\_unix(conn\_sock);  
42.     close(conn\_sock);  
43.     **return** 0;  
44. \}

unix域套接字的服务器;

**\[cpp\]**  [view plain][] [copy][view plain]

1.  \#include <sys/un.h>  
2.  \#include <stdio.h>  
3.  \#include <signal.h>  
4.  \#include <errno.h>  
5.  \#include <stdlib.h>  
6.  \#include <sys/types.h>  
7.  \#include <sys/wait.h>  
8.  \#include <sys/socket.h>  
9.    
10. \#define MAX\_RECV 1025  
11. \#define UNIX\_SERV\_PATH "/tmp/sinfor"  
12. **void** client\_dump(**int** sock\_fd)  
13. \{  
14.     **char** rec\[MAX\_RECV\] = \{0\};  
15.     **int** size;  
16.     **while**((size = read(sock\_fd, rec, MAX\_RECV)) != 0)  
17.     \{  
18.         printf("\*\*\*\*\*\*\*\*\*\*1111\*\*\*\*\*\*\*\*\*\*\*\*\\n");  
19.         printf("recv data is %s\\n", rec);  
20.         write(sock\_fd, rec, size);  
21.     \}  
22. \}  
23. **void** sig\_son(**int** num)  
24. \{  
25.     printf("son is %d\\n", getpid());  
26.     wait(NULL);  
27.     //return NULL;  
28. \}  
29. **int** main(**int** argc, **char**\*\* argv)  
30. \{  
31.     **int** acc\_sock, dump\_sock;  
32.     acc\_sock = socket(AF\_LOCAL, SOCK\_STREAM, 0);  
33.     **if**(acc\_sock == -1)  
34.     \{  
35.         perror("socket func fail ");  
36.         **return** -1;  
37.     \}  
38.     **struct** sockaddr\_un ser\_addr, cli\_addr;  
39.     ser\_addr.sun\_family = AF\_LOCAL;  
40.     strcpy(ser\_addr.sun\_path, UNIX\_SERV\_PATH);  
41.     unlink(UNIX\_SERV\_PATH);  
42.     bind(acc\_sock, (**struct** sockaddr\*)&ser\_addr, **sizeof**(ser\_addr));  
43.     listen(acc\_sock, 5);  
44.     signal(SIGCHLD, sig\_son);  
45.     **while**(1)  
46.     \{  
47.         **int** len = **sizeof**(cli\_addr);  
48.         dump\_sock = accept(acc\_sock, (**struct** sockaddr\*)&cli\_addr, &len);  
49.         **if**(dump\_sock == -1)  
50.         \{  
51.             **if**(errno == EINTR)  
52.             \{  
53.                 **continue**;  
54.             \}  
55.             **else**  
56.             \{  
57.                 perror("accept fail");  
58.                 **return** -1;  
59.             \}  
60.         \}  
61.         **if**(fork() == 0)  
62.         \{  
63.             close(acc\_sock);  
64.             client\_dump(dump\_sock);       
65.             close(dump\_sock);  
66.             exit(0);  
67.         \}  
68.         close(dump\_sock);  
69.     \}  
70.     close(acc\_sock);  
71.     **return** 0;  
72. \}

这章还有用户认证和描述符通过unix套接字在不同进程之间传递，看完了，太累了，就不写了，有兴趣的自己看看unp吧

[0_1321156193Kl7A.gif]: /images/20220731/06156fa7fca640e292eddfe801d3ac5e.png
[view plain]: http://blog.csdn.net/youkuxiaobin/article/details/6965527#