Chinaunix首页 | 论坛 | 博客

RoadLee

首页　| 　博文目录　| 　关于我

Roadlee

  • 博客访问： 33493
  • 博文数量： 14
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 165
  • 用 户 组： 普通用户
  • 注册时间： 2022-11-22 23:41
个人简介

将分享技术博文作为一种快乐，提升自己帮助他人

文章分类

全部博文（14）

文章存档

2023年（9）

2022年（5）

我的朋友
最近访客
推荐博文
相关博文
进程间通信之UNIX域套接字

分类： LINUX

2022-12-28 23:55:58

进程间通信之UNIX域套接字


  UNIX域套接字主要用于同一主机上进程间的通信，在许多应用中都会被用到。熟悉UNIX套接字的常用编程手段，在一些应用项目中遇到它就不再会感觉陌生，而自身在做软件方案设计时，使用起来也会如鱼得水。本文先通过socket API的介绍抛出UNIX域套接字，再总结UNIX域套接字的相关知识点，并针对无名、有名和抽象套接字进行实操演练，详细介绍SOCK_SEQPACKET类型UNIX文件名套接字的使用。

1. 创建socket的接口及通信过程

创建socket的接口定义如下：
int socket(int domain, int type, int protocol);
成功返回文件(套接字)描述符，错误返回-1。

其中domain是指通信域，决定了将要使用的通讯类型，如AF_INET、AF_INET6和AF_UNIX等，其定义在sys/socket.h头文件中；type指套接字类型，当前定义的类型有6种：

     类型
                                描  述
SOCK_DGRAM
 长度固定、无连接的不可靠的报文传递
SOCK_STREAM
 有序、可靠、双向的面向连接的字节流
SOCK_SEQPACKET
 长度固定、有序、可靠的面向连接的报文传递
SOCK_RAW
 原始套接字
SOCK_RDM
 提供不保证有序的可靠数据报传递
 SOCK_PACKET
 报文套接字，允许用户在设备驱动层接收和发送报文，在用户态实现协议

参数protocol通常是零，表示按给定的域和套接字类型选择默认协议。当对同一域和套接字类型支持多个协议时，可以使用protocol参数选择一个特定协议。
socket API原始目的主要是使用IP和端口号实现不同主机上进程间通信和同一主机上不同进程间通信。常用的就是使用面向连接的字节流TCP套接字和无连接面向数据报的UDP套接字。TCP网络编程通信过程如下图所示：


TCP 服务器/客户端通信过程
UDP套接字的服务器和客户端通信过程如下图所示：

UDP 服务器/客户端通信过程

2. UNIX套接字知识点梳理

domain为AF_UNIX或AF_LOCAL，则为unix套接字，用于同一主机上进程间通信。第三个参数表示协议，对于Unix域套接字来说，其一般设置成0。UNIX套接字的知识点见如下思维导图：


(1) UNIX域套接字的种类

UNIX域socket可以是未命名的，可以是绑定到文件系统中的文件，也可以是独立于文件系统的抽象命名空间。

UNIX套接字的地址结构如下：

点击(此处)折叠或打开

  1. struct sockaddr_un {
  2.    sa_family_t sun_family; /* AF_UNIX */
  3.    char sun_path[108]; /* Pathname */
  4. };
不同UNIX域套接字的地址结构不同：
  • Pathname: sun_path[]的长度不可超过108，并且必须带有结束符。使用bind()将UNIX域套接字绑定到文件系统路径名。它的长度等于sizeof(sa_family_t) + strlen(sun_path) + 1。该地址结构具有较好的扩展性。文件命名的socket在使用完后，需要unlink该套接字，否则可能会导致绑定套接字失败的问题。
  • Unnamed: 没有用bind()绑定文件路径。socketpair()创建的是未命名的。当一个未命名的地址返回时，它的长度是sizeof(sa_family_t)。
  • Abstract: 与命名化的socket的差异是，sun_path[0]='\0'。socket名字没有文件系统路径。获取一个抽象socket的地址时，其长度为sizeof(sa_family_t)+2，socket的名字为sun_path的{BANNED}首选addrlen-sizeof(sa_family_t)字节。抽象套接字随着所有引用套接字的引用关闭而自动消失。

