UNIX域套接字

最新推荐文章于 2021-04-19 11:35:14 发布
最新推荐文章于 2021-04-19 11:35:14 发布
阅读量151 收藏 1
点赞数
分类专栏： # Linux进程间通信 文章标签： linux socket c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L_insting/article/details/110745513
版权
本文详细阐述了UNIX域套接字在UDP和TCP协议下的服务端与客户端工作流程，包括创建套接字、地址绑定、通信处理及示例代码。重点介绍了UDP的无连接通信和TCP的连接导向，以及客户端使用bind()的注意事项。
摘要由CSDN通过智能技术生成

UNIX域套接字

socket通信流程

udp

udp

服务端工作流程和示例

服务端工作流程
  1. 创建服务端的socket。
  2. 把服务端用于通信的地址绑定到本地socket套接字上。
  3. 与客户端通信，接收客户端发过来的报文后处理。
  4. 不断重复recvfrom()/sendto()，直到客户端断开连接。
  5. 关闭socket，释放资源。
服务端示例
/*
 * function: 演示本地unix域套接字用于进程间通信(udp协议)
 *           此进程为服务端
 *
 * 2020-12-05
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/un.h>     // struct sockaddr_un

int main(int argc, char *argv[])
{
    int sockfd = 0;

    // 第一步: 创建unix域udp协议socket套接字
    if ((sockfd = socket(AF_UNIX, SOCK_DGRAM, 0)) == -1) 
    {   
        perror("socket faild");
        exit(1);
    }   

    unlink("udpserver.sock");   // 删除文件udpserver.sock,防止文件被占用
    							// 注意: 不要删除正在使用的socket

    struct sockaddr_un serveraddr; // 服务端的地址
    memset(&serveraddr, 0, sizeof(serveraddr));
    serveraddr.sun_family = AF_UNIX;
    strcpy(serveraddr.sun_path, "udpserver.sock");
    
    // 第二步: 把服务端用于通信的地址绑定到本地socket套接字上。
    if (bind(sockfd, (struct sockaddr *)&serveraddr, (socklen_t)sizeof(serveraddr)) == -1) 
    {   
        perror("bind faild");
        close(sockfd);
        exit(1);
    }


    struct sockaddr_un clientaddr;     // 用来存放客户端的地址
    memset(&clientaddr, 0, sizeof(clientaddr));
    socklen_t client_addr_len = sizeof(clientaddr); // struct sockaddr_un 的大小

    char buf[BUFSIZ] = {0};

    // 第三步: 与客户端通信，接收客户端发过来的报文后处理。
    // 第四步: 不断重复recvfrom()/sendto()，直到客户端断开连接。
    while (1)
    {
        // 注意: recvfrom最后一个参数表示clientaddr可接收多大的数据,应为clientaddr的大小,即sizeof(clientaddr), 而不是0.
        size_t n = recvfrom(sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&clientaddr, &client_addr_len);
        if (n == -1)
        {
            perror("recvfrom faild");
            unlink("udpserver.sock");
            close(sockfd);
            exit(1);
        }
        printf("receive: %s\n", buf);

        n = sendto(sockfd, buf, strlen(buf), 0, (struct sockaddr *)&clientaddr, client_addr_len);
        if (n == -1)
        {
            perror("sendto faild");
            unlink("udpserver.sock");
            close(sockfd);
            exit(1);
        }
        printf("send: %s\n", buf);
    }

    unlink("udpserver.sock");   // 删除文件udpserver.sock

    // 第五步: 关闭socket，释放资源
    close(sockfd);

    return 0;
}

客户端工作流程和示例

客户端工作流程
  1. 创建客户端的socket。
  2. 把客户端用于通信的地址绑定到本地socket套接字上。
  3. 与服务端通信，将报文发送给服务端。
  4. 不断重复sendto()/recvfrom()，直到数据发送完毕。
  5. 关闭socket，释放资源。
客户端示例
/*
 * function: 演示本地unix域套接字用于进程间通信(udp协议)
 *           此进程为客户端
 *
 * 2020-12-05
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/un.h>     // struct sockaddr_un

int main(int argc, char *argv[])
{
    int sockfd = 0;

    // 第一步：创建unix域udp协议socket套接字
    if ((sockfd = socket(AF_UNIX, SOCK_DGRAM, 0)) == -1) 
    {   
        perror("socket faild");
        exit(1);
    }   

    unlink("udpclient.sock");   // 删除文件udpclient.sock,防止文件被占用
    							// 注意: 不要删除正在使用的socket

    struct sockaddr_un clientaddr; // 客户端的地址
    clientaddr.sun_family = AF_UNIX;
    strcpy(clientaddr.sun_path, "udpclient.sock");

    // 第二步:  把客户端用于通信的地址绑定到本地socket套接字上
    // 注意: 如果不进行绑定，服务端的recvfrom函数将不能收到客户端的地址
    if (bind(sockfd, (struct sockaddr *)&clientaddr, (socklen_t)sizeof(clientaddr)) == -1) 
    {   
        perror("bind faild");
        close(sockfd);
        exit(1);
    }

    struct sockaddr_un serveraddr;    // 服务端的地址
    serveraddr.sun_family = AF_UNIX;
    strcpy(serveraddr.sun_path, "udpserver.sock");

    char buf[BUFSIZ] = {0};
    char sendbuf[] = "hello world";

    // 第三步: 与服务端通信，将报文发送给服务端
    // 第四步: 不断重复sendto()/recvfrom()，直到数据发送完毕。
    while (1)
    {
        // 发送报文
        // 注意: sendbuf[], 内容为字符串, 因此才使用strlen(sendbuf), strlen()函数需要谨慎使用。
        size_t n = sendto(sockfd, sendbuf, strlen(sendbuf), 0, (struct sockaddr *)&serveraddr, (socklen_t)sizeof(serveraddr));
        if (n == -1)
        {
            perror("sendto faild");
            unlink("udpclient.sock");
            close(sockfd);
            exit(1);
        }
        printf("send: %s\n", sendbuf);

        // 接收报文
        n = recvfrom(sockfd, buf, sizeof(buf), 0, 0, 0);
        if (n == -1)
        {
            perror("sendto faild");
            unlink("udpclient.sock");
            close(sockfd);
            exit(1);
        }
        printf("receive: %s\n", buf);

        sleep(2);
    }

    unlink("udpclient.sock");   // 删除文件udpclient.sock

    // 第五步: 关闭socket，释放资源
    close(sockfd);

    return 0;
}

udp

tcp

tcp

服务端工作流程和示例

服务端工作流程
  1. 创建服务端的socket。
  2. 把服务端用于通信的地址和端口绑定到socket上。
  3. 把socket设置为监听模式。
  4. 接受客户端的连接。
  5. 与客户端通信，接收客户端发过来的报文后，回复处理结果。
  6. 不断的重复第5步，直到客户端断开连接。
  7. 关闭socket，释放资源。
服务端示例
/*
 * function: 演示本地unix域套接字用于进程间通信(tcp协议)
 *           此进程为服务端
 *
 * 2020-12-07
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/un.h>     // struct sockaddr_un

int main(int argc, char *argv[])
{
    int serverFd = 0;

    // 第一步: 创建unix域tcp协议socket套接字
    if ((serverFd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) 
    {   
        perror("socket faild");
        exit(1);
    }   

    unlink("tcpserver");  // 删除tcpserver,防止文件被占用
                          // 注意: 不要删除正在使用的socket

    struct sockaddr_un serveraddr;      // 服务端的地址
    memset(&serveraddr, 0, sizeof(serveraddr));
    serveraddr.sun_family = AF_UNIX;
    strcpy(serveraddr.sun_path, "tcpserver");

    // 第二步: 指定用于通信的地址
    if (bind(serverFd, (struct sockaddr *)&serveraddr, (socklen_t)sizeof(serveraddr)) == -1) 
    {   
        perror("bind faild");
        exit(1);
    }

    // 第三步: 把socket设置为监听
    if (listen(serverFd, 5) == -1)
    {
        perror("listen faild");
        unlink("tcpserver");
        close(serverFd);
        exit(1);
    }

    int clientFd = 0;
    struct sockaddr_un clientaddr;              // 客户端的地址信息
    memset(&clientaddr, 0, sizeof(clientaddr));
    socklen_t socklen = sizeof(clientaddr);     // struct sockaddr_un 的大小

    // 第四步: 接受客户端的连接
    if ((clientFd = accept(serverFd, (struct sockaddr *)&clientaddr, &socklen)) == -1)
    {
        perror("accept faild");
        unlink("tcpserver");
        close(serverFd);
        exit(1);
    }
    printf("客户端(%s)连接成功!!!\n", clientaddr.sun_path);

    char buf[BUFSIZ] = {0};

    // 第五步: 与客户端通信，接收客户端发过来的报文后，回复处理结果。
    // 第六步: 不断的重复第五步，直到客户端断开连接。
    while (1)
    {
        // 接收报文
        size_t n = recv(clientFd, buf, sizeof(buf), 0);
        if (n == -1)
        {
            perror("recv faild");
            unlink("tcpserver");
            close(serverFd); close(clientFd);
            exit(1);
        }
        printf("receive: %s\n", buf);

        // 发送报文
        n = send(clientFd, buf, strlen(buf), 0);
        if (n == -1)
        {
            perror("send faild");
            unlink("tcpserver");
            close(serverFd); close(clientFd);
            exit(1);
        }
        printf("send: %s\n", buf);
    }

    unlink("tcpserver");   // 删除文件tcpserver

    // 第七步: 关闭socket,释放资源
    close(serverFd); close(clientFd);

    return 0;
}

客户端工作流程和示例

客户端工作流程
  1. 创建客户端的socket。
  2. 向服务器发起连接请求。
  3. 与服务端通信，发送一个报文后等待回复，然后再发下一个报文。
  4. 不断的重复第3步，直到全部的数据被发送完。
  5. 第4步：关闭socket，释放资源。
客户端示例
/*
 * function: 演示本地unix域套接字用于进程间通信(tcp协议)
 *           此进程为客户端
 *
 * 2020-12-07
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/un.h>     // struct sockaddr_un

int main(int argc, char *argv[])
{
    int sockfd = 0;

    // 第一步: 创建unix域tcp协议的socket套接字
    if ((sockfd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) 
    {   
        perror("socket faild");
        exit(1);
    }   

    unlink("tcpclient");    // 删除tcpclient,防止文件被占用
                            // 注意: 不要删除正在使用的socket

#if 0       
    struct sockaddr_un clientaddr;  // 客户端的地址
    clientaddr.sun_family = AF_UNIX;
    strcpy(clientaddr.sun_path, "tcpclient");

    // 如果使用bind绑定客户端的通信地址后,服务端的accept()函数的第二个参数可以接收到客户端的地址,否则不能接收到。
    if (bind(sockfd, (struct sockaddr *)&clientaddr, (socklen_t)sizeof(clientaddr)) == -1)
    {
        perror("bind faild");
        close(sockfd);
        exit(1);
    }
#endif

    struct sockaddr_un serveraddr;    // 服务端的地址
    serveraddr.sun_family = AF_UNIX;
    strcpy(serveraddr.sun_path, "tcpserver");

    // 第二步: 向服务器发起连接请求
    if (connect(sockfd, (struct sockaddr *)&serveraddr, (socklen_t)sizeof(serveraddr)) == -1)
    {
        perror("connect faild");
        unlink("tcpclient");
        close(sockfd);
        exit(1);
    }
    printf("连接服务端成功!!!\n");

    char sendBuf[] = "hello world";
    char buf[BUFSIZ] = {0};

    // 第三步: 与服务端通信，发送一个报文后等待回复, 然后发下一个报文。
    // 第四步: 不断的重复第三步，直到全部的数据被发送完。
    while (1)
    {
        // 发送报文
        // 注意: sendBuf[], 内容为字符串, 因此才使用strlen(sendBuf), strlen()函数需要谨慎使用。
        size_t n = send(sockfd, sendBuf, strlen(sendBuf), 0);
        if (n == -1)
        {
            perror("send faild");
            unlink("tcpclient");
            close(sockfd);
            exit(1);
        }
        printf("send: %s\n", sendBuf);

        // 接收报文
        n = recv(sockfd, buf, sizeof(buf), 0);
        if (n == -1)
        {
            perror("recv faild");
            unlink("tcpclient");
            close(sockfd);
            exit(1);
        }
        printf("recevie: %s\n", buf);

        sleep(2);
    }

    unlink("tcpclient");    // 删除文件tcpclient

    // 第五步: 关闭socket,释放资源
    close(sockfd);

    return 0;
}

客户端代码没有打开注释位置，即未使用bind绑定客户端的地址
tcp1
客户端代码打开了注释位置，即使用bind绑定客户端的地址
tcp2

注意事项

1. 关于客户端使用bind()函数

1）对于udp协议，如果客户端未使用bind() 函数，那么我们只能实现客户端向服务端发送信息，但服务端不能向客户端回复信息，因为服务端得不到客户端的地址。
2）对于tcp协议，如果客户端未使用bind() 函数，服务端与客户端可以正常通信，只是服务端同样得不到客户端本地socket的名字。

2. 关于recvfrom()函数

函数原型：

ssize_t recvfrom(int socket, void *restrict buffer, size_t length, 
				 int flags, struct sockaddr *restrict address,
				 socklen_t *restrict address_len);

对于最有一个参数address_len，看着像一个传出参数，得到的是address的大小。
实际上，address_len表示的是address可以接收多大，为传入参数，应该传入sizeof(address_len).

linuxcpp_
关注
专栏目录
Unix域套接字
博客
04-19 2578
Unxi域套接字并不是一个实际的协议族，而是在单个主机上执行客户/服务器通信的一种方法，所用API就是在不同主机上执行客户/服务器通信所用的API。可以视为IPC方法之一。 UNix域提供两类套接字：字节流套接字（类似TCP），数据报套接字（类似UDP） 使用Unix域套接字有以下三个理由：     1、Unix域套接字往往比通信两端位于同一主机的TCP套接字快出一倍。X Window
Unix域套接字 2024.9.5
最新发布
m0_46380369的博客
09-05 163
1.流式域套接字服务器端实现。2、报式域套接字服务器端。
unix域套接字
小豆角的博客
04-27 537
Unix域套接字只能用于在同一个计算机的进程间进行通信。虽然网络套接字也可以用于单机进程间的通信，但是使用Unix域套接字效率会更高，因为Unix域套接字仅仅进行数据复制，不会执行在网络协议栈中需要处理的添加、删除报文头、计算校验和、计算报文顺序等复杂操作，因而在单机的进程间通信中，更加推荐使用Unix域套接字。 ------https://www.jianshu.com/p/43ed6e40...
UNIX 域套接字
u010518627的博客
04-19 139
文章目录UNIX域套接字UNIX域（流式）套接字UNIX域（用户数据报）套接字 UNIX域套接字 socket 同样可以用于本地通信 创建套接字时使用本地协议 PF_UNIX（或 PF_LOCAL）。 分为流式套接字和用户数据报套接字 和其他进程间通信方式相比使用方便、效率更高 常用于前后台进程通信 本地信息结构体 sockaddr_un #include <sys/un.h> struct sockaddr_un{ __SOCKADDR_COMMON (sun_);
《UNIX环境高级编程》笔记--UNIX域套接字
TODD911的专栏
03-02 7465
1.非命名的UNIX域套接字 UNIX套接字用于在用一台机器上运行的进程之间通信。UNIX套接字比因特网域套接字的效率更高。UNIX与套接字提供和 数据报两种接口，UNIX域数据报服务是可靠的，就不会丢失消息也不会传递出错。UNIX域套接字是套接字和管道之间的混合物。 为了创建一对非命名的，相互连接的UNXI域套接字，用户可以使用socketopair函数。 #include int so
java基于UNIX域套接字(unix domain socket)连接redis
12-24
为了优化网络通信，有时我们会选择使用UNIX域套接字（UNIX Domain Socket，简称UDS）来代替传统的TCP/IP套接字进行进程间通信（IPC）。本篇将详细讲解如何在Java环境下，利用UNIX域套接字连接并操作Redis，以及涉及...
unix-path-max:获取Unix域套接字的路径的最大允许长度
05-26
获取Unix域套接字的路径的 在Windows上不起作用。 安装 $ npm install unix-path-max 用法 const unixPathMax = require ( 'unix-path-max' ) ; ( async ( ) => { console . log ( await unixPathMax ( ) ) ; /...
nbudstee:非阻塞Unix域套接字三通
05-02
nbudstee：非阻塞Unix域套接字Tee 将Tees输入到零个或多个非阻塞Unix域套接字，每个套接字可以具有零个或多个连接的读取器， 和/或零个或多个现有FIFO，每个FIFO可以恰好具有一个现有读取器。 除非使用-n /-no-...
sockdump:使用bpf转储unix域套接字流量
05-09
转储Unix域套接字流量。 要求 密件抄送 python密件抄送绑定 例子 字符串输出 $ sudo ./sockdump.py --format string /var/run/docker.sock waiting for data 19:23:06.633 >>> process docker [31042 -> 13710] len...
UNIX域套接字实现服务器客户端之间的通信
09-04
UNIX域套接字实现服务器客户端之间的通信
Unix域套接字（Unix Domain Socket）介绍
热门推荐
Roland_Sun的专栏
12-16 3万+
在Linux系统中，有很多进程间通信方式，套接字（Socket）就是其中的一种。但传统的套接字的用法都是基于TCP/IP协议栈的，需要指定IP地址。如果不同主机上的两个进程进行通信，当然这样做没什么问题。但是，如果只需要在一台机器上的两个不同进程间通信，还要用到IP地址就有点大材小用了。 其实很多人并不一定知道，对于套接字来说，还存在一种叫做Unix域套接字的类别，专门用来解决这个问题。其API
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值