https://github.com/sile/rusturn

A Rust Implementation of TURN server and client
https://github.com/sile/rusturn

asynchronous rust turn

Last synced: 10 months ago
JSON representation

A Rust Implementation of TURN server and client

• Host: GitHub
• URL: https://github.com/sile/rusturn
• Owner: sile
• License: mit
• Created: 2017-02-28T17:04:55.000Z (over 9 years ago)
• Default Branch: master
• Last Pushed: 2024-02-23T01:05:25.000Z (over 2 years ago)
• Last Synced: 2024-05-01T23:47:29.492Z (about 2 years ago)
• Topics: asynchronous, rust, turn
• Language: Rust
• Size: 132 KB
• Stars: 105
• Watchers: 6
• Forks: 10
• Open Issues: 2
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

          
rusturn

=======

[![rusturn](https://img.shields.io/crates/v/rusturn.svg)](https://crates.io/crates/rusturn)

[![Documentation](https://docs.rs/rusturn/badge.svg)](https://docs.rs/rusturn)

[![Actions Status](https://github.com/sile/rusturn/workflows/CI/badge.svg)](https://github.com/sile/rusturn/actions)

[![Coverage Status](https://coveralls.io/repos/github/sile/rusturn/badge.svg?branch=master)](https://coveralls.io/github/sile/rusturn?branch=master)

[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)

A Rust implementation of [TURN][RFC 5766] server and client.

[Documentation](https://docs.rs/rusturn)

Examples

--------

```rust

use futures::Future;

use rustun::message::Request;

use rustun::transport::StunUdpTransporter;

use rusturn::auth::AuthParams;

use rusturn::transport::UdpOverTurnTransporter;

use stun_codec::{rfc5389, MessageDecoder, MessageEncoder};

let client_auth_params = AuthParams::new("foo", "bar")?;

let server_auth_params =

    AuthParams::with_realm_and_nonce("foo", "bar", "baz", "qux")?;

// STUN server (peer)

let stun_server = fibers_global::execute(rustun::server::UdpServer::start(

    fibers_global::handle(),

    "127.0.0.1:0".parse().unwrap(),

    rustun::server::BindingHandler,

))?;

let stun_server_addr = stun_server.local_addr();

fibers_global::spawn(stun_server.map(|_| ()).map_err(|e| panic!("{}", e)));

// TURN server

let turn_server = fibers_global::execute(rusturn::server::UdpServer::start(

    "127.0.0.1:0".parse().unwrap(),

    server_auth_params,

))?;

let turn_server_addr = turn_server.local_addr();

fibers_global::spawn(turn_server.map_err(|e| panic!("{}", e)));

// TURN client

let turn_client = fibers_global::execute(rusturn::client::UdpClient::allocate(

    turn_server_addr,

    client_auth_params

))?;

let transporter =

    UdpOverTurnTransporter::<_, MessageEncoder<_>, MessageDecoder<_>>::new(turn_client);

// STUN client (over TURN)

let stun_channel = rustun::channel::Channel::new(StunUdpTransporter::new(transporter));

let stun_client = rustun::client::Client::new(&fibers_global::handle(), stun_channel);

// BINDING request

let request = Request::::new(rfc5389::methods::BINDING);

let response = fibers_global::execute(

    stun_client.call(stun_server_addr, request)

)?;

assert!(response.is_ok(), "{:?}", response);

```

References

----------

- [RFC 5766: Traversal Using Relays around NAT (TURN)][RFC 5766]

[RFC 5766]: https://tools.ietf.org/html/rfc5766