ldap-client-ber 0.6.0

ASN.1 BER codec for LDAP
Documentation 
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

// SPDX-License-Identifier: MIT OR Apache-2.0

/// BER tag class (top 2 bits of the identifier byte).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u8)]
pub enum Class {
    Universal = 0,
    Application = 1,
    Context = 2,
    Private = 3,
}

impl Class {
    pub fn from_byte(b: u8) -> Self {
        match b >> 6 {
            0 => Self::Universal,
            1 => Self::Application,
            2 => Self::Context,
            3 => Self::Private,
            _ => unreachable!(),
        }
    }
}

/// Fully decoded BER tag: class + constructed flag + tag number.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Tag {
    pub class: Class,
    pub constructed: bool,
    pub number: u32,
}

impl Tag {
    pub const fn universal(number: u32) -> Self {
        Self {
            class: Class::Universal,
            constructed: false,
            number,
        }
    }

    pub const fn sequence() -> Self {
        Self {
            class: Class::Universal,
            constructed: true,
            number: SEQUENCE,
        }
    }

    pub const fn set() -> Self {
        Self {
            class: Class::Universal,
            constructed: true,
            number: SET,
        }
    }

    pub const fn context(number: u32) -> Self {
        Self {
            class: Class::Context,
            constructed: false,
            number,
        }
    }

    pub const fn context_constructed(number: u32) -> Self {
        Self {
            class: Class::Context,
            constructed: true,
            number,
        }
    }

    pub const fn application(number: u32) -> Self {
        Self {
            class: Class::Application,
            constructed: true,
            number,
        }
    }

    pub const fn application_primitive(number: u32) -> Self {
        Self {
            class: Class::Application,
            constructed: false,
            number,
        }
    }

    pub fn with_constructed(self, constructed: bool) -> Self {
        Self {
            constructed,
            ..self
        }
    }

    /// Encode the identifier byte(s).
    pub fn encode(&self) -> Vec<u8> {
        let mut first = (self.class as u8) << 6;
        if self.constructed {
            first |= 0x20;
        }

        if self.number < 31 {
            first |= self.number as u8;
            vec![first]
        } else {
            first |= 0x1F;
            // Encode tag number in base-128. A u32 needs at most 5 base-128 digits.
            let mut buf = [0u8; 5];
            let mut pos = buf.len();
            let mut n = self.number;
            loop {
                pos -= 1;
                buf[pos] = (n & 0x7F) as u8;
                n >>= 7;
                if n == 0 {
                    break;
                }
            }
            // Set continuation bits on all but the last byte.
            let end = buf.len() - 1;
            for b in &mut buf[pos..end] {
                *b |= 0x80;
            }
            let mut result = Vec::with_capacity(1 + buf.len() - pos);
            result.push(first);
            result.extend_from_slice(&buf[pos..]);
            result
        }
    }
}

// Well-known universal tag numbers.
pub const BOOLEAN: u32 = 0x01;
pub const INTEGER: u32 = 0x02;
pub const OCTET_STRING: u32 = 0x04;
pub const NULL: u32 = 0x05;
pub const ENUMERATED: u32 = 0x0A;
pub const SEQUENCE: u32 = 0x10;
pub const SET: u32 = 0x11;