(2) UNIX域套接字支持的类型

支持三种类型的套接字
  • SOCK_DGRAM：用于保留消息边界的面向数据报(无连接)的套接字(在大多数UNIX实现中，UNIX域数据报套接字总是可靠的，并且不会对数据报重新排序)；
  • SOCK_STREAM：用于面向流(或面向连接)的套接字。
  • SOCK_SEQPACKET：对于面向连接的序列数据包套接字，将保留消息边界，并按照发送的顺序传递消息。

UNIX的流套接字和数据报套接字与AF_INET的socket的差异：由于都是在本机通过内核通信，所以SOCK_STREAM和SOCK_DGRAM都是可靠的，不会丢包也不会出现发送包的次序和接收包的次序不一致的问题。
UNIX流套接字和数据报套接字的差异：SOCK_STREAM无论发送多大的数据都不会被截断，而对于SOCK_DGRAM来说，如果发送的数据超过了一个报文的{BANNED}{BANNED}{BANNED}最佳佳佳大长度，则数据会被截断。
UNIX域套接字的上SOCK_DGRAM和SOCK_SEQPACKET主要区别：

  • SOCK_DGRAM是“面向数据报”，SOCK_SEQPACKET是“面向连接”。
  • 使用SOCK_DGRAM类型，不需要创建连接(例如connect到服务器)，只需将数据包发送到服务器套接字，接口传输消息。但如果服务器需要回复消息时，客户端也需创建自己的unix套接字，让服务器知道这个套接字，然后服务器方可向它回复消息(强行按照网络数据报类型的流程处理，执行会报错误：Transport endpoint is not connected)。这对应用而言并不友好，适用于仅需客户端发送消息给服务端，无需服务器回复的场景。
  • 对于以上场景，可使用面向连接的方法，SOCK_SEQPACKET就是首选。

3. UNIX套接字实操

(1) 无名套接字

使用socketpair()函数可创建一对未命名的套接字，函数定义如下：
int socketpair(int domain, int type, int protocol, int sv[2]);

创建一对未命名的连接的socket，返回值sv[0]和sv[1]是被引用与新socket的文件描述符。成功时返回0； 失败时返回-1，errno被设置，sv[]不会被修改。

无名套接字优点类似与管道的用法，使用示例：

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>

  5. #include <sys/types.h>
  6. #include <sys/socket.h>

  8. int main()
  9. {
  10.     int fd[2];
  11.     int ret;

  13.     ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fd);
  14.     if (ret == -1) {
  15.         perror("socketpair");
  16.         return -1;
  17.     }

  19.     pid_t pid = fork();
  20.     if (pid == 0) { // sub process
  21.         int val;
  22.         close(fd[0]);
  23.         while (1) {
  24.             read(fd[1], &val, sizeof(val));
  25.             val++;
  26.             write(fd[1], &val, sizeof(val));
  27.         }
  28.     } else {
  29.         close(fd[1]);
  30.         int val = 0;

  32.         while (1) {
  33.             sleep(1);
  34.             val++;
  35.             printf("send value:%d\n", val);
  36.             write(fd[0], &val, sizeof(val));
  37.             read(fd[0], &val, sizeof(val));
  38.             printf("recv value:%d\n", val);
  39.         }        
  40.     }

  42.     return 0;
  43. }

(2) 抽象套接字

