venues 0.3.2

Privacy friendly online meeting service
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use std::io;

use async_std::{
    channel::Sender,
    net::{TcpStream, ToSocketAddrs},
};
use futures::AsyncWriteExt;
use log::*;
use rustls_acme::{futures_rustls::server::TlsStream, AccountCache, CertCache};

pub async fn acme(
    prod: bool,
    on: impl ToSocketAddrs + std::fmt::Debug,
    domains: impl IntoIterator<Item = impl AsRef<str>>,
    contact: Option<impl AsRef<str>>,
    cert_tx: Sender<Option<(Vec<String>, Vec<u8>)>>,
    conns_tx: Option<Sender<TlsStream<TcpStream>>>,
) {
    let res = acme_handle(prod, on, domains, contact, cert_tx.clone(), conns_tx).await;
    if let Err(e) = res {
        warn!("ACME failed: {e}")
    }
    // making sure we keep a ref to sender to keep channel alive
    cert_tx.send(None).await.expect("no certs to send");
}

async fn acme_handle(
    prod: bool,
    on: impl ToSocketAddrs + std::fmt::Debug,
    domains: impl IntoIterator<Item = impl AsRef<str>>,
    contact: Option<impl AsRef<str>>,
    cert_tx: Sender<Option<(Vec<String>, Vec<u8>)>>,
    conns_tx: Option<Sender<TlsStream<TcpStream>>>,
) -> std::io::Result<()> {
    use futures::prelude::stream::StreamExt;
    use rustls_acme::{caches::DirCache, AcmeConfig};

    let contact = contact
        .ok_or_else(|| io::Error::new(io::ErrorKind::Other, "No ACME without contact (mailto:)"))?;

    let cfg = AcmeConfig::new(domains)
        .contact_push(contact)
        .cache(SharingCache(DirCache::new("./rustls_acme_cache"), cert_tx))
        .directory_lets_encrypt(prod);

    info!("Running ACME on {on:?}: {cfg:?}");

    let tcp_listener = async_std::net::TcpListener::bind(on).await?;

    let mut tls_incoming = cfg.incoming(tcp_listener.incoming(), Vec::new());

    while let Some(tls) = tls_incoming.next().await {
        let mut tls = tls?;
        if let Some(tx) = &conns_tx {
            tx.send(tls).await;
        } else {
            tls.write_all(HELLO).await?;
            tls.close().await?;
        }
    }
    const HELLO: &'static [u8] = br#"HTTP/1.1 200 OK
Content-Length: 10
Content-Type: text/plain; charset=utf-8

Hello Tls!"#;
    Ok(())
}

struct SharingCache<T>(T, Sender<Option<(Vec<String>, Vec<u8>)>>);

#[async_trait::async_trait]
impl<T> AccountCache for SharingCache<T>
where
    T: AccountCache,
{
    type EA = T::EA;

    #[must_use]
    #[allow(clippy::type_complexity, clippy::type_repetition_in_bounds)]
    async fn load_account(
        &self,
        contact: &[String],
        directory_url: &str,
    ) -> Result<Option<Vec<u8>>, Self::EA> {
        self.0.load_account(contact, directory_url).await
    }

    #[must_use]
    #[allow(clippy::type_complexity, clippy::type_repetition_in_bounds)]
    async fn store_account(
        &self,
        contact: &[String],
        directory_url: &str,
        account: &[u8],
    ) -> Result<(), Self::EA> {
        self.0.store_account(contact, directory_url, account).await
    }
}
#[async_trait::async_trait]

impl<T> CertCache for SharingCache<T>
where
    T: CertCache + std::marker::Sync + std::marker::Send,
    T::EC: std::marker::Sync + std::marker::Send,
{
    type EC = T::EC;

    #[must_use]
    #[allow(clippy::type_complexity, clippy::type_repetition_in_bounds)]
    async fn load_cert(
        &self,
        domains: &[String],
        directory_url: &str,
    ) -> Result<Option<Vec<u8>>, Self::EC> {
        let loaded = self.0.load_cert(domains, directory_url).await;
        match loaded {
            Ok(Some(cert)) => {
                self.1
                    .send(Some((domains.to_vec(), cert.clone())))
                    .await
                    .ok();
                Ok(Some(cert))
            }
            other => other,
        }
    }

    #[must_use]
    #[allow(clippy::type_complexity, clippy::type_repetition_in_bounds)]
    async fn store_cert(
        &self,
        domains: &[String],
        directory_url: &str,
        cert: &[u8],
    ) -> Result<(), Self::EC> {
        self.1
            .send(Some((domains.to_vec(), cert.to_vec())))
            .await
            .ok();
        self.0.store_cert(domains, directory_url, cert).await
    }
}