libtun 0.1.0

a cross-platform(macosx, linux) tunnel library
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

use async_channel;

enum Multiplex<T> {
  Msg(T),
  Close,
}

pub fn unbound<T>() -> (Writer<T>, Reader<T>) {
  let (writer, reader) = async_channel::unbounded();
  let closer = Closer::new(writer.clone());
  (Writer::new(writer.clone()), Reader::new(reader, closer))
}

pub fn closer() -> (Closer<()>, CloserReader) {
  let (writer, reader) = unbound::<()>();
  (
    Closer {
      raw: writer.raw.clone(),
    },
    CloserReader {
      raw: reader.raw,
      closer: reader.closer,
    },
  )
}

pub type CloserReader = Reader<()>;

pub struct Closer<T> {
  raw: async_channel::Sender<Multiplex<T>>,
}

impl<T> Closer<T> {
  fn new(raw: async_channel::Sender<Multiplex<T>>) -> Closer<T> {
    Closer { raw }
  }

  pub async fn close(self) {
    let _ = self.raw.send(Multiplex::Close).await;
  }
}

impl<T> Clone for Closer<T> {
  fn clone(&self) -> Closer<T> {
    Self {
      raw: self.raw.clone(),
    }
  }
}

pub struct Reader<T> {
  raw: async_channel::Receiver<Multiplex<T>>,
  closer: Closer<T>,
}

impl<T> Reader<T> {
  fn new(raw: async_channel::Receiver<Multiplex<T>>, closer: Closer<T>) -> Reader<T> {
    Reader { raw, closer }
  }

  pub async fn read(&self) -> Option<T> {
    loop {
      match self.raw.recv().await {
        Ok(item) => match item {
          Multiplex::Msg(item) => return Some(item),
          Multiplex::Close => return None,
        },
        Err(_) => return None,
      }
    }
  }

  pub fn closer(&self) -> Closer<T> {
    self.closer.clone()
  }
}

pub struct Writer<T> {
  raw: async_channel::Sender<Multiplex<T>>,
}

impl<T> Clone for Writer<T> {
  fn clone(&self) -> Writer<T> {
    Writer {
      raw: self.raw.clone(),
    }
  }
}

impl<T> Writer<T> {
  fn new(raw: async_channel::Sender<Multiplex<T>>) -> Writer<T> {
    Writer { raw }
  }

  pub async fn write(&self, t: T) -> bool {
    match self.raw.send(Multiplex::Msg(t)).await {
      Ok(_) => true,
      Err(_) => false,
    }
  }

  pub async fn close(self) {
    let closer = self.closer();
    closer.close().await;
  }

  pub fn closer(&self) -> Closer<T> {
    Closer {
      raw: self.raw.clone(),
    }
  }
}