cyfs_bdt/sn/
types.rs

1use std::{
2    time::{Duration, SystemTime, UNIX_EPOCH},
3    convert::TryFrom
4};
5use cyfs_base::*;
6use crate::types::*;
7
8
9#[derive(Clone, Copy, PartialEq, PartialOrd, Ord, Eq, Debug)]
10pub enum SnServiceGrade {
11    None = 0,
12    Discard = 1,
13    Passable = 2,
14    Normal = 3,
15    Fine = 4,
16    Wonderfull = 5,
17}
18
19impl SnServiceGrade {
20    pub fn is_accept(&self) -> bool {
21        *self >= SnServiceGrade::Passable
22    }
23    pub fn is_refuse(&self) -> bool {
24        !self.is_accept()
25    }
26}
27
28impl TryFrom<u8> for SnServiceGrade {
29    type Error = BuckyError;
30    fn try_from(v: u8) -> Result<Self, Self::Error> {
31        match v {
32            0 => Ok(Self::None),
33            1 => Ok(Self::Discard),
34            2 => Ok(Self::Passable),
35            3 => Ok(Self::Normal),
36            4 => Ok(Self::Fine),
37            5 => Ok(Self::Wonderfull),
38            _ => Err(BuckyError::new(
39                BuckyErrorCode::InvalidParam,
40                "invalid SnServiceGrade value",
41            )),
42        }
43    }
44}
45
46impl RawFixedBytes for SnServiceGrade {
47    fn raw_bytes() -> Option<usize> {
48        Some(1)
49    }
50}
51
52impl RawEncode for SnServiceGrade {
53    fn raw_measure(&self, _purpose: &Option<RawEncodePurpose>) -> Result<usize, BuckyError> {
54        Ok(Self::raw_bytes().unwrap())
55    }
56
57    fn raw_encode<'a>(
58        &self,
59        buf: &'a mut [u8],
60        _purpose: &Option<RawEncodePurpose>,
61    ) -> Result<&'a mut [u8], BuckyError> {
62        let bytes = Self::raw_bytes().unwrap();
63        if buf.len() < bytes {
64            let msg = format!("not enough buffer for encode SnServiceGrade, except={}, got={}", bytes, buf.len());
65            error!("{}", msg);
66            
67            return Err(BuckyError::new(
68                BuckyErrorCode::OutOfLimit,
69                msg,
70            ));
71        }
72        buf[0] = (*self) as u8;
73        Ok(&mut buf[1..])
74    }
75}
76
77impl<'de> RawDecode<'de> for SnServiceGrade {
78    fn raw_decode(buf: &'de [u8]) -> Result<(Self, &'de [u8]), BuckyError> {
79        let bytes = Self::raw_bytes().unwrap();
80        if buf.len() < bytes {
81            let msg = format!("not enough buffer for decode SnServiceGrade, except={}, got={}", bytes, buf.len());
82            error!("{}", msg);
83            
84            return Err(BuckyError::new(
85                BuckyErrorCode::OutOfLimit,
86                msg,
87            ));
88        }
89        let v = Self::try_from(buf[0])?;
90        Ok((v, &buf[Self::raw_bytes().unwrap()..]))
91    }
92}
93
94#[derive(Clone, Copy, PartialEq, Debug)]
95pub enum SnServiceReceiptVersion {
96    Invalid = 0,
97    Current = 1,
98}
99
100impl TryFrom<u8> for SnServiceReceiptVersion {
101    type Error = BuckyError;
102    fn try_from(v: u8) -> Result<Self, Self::Error> {
103        match v {
104            0 => Ok(Self::Invalid),
105            1 => Ok(Self::Current),
106            _ => Err(BuckyError::new(
107                BuckyErrorCode::UnSupport,
108                format!("unsupport version({})", v).as_str(),
109            )),
110        }
111    }
112}
113
114impl RawFixedBytes for SnServiceReceiptVersion {
115    fn raw_bytes() -> Option<usize> {
116        Some(1)
117    }
118}
119
120impl RawEncode for SnServiceReceiptVersion {
121    fn raw_measure(&self, _purpose: &Option<RawEncodePurpose>) -> Result<usize, BuckyError> {
122        Ok(Self::raw_bytes().unwrap())
123    }
124
125    fn raw_encode<'a>(
126        &self,
127        buf: &'a mut [u8],
128        _purpose: &Option<RawEncodePurpose>,
129    ) -> Result<&'a mut [u8], BuckyError> {
130        let bytes = Self::raw_bytes().unwrap();
131        if buf.len() < bytes {
132            let msg = format!("not enough buffer for encode SnServiceReceiptVersion, except={}, got={}", bytes, buf.len());
133            error!("{}", msg);
134            
135            return Err(BuckyError::new(
136                BuckyErrorCode::OutOfLimit,
137                msg,
138            ));
139        }
140        buf[0] = (*self) as u8;
141        Ok(&mut buf[1..])
142    }
143}
144
145impl<'de> RawDecode<'de> for SnServiceReceiptVersion {
146    fn raw_decode(buf: &'de [u8]) -> Result<(Self, &'de [u8]), BuckyError> {
147        let bytes = Self::raw_bytes().unwrap();
148        if buf.len() < bytes {
149            let msg = format!("not enough buffer for decode SnServiceReceiptVersion, except={}, got={}", bytes, buf.len());
150            error!("{}", msg);
151            
152            return Err(BuckyError::new(
153                BuckyErrorCode::OutOfLimit,
154                msg,
155            ));
156        }
157        let v = Self::try_from(buf[0])?;
158        Ok((v, &buf[Self::raw_bytes().unwrap()..]))
159    }
160}
161
162struct SnServiceReceiptSignature {
163    sn_peerid: DeviceId,
164    receipt: SnServiceReceipt,
165}
166
167impl RawEncode for SnServiceReceiptSignature {
168    fn raw_measure(&self, purpose: &Option<RawEncodePurpose>) -> Result<usize, BuckyError> {
169        let len = self.sn_peerid.raw_measure(purpose)? + self.receipt.raw_measure(purpose)?;
170        Ok(len)
171    }
172
173    fn raw_encode<'a>(
174        &self,
175        buf: &'a mut [u8],
176        purpose: &Option<RawEncodePurpose>,
177    ) -> Result<&'a mut [u8], BuckyError> {
178        let buf = self.sn_peerid.raw_encode(buf, purpose)?;
179        self.receipt.raw_encode(buf, purpose)
180    }
181}
182
183#[derive(Copy, Clone, Debug)]
184pub struct SnServiceReceipt {
185    pub version: SnServiceReceiptVersion,
186    pub grade: SnServiceGrade,
187    pub rto: u16,
188    pub duration: Duration,
189    pub start_time: SystemTime,
190    pub ping_count: u32,
191    pub ping_resp_count: u32,
192    pub called_count: u32,
193    pub call_peer_count: u32,
194    pub connect_peer_count: u32,
195    pub call_delay: u16,
196}
197
198impl SnServiceReceipt {
199    pub fn sign(
200        &self,
201        sn_peerid: &DeviceId,
202        _private_key: &PrivateKey,
203    ) -> Result<Signature, BuckyError> {
204        let _sig_fields = SnServiceReceiptSignature {
205            sn_peerid: sn_peerid.clone(),
206            receipt: self.clone(),
207        };
208        //FIMXE: sign
209        unimplemented!()
210        // Authorized::sign(&sig_fields, private_key)
211    }
212
213    pub fn verify(
214        &self,
215        sn_peerid: &DeviceId,
216        _sign: &Signature,
217        _const_info: &DeviceDesc,
218    ) -> bool {
219        let _sig_fields = SnServiceReceiptSignature {
220            sn_peerid: sn_peerid.clone(),
221            receipt: self.clone(),
222        };
223        //FIMXE: verify
224        unimplemented!()
225        //Authorized::verify(&sig_fields, sign, const_info)
226    }
227}
228
229impl Default for SnServiceReceipt {
230    fn default() -> Self {
231        SnServiceReceipt {
232            version: SnServiceReceiptVersion::Invalid,
233            grade: SnServiceGrade::None,
234            rto: 0,
235            duration: Duration::from_millis(0),
236            start_time: UNIX_EPOCH,
237            ping_count: 0,
238            ping_resp_count: 0,
239            called_count: 0,
240            call_peer_count: 0,
241            connect_peer_count: 0,
242            call_delay: 0,
243        }
244    }
245}
246
247impl RawEncode for SnServiceReceipt {
248    fn raw_measure(&self, purpose: &Option<RawEncodePurpose>) -> Result<usize, BuckyError> {
249        let mut size = self.version.raw_measure(purpose)?;
250        size += self.grade.raw_measure(purpose)?;
251        size += self.rto.raw_measure(purpose)?;
252        size += 0u32.raw_measure(purpose)?;
253        size += 0u64.raw_measure(purpose)?;
254        size += self.ping_count.raw_measure(purpose)?;
255        size += self.ping_resp_count.raw_measure(purpose)?;
256        size += self.called_count.raw_measure(purpose)?;
257        size += self.call_peer_count.raw_measure(purpose)?;
258        size += self.connect_peer_count.raw_measure(purpose)?;
259        size += self.call_delay.raw_measure(purpose)?;
260        Ok(size)
261    }
262
263    fn raw_encode<'a>(
264        &self,
265        buf: &'a mut [u8],
266        purpose: &Option<RawEncodePurpose>,
267    ) -> Result<&'a mut [u8], BuckyError> {
268        let buf = self.version.raw_encode(buf, purpose)?;
269        let buf = self.grade.raw_encode(buf, purpose)?;
270        let buf = self.rto.raw_encode(buf, purpose)?;
271        let buf = (self.duration.as_millis() as u32).raw_encode(buf, purpose)?;
272        let buf = system_time_to_bucky_time(&self.start_time).raw_encode(buf, purpose)?;
273        let buf = self.ping_count.raw_encode(buf, purpose)?;
274        let buf = self.ping_resp_count.raw_encode(buf, purpose)?;
275        let buf = self.called_count.raw_encode(buf, purpose)?;
276        let buf = self.call_peer_count.raw_encode(buf, purpose)?;
277        let buf = self.connect_peer_count.raw_encode(buf, purpose)?;
278        let buf = self.call_delay.raw_encode(buf, purpose)?;
279        Ok(buf)
280    }
281}
282
283impl<'de> RawDecode<'de> for SnServiceReceipt {
284    fn raw_decode(buf: &'de [u8]) -> Result<(Self, &'de [u8]), BuckyError> {
285        let (version, buf) = SnServiceReceiptVersion::raw_decode(buf)?;
286        let (grade, buf) = SnServiceGrade::raw_decode(buf)?;
287        let (rto, buf) = u16::raw_decode(buf)?;
288        let (duration, buf) = u32::raw_decode(buf)?;
289        let duration = Duration::from_millis(duration as u64);
290        let (timestamp, buf) = Timestamp::raw_decode(buf)?;
291        if timestamp < MIN_BUCKY_TIME {
292            return Err(BuckyError::new(
293                BuckyErrorCode::InvalidData,
294                "invalid timestamp",
295            ));
296        }
297        let start_time = bucky_time_to_system_time(timestamp);
298        let (ping_count, buf) = u32::raw_decode(buf)?;
299        let (ping_resp_count, buf) = u32::raw_decode(buf)?;
300        let (called_count, buf) = u32::raw_decode(buf)?;
301        let (call_peer_count, buf) = u32::raw_decode(buf)?;
302        let (connect_peer_count, buf) = u32::raw_decode(buf)?;
303        let (call_delay, buf) = u16::raw_decode(buf)?;
304        Ok((
305            SnServiceReceipt {
306                version,
307                grade,
308                rto,
309                duration,
310                start_time,
311                ping_count,
312                ping_resp_count,
313                called_count,
314                call_peer_count,
315                connect_peer_count,
316                call_delay,
317            },
318            buf,
319        ))
320    }
321}
322
323#[derive(Debug)]
324pub struct ReceiptWithSignature(SnServiceReceipt, Signature);
325
326impl ReceiptWithSignature {
327    pub fn receipt(&self) -> &SnServiceReceipt {
328        &self.0
329    }
330
331    pub fn signature(&self) -> &Signature {
332        &self.1
333    }
334}
335
336impl RawEncode for ReceiptWithSignature {
337    fn raw_measure(&self, purpose: &Option<RawEncodePurpose>) -> Result<usize, BuckyError> {
338        Ok(self.0.raw_measure(purpose)? + self.1.raw_measure(purpose)?)
339    }
340
341    fn raw_encode<'a>(
342        &self,
343        buf: &'a mut [u8],
344        purpose: &Option<RawEncodePurpose>,
345    ) -> Result<&'a mut [u8], BuckyError> {
346        let buf = self.0.raw_encode(buf, purpose)?;
347        let buf = self.1.raw_encode(buf, purpose)?;
348        Ok(buf)
349    }
350}
351
352impl<'de> RawDecode<'de> for ReceiptWithSignature {
353    fn raw_decode(buf: &'de [u8]) -> Result<(Self, &'de [u8]), BuckyError> {
354        let (receipt, buf) = RawDecode::raw_decode(buf)?;
355        let (sig, buf) = RawDecode::raw_decode(buf)?;
356        Ok((Self(receipt, sig), buf))
357    }
358}
359
360impl From<(SnServiceReceipt, Signature)> for ReceiptWithSignature {
361    fn from(v: (SnServiceReceipt, Signature)) -> Self {
362        Self(v.0, v.1)
363    }
364}
cyfs_bdt/sn/types.rs

cyfs_bdt/sn/
types.rs
