docker 0.0.41

Docker Remote API in Rust
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
143
144
145
146
147
148

use std;
use std::io::{Read, Write};
use std::path::Path;
use std::error::Error;

use openssl;

pub struct TcpStream {
    tls: bool,
    stream: std::net::TcpStream,
    ssl_stream: Option<openssl::ssl::SslStream<std::net::TcpStream>>
}

impl TcpStream {
    pub fn connect(addr: &str) -> std::io::Result<TcpStream> {
        let stream = try!(std::net::TcpStream::connect(addr));
        
        let tcp_stream = TcpStream {
            tls: false,
            stream: stream,
            ssl_stream: None,
        };
        
        return Ok(tcp_stream);
    }

    pub fn set_ssl_context(&mut self, key: &Path, cert: &Path, ca: &Path) -> std::io::Result<()> {
        self.tls = true;

        let mut context = match openssl::ssl::SslContext::new(openssl::ssl::SslMethod::Tlsv1) {
            Ok(context) => context,
            Err(e) => {
                let err = std::io::Error::new(std::io::ErrorKind::NotConnected,
                                              e.description());
                return Err(err);
            }
        };

        match context.set_private_key_file(key, openssl::x509::X509FileType::PEM) {
            Ok(_) => {}
            Err(e) => {
                let err = std::io::Error::new(std::io::ErrorKind::InvalidInput,
                                              e.description());
                return Err(err);
            }
        }

        match context.set_certificate_file(cert, openssl::x509::X509FileType::PEM) {
            Ok(_) => {}
            Err(e) => {
                let err = std::io::Error::new(std::io::ErrorKind::NotConnected,
                                              e.description());
                return Err(err);
            }
        }

        match context.set_CA_file(ca) {
            Ok(_) => {}
            Err(e) => {
                let err = std::io::Error::new(std::io::ErrorKind::NotConnected,
                                              e.description());
                return Err(err);
            }
        }
        
        let stream = self.stream.try_clone().unwrap();
        let ssl_stream = match openssl::ssl::SslStream::new(&context, stream) {
            Ok(ssl_stream) => ssl_stream,
            Err(e) => {
                let err = std::io::Error::new(std::io::ErrorKind::NotConnected,
                                              e.description());
                return Err(err);
            }
        };

        self.ssl_stream = Some(ssl_stream);
        
        return Ok(());
    }

    pub fn read(&mut self, buf: &[u8]) -> std::io::Result<Vec<u8>> {
        let raw = match self.tls {
            false => {
                let mut stream = self.stream.try_clone().unwrap();
                let _ = stream.write(buf);
                let raw = try!(TcpStream::read_from_stream(&mut stream));
                raw
            }
            true => {
                let mut ssl_stream = self.ssl_stream.as_mut().unwrap().try_clone().unwrap();
                let _ = ssl_stream.write(buf);
                let raw = try!(TcpStream::read_from_stream(&mut ssl_stream));
                raw
            }
        };
        return Ok(raw);
    }

    fn read_from_stream<S: Read>(stream: &mut S) -> std::io::Result<Vec<u8>> {
        const BUFFER_SIZE: usize = 1024;
        let mut buffer: [u8; BUFFER_SIZE] = [0; BUFFER_SIZE];
        let mut raw: Vec<u8> = Vec::new();
        let mut is_shaked = false;
        loop {
            let len = match stream.read(&mut buffer) {
                Ok(size) => size,
                Err(e) => {
                    let err = std::io::Error::new(std::io::ErrorKind::NotConnected,
                                                  e.description());
                    return Err(err);
                }
            };

            if len == 4 &&
                buffer[0] == 13 &&
                buffer[1] == 10 &&
                buffer[2] == 13 &&
                buffer[3] == 10  { break; }

            for i in 0..len { raw.push(buffer[i]); }

            if len > 1 && buffer[len - 2] == 13 && buffer[len - 1] == 10 { is_shaked = false; continue; }
            if is_shaked == false && len <= BUFFER_SIZE { is_shaked = true; continue; }
            if len < BUFFER_SIZE { break; }
        }

        return Ok(raw);
    }
}

impl Clone for TcpStream {
    fn clone(&self) -> Self {
        let ssl_stream = match self.ssl_stream {
            Some(ref ssl_stream) => {
                Some(ssl_stream.try_clone().unwrap())
            }
            None => None
        };
        
        let stream = TcpStream {
            tls: self.tls.clone(),
            stream: self.stream.try_clone().unwrap(),
            ssl_stream: ssl_stream
        };

        return stream;
    }
}