【Linux系统编程】UDP通信、本地套接字

最新推荐文章于 2023-05-15 20:28:55 发布
最新推荐文章于 2023-05-15 20:28:55 发布
阅读量513 收藏 3
点赞数
分类专栏： Linux高并发服务器开发 文章标签： udp linux 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/beyon_sir/article/details/126426494
版权

UDP

UDP通信

在这里插入图片描述

#include <sys/types.h>
#include <sys/socket.h>
// 用于UDP通信
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);
    - 参数：
        - sockfd : 通信的fd
        - buf : 要发送的数据
        - len : 发送数据的长度
        - flags : 0
        - dest_addr : 通信的另外一端的地址信息
        - addrlen : 地址的内存大小
    返回值：
        - success, these calls return the number of bytes sent.  
        - error, -1 is returned, and errno is set appropriately.
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);
    - 参数：
        - sockfd : 通信的fd
        - buf : 接收数据的数组
        - len : 数组的大小
        - flags : 0
        - src_addr : 用来保存另外一端的地址信息，不需要可以指定为NULL
        - addrlen : src_addr的内存大小
    返回值：
        - success, these calls return the number of bytes received.  
        - error, -1 is returned, and errno is set appropriately.
// 用于TCP通信
ssize_t send(int sockfd, const void *buf, size_t len, int flags);
ssize_t recv(int sockfd, void *buf, size_t len, int flags);

示例：基于UDP实现服务器同时支持多个客户端进行接入(并发服务器)

// 服务器端
#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
int main()
{
    // 1. 创建一个通信socket
    int fd = socket(PF_INET, SOCK_DGRAM, 0);
    if(fd == -1)
    {
        perror("socket");
        exit(-1);
    }
    // 2. 绑定
    struct sockaddr_in addr;
    addr.sin_family = PF_INET;
    addr.sin_port = htons(9999);
    addr.sin_addr.s_addr = INADDR_ANY;
    int ret = bind(fd, (struct sockaddr*) &addr, sizeof(addr));
    if(ret == -1)
    {
        perror("bind");
        exit(-1);
    }
    // 3. 通信
    while(1)
    {
        char recvbuf[128];
        char ipbuf[16];
        struct sockaddr_in cliaddr;
        int len = sizeof(cliaddr);
        // 接收数据
        int num =recvfrom(fd, recvbuf, sizeof(recvbuf), 0, (struct sockaddr*)&cliaddr, &len);
        if(num == -1)
        {
            perror("recvfrom");
            exit(-1);
        }
        printf("client IP: %s, Port: %d\n", 
                inet_ntop(AF_INET, &cliaddr.sin_addr.s_addr, ipbuf, sizeof(ipbuf)),
                ntohs(cliaddr.sin_port));
        printf("client said: %s\n", recvbuf);

        // 发送数据
        sendto(fd, recvbuf, strlen(recvbuf) + 1, 0, (struct sockaddr*) &cliaddr, sizeof(cliaddr));
    }
    close(fd);
    return 0;
}

// 客户端
#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
int main()
{
    // 1. 创建一个通信socket
    int fd = socket(PF_INET, SOCK_DGRAM, 0);
    if(fd == -1)
    {
        perror("socket");
        exit(-1);
    }
    struct sockaddr_in saddr;
    saddr.sin_family = PF_INET;
    saddr.sin_port = htons(9999);
    inet_pton(AF_INET, "127.0.0.1", &saddr.sin_addr.s_addr);
    int num = 0;
    // 3. 通信
    while(1)
    {
        char sendbuf[128];
        sprintf(sendbuf, "hello, i am client %d\n", num++);
        char ipbuf[16];
        // 发送数据
        sendto(fd, sendbuf, strlen(sendbuf) + 1, 0, (struct sockaddr*) &saddr, sizeof(saddr));
        // 接收数据
        int num =recvfrom(fd, sendbuf, sizeof(sendbuf), 0, NULL, NULL);
        if(num == -1)
        {
            perror("recvfrom");
            exit(-1);
        }
        printf("server IP: %s, Port: %d\n", 
                inet_ntop(AF_INET, &saddr.sin_addr.s_addr, ipbuf, sizeof(ipbuf)),
                ntohs(saddr.sin_port));
        printf("server said: %s\n", sendbuf);
        sleep(1);
    }
    close(fd);
    return 0;
}

广播

向子网中多台计算机发送消息，并且子网中所有的计算机都可以接收到发送方发送的消息，每个广播消息都包含一个特殊的IP地址，这个IP中子网内主机标志部分的二进制全部为1。

  • 只能在局域网中使用。
  • 客户端需要绑定服务器广播使用的端口，才可以接收到广播消息。

