xCommonLib/protocol/
mod.rs1use tracing::info;
2
3use self::{protocol_v1::ProtocolV1Reader, protocol_v2::ProtocolV2Reader};
4use crate::{protocol::protocol_dxc::ProtocolDXC, service::sys_service_api::ServiceKey};
5use std::hash::Hash;
6
7pub mod protocol_dxc;
8pub mod protocol_ipc;
9pub mod protocol_v1;
10pub mod protocol_v2;
11
12pub const IPC_INITED_REQ_ID: i64 = -1;
14pub const SYSTEM_CALL_FINALIZE_REQ_ID: i64 = -2;
15
16#[derive(PartialEq, Debug)]
17pub enum MsgType {
18 HeartBit, NormalMsg, RspNormalMsg, AckNormalMsg, System, }
24
25impl MsgType {
26 pub fn from(value: i32) -> Option<Self> {
27 match value {
28 0 => Some(MsgType::HeartBit),
29 1 => Some(MsgType::NormalMsg),
30 2 => Some(MsgType::RspNormalMsg),
31 3 => Some(MsgType::AckNormalMsg),
32 4 => Some(MsgType::System),
33 _ => None,
34 }
35 }
36}
37
38#[derive(Copy, Clone)]
39pub struct XID {
40 pub conn_id: i64,
41 pub request_id: i64,
42}
43
44impl Hash for XID {
45 fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
46 self.conn_id.hash(state);
47 self.request_id.hash(state);
48 }
49}
50
51impl PartialEq for XID {
52 fn eq(&self, other: &Self) -> bool {
53 self.conn_id == other.conn_id && self.request_id == other.request_id
54 }
55}
56impl Eq for XID {}
57
58impl Default for XID {
59 fn default() -> XID {
60 XID {
61 conn_id: 0,
62 request_id: 0,
63 }
64 }
65}
66impl XID {
67 pub fn new(conn_id: i64, msg_id: i64) -> Self {
68 XID {
69 conn_id,
70 request_id: msg_id,
71 }
72 }
73
74 pub fn is_empty(&self) -> bool {
75 self.request_id == 0
76 }
77}
78
79pub fn get_version(message: &[u8]) -> u16 {
83 unsafe {
84 let ptr = message.as_ptr().offset(4);
85 let bytes = *(ptr as *const [u8; 2]);
86 u16::from_le_bytes(bytes)
87 }
88}
89
90pub fn get_msg_type(message: &[u8]) -> Option<MsgType> {
91 let version = get_version(message);
92 match version {
93 1 => {
94 let v1_reader = ProtocolV1Reader::new(message);
95
96 v1_reader.msg_type()
97 }
98 2 => {
99 let v2_reader = ProtocolV2Reader::new(message);
100
101 v2_reader.msg_type()
102 }
103 _ => None,
104 }
105}
106
107pub fn to_dxc_protocol_msg(
109 channel_id: i64,
110 from_addr: String,
111 message: &[u8],
112) -> Option<(Vec<u8>, ServiceKey)> {
113 let version = get_version(message);
115 match version {
116 1 => {
117 let dxc_msg = ProtocolDXC::from_v1(channel_id, message);
118
119 let v1_reader = ProtocolV1Reader::new(message);
120
121 Some((dxc_msg, v1_reader.sender()))
122 }
123 2 => {
124 let dxc_msg = ProtocolDXC::from_v2(channel_id, from_addr, message);
125
126 let v2_reader = ProtocolV2Reader::new(message);
127
128 Some((dxc_msg, v2_reader.sender()))
129 }
130 _ => None,
131 }
132}
133
134pub fn get_sender_service_key(message: &[u8]) -> Option<ServiceKey> {
135 let version = get_version(message);
136 match version {
137 1 => {
138 let v1_reader = ProtocolV1Reader::new(message);
139
140 Some(v1_reader.sender())
141 }
142 2 => {
143 let v2_reader = ProtocolV2Reader::new(message);
144
145 Some(v2_reader.sender())
146 }
147 _ => None,
148 }
149}
150
151pub fn get_receiver_service_key(message: &[u8]) -> Option<ServiceKey> {
152 let version = get_version(message);
153
154 match version {
155 1 => {
156 let v1_reader = ProtocolV1Reader::new(message);
157 Some(v1_reader.receiver())
158 }
159 2 => {
160 let v2_reader = ProtocolV2Reader::new(message);
161 Some(v2_reader.receiver())
162 }
163 _ => None,
164 }
165}