net_socket_packet/packet/
packet.rs

1extern crate buf_redux;
2extern crate byteorder; // 1.2.7
3use crate::log;
4use std::cmp;
5use byteorder::ByteOrder;
6use num_derive::FromPrimitive;    
7use num_traits::FromPrimitive;
8
9const S : u16 = 83;// utils::stringutil::get_char_code(&"S"); 83
10const D : u16 = 68;// utils::stringutil::get_char_code(&"D"); 68
11// const C : u8 = 67;// utils::stringutil::get_char_code(&"C"); 67
12const PACKET_MAGIC_D:u16 = (S << 8) | D; //'DS'   default=not zip
13// const PACKET_MAGIC_C:u8 = (S << 8) | C; //'CS'    zip
14pub const HEAD_BYTES_SIZE:usize = 2 + 4 + 4 + 4 + 4 + 8;
15
16
17#[repr(u8)]
18#[derive(FromPrimitive)]
19pub enum PacketHeaderKey {
20    OPCODE = 0,
21    PARAM = 1,
22    TIMESTAMP = 2,
23    BLEN = 3,
24    MAGIC = 4,
25}
26/**
27   * // --- Header structure --- \\
28   * +------------------------------------------------------------+
29   * |    magic   +   uint16  +   2Bytes  +       zip or not      |
30   * +------------------------------------------------------------+
31   * |  body_len  +   uint32  +   2Bytes  +   Packet body length  |
32   * +------------------------------------------------------------+
33   * |    opcode  +   uint32  +   4Bytes  +    operation code     |
34   * +------------------------------------------------------------+
35   * |    uuid    +   uint32  +   4Bytes  +  Connection SessionID |
36   * +------------------------------------------------------------+
37   * |    param   +   uint32  +   4Bytes  +   parameter of packet |
38   * +------------------------------------------------------------+
39   * |    timestamp   +   double  +   8Bytes  +   parameter of packet |
40   * +------------------------------------------------------------+
41   */
42
43// const OPCODE_REGXP = Regex::new(r"/^_(OP_.+)/").unwrap();
44pub struct Packet {
45    // ==== commn
46    opcode:u8,
47    // ==== packetheader
48    head_len :usize,
49    body_len:u8,
50    head_param:u8,
51    head_uuid:u8,
52    head_time_stamp:u32,
53    head_magic:u16,
54    head_offset:u8,
55    head_buf:Vec<u8>,
56    // ==== packet
57    buf : Vec<u8>,
58}
59
60impl Packet {
61    pub fn new() -> Self {
62        Packet { 
63            head_len : HEAD_BYTES_SIZE,
64            body_len : 0,
65            opcode : 0,
66            head_param : 0,
67            head_uuid:0,
68            head_time_stamp : 0,
69            head_magic : PACKET_MAGIC_D,
70            head_offset:0,
71            head_buf : vec![],
72            buf: vec![]
73        }
74    }
75    // ========================== packetHead
76    pub fn set_params(&mut self , key:PacketHeaderKey, data:usize){
77        match key {
78          PacketHeaderKey::OPCODE=> {
79              self.opcode = u8::from_usize(data).unwrap();
80          },
81          PacketHeaderKey::BLEN=>{
82              self.body_len= u8::from_usize(data).unwrap();
83          },
84          PacketHeaderKey::MAGIC=>{
85              self.head_magic= u16::from_usize(data).unwrap();
86          },
87          PacketHeaderKey::PARAM=>{
88              self.head_param= u8::from_usize(data).unwrap();
89          },
90          PacketHeaderKey::TIMESTAMP=>{
91              self.head_time_stamp= u32::from_usize(data).unwrap();
92          }
93        }
94     }
95  
96     pub fn get_params(&self,key:PacketHeaderKey)->usize{
97      match key {
98          PacketHeaderKey::OPCODE=> {
99              usize::from_u8(self.opcode).unwrap()
100          },
101          PacketHeaderKey::BLEN=>{
102              usize::from_u8(self.body_len).unwrap()
103          },
104          PacketHeaderKey::MAGIC=>{
105              usize::from_u16(self.head_magic).unwrap()
106          },
107          PacketHeaderKey::PARAM=>{
108              usize::from_u8(self.head_param).unwrap()
109          },
110          PacketHeaderKey::TIMESTAMP=>{
111              usize::from_u32(self.head_time_stamp).unwrap()
112          }
113        }
114     }
115  
116     pub fn get_buf(&mut self) -> &Vec<u8> {
117         &self.buf
118     }
119  
120     pub fn set_buf<'a>(&'a mut self ,buffer:&Vec<u8>){
121        //  self.buf.clear();
122         self.buf = buffer.clone()[..].to_vec();
123     }
124  
125     pub fn update_offset<'a>(&'a mut self,offset:u8)-> &'a u8{
126         self.head_offset += offset;
127         &self.head_offset
128     }
129  
130     pub fn pack<'a>(&'a mut self)-> &'a Vec<u8> {
131         self.clean_buf();
132         let mut vec_u8 = Vec::with_capacity(HEAD_BYTES_SIZE);
133         let true_cap = vec_u8.capacity();
134         unsafe {
135             vec_u8.set_len(true_cap);
136         };
137         let mut output= vec_u8.into_boxed_slice();
138         byteorder::NativeEndian::write_u16(&mut output[..2],self.head_magic);
139         self.head_offset+=2;
140         byteorder::NativeEndian::write_u32(&mut output[2..6],u32::from_u8(self.body_len).unwrap());
141         self.head_offset+=4;
142         byteorder::NativeEndian::write_u32(&mut output[6..10],u32::from_u8(self.opcode).unwrap());
143         self.head_offset+=4;
144         byteorder::NativeEndian::write_u32(&mut output[10..14],u32::from_u8(self.head_uuid).unwrap());
145         self.head_offset+=4;
146         byteorder::NativeEndian::write_u32(&mut output[14..18],u32::from_u8(self.head_param).unwrap());
147         self.head_offset+=4;
148         byteorder::NativeEndian::write_u64(&mut output[18..],u64::from_u32(self.head_time_stamp).unwrap());
149         self.head_offset+=8;
150         self.buf = output.as_ref().to_vec();
151         &self.buf
152     }
153  
154     pub fn un_pack(& mut self,buffer:&mut [u8]) -> u8 {
155        let true_cap = buffer.len();
156        if true_cap < HEAD_BYTES_SIZE {
157            log!("Packet header length invalid.{:?}","error");
158            return 0;
159        }
160        let mut offset:u8 = 0;
161        self.head_magic = byteorder::NativeEndian::read_u16(&mut buffer[..2]);
162        offset += 2;
163  
164        self.body_len = u8::from_u32(byteorder::NativeEndian::read_u32(&mut buffer[2..6])).unwrap();
165        offset += 4;
166    
167        self.opcode =  u8::from_u32(byteorder::NativeEndian::read_u32(&mut buffer[6..10])).unwrap();
168        offset += 4;
169    
170        // Do not read uuid
171        self.head_uuid = u8::from_u32(byteorder::NativeEndian::read_u32(&mut buffer[10..14])).unwrap();
172        offset += 4;
173    
174        self.head_param = u8::from_u32(byteorder::NativeEndian::read_u32(&mut buffer[14..18])).unwrap();
175        offset += 4;
176    
177        self.head_time_stamp = byteorder::NativeEndian::read_u32(&mut buffer[18..]);
178        offset += 8;
179    
180        offset
181     }
182  
183     pub fn clean_buf(&mut self){
184        self.head_offset = 0;
185        self.head_buf.clear();
186     }
187    // ========================== packet
188    pub fn serialization(&mut self) -> Vec<u8>{
189        let buf:Vec<u8> ;
190        self.mkHead();
191        let head_buf = self.get_buf();
192        let mut head_buf_available = head_buf.clone();
193        let len = cmp::min(head_buf_available[HEAD_BYTES_SIZE..].len(), self.buf.len());
194        head_buf_available[HEAD_BYTES_SIZE..][..len].copy_from_slice(&self.buf[..len]);
195
196        self.head_offset += 1;
197        buf = self.get_buf().to_vec();
198        // buf.split_at(HEAD_BYTES_SIZE + len);
199        buf
200    }
201
202    pub fn deserialization(&mut self,buf:&mut [u8]) -> bool{
203        if buf.len() < HEAD_BYTES_SIZE {
204            log!("Packet is smaller than header size.{:?}","error");
205            return false;
206        }
207      
208        let pos = usize::from_u8(self.un_pack(buf)).unwrap();
209        let content_len = self.get_params(PacketHeaderKey::BLEN);
210        unsafe {
211            self.buf.set_len(content_len);
212        };
213        self.buf = buf[0..pos].to_vec();
214        false
215    }
216
217    pub fn peek_body_length(&mut self , buf:&mut [u8]) -> usize{
218        let mut body_len = usize::from_i8(-1).unwrap();
219        if buf.len() < HEAD_BYTES_SIZE {
220            return body_len
221        }
222        
223        self.un_pack(buf);
224        body_len = self.get_params(PacketHeaderKey::BLEN);
225        body_len
226    }
227
228    pub fn init(&mut self, opcode: usize, param:usize) {
229        self.set_params(PacketHeaderKey::OPCODE, opcode);
230        self.set_params(PacketHeaderKey::PARAM, param);
231    }
232
233    fn mkHead(&mut self){
234        self.set_params(PacketHeaderKey::BLEN, self.buf.len());
235        let head_buf = self.pack();
236        self.buf = head_buf.clone()[..].to_vec();
237    }
238}
net_socket_packet/packet/packet.rs

net_socket_packet/packet/
packet.rs
