Rust Udp组播：0 - 一个入门例子

已于 2024-05-25 17:38:55 修改
阅读量493 收藏 3
点赞数 14
文章标签： rust udp 开发语言
于 2024-05-24 11:13:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gregmankiw/article/details/139169059
版权

系列文章目录

文章目录

前言

实现Rust Udp组播。

一、项目创建

  1. cmd新建cargo工程目录
cargo new s1
  1. 切到s1目录新建两个子工程：udpclient，udpserver
cd s1
cargo new udpclient1
cargo new udpclient2
cargo new udpserver
  1. 修改s1目录下Cargo.toml添加子工程
[workspace]
members = ["tcpserver", "tcpclient1", "tcpclient2"]

在这里插入图片描述

二、Udp组播

  1. 编辑tcpclient1\src\main.rs，demo目录下执行命令cargo run -p tcpclient1
use std::net::UdpSocket;
use std::thread;

fn main() {
    let socket = UdpSocket::bind("127.0.0.1:1111").unwrap();
    const COUNT: usize = 100;
    loop {
        let buf = [0x41; COUNT];
        socket.send_to(&buf, "127.0.0.1:8888").unwrap();
        thread::sleep(std::time::Duration::from_millis(1000));
    }
}
  1. 编辑tcpclient2\src\main.rs，demo目录下执行命令cargo run -p tcpclient2
use std::net::UdpSocket;
use std::thread;

fn main() {
    let socket = UdpSocket::bind("127.0.0.1:2222").unwrap();
    const COUNT: usize = 100;
    loop {
        let buf = [0x41; COUNT];
        socket.send_to(&buf, "127.0.0.1:8888").unwrap();
        thread::sleep(std::time::Duration::from_millis(1000));
    }
}
  1. 编辑tcpserver\src\main.rs，demo目录下执行命令cargo run -p tcpserver
use std::net::{Ipv4Addr, UdpSocket};

fn main() {
    let socket = UdpSocket::bind("127.0.0.1:8888").unwrap();
    let multicast_addr = Ipv4Addr::new(234, 2, 2, 2);
    let inter = Ipv4Addr::new(0, 0, 0, 0);
    socket.join_multicast_v4(&multicast_addr, &inter).unwrap();

    let mut buf = [0u8; 65536];
    loop {
        let (amt, src) = socket.recv_from(&mut buf).unwrap();
        println!("{}: {:?}", amt, src);
    }
    socket.leave_multicast_v4(&multicast_addr, &inter).unwrap();
}
  1. 效果
    在这里插入图片描述

补充

  • 补充1：crossbeam的一些例子
  1. Cargo.toml添加依赖
[dependencies]
crossbeam = "0.8"
  1. main.rs
// 使用 crossbeam 库和 SegQueue 实现线程间的通信与数据同步
use crossbeam::{self, queue::SegQueue, scope};
use std::{thread, time::Duration};

fn main() {
    // 创建一个 SegQueue 实例用于线程间的数据传递
    let seg_queue = SegQueue::new();

    // 使用 crossbeam 的 scope 函数来创建一个作用域，内部可以并发执行多个任务
    scope(|s| {
        // 第一个任务：向队列中推入 0 到 9 的数字
        s.spawn(|_| {
            for i in 0..10 {
                seg_queue.push(i);
                println!("Thread 1: {}", i);
            }
        });

        // 第二个任务：从队列中弹出数据并打印，重复执行五次
        s.spawn(|_| {
            let mut i = 0;
            'outer: loop {
                while let Some(item) = seg_queue.pop() {
                    println!("Thread 2: {}", item);
                    i += 1;
                    if i >= 5 {
                        break 'outer;
                    };
                }
            }
        });
    })
    // 处理 scope 中的任务，如果有错误则.unwrap()会触发 panic
    .unwrap();

    // 主线程从队列中弹出剩余的数据并打印
    while let Some(item) = seg_queue.pop() {
        println!("Main Thread: {}", item);
    }
}
  1. 输出
Thread 1: 0
Thread 2: 0
Thread 2: 1
Thread 1: 1
Thread 1: 2
Thread 1: 3
Thread 1: 4
Thread 1: 5
Thread 1: 7
Thread 1: 8
Thread 1: 9
Thread 2: 2
Thread 2: 3
Thread 2: 4
Thread 2: 5
Main Thread: 6
Main Thread: 7
Main Thread: 8
Main Thread: 9
  • 补充2：udpsocket+crossbeam无锁队列+数据筛选
  1. udpserver.rs
use crossbeam::{self, queue::SegQueue, scope};
use std::net::{Ipv4Addr, UdpSocket};
use std::{thread, time::Duration};

