1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
use common::TagClass;
use super::ASNTag;
use universal;
use structure;
use std::default;
use byteorder::{BigEndian, WriteBytesExt};
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Integer {
pub id: u64,
pub class: TagClass,
pub inner: i64,
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Enumerated {
pub id: u64,
pub class: TagClass,
pub inner: i64,
}
fn i_e_into_structure(id: u64, class: TagClass, inner: i64) -> structure::StructureTag {
let mut count = 0u8;
let mut rem: i64 = if inner >= 0 { inner } else { inner * -1 };
while {count += 1; rem >>= 8; rem > 0 }{}
if inner > 0 && inner >> ((8 * count) - 1) == 1 {
count += 1;
}
let mut out: Vec<u8> = Vec::with_capacity(count as usize);
out.write_int::<BigEndian>(inner, count as usize).unwrap();
structure::StructureTag {
id: id,
class: class,
payload: structure::PL::P(out),
}
}
impl ASNTag for Integer {
fn into_structure(self) -> structure::StructureTag {
i_e_into_structure(self.id, self.class, self.inner)
}
}
impl ASNTag for Enumerated {
fn into_structure(self) -> structure::StructureTag {
i_e_into_structure(self.id, self.class, self.inner)
}
}
impl default::Default for Integer {
fn default() -> Integer {
Integer {
id: universal::Types::Integer as u64,
class: TagClass::Universal,
inner: 0i64,
}
}
}
impl default::Default for Enumerated {
fn default() -> Enumerated {
Enumerated {
id: universal::Types::Enumerated as u64,
class: TagClass::Universal,
inner: 0i64,
}
}
}
#[cfg(test)]
mod test {
use super::i_e_into_structure;
use common::TagClass;
use structure;
#[test]
fn test_not_unnecessary_octets() {
let result = i_e_into_structure(2, TagClass::Universal, 127);
let correct = structure::PL::P(vec![127]);
assert_eq![result.payload, correct];
}
#[test]
fn test_not_positive_getting_negative() {
let result = i_e_into_structure(2, TagClass::Universal, 128);
let correct = structure::PL::P(vec![0, 128]);
assert_eq![result.payload, correct];
}
}