wtx 0.28.0

A collection of different transport implementations and related tools focused primarily on web technologies.
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
149
150

use crate::{
  misc::{
    ConnectionState, LeaseMut, Lock, Stream, StreamReader, StreamWriter, Vector, Xorshift64,
    partitioned_filled_buffer::PartitionedFilledBuffer,
  },
  web_socket::{
    Frame, FrameMut, compression::NegotiatedCompression,
    web_socket_parts::web_socket_part_owned::WebSocketCommonPartOwned, web_socket_writer,
  },
};

#[derive(Debug)]
pub(crate) struct WebSocketCommonPart<CS, NC, RNG, S, const IS_CLIENT: bool> {
  pub(crate) connection_state: CS,
  pub(crate) nc: NC,
  pub(crate) rng: RNG,
  pub(crate) stream: S,
}

#[derive(Debug)]
pub(crate) struct WebSocketReaderPart<PFB, V, const IS_CLIENT: bool> {
  pub(crate) max_payload_len: usize,
  pub(crate) nc_rsv1: u8,
  pub(crate) network_buffer: PFB,
  pub(crate) no_masking: bool,
  pub(crate) reader_buffer_first: V,
  pub(crate) reader_buffer_second: V,
}

impl<PFB, V, const IS_CLIENT: bool> WebSocketReaderPart<PFB, V, IS_CLIENT>
where
  PFB: LeaseMut<PartitionedFilledBuffer>,
  V: LeaseMut<Vector<u8>>,
{
  #[inline]
  pub(crate) async fn read_frame_from_stream<CS, NC, RNG, S>(
    &mut self,
    common: &mut WebSocketCommonPart<CS, NC, RNG, S, IS_CLIENT>,
  ) -> crate::Result<FrameMut<'_, IS_CLIENT>>
  where
    CS: LeaseMut<ConnectionState>,
    NC: NegotiatedCompression,
    RNG: LeaseMut<Xorshift64>,
    S: Stream,
  {
    let WebSocketCommonPart { connection_state, nc, rng, stream } = common;
    let Self {
      max_payload_len,
      nc_rsv1,
      network_buffer,
      no_masking,
      reader_buffer_first,
      reader_buffer_second,
    } = self;
    let frame = read_frame!(
      *max_payload_len,
      (NC::IS_NOOP, *nc_rsv1),
      network_buffer.lease_mut(),
      *no_masking,
      reader_buffer_first.lease_mut(),
      reader_buffer_second.lease_mut(),
      stream,
      (
        stream,
        WebSocketCommonPart::<_, _, _, _, IS_CLIENT> {
          connection_state: &mut *connection_state,
          nc: &mut *nc,
          rng: &mut *rng,
          stream: &mut *stream
        }
      )
    );
    Ok(frame)
  }

  #[inline]
  pub(crate) async fn read_frame_from_parts<C, NC, SR, SW>(
    &mut self,
    common: &mut C,
    stream_reader: &mut SR,
  ) -> crate::Result<FrameMut<'_, IS_CLIENT>>
  where
    C: Lock<Resource = WebSocketCommonPartOwned<NC, SW, IS_CLIENT>>,
    NC: NegotiatedCompression,
    SR: StreamReader,
    SW: StreamWriter,
  {
    let Self {
      max_payload_len,
      network_buffer,
      nc_rsv1,
      no_masking,
      reader_buffer_first,
      reader_buffer_second,
    } = self;
    let parts = &mut (stream_reader, common);
    let frame = read_frame!(
      *max_payload_len,
      (NC::IS_NOOP, *nc_rsv1),
      network_buffer.lease_mut(),
      *no_masking,
      reader_buffer_first.lease_mut(),
      reader_buffer_second.lease_mut(),
      parts,
      (&mut parts.0, &mut parts.1.lock().await.wsc)
    );
    Ok(frame)
  }
}

/// Auxiliary structure that can be used when it is necessary to write a received frame that belongs
/// to the same instance.
#[derive(Debug)]
pub(crate) struct WebSocketWriterPart<V, const IS_CLIENT: bool> {
  pub(crate) no_masking: bool,
  pub(crate) writer_buffer: V,
}

impl<V, const IS_CLIENT: bool> WebSocketWriterPart<V, IS_CLIENT>
where
  V: LeaseMut<Vector<u8>>,
{
  #[inline]
  pub(crate) async fn write_frame<CS, NC, P, RNG, SW>(
    &mut self,
    common: &mut WebSocketCommonPart<CS, NC, RNG, SW, IS_CLIENT>,
    frame: &mut Frame<P, IS_CLIENT>,
  ) -> crate::Result<()>
  where
    CS: LeaseMut<ConnectionState>,
    NC: NegotiatedCompression,
    P: LeaseMut<[u8]>,
    RNG: LeaseMut<Xorshift64>,
    SW: StreamWriter,
  {
    let WebSocketCommonPart { connection_state, nc, rng, stream } = common;
    let Self { no_masking, writer_buffer } = self;
    web_socket_writer::write_frame(
      connection_state.lease_mut(),
      frame,
      *no_masking,
      nc,
      rng.lease_mut(),
      stream,
      writer_buffer.lease_mut(),
    )
    .await?;
    Ok(())
  }
}