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

NetworkError

Network errors.

ScionSocketBindError

Error return when binding a socket.

ScionSocketConnectError

SCION socket connect errors.

ScionSocketReceiveError

SCION socket receive errors.

ScionSocketSendError

SCION socket send errors.

SocketKind

Available kinds of SCION sockets.

Constants

DEFAULT_CONNECT_TIMEOUT

Default timeout for creating a connected socket