在这里插入图片描述

// 设置广播属性的函数
int setsockopt(int sockfd, int level, int optname,const void *optval, socklen_t
optlen);
	参数：
        - sockfd : 文件描述符
        - level : SOL_SOCKET
        - optname : SO_BROADCAST
        - optval : int类型的值，为1表示允许广播
        - optlen : optval的大小

示例：广播(向子网为192.168.241.0的所有主机发送广播)

// 服务器
#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

int main()
{
    // 1. 创建一个通信socket
    int fd = socket(PF_INET, SOCK_DGRAM, 0);
    if(fd == -1)
    {
        perror("socket");
        exit(-1);
    }
    // 2. 设置广播属性
    int op = 1;
    setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &op, sizeof(op));

    // 3. 创建一个广播地址
    struct sockaddr_in cliaddr;
    cliaddr.sin_family = AF_INET;
    cliaddr.sin_port = htons(9999);
    inet_pton(AF_INET, "192.168.241.255", &cliaddr.sin_addr.s_addr);

    // 3. 通信
    int num = 0;
    while(1)
    {
        char sendBuf[128];
        sprintf(sendBuf, "hello, client...%d\n", num++);
        // 发送数据
        sendto(fd, sendBuf, strlen(sendBuf) + 1, 0, (struct sockaddr*) &cliaddr, sizeof(cliaddr));
        printf("广播的数据: %s\n", sendBuf);
        sleep(1);
    }
    close(fd);
    return 0;
}

// 客户端
#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

int main()
{
    // 1. 创建一个通信socket
    int fd = socket(PF_INET, SOCK_DGRAM, 0);
    if(fd == -1)
    {
        perror("socket");
        exit(-1);
    }

    // 2. 客户端绑定本地的IP和端口
    struct sockaddr_in addr;
    addr.sin_family = PF_INET;
    addr.sin_port = htons(9999);
    addr.sin_addr.s_addr = INADDR_ANY;
    int ret = bind(fd, (struct sockaddr*) &addr, sizeof(addr));
    if(ret == -1)
    {
        perror("bind");
        exit(-1);
    }
    // 3. 通信
    while(1)
    {
        char buf[128];

        // 接收数据
        int num =recvfrom(fd, buf, sizeof(buf), 0, NULL, NULL);
        if(num == -1)
        {
            perror("recvfrom");
            exit(-1);
        }
        printf("server said: %s\n", buf);
    }
    close(fd);
    return 0;
}

组播（多播）

单播地址标识单个 IP 接口，广播地址标识某个子网的所有 IP 接口，多播地址标识一组 IP 接口。单播和广播是寻址方案的两个极端（要么单个要么全部），多播则意在两者之间提供一种折中方案。多播数据报只应该由对它感兴趣的接口接收，也就是说由运行相应多播会话应用系统的主机上的接口接收。

另外，广播一般局限于局域网内使用，而多播则既可以用于局域网，也可以跨广域网使用。

  • 组播既可以用于局域网，也可以用于广域网
  • 客户端需要加入多播组，才能接收到多播的数据

在这里插入图片描述

组播地址

IP 多播通信必须依赖于 IP 多播地址，在 IPv4 中它的范围从 224.0.0.0 到 239.255.255.255 ，并被划分为局部链接多播地址、预留多播地址和管理权限多播地址三类：

IP地址说明
224.0.0.0~224.0.0.255局部链接多播地址：是为路由协议和其它用途保留的地址，路由器并不转发属于此范围的IP包
224.0.1.0~224.0.1.255预留多播地址：公用组播地址，可用于Internet；使用前需要申请
224.0.2.0~238.255.255.255预留多播地址：用户可用组播地址(临时组地址)，全网范围内有效
239.0.0.0~239.255.255.255本地管理组播地址，可供组织内部使用，类似于私有 IP 地址，不能用于 Internet，可限制多播范围

  • 设置组播

    int setsockopt(int sockfd, int level, int optname,const void *optval,socklen_t optlen);
	参数：
    // 服务器设置多播的信息，外出接口
        - level : IPPROTO_IP
        - optname : IP_MULTICAST_IF 指定外出接口
        - optval : struct in_addr
        - optlen
    // 客户端加入到多播组：
        - level : IPPROTO_IP
        - optname : IP_ADD_MEMBERSHIP 加入多播组
        - optval : struct ip_mreq


struct ip_mreq{
    /* IP multicast address of group. */
    struct in_addr imr_multiaddr; // 组播的IP地址
    /* Local IP address of interface. */
    struct in_addr imr_interface; // 本地的IP地址
};
typedef uint32_t in_addr_t;

