xCommonLib/protocol/
mod.rs

1use 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
12//
13pub 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,     //心跳
19    NormalMsg,    // 普通消息
20    RspNormalMsg, // 回应普通消息
21    AckNormalMsg, //确认消息
22    System,       //  系统消息
23}
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
79/**
80 *  ======= 读取内容 ======
81 */
82pub 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
107// 转换为 dxc 的协议
108pub fn to_dxc_protocol_msg(
109    channel_id: i64,
110    from_addr: String,
111    message: &[u8],
112) -> Option<(Vec<u8>, ServiceKey)> {
113    //
114    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}