fn main() {
    let socket = UdpSocket::bind("127.0.0.1:8888").unwrap();
    let multicast_addr = Ipv4Addr::new(234, 2, 2, 2);
    let inter = Ipv4Addr::new(0, 0, 0, 0);
    socket.join_multicast_v4(&multicast_addr, &inter).unwrap();

    let seg_queue = SegQueue::<u8>::new();
    scope(|s| {
        s.spawn(|_| loop {
            let mut buf = [0; 1024];
            let (number_of_bytes, _) = socket.recv_from(&mut buf).unwrap();
            for i in 0..number_of_bytes {
                seg_queue.push(buf[i]);
            }
        });
        s.spawn(|_| loop {
            let mut data = [0u8; 4];
            let mut d1 = 0u8;
            let mut d2 = 0u8;
            let mut index = 0;
            while let Some(item) = seg_queue.pop() {
                if index == 0 {
                    if item == 1u8 {
                        d1 = item;
                        index += 1;
                    } else {
                        continue;
                    }
                } else if index == 1 {
                    if item == 2u8 {
                        d2 = item;
                        data[0] = d1;
                        data[1] = d2;
                        index += 1;
                    } else {
                        index = 0;
                        continue;
                    }
                } else {
                    data[index] = item;
                    if index == 3 {
                        index = 0;
                        println!("receive: {:#?}", data);
                        continue;
                    }
                    index += 1;
                }
                thread::sleep(Duration::from_millis(5));
            }
        });
    })
    .unwrap();
    socket.leave_multicast_v4(&multicast_addr, &inter).unwrap();
}
  1. udpclient.rs
use std::net::UdpSocket;
use std::thread;

fn main() {
    let socket = UdpSocket::bind("127.0.0.1:1111").unwrap();
    const COUNT: usize = 10;
    loop {
        let mut buf = [0x41; COUNT];
        for i in 0..COUNT {
            buf[i] = (i + 1) as u8;
        }
        println!("send: {:#?}", buf);
        socket.send_to(&buf, "127.0.0.1:8888").unwrap();
        thread::sleep(std::time::Duration::from_millis(1000));
    }
}
  1. 效果

在这里插入图片描述

  • 补充3：数据流提取帧的一个算法
s.spawn(|_| {
            let mut data = [0u8; 5];
            let mut data_index = 0;

            loop {
                let mut buf = [0u8; 65535];
                let (number_of_bytes, _) = socket.recv_from(&mut buf).unwrap();
                let filled_buf = &mut buf[..number_of_bytes];
                
                for i in 0..number_of_bytes {
                    if data_index == 0 {
                        if filled_buf[i] == 0x1 {
                            data[data_index] = filled_buf[i];
                            data_index += 1;
                        }
                    } else if data_index == 1 {
                        if filled_buf[i] == 0x2 {
                            data[data_index] = filled_buf[i];
                            data_index += 1;
                        } else {
                            data_index = 0;
                        }
                    } else if data_index == 4 {
                        if filled_buf[i] == 0x5 {
                            data[data_index] = filled_buf[i];
                            println!("algrithm2：{:#?}", data);
                        }
                        data_index = 0;
                    } else {
                        data[data_index] = filled_buf[i];
                        data_index += 1;
                    }
                }
                

                //for i in 0..number_of_bytes {
                //    seg_queue.push(buf[i]);
                //}
            }
        });

总结

以上就是今天要讲的内容，本文仅仅简单介绍了rust Udp 组播的使用，而std::net提供了大量能使我们快速便捷地处理数据的函数和方法。