抽象套接字sun_path[0]='\0'，文件系统下无文件名。套接字会随着文件描述符关闭而自动关闭，使用示例见如下客户端和服务器端代码：
server端：

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <unistd.h>

  6. #include <sys/types.h>
  7. #include <sys/socket.h>
  8. #include <sys/un.h>

  10. #define BUFF_SIZE 256

  12. int main(int argc, char **argv)
  13. {
  14.     struct sockaddr_un saddr;
  15.     int server_fd, client_fd;
  16.     char buf[BUFF_SIZE];
  17.     int cnt = 0;
  18.     int ret;

  20.     // 1. 创建流套接字
  21.     server_fd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
  22.     if (server_fd == -1) {
  23.         perror("fail to create socket.\n");
  24.         return -1;
  25.     }

  27.     // 2. 编写服务器地址信息
  28.     memset(&saddr, 0, sizeof(saddr));
  29.     saddr.sun_family = AF_UNIX;
  30.     saddr.sun_path[0] = '\0';

  32.     // 3. 绑定监听套接字和服务器地址
  33.     ret = bind(server_fd, (struct sockaddr*)&saddr, sizeof(saddr));
  34.     if (ret == -1) {
  35.         perror("bind failed!");
  36.         close(server_fd);
  37.         return -1;
  38.     }

  40.     // 4. 设置监听客户端连接队列上限
  41.     ret = listen(server_fd, 1);
  42.     if (ret == -1) {
  43.         perror("listen failed!");
  44.         goto out;
  45.     }

  47.     // 5. 等待客户端链接
  48.     client_fd = accept(server_fd, NULL, NULL);
  49.     if (client_fd == -1) {
  50.         perror("accept client failed!");
  51.         goto out;
  52.     }

  54.     struct sockaddr_un skaddr = {0};
  55.     socklen_t sklen;
  56.     ret = getsockname(server_fd, (struct sockaddr *)&skaddr, &sklen);
  57.     printf("pathname=%s len=%d sizeof(sun_family)=%lu\n", skaddr.sun_path, sklen, sizeof(skaddr.sun_family));

  59.     char data[BUFF_SIZE] = "欢迎连接，请输入数据\n";
  60.     write(client_fd, data, strlen(data));

  62.     while (1) {
  63.         memset(buf, 0, sizeof(buf));
  64.         int size = read(client_fd, buf, sizeof(buf));
  65.         if (size == -1) {
  66.             perror("read error");
  67.             goto close_cfd;
  68.         }
  69.         if (strncmp(buf, "quit", 4) == 0)
  70.             goto close_cfd;

  72.         printf("From %d: %s\n", server_fd, buf);
  73.         memset(data, 0, sizeof(data));
  74.         sprintf(data, "接收到数据次数%d", cnt);
  75.         size = write(client_fd, data, strlen(data));
  76.         if (size == -1) {
  77.             perror("write");
  78.             goto close_cfd;
  79.         }
  80.         cnt += 1;
  81.     }

  83. close_cfd:
  84.     close(client_fd);

  86. out:
  87.     close(server_fd);

  89.     return ret;
  90. }
client端：

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <unistd.h>
  4. #include <sys/types.h>
  5. #include <sys/socket.h>
  6. #include <sys/un.h>

  8. #define BUFF_SIZE 1024

  10. int main(int argc, char **argv)
  11. {
  12.     struct sockaddr_un saddr;
  13.     char buf[BUFF_SIZE];
  14.     int client_fd;
  15.     int ret;
  16.     int size;

  18.     // 1. 创建流套接字
  19.     client_fd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
  20.     if (client_fd == -1) {
  21.         perror("fail to create socket.\n");
  22.         return -1;
  23.     }

  25.     // 2. 填充服务器地址信息并连接服务器
  26.     memset(&saddr, 0, sizeof(saddr));
  27.     saddr.sun_family = AF_UNIX;
  28.     saddr.sun_path[0] = '\0';
  29.     ret = connect(client_fd, (struct sockaddr*)&saddr, sizeof(saddr));
  30.     if (ret == -1) {
  31.         perror("connect failed!\n");
  32.         close(client_fd);
  33.         return -1;
  34.     }

  36.     // 3. 读写数据
  37.     ret = read(client_fd, buf, sizeof(buf));
  38.     if (ret == -1) {
  39.         printf("server is offline!\n");
  40.         goto out;
  41.     }
  42.     printf("receive:%s", buf);

  44.     while (1) {
  45.         memset(buf, 0, sizeof(buf));
  46.         fgets(buf, sizeof(buf), stdin);

  48.         size = write(client_fd, buf, strlen(buf));
  49.         if (size == -1) {
  50.             perror("wirte error");
  51.             goto out;
  52.         }
  53.         if (strncmp(buf, "quit", 4) == 0)
  54.             break;
  55.     
  56.         memset(buf, 0, sizeof(buf));
  57.         size = read(client_fd, buf, sizeof(buf));
  58.         if (size == -1) {
  59.             perror("server is offline!");
  60.             goto out;
  61.         }
  62.         printf("receive:%s\n", buf);
  63.     }

  65. out:
  66.     close(client_fd);

  68.     return 0;
  69. }

