beem 0.1.1

Object protocol base for weev
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

#![no_std]
use embedded_io::{ErrorType, Read, ReadExactError, Write};

use weev::Stream;
use sha3::Digest;

pub trait Beem: ErrorType + Sized{
    fn accept(&mut self, seed: &[u8]) -> Result<Self,Self::Error>;
    fn offer(&mut self) -> Result<Self,ReadExactError<Self::Error>>;
}
pub trait AsyncBeem: ErrorType + Sized{
    async fn accept(&mut self, seed: &[u8]) -> Result<Self,Self::Error>;
    async fn offer(&mut self) -> Result<Self,ReadExactError<Self::Error>>;
}
impl<S: Clone,Q: Clone> Beem for Stream<S,Q> where Stream<S,Q>: embedded_io::Read + embedded_io::Write{
    fn accept(&mut self, seed: &[u8]) -> Result<Self,Self::Error> {
        let seed: [u8;32] = sha3::Sha3_256::digest(seed).try_into().unwrap();
        self.write_all(&seed)?;
        let mut n = sha3::Sha3_256::new();
        n.update(seed);
        n.update(self.sid);
        let n = n.finalize().try_into().unwrap();
        Ok(Self { core: self.core.clone(), sid: n })
    }

    fn offer(&mut self) -> Result<Self, ReadExactError<Self::Error>> {
        let mut seed = [0u8;32];
        self.read_exact(&mut seed)?;
        let mut n = sha3::Sha3_256::new();
        n.update(seed);
        n.update(self.sid);
        let n = n.finalize().try_into().unwrap();
        Ok(Self { core: self.core.clone(), sid: n })
    }
}
impl<S: Clone,Q: Clone> AsyncBeem for Stream<S,Q> where Stream<S,Q>: embedded_io_async::Read + embedded_io_async::Write{
    async fn accept(&mut self, seed: &[u8]) -> Result<Self,Self::Error> {
        use embedded_io_async::Write;
        let seed: [u8;32] = sha3::Sha3_256::digest(seed).try_into().unwrap();
        self.write_all(&seed).await?;
        let mut n = sha3::Sha3_256::new();
        n.update(seed);
        n.update(self.sid);
        let n = n.finalize().try_into().unwrap();
        Ok(Self { core: self.core.clone(), sid: n })
    }

    async fn offer(&mut self) -> Result<Self, ReadExactError<Self::Error>> {
        use embedded_io_async::Read;
        let mut seed = [0u8;32];
        self.read_exact(&mut seed).await?;
        let mut n = sha3::Sha3_256::new();
        n.update(seed);
        n.update(self.sid);
        let n = n.finalize().try_into().unwrap();
        Ok(Self { core: self.core.clone(), sid: n })
    }
}