eejit 0.2.1

A self-hosted Git server that's easy to set up, use, and maintain.
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

use std::collections::HashMap;
use std::sync::Arc;

use async_trait::async_trait;
use russh::server::{Msg, Session};
use russh::*;
use russh_keys::*;
use tokio::io::AsyncWriteExt;
use tokio::process::ChildStdin;

use log::error;
use tokio::sync::Mutex;

use crate::config::server::ServerUser;
use crate::State;

mod keys;
use self::keys::server_keys;

mod commands;
mod messages;

pub async fn start_server(state: Arc<Mutex<State>>) -> anyhow::Result<()> {
    let config = russh::server::Config {
        connection_timeout: Some(std::time::Duration::from_secs(3600)),
        auth_rejection_time: std::time::Duration::from_secs(3),
        auth_rejection_time_initial: Some(std::time::Duration::from_secs(0)),
        keys: vec![server_keys()?],
        ..Default::default()
    };

    let config = Arc::new(config);

    let sh = Server {
        state: state.clone(),
    };

    let port = state.lock().await.server_config.port;

    russh::server::run(config, ("0.0.0.0", port), sh).await?;

    Ok(())
}

struct Server {
    state: Arc<Mutex<State>>,
}

impl server::Server for Server {
    type Handler = Handler;
    fn new_client(&mut self, _: Option<std::net::SocketAddr>) -> Handler {
        Handler {
            stdin: HashMap::default(),
            state: self.state.clone(),
            user: None,
            username: None,
        }
    }
}

struct Handler {
    stdin: HashMap<ChannelId, ChildStdin>,
    state: Arc<Mutex<State>>,
    user: Option<ServerUser>,
    username: Option<String>,
}

impl Handler {
    async fn send_stdin(&mut self, channel_id: ChannelId, data: &[u8]) -> anyhow::Result<()> {
        if let Some(stdin) = self.stdin.get_mut(&channel_id) {
            stdin.write_all(data).await?;
        }

        Ok(())
    }
}

#[async_trait]
impl server::Handler for Handler {
    type Error = anyhow::Error;

    async fn channel_open_session(
        mut self,
        _channel: Channel<Msg>,
        session: Session,
    ) -> anyhow::Result<(Self, bool, Session)> {
        Ok((self, true, session))
    }

    async fn auth_publickey(
        mut self,
        _: &str,
        key: &key::PublicKey,
    ) -> anyhow::Result<(Self, server::Auth)> {
        let key = key.public_key_base64();
        if let Some(data) = self.state.lock().await.server_config.get_user(&key) {
            self.username = Some(data.0);
            self.user = Some(data.1);
        }
        Ok((self, server::Auth::Accept))
    }

    async fn data(
        mut self,
        channel: ChannelId,
        data: &[u8],
        session: Session,
    ) -> anyhow::Result<(Self, Session)> {
        self.send_stdin(channel, data).await?;
        Ok((self, session))
    }

    async fn channel_eof(
        mut self,
        channel: ChannelId,
        session: Session,
    ) -> Result<(Self, Session), Self::Error> {
        let stdin = self.stdin.remove(&channel);
        if let Some(mut stdin) = stdin {
            stdin.shutdown().await?;
        }

        Ok((self, session))
    }

    async fn exec_request(
        mut self,
        channel: ChannelId,
        data: &[u8],
        session: Session,
    ) -> anyhow::Result<(Self, Session)> {
        let handle = session.handle();
        if let Err(e) = self.handle_command(handle.clone(), channel, data).await {
            error!("{:#}", e);
            handle.close(channel).await.unwrap();
        }
        Ok((self, session))
    }
}