(3)文件名套接字

文件名套接字创建时会在指定的文件路径下创建socket文件，该socket文件创建后，可通过chmod或chown修改。如前面所述文件名套接字可以是SOCK_DGRAM、SOCK_STREAM和SOCK_SEQPACKET类型。无连接的数据报套接字和面向连接的字节流套接字和网络套接字中的用法是类似的，但需要注意的是UNIX域的无连接数据报套接字的服务器端无法向客户端回复数据。SOCK_SEQPACKET类型具有前两者的共同属性，关于这个的使用说明并不多。下面就以SEQPACKET类型的套接字为例，构造了一个支持多个客户端同时连接的服务器端。
server端：

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stdint.h>
  4. #include <signal.h>
  5. #include <stdbool.h>
  6. #include <unistd.h>
  7. #include <pthread.h>

  9. #include <sys/prctl.h>
  10. #include <sys/types.h>
  11. #include <sys/socket.h>
  12. #include <sys/un.h>

  14. #define MAX_CLIENT_NUM 1
  15. #define SOCKET_NAME "/tmp/my_socket"
  16. #define MAX_CONNECTIONS 10

  18. struct socket {
  19.     int sock;
  20.     char path[sizeof(((struct sockaddr_un *)0)->sun_path)];
  21.     unsigned int num_clients;
  22. };

  24. struct socket g_socket;
  25. bool force_quit = false;

  27. static void
  28. signal_handler(int signum)
  29. {
  30.     if (signum == SIGINT || signum == SIGTERM) {
  31.         printf("\n\nSignal %d received, preparing to exit...\n",
  32.                 signum);
  33.         force_quit = true;
  34.     }
  35. }

  37. static int create_socket(void)
  38. {
  39.     struct sockaddr_un saddr;
  40.     unsigned int conns;
  41.     int server_fd;
  42.     pthread_t th;
  43.     int ret;

  45.     // 1. 创建流套接字
  46.     server_fd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
  47.     if (server_fd == -1) {
  48.         perror("fail to create socket.\n");
  49.         return -1;
  50.     }

  52.     // 2. 编写服务器地址信息
  53.     memset(&saddr, 0, sizeof(saddr));
  54.     saddr.sun_family = AF_UNIX;
  55.     sprintf(saddr.sun_path, "%s", SOCKET_NAME);

  57.     // 3. 绑定监听套接字和服务器地址
  58.     ret = bind(server_fd, (struct sockaddr*)&saddr, sizeof(saddr));
  59.     if (ret == -1) {
  60.         perror("bind failed!");
  61.         close(server_fd);
  62.         return -1;
  63.     }

  65.     // 4. 设置监听客户端连接队列上限
  66.     ret = listen(server_fd, MAX_CLIENT_NUM);
  67.     if (ret == -1) {
  68.         perror("listen failed!");
  69.         goto out;
  70.     }

  72.     g_socket.sock = server_fd;
  73.     memcpy(g_socket.path, SOCKET_NAME, sizeof(SOCKET_NAME));
  74.     return 0;

  76. out:
  77.     close(g_socket.sock);
  78.     unlink(SOCKET_NAME);

  80.     return ret;
  81. }

  83. static void *client_handler(void *cfd)
  84. {
  85.     unsigned int cnt = 0;
  86.     unsigned int conns;
  87.     int sock_id = (int)(uintptr_t)cfd;
  88.     char buffer[1024];
  89.     int bytes;

  91.     char data[256] = "欢迎连接，请输入命令\n";
  92.     bytes = write(sock_id, data, strlen(data));
  93.     if (bytes < 0) {
  94.         close(sock_id);
  95.         return NULL;
  96.     }

  98.     char name[128];
  99.     sprintf(name, "client-%lu", pthread_self());
  100.     prctl(PR_SET_NAME, name);

  102.     bytes = read(sock_id, buffer, sizeof(buffer) - 1);
  103.     while (bytes > 0) {
  104.         if (strncmp(buffer, "client_num", strlen("client_num")) == 0) {
  105.             conns = __atomic_load_n(&g_socket.num_clients,
  106.                                     __ATOMIC_RELAXED);
  107.             sprintf(buffer, "Current client num: %u", conns);
  108.         } else {
  109.             sprintf(buffer, "Total received request count = %u", cnt);
  110.             cnt++;
  111.         }
  112.         write(sock_id, buffer, strlen(buffer));

  114.         bytes = read(sock_id, buffer, sizeof(buffer) - 1);
  115.     }
  116.     printf("thread-Id=%ld exit\n", pthread_self());
  117.     close(sock_id);
  118.     __atomic_sub_fetch(&g_socket.num_clients, 1, __ATOMIC_RELAXED);

  120.     return NULL;
  121. }

  123. static void* socket_listener(void *socket)
  124. {
  125.     struct socket *s = (struct socket *)socket;
  126.     unsigned int conns;
  127.     int client_fd;
  128.     pthread_t th;
  129.     int ret;

  131.     prctl(PR_SET_NAME, "socket_listener");
  132.     while (1) {
  133.         client_fd = accept(g_socket.sock, NULL, NULL);
  134.         if (client_fd == -1) {
  135.             perror("accept client failed!");
  136.             return NULL;
  137.         }

  139.         conns = __atomic_load_n(&g_socket.num_clients, __ATOMIC_RELAXED);
  140.         if (conns == MAX_CONNECTIONS) {
  141.             close(client_fd);
  142.             continue;
  143.         }

  145.         __atomic_add_fetch(&g_socket.num_clients, 1, __ATOMIC_RELAXED);
  146.         ret = pthread_create(&th, NULL, client_handler, (void *)(uintptr_t)client_fd);
  147.         if (ret != 0) {
  148.             printf("fail to create client handler thread.\n");
  149.             __atomic_sub_fetch(&g_socket.num_clients, 1, __ATOMIC_RELAXED);
  150.             return NULL;
  151.         }
  152.         printf("create a thread id=%lu\n", th);
  153.         pthread_detach(th);
  154.     }

  156.     return NULL;
  157. }

  159. static void unlink_sockets(void)
  160. {
  161.     if (g_socket.path[0]) {
  162.         close(g_socket.sock);
  163.         unlink(SOCKET_NAME);
  164.     }

  166.     printf("unlink exit...\n");
  167. }

  169. int main(int argc, char **argv)
  170. {
  171.     pthread_t th;
  172.     int ret;

  174.     ret = create_socket();
  175.     if (ret != 0)
  176.         return ret;

  178.     signal(SIGINT, signal_handler);
  179.     signal(SIGTERM, signal_handler);
  180.     ret = pthread_create(&th, NULL, socket_listener, &g_socket);
  181.     if (ret != 0) {
  182.         printf("fail to create socket listener thread.\n");
  183.         return ret;
  184.     }
  185.     pthread_detach(th);
  186.     atexit(unlink_sockets);

  188.     while (!force_quit);

  190.     return 0;
  191. }