gregmankiw
关注
  • 14
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Rust and C 多播案例
aLingYun的博客
05-08 616
下面将分别用 Rust 和 C 实现一个 Linux 上的多播案例：发送端循环发送十次数据，接受端循环接收十次数据并打印到屏幕。 Rust 实现 // ./send/src/main.rs use std::net::UdpSocket; use std::thread; fn main() { let socket = UdpSocket::bind("127.0.0.1:9999").unwrap(); const COUNT: usize = 100; for i in 0.
mdns:Rust中的多播DNS客户端
05-25
dns Rust中的组播DNS客户端。 错误日志记录由log库处理。 例子 查找本地网络上所有Chromecast的IP地址。 use futures_util :: {pin_mut, stream :: StreamExt}; use mdns :: {Error, Record, RecordKind}; use std :: {net :: IpAddr, time :: Duration}; const SERVICE_NAME: & ' static str = "_googlecast._tcp.local" ; #[async_std::main] async fn main () -> Result <(), Error> { // Iterate through responses from each Cast device, asking for new
Rust实现udp 服务端和客户端
、Edgar的博客
08-21 1582
客户端 use std::io::{self}; use std::net::UdpSocket; fn main() { let client = UdpSocket::bind("127.0.0.1:8889").unwrap(); client.connect("127.0.0.1:8080").unwrap(); let mut buf = String::new(); loop { let size = io::stdin().read_lin
Socket网络编程之组播实现（C++，Rust）
让我思考一下
07-11 1万+
实际项目中，经常需要使用组播，本文给出了组播代码示例......
udp网络通信例子源代码(单播、组播、广播）
11-22
udp网络通信例子源代码(单播、组播、广播）
Rust网络编程入门：TCP与UDP的精髓解析
silenceallat的博客
04-18 722
本文深入探讨了Rust语言中的网络编程基础，详细介绍了TCP和UDP协议的使用方法。通过实际案例，我们学习了如何使用Rust标准库进行TCP和UDP编程，并探讨了如何使用async-std库和tokio进行异步网络编程。同时，我们还介绍了网络编程中的性能优化和错误处理技巧。希望本文能为初学者提供Rust网络编程的敲门砖，并在实际项目中灵活应用所学知识。
rust-json-over-udp-example:Rust 中的 JSON-over-UDP 示例
06-07
Rust 中的 JSON-over-UDP 示例 设置 安装 Rust 和 netcat 用法 打开终端并输入： cargo run 然后在另一种终端类型中： echo -n '{"recipient":"lauri","content":"foo"}' | nc -u 127.0.0.1 34254 # nc is ...
godot-rust-first-try：godot-rust绑定：first-try
02-04
总之，"godot-rust-first-try"项目展示了如何结合Godot和Rust的优势，为游戏开发提供一个强大且安全的解决方案。通过学习和实践，开发者可以提高开发效率，编写出更加稳定、高效的代码，进一步提升游戏的品质。
rust-crypto-nacl:Rust-Crypto-NaCl
06-25
Rust-Crypto-NaCl 选定 NaCl 原语的基于 Rust-Crypto 的实现。 Rust-Crypto-NaCl 试图从流行的 NaCl/TweetNaCl/libsodium 密码库家族中提供精选的高级原语。 具有仿照 API 的 C++ 版本建模的接口。用法要使用 Rust-...
Rust 从入门到精通01-简介-rust编译器
06-28
Rust 语言始于 2006 年，最初是由 Mozilla 公司员工 Graydon Hoare 个人发起的一个项目。随着项目的进展，Mozilla 在 2009 年正式开始支持该项目。Rust 的首个版本号编译器于 2012 年 1 月发布，而 Rust 1.0 的稳定...
TCP UDP 测试工具，网络开发测试必备工具
08-08
TCP UDP 测试工具 网络开发 网络测试 网络工具
Rust通用代码生成器：莲花-Rust资源
最新发布
07-01
RustJavaRust rust 1.69Axum 0.6.20Tokio 1.32.0sqlx 0.7.1MariaDB, MySQL 8, PostgreSQLOracle
145、Rust语言高级网络编程：TCP与UDP实战
silenceallat的博客
04-29 896
本文介绍了Rust语言中TCP和UDP协议的高级特性，并通过实际案例展示了如何使用这些特性构建高性能的网络应用。我们深入了解了TCP和UDP协议的基本概念和高级特性，并学会了如何使用`tokio-tcp`和`tokio-udp`库进行Rust网络编程。通过本文，读者应该能够更好地利用Rust语言和网络协议的高级特性来构建高效的网络应用。
UDP通信绑定指定IP
热门推荐
蚂蚁啃大象
03-16 1万+
<br />由于测试需要，自己用vconfig在自己的虚拟机里添加了很多ip，实现不同Ip间的通信。UDP客户端向服务器发送报文时，绑定会有最近IP原则，比如，你机器上有如下几个IP：10.1.1.1   ，10.1.1.2 ，  10.1.1.50,  10.1.2.51 ， 10.1.2.90  ， 10.1.3.91 ，10.0.0.1， 192.168.42.137，现在要向192.168.42.1发送报文，系统会自动给你分配离192.168.42.1最近的ip 192.168.42.137绑定，如
计算机网络知识详解：Rust中DHCP服务器分配IP地址的过程
IraDebug的博客
09-17 169
其中，DHCP_SERVER_ADDR指定了DHCP服务器的地址和端口，DHCP_CLIENT_ADDR指定了DHCP客户端的地址和端口，DHCP_POOL_START和DHCP_POOL_END指定了IP地址池的起始和结束地址，DHCP_LEASE_TIME指定了IP地址的租约时间，DHCP_MAGIC_COOKIE是DHCP协议中的魔术数。在本文中，我们将使用Tokio来实现我们的DHCP服务器。然后，我们使用自定义的DhcpPacket结构体来解析DHCP请求，并根据消息类型执行相应的处理逻辑。
Rust pnet库的使用
techdashen的博客
01-10 1218
是最常用的网络诊断工具之一，用于测试机器之间的连通性。关于"eth0"和"tun3",这是两种不同类型的网络接口，简言之,"eth0"是一种物理以太网接口，通常用于常规的网络通信，而"tun3"是一种虚拟网络接口，通常用于建立安全的隧道连接。ICMP是包含在IP数据包中的，但是对ICMP消息通常会特殊处理，会和一般IP数据包的处理不同，而不是作为IP的一个子协议来处理。ping 则是用ICMP的"Echo request"（类别代码：8）和"Echo reply"（类别代码：0）消息来实现的。
Socket网络编程之UDP实现(C++，Rust)
m0_67401920的博客
04-22 1513
以下是最基础的UDP服务端与客户端源代码，实现客户端发送数据，服务器接收数据的功能。与TCP的区别在于客户端与服务端无需经过三次握手建立连接，可直接在相应端口收发数据。且内部没有流控，重发等机制进行可靠性保证，协议实现相对TCP简单。可简单认为是带有端口信息的IP数据报。 一、C++实现 【1】服务端源代码（Windows） #include "stdafx.h" #include<WinSock2.h> #include<iostream> using namespace std
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值