struct in_addr{
    in_addr_t s_addr;
};

    注意：

    #if defined _BSD_SOURCE || defined _SVID_SOURCE 
# define __USE_MISC  1 
#endif 
...
#ifdef__USE_MISC
struct ip_mreq{...};
#endif
...
/*
所以使用struct ip_mreq 我们先宏定义_BSD_SOURCE 或者 _SVID_SOURCE 
但是由于warning "_BSD_SOURCE and _SVID_SOURCE are deprecated, use _DEFAULT_SOURCE"
使用_DEFAULT_SOURCE
cited from: http://cn.voidcc.com/question/p-yqvqmpvc-db.html
*/

示例：广播(向加入多播组为239.0.0.10的所有主机发送组播)

// 客户端
#define _DEFAULT_SOURCE
...(和广播示例一致)
int main()
{
    // 1. 创建一个通信socket
	...
	// 2. 客户端绑定本地的IP和端口
    struct sockaddr_in addr;
    addr.sin_family = PF_INET;
    addr.sin_port = htons(9999);
    addr.sin_addr.s_addr = INADDR_ANY;
    int ret = bind(fd, (struct sockaddr*) &addr, sizeof(addr));
    if(ret == -1)
    {
        perror("bind");
        exit(-1);
    }

    // 加入到多播组
    struct ip_mreq op;
    inet_pton(AF_INET, "239.0.0.10", &op.imr_multiaddr.s_addr);
    op.imr_interface.s_addr = INADDR_ANY;

    setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &op, sizeof(op));
    // 开始通信
    ...
}

// 服务器
...
int main()
{
	// 1. 创建一个通信socket
	...
	// 2. 设置多播属性，设置外出接口
    struct in_addr imr_multiaddr;
    // 初始化多播地址
    inet_pton(AF_INET, "239.0.0.10", &imr_multiaddr.s_addr);
    setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, &imr_multiaddr, sizeof(imr_multiaddr));

    // 3. 初始化客户端的地址信息
    struct sockaddr_in cliaddr;
    cliaddr.sin_family = AF_INET;
    cliaddr.sin_port = htons(9999);
    inet_pton(AF_INET, "239.0.0.10", &cliaddr.sin_addr.s_addr);
    // 4. 通信
    ...
}

本地套接字

本地套接字的作用：本地的进程间通信

  • 有关系的进程间的通信
  • 没有关系的进程间的通信

本地套接字实现流程和网络套接字类似，一般采用TCP的通信流程。

在这里插入图片描述

// 本地套接字通信的流程 - tcp
// 服务器端
1. 创建监听的套接字
	int lfd = socket(AF_UNIX/AF_LOCAL, SOCK_STREAM, 0);
2. 监听的套接字绑定本地的套接字文件 -> server端
    struct sockaddr_un addr;
    // 绑定成功之后，指定的sun_path中的套接字文件会自动生成。
    bind(lfd, addr, len);
3. 监听
    listen(lfd, 100);
4. 等待并接受连接请求
    struct sockaddr_un cliaddr;
    int cfd = accept(lfd, &cliaddr, len);
5. 通信
    接收数据：read/recv 
    发送数据：write/send
6. 关闭连接
    close();

// 客户端的流程
1. 创建通信的套接字
    int fd = socket(AF_UNIX/AF_LOCAL, SOCK_STREAM, 0);
2. 监听的套接字绑定本地的IP 端口
    struct sockaddr_un addr;
    // 绑定成功之后，指定的sun_path 的套接字文件会自动生成。
    bind(lfd, addr, len);
3. 连接服务器
    struct sockaddr_un serveraddr;
    connect(fd, &serveraddr, sizeof(serveraddr));
4. 通信
    接收数据：read/recv
    发送数据：write/send
5. 关闭连接
    close();

// 头文件: sys/un.h
#define UNIX_PATH_MAX 108
struct sockaddr_un {
    sa_family_t sun_family; // 地址族协议 af_local
    char sun_path[UNIX_PATH_MAX]; // 套接字文件的路径, 这是一个伪文件, 大小永远=0
};

#include <unistd.h>
// 从文件系统中删除一个指定的文件
int unlink(const char *pathname);

示例：实现本地进程间通信(IPC)

// 服务器端
#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/un.h>