服务器端代码说明：
1) 使用listen()监听套接字时设置队列上限为1，对于SOCK_SEQPACKET类型套接字实际可连接的不是这个上限，示例中是另外增加MAX_CONNECTIONS宏控制连接数。
2) 服务器端通过宏控制总共支持MAX_CONNECTIONS个客户端同时上线，每个客户端上线后会拉起一个客户端处理线程。该处理线程支持简单的命令响应：

a) 当客户输入client_num查询当前在线的客户端数量；
b）客户端输入其他字符串后，则返回服务端处理该类命令的个数。当客户端下线时，该处理线程就自动结束。

3) 注意：accept是一个阻塞等待客户端接入的函数，如果在main函数中直接使用while循环等待，ctrl+C信号将很难将进程终止掉。而创建的socket监听线程，很好的处理了这一点，使用pthread_detach()将子线程与主线程分离，主线程无需等到子线程结束回收子线程的资源，而是子线程结束时自己释放自身的资源。

client端：

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <unistd.h>
  3. #include <sys/types.h>
  4. #include <sys/socket.h>
  5. #include <sys/un.h>

  7. #define BUFF_SIZE 1024
  8. #define SOCKET_NAME "/tmp/my_socket"

  10. int main(int argc, char **argv)
  11. {
  12.     struct sockaddr_un saddr;
  13.     char buf[BUFF_SIZE];
  14.     int client_fd;
  15.     int ret;
  16.     int size;

  18.     // 1. 创建流套接字
  19.     client_fd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
  20.     if (client_fd == -1) {
  21.         perror("fail to create socket.\n");
  22.         return -1;
  23.     }

  25.     // 2. 填充服务器地址信息并连接服务器
  26.     memset(&saddr, 0, sizeof(saddr));
  27.     saddr.sun_family = AF_UNIX;
  28.     strncpy(saddr.sun_path, SOCKET_NAME, sizeof(saddr.sun_path) - 1);
  29.     ret = connect(client_fd, (struct sockaddr*)&saddr, sizeof(saddr));
  30.     if (ret == -1) {
  31.         perror("connect failed!\n");
  32.         close(client_fd);
  33.         return -1;
  34.     }

  36.     // 3. 读写数据
  37.     ret = read(client_fd, buf, sizeof(buf));
  38.     if (ret == -1) {
  39.         printf("server is offline!\n");
  40.         goto out;
  41.     }
  42.     printf("From server: %s", buf);

  44.     while (1) {
  45.         memset(buf, 0, sizeof(buf));
  46.         fgets(buf, sizeof(buf), stdin);
  47.         if (strncmp(buf, "quit", 4) == 0)
  48.             break;
  49.         size = write(client_fd, buf, strlen(buf));
  50.         if (size == -1) {
  51.             perror("wirte error");
  52.             goto out;
  53.         }

  55.         memset(buf, 0, sizeof(buf));
  56.         size = read(client_fd, buf, sizeof(buf));
  57.         if (size == -1) {
  58.             perror("server is offline!");
  59.             goto out;
  60.         }
  61.         printf("From server: %s\n", buf);
  62.     }

  64. out:
  65.     close(client_fd);

  67.     return 0;
  68. }

分别编译服务器段和客户端代码，得到服务器端app: server和客户端app：client。

运行测试：

a. 先运行服务器端app，再连续运行三个client，并查询当前线上客户端的数量和其他命令测试，结果如下。

在第三个运行的客户端中查询当前线上客户端的数量和其他命令测试。服务器端结果打印如下:


显示当前有三个客户端在线，返回处理非查询客户端在线数的命令个数。

b. 再启动一个客户端并查询当前在线的客户端数为4：

c. 从另外一个客户端查询当前在线的客户端数目为4，退出第4个客户端，再查询客户端在线数为3，操作如下：


d. 将所有客户端退出，server端有对应线程退出的打印。server端ctrl+C终止后，关闭了socket并unlink套接字文件。


总结，UNIX域套接字主要用于同一主机上进程间的通信，在许多应用中都被用到。SOCK_SEQPACKET类型的文件名套接字用法是比较常见的，例如可以通过socket通信方式查询进程的一些信息。


阅读(1845) | 评论(0) | 转发(0) |
0

上一篇：DPDK中的总线、设备和驱动及设备探测

下一篇：DPDK中Telemetry库介绍及使用

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6