Module stack 

The SCION endhost stack.

ScionStack is a stateful object that is the conceptual equivalent of the TCP/IP-stack found in today’s common operating systems. It is meant to be instantiated once per process.

Basic Usage

Creating a path-aware socket (recommended)

use scion_stack::stack::{ScionStack, ScionStackBuilder};
use sciparse::address::ip_socket_addr::ScionSocketIpAddr;
use url::Url;

// Create a SCION stack builder
let control_plane_addr: url::Url = "http://127.0.0.1:1234".parse()?;
let builder = ScionStackBuilder::new().with_auth_token("SNAP token".to_string());

let scion_stack = builder.build().await?;
let socket = scion_stack.bind(None).await?;

// Parse destination address
let destination: ScionSocketIpAddr = "1-ff00:0:111,[192.168.1.1]:8080".parse()?;

socket.send_to(b"hello", destination).await?;
let mut buffer = [0u8; 1024];
let (len, src) = socket.recv_from(&mut buffer).await?;
println!("Received: {:?} from {:?}", &buffer[..len], src);

Creating a connected socket.

use scion_stack::stack::{ScionStack, ScionStackBuilder};
use sciparse::address::ip_socket_addr::ScionSocketIpAddr;
use url::Url;

// Create a SCION stack builder
let control_plane_addr: url::Url = "http://127.0.0.1:1234".parse()?;
let builder = ScionStackBuilder::new().with_auth_token("SNAP token".to_string());

// Parse destination address
let destination: ScionSocketIpAddr = "1-ff00:0:111,[192.168.1.1]:8080".parse()?;

let scion_stack = builder.build().await?;
let connected_socket = scion_stack.connect(destination, None).await?;
connected_socket.send(b"hello").await?;
let mut buffer = [0u8; 1024];
let len = connected_socket.recv(&mut buffer).await?;
println!("Received: {:?}", &buffer[..len]);

Creating a path-unaware socket

use scion_stack::stack::{ScionStack, ScionStackBuilder};
use sciparse::{address::ip_socket_addr::ScionSocketIpAddr, path::ScionPath};
use url::Url;

// Create a SCION stack builder
let control_plane_addr: url::Url = "http://127.0.0.1:1234".parse()?;
let builder = ScionStackBuilder::new().with_auth_token("SNAP token".to_string());

// Parse addresses
let bind_addr: ScionSocketIpAddr = "1-ff00:0:110,[127.0.0.1]:8080".parse()?;
let destination: ScionSocketIpAddr = "1-ff00:0:111,[127.0.0.1]:9090".parse()?;

// Create a local path for demonstration
let path = ScionPath::local(bind_addr.isd_asn()).expect("not a wildcard AS");

let scion_stack = builder.build().await?;
let socket = scion_stack.bind_path_unaware(Some(bind_addr)).await?;
socket.send_to_via(b"hello", destination, &path).await?;
let mut buffer = [0u8; 1024];
let (len, sender) = socket.recv_from(&mut buffer).await?;
println!("Received: {:?} from {:?}", &buffer[..len], sender);

Resolving SCION TXT records

use scion_stack::resolver::{ScionDnsResolver, txt::ScionTxtDnsResolver};

let resolver = ScionTxtDnsResolver::new()?;
let addresses = resolver.resolve("example.com").await?;

for address in addresses {
    println!("Resolved: {}", address);
}

Advanced Usage

Inspecting and choosing paths manually

Path-aware sockets manage path selection automatically. To choose a path deliberately, use a path-unaware socket (ScionStack::bind_path_unaware) together with a PathFetcher obtained from create_path_fetcher: fetch the set of available paths, pick one, and send over it with send_to_via.

use scion_stack::{path::fetcher::traits::PathFetcher, stack::ScionStackBuilder};
use sciparse::address::ip_socket_addr::ScionSocketIpAddr;

let stack = ScionStackBuilder::new()
    .with_auth_token("SNAP token".to_string())
    .build()
    .await?;

let bind_addr: ScionSocketIpAddr = "1-ff00:0:110,[127.0.0.1]:8080".parse()?;
let destination: ScionSocketIpAddr = "1-ff00:0:111,[127.0.0.1]:9090".parse()?;

let socket = stack.bind_path_unaware(Some(bind_addr)).await?;

// Fetch the available paths to the destination and pick one deliberately.
let paths = stack
    .create_path_fetcher()
    .fetch_paths(bind_addr.isd_asn(), destination.isd_asn())
    .await?;
let path = paths.first().ok_or("no path to destination")?;

socket.send_to_via(b"hello", destination, path).await?;

Re-exports

pub use socket::PathUnawareUdpScionSocket;

pub use socket::RawScionSocket;

pub use socket::ScmpScionSocket;

pub use socket::UdpScionSocket;

pub use self::builder::ScionStackBuilder;

Modules

builder

SCION stack builder.

scmp_handler

SCION stack SCMP handlers.

socket

SCION socket types.

Structs

ScionStack

The SCION stack can be used to create path-aware SCION sockets or even Quic over SCION connections.

SocketConfig

Configuration for a path aware socket.

Enums

InvalidBindAddressError

Error related to the bind address of the socket.

ScionSocketBindError

Error return when binding a socket.

ScionSocketConnectError

SCION socket connect errors.

ScionSocketReceiveError

SCION socket receive errors.

ScionSocketSendError

SCION socket send errors.

SnapConnectionError

Error related to the connection to the SNAP data plane.

Constants

DEFAULT_CONNECT_TIMEOUT

Default timeout for creating a connected socket

DEFAULT_SEGMENT_FETCHER_TIMEOUT

Default timeout for segment fetchers to avoid waiting indefinitely for slow or unresponsive fetchers.