veloren_network_protocol/
message.rs

1use crate::{
2    frame::OTFrame,
3    types::{Mid, Sid},
4};
5use bytes::{Bytes, BytesMut};
6
7pub(crate) const ALLOC_BLOCK: usize = 16_777_216;
8
9/// Contains a outgoing message for TCP protocol
10/// All Chunks have the same size, except for the last chunk which can end
11/// earlier. E.g.
12/// ```ignore
13/// msg = OTMessage::new();
14/// msg.next();
15/// msg.next();
16/// ```
17#[derive(Debug)]
18pub(crate) struct OTMessage {
19    data: Bytes,
20    original_length: u64,
21    send_header: bool,
22    mid: Mid,
23    sid: Sid,
24    start: u64, /* remove */
25}
26
27#[derive(Debug)]
28pub(crate) struct ITMessage {
29    pub data: BytesMut,
30    pub sid: Sid,
31    pub length: u64,
32}
33
34impl OTMessage {
35    pub(crate) const FRAME_DATA_SIZE: u64 = 1400;
36
37    pub(crate) fn new(data: Bytes, mid: Mid, sid: Sid) -> Self {
38        let original_length = data.len() as u64;
39        Self {
40            data,
41            original_length,
42            send_header: false,
43            mid,
44            sid,
45            start: 0,
46        }
47    }
48
49    fn get_header(&self) -> OTFrame {
50        OTFrame::DataHeader {
51            mid: self.mid,
52            sid: self.sid,
53            length: self.data.len() as u64,
54        }
55    }
56
57    fn get_next_data(&mut self) -> OTFrame {
58        let to_send = std::cmp::min(self.data.len(), Self::FRAME_DATA_SIZE as usize);
59        let data = self.data.split_to(to_send);
60        self.start += Self::FRAME_DATA_SIZE;
61
62        OTFrame::Data {
63            mid: self.mid,
64            data,
65        }
66    }
67
68    /// returns if something was added
69    pub(crate) fn next(&mut self) -> Option<OTFrame> {
70        if !self.send_header {
71            self.send_header = true;
72            Some(self.get_header())
73        } else if !self.data.is_empty() {
74            Some(self.get_next_data())
75        } else {
76            None
77        }
78    }
79
80    pub(crate) fn get_sid_len(&self) -> (Sid, u64) { (self.sid, self.original_length) }
81}
82
83impl ITMessage {
84    pub(crate) fn new(sid: Sid, length: u64, _allocator: &mut BytesMut) -> Self {
85        //allocator.reserve(ALLOC_BLOCK);
86        //TODO: grab mem from the allocatior, but this is only possible with unsafe
87        Self {
88            sid,
89            length,
90            data: BytesMut::with_capacity((length as usize).min(ALLOC_BLOCK /* anti-ddos */)),
91        }
92    }
93}
94
95/*
96/// Contains a outgoing message and store what was *send* and *confirmed*
97/// All Chunks have the same size, except for the last chunk which can end
98/// earlier. E.g.
99/// ```ignore
100/// msg = OutgoingMessage::new();
101/// msg.next();
102/// msg.next();
103/// msg.confirm(1);
104/// msg.confirm(2);
105/// ```
106#[derive(Debug)]
107#[expect(dead_code)]
108pub(crate) struct OUMessage {
109    buffer: Arc<MessageBuffer>,
110    send_index: u64, // 3 => 4200 (3*FRAME_DATA_SIZE)
111    send_header: bool,
112    mid: Mid,
113    sid: Sid,
114    max_index: u64, //speedup
115    missing_header: bool,
116    missing_indices: VecDeque<u64>,
117}
118
119#[expect(dead_code)]
120impl OUMessage {
121    pub(crate) const FRAME_DATA_SIZE: u64 = 1400;
122
123    pub(crate) fn new(buffer: Arc<MessageBuffer>, mid: Mid, sid: Sid) -> Self {
124        let max_index =
125            (buffer.data.len() as u64 + Self::FRAME_DATA_SIZE - 1) / Self::FRAME_DATA_SIZE;
126        Self {
127            buffer,
128            send_index: 0,
129            send_header: false,
130            mid,
131            sid,
132            max_index,
133            missing_header: false,
134            missing_indices: VecDeque::new(),
135        }
136    }
137
138    /// all has been send once, but might been resend due to failures.
139    #[expect(dead_code)]
140    pub(crate) fn initial_sent(&self) -> bool { self.send_index == self.max_index }
141
142    pub fn get_header(&self) -> Frame {
143        Frame::DataHeader {
144            mid: self.mid,
145            sid: self.sid,
146            length: self.buffer.data.len() as u64,
147        }
148    }
149
150    pub fn get_data(&self, index: u64) -> Frame {
151        let start = index * Self::FRAME_DATA_SIZE;
152        let to_send = std::cmp::min(
153            self.buffer.data[start as usize..].len() as u64,
154            Self::FRAME_DATA_SIZE,
155        );
156        Frame::Data {
157            mid: self.mid,
158            start,
159            data: self.buffer.data[start as usize..][..to_send as usize].to_vec(),
160        }
161    }
162
163    #[expect(dead_code)]
164    pub(crate) fn set_missing(&mut self, missing_header: bool, missing_indicies: VecDeque<u64>) {
165        self.missing_header = missing_header;
166        self.missing_indices = missing_indicies;
167    }
168
169    /// returns if something was added
170    pub(crate) fn next(&mut self) -> Option<Frame> {
171        if !self.send_header {
172            self.send_header = true;
173            Some(self.get_header())
174        } else if self.send_index < self.max_index {
175            self.send_index += 1;
176            Some(self.get_data(self.send_index - 1))
177        } else if self.missing_header {
178            self.missing_header = false;
179            Some(self.get_header())
180        } else if let Some(index) = self.missing_indices.pop_front() {
181            Some(self.get_data(index))
182        } else {
183            None
184        }
185    }
186
187    pub(crate) fn get_sid_len(&self) -> (Sid, u64) { (self.sid, self.buffer.data.len() as u64) }
188}
189*/
veloren_network_protocol/message.rs

veloren_network_protocol/
message.rs
