titanite 0.3.0

Client/Server Library for Gemini protocol with Titan support
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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

pub mod expected;
pub mod not_authorized;
pub mod not_valid;

pub use expected::Expected;
pub use not_authorized::NotAuthorized;
pub use not_valid::NotValid;

use anyhow::{bail, Result};

/// [Client certificates](https://geminiprotocol.net/docs/protocol-specification.gmi#client-certificates)
pub enum Certificate {
    Expected(Expected),
    NotAuthorized(NotAuthorized),
    NotValid(NotValid),
}

impl Certificate {
    pub fn from_bytes(buffer: &[u8]) -> Result<Self> {
        if buffer.first().is_none_or(|b| *b != b'6') {
            bail!("Unexpected first byte")
        }
        match buffer.get(1) {
            Some(byte) => Ok(match byte {
                b'0' => Self::Expected(Expected::from_bytes(buffer)?),
                b'1' => Self::NotAuthorized(NotAuthorized::from_bytes(buffer)?),
                b'2' => Self::NotValid(NotValid::from_bytes(buffer)?),
                b => bail!("Unexpected second byte: {b}"),
            }),
            None => bail!("Invalid request"),
        }
    }
    pub fn into_bytes(self) -> Vec<u8> {
        match self {
            Self::Expected(this) => this.into_bytes(),
            Self::NotAuthorized(this) => this.into_bytes(),
            Self::NotValid(this) => this.into_bytes(),
        }
    }
}

#[test]
fn test() {
    // 60
    let request = format!("60 message\r\n");
    let source = Certificate::from_bytes(request.as_bytes()).unwrap();

    match source {
        Certificate::Expected(ref this) => assert_eq!(this.message, Some("message".to_string())),
        _ => panic!(),
    }
    assert_eq!(source.into_bytes(), request.as_bytes());

    // 61
    let request = format!("61 message\r\n");
    let source = Certificate::from_bytes(request.as_bytes()).unwrap();

    match source {
        Certificate::NotAuthorized(ref this) => {
            assert_eq!(this.message, Some("message".to_string()))
        }
        _ => panic!(),
    }
    assert_eq!(source.into_bytes(), request.as_bytes());

    // 62
    let request = format!("62 message\r\n");
    let source = Certificate::from_bytes(request.as_bytes()).unwrap();

    match source {
        Certificate::NotValid(ref this) => assert_eq!(this.message, Some("message".to_string())),
        _ => panic!(),
    }
    assert_eq!(source.into_bytes(), request.as_bytes());
}