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
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

use std::sync::Arc;

use prax::Filter;

use super::{view::ViewOp, NVim};

use prax::{Req, Res};
use tokio::sync::{Mutex, Notify};

use prax::lines::{LinesImprint, ToLines};

#[derive(Clone)]
pub struct Intercept(Arc<Mutex<NVim>>);

impl From<NVim> for Intercept {
    fn from(value: NVim) -> Self {
        Intercept(Arc::new(Mutex::new(value)))
    }
}

impl Filter for Intercept {
    async fn modify_request(&self, hostname: &str, req: &mut Req<Vec<u8>>) -> prax::Result<()> {
        let nvim = self.0.lock().await;
        nvim.modify_request(hostname, req).await
    }

    async fn modify_response(&self, hostname: &str, req: &mut Res<Vec<u8>>) -> prax::Result<()> {
        let nvim = self.0.lock().await;
        nvim.modify_response(hostname, req).await
    }
}

impl Filter for NVim {
    async fn modify_request(&self, _: &str, req: &mut Req<Vec<u8>>) -> prax::Result<()> {
        let content = req.to_lines()?;

        let notify = {
            let mut backlog = self.backlog.lock().await;

            if self
                .action
                .send(ViewOp::Intercept {
                    title: "Intercept Request".into(),
                    content,
                })
                .await
                .is_err()
            {
                return Ok(());
            };

            let notify = Arc::new(Notify::new());
            backlog.push_back(notify.clone());
            notify
        };

        notify.notified().await;

        let view = self.view.lock().await;
        let content = view.intercept_buffer().await?;

        req.imprint(content)?;

        Ok(())
    }

    async fn modify_response(&self, _: &str, res: &mut Res<Vec<u8>>) -> prax::Result<()> {
        let content = res.to_lines()?;

        let notify = {
            let mut backlog = self.backlog.lock().await;

            if self
                .action
                .send(ViewOp::Intercept {
                    title: "Intercept Response".into(),
                    content,
                })
                .await
                .is_err()
            {
                return Ok(());
            }

            let notify = Arc::new(Notify::new());
            backlog.push_back(notify.clone());
            notify
        };

        notify.notified().await;

        let view = self.view.lock().await;
        let content = view.intercept_buffer().await?;

        res.imprint(content)?;

        Ok(())
    }
}