int main()
{
    // 从文件系统中删除一个指定的文件
    // 否则多次运行会报错 “bind: Address already in use”
    unlink("./server.sock");
    // 1. 创建监听的套接字
    int lfd = socket(AF_LOCAL, SOCK_STREAM, 0);
    // 2. 绑定本地套接字文件
    struct sockaddr_un addr;
    addr.sun_family = AF_LOCAL;
    strcpy(addr.sun_path, "./server.sock");
    int ret = bind(lfd,(struct sockaddr*) &addr, sizeof(addr));
    // 3. 监听
    ret = listen(lfd, 128);
    // 4. 等待客户端连接
    struct sockaddr_un cliaddr;
    int len = sizeof(cliaddr);
    int cfd = accept(lfd, (struct sockaddr*) &cliaddr,&len);
    printf("client socket filename: %s\n",cliaddr.sun_path);
    // 5. 通信
    while(1)
    {
        char buf[128];
        int len = recv(cfd, buf, sizeof(buf), 0);
        if(len == -1)
        {
            perror("recv");
            exit(-1);
        }
        else if(len == 0)
        {
            printf("client closed...\n");
            break;
        }
        else if(len > 0)
        {
            printf("client data: %s\n", buf);
            send(cfd, buf, len + 1, 0);
        }
    }
    close(cfd);
    close(lfd);
    return 0;
}

