linux本机进程间通信之UDS

本机进程间通信有很多方式,百度有太多的文章来介绍相关,大致有消息队列、共享内存、socket等、这里重点介绍下socket(套接字)的一种用法,一般情况下在socket是用于不同主机间的通信,但是当通信双方在同一台主机上该如何利用socket进行通信呢?

UDS:unix domain sokcet或者ipc套接字,含义在同一台机器不同进程进行通信的一种方式

UDS中有效的套接字有以下三种,与我们经常用使用的套接字类型大体相同:

  • SOCK_STREAM(流协议)
  • SOCK_DGRAM(数据报)
  • SOCK_SEQPACKET 面向连接的序列数据包套接字,保留消息边界,并按照发送消息的顺序传递信息

基础概念

创建socket需要指定协议族和type信息

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
#define UNIX_PATH_MAX    108  //大小为96~108

struct sockaddr_un {
     sa_family_t sun_family;               /* AF_UNIX */
     char        sun_path[UNIX_PATH_MAX];  /* pathname */
 };

 sokcet接口如下所示:

socket 函数的定义是下面这样子的:
#include <sys/types.h>
#include <sys/socket.h>c
int socket( int domain , int type , int protocol) ;

上面的接口中domain的含义是指定协议族,其取值范围是AF_UNIX,AF_LOCAL,AF_INET,PF_UNIX,PF_LOCAL,PF_INET,这些值的关系如下:

AF_UNIX=AF_LOCAL, PF_UNIX=PF_LOCAL, AF_LOCAL=PF_LOCAL, AF_INET=PF_INET.

#define PF_LOCAL	1	/* Local to host (pipes and file-domain).  */
#define PF_UNIX		PF_LOCAL /* POSIX name for PF_LOCAL.  */
#define PF_FILE		PF_LOCAL /* Another non-standard name for PF_LOCAL.  */
#define PF_INET		2	/* IP protocol family.  */

#define AF_LOCAL	PF_LOCAL
#define AF_UNIX		PF_UNIX
#define AF_FILE		PF_FILE
#define AF_INET		PF_INET

从上可以看出AF_UNIX与AF_LOCAL是一回事。

type参数的含义是socket类型,其取值范围是SOCK_STREAM(流媒体协议类型) SOCK_DGRAM(数据报类型)SOCK_RAW(原始类型)常用的就是这三种。

protocol类型参数一般用不到。这里不过多赘述。

本机进程间通信socket实现

上面进行了对创建socket进行了简要的介绍,其中domain参数进行了介绍。不知大家注意到没有,我们进行网络通信时经常用到的是AF_INET,采用该协议族创建的socket进行数据收发时就会进入网络协议栈,即数据需要进行tcp层 ip层物理层等还有另外一个宏AF_UNIX,这个宏应用的比较少,但是这个宏就是用来解决socket本机通信而出现的,这也是本章内容重点

AF_INET数据收发示意图

AF_UNIX数据收发流程图

通过上面的两幅图可以很明显的看出这二者不同的协议族之间的区别。

一句话:

AF_INET协议族下数据收发需要经过协议栈,该协议族的使用场景重要是针对不同主机之间进程间通信

AF_UNIX协议族下数据收发无需进入协议栈,数据将直接通过发送方socket的内核缓冲区直接拷贝到接收方socket的内核缓冲区。该协议族的使用场景是针对同一台主机不同进程间通信。例如fdbus甚至是opendds同一台主机间通信

AF_UNIX使用与AF_INET使用的不同点

这二者使用方法大体相同,只是绑定的时候这二者使用的结构体不同。

创建socket

fd = socket(AF_UNIX,SOCK_STREAM,0);  //创建本地域socket
fd = socket(AF_INET,SOCK_STREAM,0);  //创建网络域socket

 bind接口使用的结构不一致,AF_INET使用的结构是sockaddr_in(指定ip和端口号),而AF_UNIX使用的结构体是sockaddr_un(指定路径名),代码实例如下所示:

struct sockaddr_un // <sys/un.h>
{
sa_family_t sun_family;
char sun_path[108]; // 套接字文件的路径
};

   struct sockaddr_un sun;
   bzero(&sun,sizeof(sun));

   sun.sun_family = AF_LOCAL;
	
   strncpy(sun.sun_path,UNIX_DOMAIN_FILE,strlen(UNIX_DOMAIN_FILE));
   /* 2.2 绑定*/
   if(bind(fd,(struct sockaddr *)&sun,sizeof(sun)))
   {
        perror("bind");
        goto _error1;
   }

 AF_INET bind的使用方法

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
 
