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

use bytes::{Buf, BufMut, BytesMut};
use log::{error, trace};
use rasn::{ber, de::Decode};
use rasn_ldap::LdapMessage;
use tokio_util::codec::{Decoder, Encoder};

use crate::error::Error;

pub(crate) struct LdapCodec;

impl Decoder for LdapCodec {
    type Item = LdapMessage;
    type Error = Error;

    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
        if !src.has_remaining() {
            return Ok(None);
        }

        let mut decoder = ber::de::Decoder::new(src, ber::de::DecoderOptions::ber());

        match LdapMessage::decode(&mut decoder) {
            Ok(msg) => {
                let len = decoder.decoded_len();
                src.advance(len);
                trace!("Decoded message of {} bytes: {:?}", len, msg);
                Ok(Some(msg))
            }
            Err(ber::de::Error::Incomplete { needed }) => {
                trace!("Incomplete request, needed: {:?}", needed);
                Ok(None)
            }
            Err(e) => {
                error!("Decoder error: {}", e);
                Err(e.into())
            }
        }
    }
}

impl Encoder<LdapMessage> for LdapCodec {
    type Error = Error;

    fn encode(&mut self, item: LdapMessage, dst: &mut BytesMut) -> Result<(), Self::Error> {
        let encoded = ber::encode(&item)?;
        trace!("Encoded message of {} bytes: {:?}", encoded.len(), item);
        dst.reserve(encoded.len());
        dst.put_slice(&encoded);
        Ok(())
    }
}