Module scionstack 

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_proto::address::SocketAddr;
use scion_stack::scionstack::{ScionStack, ScionStackBuilder};
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(control_plane_addr).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: SocketAddr = "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_proto::address::SocketAddr;
use scion_stack::scionstack::{ScionStack, ScionStackBuilder};
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(control_plane_addr).with_auth_token("SNAP token".to_string());

// Parse destination address
let destination: SocketAddr = "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_proto::{address::SocketAddr, path::Path};
use scion_stack::scionstack::{ScionStack, ScionStackBuilder};
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(control_plane_addr).with_auth_token("SNAP token".to_string());

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

// Create a local path for demonstration
let path: scion_proto::path::Path<bytes::Bytes> = Path::local(bind_addr.isd_asn());

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.to_slice_path())
    .await?;
let mut buffer = [0u8; 1024];
let (len, sender) = socket.recv_from(&mut buffer).await?;
println!("Received: {:?} from {:?}", &buffer[..len], sender);

Advanced Usage

Custom path selection

// Implement your own path selection logic
use std::{sync::Arc, time::Duration};

use bytes::Bytes;
use chrono::{DateTime, Utc};
use scion_proto::{
    address::{IsdAsn, SocketAddr},
    path::Path,
};
use scion_stack::{
    path::manager::traits::PathManager,
    scionstack::{ScionStack, ScionStackBuilder, UdpScionSocket},
    types::ResFut,
};

struct MyCustomPathManager;

impl scion_stack::path::manager::traits::SyncPathManager for MyCustomPathManager {
    fn register_path(
        &self,
        _src: IsdAsn,
        _dst: IsdAsn,
        _now: DateTime<Utc>,
        _path: Path<Bytes>,
    ) {
        // Optionally implement registration logic
    }

    fn try_cached_path(
        &self,
        _src: IsdAsn,
        _dst: IsdAsn,
        _now: DateTime<Utc>,
    ) -> std::io::Result<Option<Path<Bytes>>> {
        todo!()
    }
}

impl scion_stack::path::manager::traits::PathManager for MyCustomPathManager {
    fn path_wait(
        &self,
        src: IsdAsn,
        _dst: IsdAsn,
        _now: DateTime<Utc>,
    ) -> impl ResFut<'_, Path<Bytes>, scion_stack::path::manager::traits::PathWaitError>
    {
        async move { Ok(Path::local(src)) }
    }
}

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

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

let scion_stack = builder.build().await?;
let path_unaware_socket = scion_stack.bind_path_unaware(Some(bind_addr)).await?;
let socket = UdpScionSocket::new(
    path_unaware_socket,
    Arc::new(MyCustomPathManager),
    Duration::from_secs(30),
    scion_stack::types::Subscribers::new(),
);
socket.send_to(b"hello", destination).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.

quic

SCION stack QUICK endpoint.

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.

SocketKind

Available kinds of SCION sockets.

Constants

DEFAULT_CONNECT_TIMEOUT

Default timeout for creating a connected socket