int main(int argc,char *argv[])
{
  if (argc!=2)
  {
    printf("Using:./server port\nExample:./server 5005\n\n"); return -1;
  }
 
  // 第1步:创建服务端的socket。
  int listenfd;
  if ( (listenfd = socket(AF_INET,SOCK_STREAM,0))==-1) { perror("socket"); return -1; }
 
  // 第2步:把服务端用于通信的地址和端口绑定到socket上。
  struct sockaddr_in servaddr;    // 服务端地址信息的数据结构。
  memset(&servaddr,0,sizeof(servaddr));
  servaddr.sin_family = AF_INET;  // 协议族,在socket编程中只能是AF_INET。
  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);          // 任意ip地址。
  //servaddr.sin_addr.s_addr = inet_addr("192.168.190.134"); // 指定ip地址。
  servaddr.sin_port = htons(atoi(argv[1]));  // 指定通信端口。
  if (bind(listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr)) != 0 )
  { perror("bind"); close(listenfd); return -1; }
 
  // 第3步:把socket设置为监听模式。
  if (listen(listenfd,5) != 0 ) { perror("listen"); close(listenfd); return -1; }
 
  // 第4步:接受客户端的连接。
  int  clientfd;                  // 客户端的socket。
  int  socklen=sizeof(struct sockaddr_in); // struct sockaddr_in的大小
  struct sockaddr_in clientaddr;  // 客户端的地址信息。
  clientfd=accept(listenfd,(struct sockaddr *)&clientaddr,(socklen_t*)&socklen);
  printf("客户端(%s)已连接。\n",inet_ntoa(clientaddr.sin_addr));
 
  // 第5步:与客户端通信,接收客户端发过来的报文后,回复ok。
  char buffer[1024];
  while (1)
  {
    int iret;
    memset(buffer,0,sizeof(buffer));
    if ( (iret=recv(clientfd,buffer,sizeof(buffer),0))<=0) // 接收客户端的请求报文。
    {
       printf("iret=%d\n",iret); break;  
    }
    printf("接收:%s\n",buffer);
 
    strcpy(buffer,"ok");
    if ( (iret=send(clientfd,buffer,strlen(buffer),0))<=0) // 向客户端发送响应结果。
    { perror("send"); break; }
    printf("发送:%s\n",buffer);
  }
 
  // 第6步:关闭socket,释放资源。
  close(listenfd); close(clientfd);
}

通过代码也可以看出accep的结构也有区别,同样是AF_INET使用的是sockaddr_in;AF_UNIX使用的是sockaddr_un。其它接口如果有类似的情况的请参考accept和bind接口使用方法。

约束条件

  • AF_UNIX不能在windows操作系统上使用,在Windows上是否存在类似的方便的本机通信需要调研

参考链接

