Struct portal_lib::Portal

pub struct Portal { /* fields omitted */ }

The primary interface into the library. The Portal struct contains data associated with either a new request or a response from a peer.

Implementations

impl Portal

pub fn init(
    direction: Direction,
    id: String,
    password: String,
    filename: Option<String>
) -> (Portal, Vec<u8>)

Initialize a new portal request

Example

use portal_lib::{Portal,Direction};
 
// the shared password should be secret and hard to guess/crack
// see the portal-client as an example of potential usage
let id = "my client ID".to_string();
let password = "testpasswd".to_string(); 
let portal = Portal::init(Direction::Sender,id,password,None);

pub fn parse(data: &[u8]) -> Result<Portal>

Initialize with existing data, attempting to deserialize bytes into a Portal struct

Example

use portal_lib::Portal;
use std::io::Read;
fn example(mut client: std::net::TcpStream) { 
    let mut buf = [0; 1024];
    let len = client.read(&mut buf);
    let response = match Portal::parse(&buf) {
         Ok(r) => r,
         Err(_) => {
              println!("Failed to read request/response...");
              return;
         }
    };
}

pub fn read_response_from<R>(reader: R) -> Result<Portal> where
    R: Read, 

Initialize by reading from a stream that implements the std::io::Read trait, consuming the bytes

Example

use portal_lib::Portal;
fn example(client: std::net::TcpStream) { 
    let response = match Portal::read_response_from(&client) {
         Ok(r) => r,
         Err(_) => {
              println!("Failed to read response...");
              return;
         }
    };
}

pub fn read_confirmation_from<R>(reader: R) -> Result<PortalConfirmation> where
    R: Read, 

Receive the bytes necessary for a confirmation message from a stream that implements std::io::Read, consuming the bytes

pub fn serialize(&self) -> Result<Vec<u8>>

Attempt to serialize a Portal struct into a vector

pub fn load_file<'a>(&'a self, f: &str) -> Result<PortalFile>

pub fn create_file<'a>(&'a self, f: &str, size: u64) -> Result<PortalFile>

pub fn derive_key(&mut self, msg_data: &[u8]) -> Result<()>

Derive a shared key with the exchanged data at this point in the exchange we have not verified that our peer has derived the same key as us

pub fn confirm_peer<R>(&mut self, client: R) -> Result<()> where
    R: Read + Write, 

Confirm that the peer has derived the same key

pub fn get_file_size(&self) -> u64

Returns the file size associated with this request

pub fn set_file_size(&mut self, size: u64)

Sets the file size associated with this request

pub fn get_file_name<'a>(&'a self) -> Result<&'a str>

Returns the file name associated with this request or a PortalError::NoneError if none exists

pub fn get_direction(&self) -> Direction

Returns a copy of the Portal::Direction associated with this Portal request

pub fn set_direction(&mut self, direction: Direction)

Sets the Portal::Direction associated with this Poral request

pub fn get_id(&self) -> &String

Returns a reference to the ID associated with this Portal request

pub fn set_id(&mut self, id: String)

Sets the ID associated with this Poral request

Trait Implementations

impl Debug for Portal

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Portal

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl PartialEq<Portal> for Portal

fn eq(&self, other: &Portal) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Portal) -> bool

This method tests for !=.

impl Serialize for Portal

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Portal