// 客户端
#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/un.h>
int main()
{
    unlink("./client.sock");
    // 1. 创建套接字
    int cfd = socket(AF_LOCAL, SOCK_STREAM, 0);
    // 2. 绑定本地套接字文件
    struct sockaddr_un addr;
    addr.sun_family = AF_LOCAL;
    strcpy(addr.sun_path, "./client.sock");
    int ret = bind(cfd,(struct sockaddr*) &addr, sizeof(addr));
    // 3. 连接服务器
    struct sockaddr_un seraddr;
    seraddr.sun_family = AF_LOCAL;
    strcpy(seraddr.sun_path, "./server.sock");
    ret = connect(cfd, (struct sockaddr*) &seraddr, sizeof(seraddr));
    // 5. 通信
    int num = 0;
    while(1)
    {
        // 发送数据
        char buf[128];
        sprintf(buf, "Hello, i am client : %d\n", num++);
        send(cfd, buf, strlen(buf) + 1, 0);
        printf("client send: %s\n", buf);
        // 接收数据
        memset(buf, 0, sizeof(buf));
        int len = recv(cfd, buf, sizeof(buf), 0);
        if(len == -1)
        {
            perror("recv");
            exit(-1);
        }
        else if(len == 0)
        {
            printf("server closed...\n");
            break;
        }
        else if(len > 0) printf("server data: %s\n", buf);
        sleep(1);
    }
    close(cfd);
    return 0;
}
Beyon.sir
关注
专栏目录
Linux/Unix网络编程之UDP的connect函数
飞在天空的鱼
05-24 4772
对于linux网络编程，我们都知道UDP是发送数据报，而且，我们只要在sendto函数中指定你要发送的端口和IP地址就可以了，我们不用绑定端口和IP。但是，如果对UDP进行connect函数的调用，会发生什么现象呢？有了这个能力，我们可以分为两个种：1，未连接的UDP，新创建的UDP套接字就是这样的。2，已连接的UDP，调用connect函数就是这样的。其中，已连接的毕未连接的多了三个变化：1，我们再也不能给输出操作指定目的IP和目的端口。也就是说，我们不能调用sendto，而是用write或者send。写
UDP通信、本地套接字1
08-03
UDP通信是一种无连接的传输层协议，相比TCP...总的来说，UDP通信、广播、组播以及本地套接字都是网络编程中实现不同通信需求的工具。它们各有特点，适用于不同的场景，开发者可以根据实际需求选择合适的方式进行通信。
Linux域套接字实现UDP本地通信
m0_45901455的博客
08-18 904
BSD UNIX最初引入套接字时只支持本地通信， 1986年之后进行了扩展，开始支持网络协议。在很多应用中，前后台进程通过UNIX域套接字进行通信。UNIX域套接字具有使用简单、效率高等特点。UNIX域套接字分为两种类型：流式套接字类型和用户数据报类型。...
网络编程5--UDP通信和本地套接字
zhaojiazb的博客
03-29 146
TCP： 面向连接的，可靠数据包传输。对于不稳定的网络层，采取完全弥补的通信方式。丢包重传。优点：稳定。数据流量稳定、速度稳定、顺序缺点：传输速度慢。相率低。开销大。使用场景：数据的完整型要求较高，不追求效率。大数据传输、文件传输。UDP： 无连接的，不可靠的数据报传递。对于不稳定的网络层，采取完全不弥补的通信方式。默认还原网络状况优点：传输速度快。相率高。开销小。缺点：不稳定。数据流量。速度。顺序。使用场景：对时效性要求较高场合。稳定性其次。游戏、视频会议、视频电话。
本地通信——基于域套接字 ：UDP、TCP
laoKdx的博客
08-15 730
基于域套接字的本地通信
Linux本地套接字通信
坚持学习
05-09 795
Linux本地套接字通信
Linux程序设计之本地套接字通信
最新发布
qq_43213240的博客
05-15 178
Linux程序设计之本地套接字通信
Linux进程间通信——使用流套接字
09-15
【Linux进程间通信——使用流套接字】这篇文章主要介绍了如何利用socket进行进程间通信，尤其是跨网络的通信。Socket，又称套接字，是一种通信机制，它允许不同计算机或同一计算机上的进程通过网络进行通信。以下是...
udp.rar_linux_socket_udp服务端编写_原始套接字udp
09-24
综上所述，这个项目涵盖了UDP套接字编程、原始套接字的使用以及ICMP回射请求的实现，是学习和实践网络编程特别是无连接服务端和客户端通信的好例子。通过理解并运行这些代码，开发者能深入理解UDP通信和网络协议的...
面向连接的套接字通信_面向连接的套接字通信_linux聊天室_
10-02
面向连接的套接字通信是网络编程中的一个重要概念，它主要应用于TCP协议，与无连接的UDP协议形成对比。在TCP/IP模型中，面向连接的通信确保了数据的可靠传输，通过建立、维护和终止连接来实现。在这个场景中，我们...
UDP和本地套接字
一条懒狗
03-11 391
TCP通信和UDP通信各自的优缺点： TCP：面向连接的，可靠的数据包传输。 对于不稳定的网络层，采取完全弥补的通信方式。丢包重传。 优点：稳定。 数据流量稳定，传输速度稳定，顺序。 缺点：传输速度慢。效率低。系统资源开销大。 使用场景：数据的完整性要求较高，不追求效率。大数据传输，文件传输。 UDP：无连接的，不可靠的数据报传递。 对于不稳定的网络层，采取完全不弥补的通信方式。默认还原网络状况。...
【网络编程】UDP+本地套接字
Intrepid_Chaser的博客
04-08 279
UDP 原理 TCP：传输控制协议 安全可靠 丢包重传 面向连接 UDP：用户数据报协议 不安全不可靠 丢包不重传 快 不面向连接 TCP通信流程： 服务器：创建流式套接字 绑定 监听 提取连接 读写 关闭 客户端：创建流式套接字 连接 读写 关闭 收发数据 read recv write send UDP通信流程： 服务器：创建报式套接字 绑定 读写 关闭 客户端：创建报式套接字 读写 关闭 发数据 ssize_t sendto(int sockfd, const void *buf, size_t
网络编程-UDP本地通讯
欢迎来到斛XX的博客
08-15 423
网络编程-UDP本地通讯
linux udp之connect函数-连接的udp
Undefined
12-22 3225
概述 connect函数不止作用与tcp连接,同样可以作用于udp连接.不过两者的作用不同. tcp与udp的connect不同 tcp使用connect函数,客户端发起三次握手协议,在收到对端的确认ack和ack后返回.对端在收到客户端的确认ack后,accept返回. udp使用connect函数,并没有发起三次握手协议(这本身就是tcp协议内容),内核会记录目的端的ip和port,如
linux添加udp,Linux上的UDP connect()和recv()
weixin_27017211的博客
05-03 395
您的程序(可能)有以下问题：>你应该使用bind()而不是connect(),和>你缺少setsockopt(…,IP_ADD_MEMBERSHIP,…).这是一个接收多播的示例程序.它使用recvfrom(),而不是recv(),但它是相同的,除了你还得到每个接收数据包的源地址.要从多个多播组接收,您有三个选项.第一个选项：为每个多播组使用单独的套接字,并将每个套接字bind()绑定...
LINUX 下，编程自学四：UDP通信（connect用于UDP）
u011241085的专栏
04-24 661
service.c #include #include #include #include #include #include #include #include #define PORT 5678 int main() { int sock; struct sockaddr_in server; struct sockaddr_in client; size_t len; cha
TCP UDP 本地套接字 网络套接字
u014426028的博客
04-21 1017
TCP UDP 在传输层 Linux socket 本地进程间通信 socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，都可以用“打开open –> 读写write/read –> 关闭close”模式来操作。Socket就是该模式的一个实现， socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）. ...
Linux套接字编程指南：TCP与UDP套接字解析
"本章深入探讨了Linux环境下的套接字编程，涵盖了套接字的类型、地址结构、位顺序调整、带外数据、连接类型以及两种主要的套接字类型——TCP和UDP套接字，最后进行了总结。" 在Linux系统中，套接字是实现进程间通信...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Beyon.sir

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值