xCommonLib/protocol/
protocol_ipc.rs

1const DATA_LEN_POS: u16 = 0;
2const VERSION_POS: u16 = 4;
3const API_ID_POS: u16 = VERSION_POS + 2;
4const REQ_ID_POS: u16 = API_ID_POS + 2; // 请求的id
5const CHANNEL_ID_POS: u16 = REQ_ID_POS + 8; // 请求的id
6const FIX_LEN_POS: u16 = CHANNEL_ID_POS + 8;
7
8
9
10
11pub mod xport {
12    //
13    pub const SEND_MESSAGE_API_ID: u16 = 1001;
14    pub const GET_ALL_CONN_ID_API_ID: u16 = 1002;
15    pub const GET_CHANNEL_ID_BY_CONN_API_ID: u16 = 1003;
16    pub const GEN_ID: u16 = 1004;
17    pub const RESP_MESSAGE_API_ID: u16 = 1005;
18    pub const GET_CONFIG_API_ID: u16 = 1006;
19    pub const NOTICE_READY_API_ID: u16 = 1007;
20    pub const NOTICE_FINIALIZE_API_ID: u16 = 1008;
21}
22
23
24
25
26// http
27pub mod log {
28    pub const OUTPUT_API_ID: u16 = 5001;
29}
30
31pub struct ProtocolIPCReader<'a> {
32    msg_buffer: &'a [u8],
33}
34impl<'a> ProtocolIPCReader<'a> {
35    pub fn new(msg_buffer: &'a [u8]) -> ProtocolIPCReader<'a> {
36        ProtocolIPCReader { msg_buffer }
37    }
38
39    // 获取 api_id
40    pub fn api_id(&self) -> u16 {
41        unsafe {
42            let ptr = self.msg_buffer.as_ptr().offset(API_ID_POS as isize);
43
44            let bytes = *(ptr as *const [u8; 2]);
45
46            u16::from_le_bytes(bytes)
47        }
48    }
49
50    // 获取 request_id
51    pub fn request_id(&self) -> i64 {
52        unsafe {
53            let ptr = self.msg_buffer.as_ptr().offset(REQ_ID_POS as isize);
54
55            let bytes = *(ptr as *const [u8; 8]);
56
57            i64::from_le_bytes(bytes)
58        }
59    }
60
61    // 获取 channel_id
62    pub fn channel_id(&self) -> i64 {
63        unsafe {
64            let ptr = self.msg_buffer.as_ptr().offset(CHANNEL_ID_POS as isize);
65
66            let bytes = *(ptr as *const [u8; 8]);
67
68            i64::from_le_bytes(bytes)
69        }
70    }
71
72    pub fn version(&self) -> u16 {
73        unsafe {
74            let ptr = self.msg_buffer.as_ptr().offset(VERSION_POS as isize);
75
76            let bytes = *(ptr as *const [u8; 2]);
77
78            u16::from_le_bytes(bytes)
79        }
80    }
81
82    /**
83     * 获取消息长度
84     */
85    pub fn msg_size(&self) -> u32 {
86        self.msg_buffer.len() as u32
87    }
88
89    pub fn msg_body(&self) -> &[u8] {
90        &self.msg_buffer[FIX_LEN_POS as usize..]
91    }
92}
93
94pub struct ProtocolIPCWriter {
95    pub msg_buffer: Vec<u8>,
96    pub msg_body_size: u32,
97}
98
99impl ProtocolIPCWriter {
100    pub fn new(msg_size: u32, api_id: u16, request_id: i64) -> ProtocolIPCWriter {
101        let msg_len = (FIX_LEN_POS as u32 + msg_size) as usize;
102
103        let mut msg_buffer: Vec<u8> = Vec::with_capacity(msg_len);
104        unsafe {
105            msg_buffer.set_len(msg_len);
106        }
107
108        let mut writer = ProtocolIPCWriter {
109            msg_buffer,
110            msg_body_size: msg_size,
111        };
112        //
113        writer.write_api_id(api_id);
114        writer.write_request_id(request_id);
115
116        writer.write_version();
117        writer.write_data_len(msg_len as u32);
118
119        writer
120    }
121
122    pub fn write_api_id(&mut self, api_id: u16) {
123        unsafe {
124            let bytes = api_id.to_le_bytes();
125
126            let ptr = self.msg_buffer.as_mut_ptr().offset(API_ID_POS as isize);
127
128            std::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr, 2);
129        }
130    }
131
132    pub fn write_request_id(&mut self, request_id: i64) {
133        unsafe {
134            let bytes = request_id.to_le_bytes();
135
136            let ptr = self.msg_buffer.as_mut_ptr().offset(REQ_ID_POS as isize);
137
138            std::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr, 8);
139        }
140    }
141
142    pub fn write_channel_id(&mut self, channel_id: i64) {
143        unsafe {
144            let bytes = channel_id.to_le_bytes();
145
146            let ptr = self.msg_buffer.as_mut_ptr().offset(CHANNEL_ID_POS as isize);
147
148            std::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr, 8);
149        }
150    }
151
152    pub fn msg_body_buffer(&mut self) -> &mut [u8] {
153        // msg_body_size
154
155        let msg_body_pos = self.msg_buffer.len() - self.msg_body_size as usize;
156
157        &mut self.msg_buffer[msg_body_pos as usize..]
158    }
159
160    fn write_version(&mut self) {
161        unsafe {
162            let bytes = (1 as u16).to_le_bytes();
163            let ptr = self.msg_buffer.as_mut_ptr().offset(VERSION_POS as isize);
164            std::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr, 2);
165        }
166    }
167
168    pub fn write_msg_body(&mut self, message: &Vec<u8>) {
169        unsafe {
170            let msg_body_pos = self.msg_buffer.len() - self.msg_body_size as usize;
171
172            println!(
173                "msg_body_pos = {} FIX_LEN_POS = {}",
174                msg_body_pos, FIX_LEN_POS
175            );
176            let dst_ptr = self.msg_buffer.as_mut_ptr().offset(msg_body_pos as isize);
177            std::ptr::copy_nonoverlapping(message.as_ptr(), dst_ptr, message.len());
178        }
179    }
180
181    pub fn write_u8_msg_body(&mut self, message: &[u8]) {
182        unsafe {
183            let msg_body_pos = self.msg_buffer.len() - self.msg_body_size as usize;
184            let dst_ptr = self.msg_buffer.as_mut_ptr().offset(msg_body_pos as isize);
185            std::ptr::copy_nonoverlapping(message.as_ptr(), dst_ptr, message.len());
186        }
187    }
188
189    /**
190     * 写入长度
191     */
192    fn write_data_len(&mut self, data_len: u32) {
193        unsafe {
194            let bytes = data_len.to_le_bytes();
195
196            let ptr = self.msg_buffer.as_mut_ptr().offset(DATA_LEN_POS as isize);
197
198            std::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr, 4);
199        }
200    }
201}
xCommonLib/protocol/protocol_ipc.rs

xCommonLib/protocol/
protocol_ipc.rs
