ldap3_client 0.7.0

LDAP Client Library for Tokio
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

use crate::LdapClient;
use crate::*;
use ldap3_proto::control::LdapControl;

#[derive(Debug)]
pub struct LdapSyncReplEntry {
    // pub entry_uuid: Uuid,
    pub entry: LdapEntry,
}

#[derive(Debug)]
pub struct LdapSyncRepl {
    pub cookie: Option<Vec<u8>>,
    pub entries: Vec<LdapSyncReplEntry>,
    pub delete_uuids: Vec<Uuid>,
    pub present_uuids: Vec<Uuid>,
}

impl LdapClient {
    #[tracing::instrument(level = "debug", skip_all)]
    pub async fn ad_dirsync<S: Into<String>>(
        &mut self,
        basedn: S,
        cookie: Option<Vec<u8>>,
    ) -> crate::LdapResult<LdapSyncRepl> {
        let msgid = self.get_next_msgid();

        let msg = LdapMsg {
            msgid,
            op: LdapOp::SearchRequest(LdapSearchRequest {
                base: basedn.into(),
                scope: LdapSearchScope::Subtree,
                aliases: LdapDerefAliases::Never,
                sizelimit: 0,
                timelimit: 0,
                typesonly: false,
                filter: LdapFilter::Present("objectClass".to_string()),
                attrs: vec![],
            }),
            ctrl: vec![LdapControl::AdDirsync {
                flags: 0,
                max_bytes: 0,
                cookie,
            }],
        };

        self.write_transport.send(msg).await?;

        let mut entries = Vec::new();
        let delete_uuids = Vec::new();
        let present_uuids = Vec::new();

        loop {
            let mut msg = self.read_transport.next().await?;

            match msg.op {
                // Happy cases here
                LdapOp::SearchResultDone(proto::LdapResult {
                    code: LdapResultCode::Success,
                    message: _,
                    matcheddn: _,
                    referral: _,
                }) => {
                    trace!("SearchResultDone");
                    if let Some(LdapControl::AdDirsync {
                        flags: _,
                        max_bytes: _,
                        cookie,
                    }) = msg.ctrl.pop()
                    {
                        break Ok(LdapSyncRepl {
                            cookie,
                            entries,
                            delete_uuids,
                            present_uuids,
                        });
                    } else {
                        error!("Invalid Ad Dirsync Control encountered");
                        break Err(LdapError::InvalidProtocolState);
                    }
                }
                LdapOp::SearchResultEntry(entry) => {
                    entries.push(LdapSyncReplEntry {
                        // entry_uuid,
                        // state,
                        entry: entry.into(),
                    })
                }
                LdapOp::SearchResultReference(_search_reference) => {
                    // pass
                }
                // Error cases below
                LdapOp::SearchResultDone(proto::LdapResult {
                    code,
                    message,
                    matcheddn: _,
                    referral: _,
                }) => {
                    error!(%message);
                    break Err(LdapError::from(code));
                }
                op => {
                    trace!(?op, "<<<<==== ");
                    break Err(LdapError::InvalidProtocolState);
                }
            };
        }
    }
}