prax 0.1.1

a web penetration proxy hosted in neovim
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

use std::{net::SocketAddr, sync::Arc};

use http_body_util::Full;
use hyper::{body::Bytes, client::conn::http1::SendRequest};
use tokio::sync::{Mutex, RwLock};
use tokio_util::sync::CancellationToken;

mod listen;
mod service;
mod tls;

pub use self::tls::Tls;

pub struct Server<F, S: 'static> {
    addr: SocketAddr,
    token: CancellationToken,
    filter: Arc<RwLock<Arc<F>>>,
    scribe: &'static S,
    tls: Option<Tls>,
}

pub struct Tunnel<F, S: 'static> {
    sender: Arc<Mutex<SendRequest<Full<Bytes>>>>,
    host: String,
    server: Server<F, S>,
}

impl<F, S: 'static> Clone for Server<F, S> {
    fn clone(&self) -> Self {
        Server {
            token: self.token.clone(),
            addr: self.addr,
            filter: self.filter.clone(),
            scribe: self.scribe,
            tls: self.tls.clone(),
        }
    }
}

impl<F, S> Server<F, S> {
    pub fn new(
        addr: SocketAddr,
        token: CancellationToken,
        filter: F,
        scribe: &'static S,
        tls: Option<Tls>,
    ) -> Self {
        let filter = Arc::new(RwLock::new(Arc::new(filter)));

        Server {
            addr,
            token,
            filter,
            scribe,
            tls,
        }
    }

    pub async fn replace(&self, filter: F) {
        let mut f = self.filter.write().await;

        *f = Arc::new(filter);
    }
}