AF_UNIX 本地通信-CSDN博客unix本地多进程通讯_af_unixhttps://blog.csdn.net/mayue_web/article/details/92798529

 UNP——socket套接字分析以及IPC_UDS_uds socket-CSDN博客

  • 6
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: Linux 进程间通讯指的是在 Linux 操作系统中不同进程间进行数据交换的方式。在 Linux 中,有多种进程间通讯的方式,如管道、消息队列、信号量、共享内存等。 UDS (Unix Domain Socket) 是一种在单一主机上通讯的套接字,它允许同一台主机上的进程进行通讯,而不需要网络协议栈的支持。UDS 具有较高的效率和低的开销。 以下是一份基于 UDS 的简单通讯代码: ``` #include <stdio.h> #include <stdlib.h> #include <errno.h> #include <string.h> #include <sys/types.h> #include <sys/socket.h> #include <sys/un.h> #define SOCK_PATH "echo_socket" int main(void) { int s, s2, len; unsigned t; struct sockaddr_un local, remote; char str[100]; if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) { perror("socket"); exit(1); } local.sun_family = AF_UNIX; strcpy(local.sun_path, SOCK_PATH); unlink(local.sun_path); len = strlen(local.sun_path) + sizeof(local.sun_family); if (bind(s, (struct sockaddr *)&local, len) == -1) { perror("bind"); exit(1); } if (listen(s, 5) == -1) { perror("listen"); exit(1); } for(;;) { int done, n; printf("Waiting for a connection...\n"); t = sizeof(remote); if ((s2 = accept(s, (struct sockaddr *)&remote, &t)) == -1) { perror("accept"); exit(1); } printf("Connected.\n"); done = 0; do { n = recv(s2, str, 100, 0); if (n <= 0) { if (n < 0) perror("recv"); done = 1; } if (!done) if (send ### 回答2: 在Linux操作系统中,进程间通讯(IPC)是指不同进程之间进行信息交换和共享资源的机制。其中一种常见的IPC方式是使用Unix Domain Socket(Uds)进行通讯。 Uds是一种特殊的套接字,用于在同一台机器上的进程间进行通讯。与网络套接字不同,Uds不需要通过网络进行数据传输,因此可以提供更高的性能和更低的延迟。 以下是一段简述了Uds通讯的代码示例: ```c // 进程A代码 #include <sys/socket.h> #include <sys/types.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <sys/un.h> int main() { int sockfd; struct sockaddr_un addr; // 创建套接字 sockfd = socket(AF_UNIX, SOCK_STREAM, 0); // 设置套接字地址 memset(&addr, 0, sizeof(addr)); addr.sun_family = AF_UNIX; strncpy(addr.sun_path, "socket_path", sizeof(addr.sun_path) - 1); // 绑定套接字 bind(sockfd, (struct sockaddr*)&addr, sizeof(addr)); // 监听套接字 listen(sockfd, 5); // 接受连接请求 int connect_fd = accept(sockfd, NULL, NULL); // 发送数据 char buffer[1024] = "Hello from Process A"; write(connect_fd, buffer, strlen(buffer)); // 关闭套接字 close(connect_fd); close(sockfd); return 0; } ``` ```c // 进程B代码 #include <sys/socket.h> #include <sys/types.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <sys/un.h> int main() { int sockfd; struct sockaddr_un addr; // 创建套接字 sockfd = socket(AF_UNIX, SOCK_STREAM, 0); // 设置套接字地址 memset(&addr, 0, sizeof(addr)); addr.sun_family = AF_UNIX; strncpy(addr.sun_path, "socket_path", sizeof(addr.sun_path) - 1); // 连接到套接字 connect(sockfd, (struct sockaddr*)&addr, sizeof(addr)); // 接收数据 char buffer[1024]; read(sockfd, buffer, sizeof(buffer)); printf("Received message: %s\n", buffer); // 关闭套接字 close(sockfd); return 0; } ``` 以上的代码中,进程A创建并绑定套接字,监听连接请求,并在接受连接后,通过write函数向连接的套接字发送数据。进程B通过connect函数连接到进程A创建的套接字,并使用read函数接收进程A发送的数据。 这样,进程A和进程B就通过Uds实现了简单的进程间通讯。当然,还有其他的通讯方式,如管道、消息队列、共享内存等,在不同的场景下可以选择不同的IPC方式来进行进程间的通讯。 ### 回答3: Linux进程间通信指的是不同进程之间通过特定的机制来交换数据和信息。其中一种常见的进程间通信方式就是使用Unix域套接字(Unix Domain Socket,简称UDS)。 UDS是一种特殊类型的套接字,用于在同一台主机上的进程间进行通信。UDS提供了一种高效的、可靠的、面向流或面向数据报的双向通信机制。 下面是一个使用UDS实现进程间通信的示例代码: ```c++ // 服务器端代码 #include <sys/socket.h> #include <sys/un.h> #include <stdio.h> #include <unistd.h> #include <stdlib.h> #define SOCKET_PATH "/tmp/my_socket" int main() { int sockfd, client_sock; struct sockaddr_un server_addr, client_addr; socklen_t client_len; char buffer[256]; // 创建套接字 sockfd = socket(AF_UNIX, SOCK_STREAM, 0); if (sockfd < 0) { perror("创建套接字失败"); exit(1); } // 绑定地址 server_addr.sun_family = AF_UNIX; strncpy(server_addr.sun_path, SOCKET_PATH, sizeof(server_addr.sun_path) - 1); unlink(SOCKET_PATH); // 确保该路径上没有残留的套接字文件 if (bind(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) { perror("绑定地址失败"); exit(1); } // 监听连接 if (listen(sockfd, 5) < 0) { perror("监听连接失败"); exit(1); } // 接受客户端连接 client_len = sizeof(client_addr); client_sock = accept(sockfd, (struct sockaddr*)&client_addr, &client_len); if (client_sock < 0) { perror("接受连接失败"); exit(1); } // 读取客户端发送的消息 bzero(buffer, sizeof(buffer)); if (read(client_sock, buffer, sizeof(buffer) - 1) < 0) { perror("读取数据失败"); exit(1); } printf("接收到的消息:%s\n", buffer); // 发送响应消息给客户端 const char* response = "Hello, client!"; if (write(client_sock, response, strlen(response)) < 0) { perror("发送响应消息失败"); exit(1); } // 关闭套接字 close(client_sock); close(sockfd); return 0; } ``` ```c++ // 客户端代码 #include <sys/socket.h> #include <sys/un.h> #include <stdio.h> #include <unistd.h> #include <stdlib.h> #define SOCKET_PATH "/tmp/my_socket" int main() { int sockfd; struct sockaddr_un server_addr; char buffer[256]; // 创建套接字 sockfd = socket(AF_UNIX, SOCK_STREAM, 0); if (sockfd < 0) { perror("创建套接字失败"); exit(1); } // 连接到服务器 server_addr.sun_family = AF_UNIX; strncpy(server_addr.sun_path, SOCKET_PATH, sizeof(server_addr.sun_path) - 1); if (connect(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) { perror("连接服务器失败"); exit(1); } // 发送消息给服务器 const char* message = "Hello, server!"; if (write(sockfd, message, strlen(message)) < 0) { perror("发送消息失败"); exit(1); } // 读取服务器的响应消息 bzero(buffer, sizeof(buffer)); if (read(sockfd, buffer, sizeof(buffer) - 1) < 0) { perror("读取响应消息失败"); exit(1); } printf("服务器的响应消息:%s\n", buffer); // 关闭套接字 close(sockfd); return 0; } ``` 以上代码展示了一个简单的UDS通信示例,服务器端在本地创建一个套接字,并绑定地址信息,然后监听连接。客户端连接到服务器,并发送一条消息,服务器接收到消息后给客户端发送响应消息。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值