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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
/*
* InspIRCd -- Internet Relay Chat Daemon
*
* Copyright (C) 2013 Adam <Adam@anope.org>
* Copyright (C) 2003-2013 Anope Team <team@anope.org>
*
* This file is part of InspIRCd. InspIRCd is free software: you can
* redistribute it and/or modify it under the terms of the GNU General Public
* License as published by the Free Software Foundation, version 2.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
typedef int LDAPQuery;
class LDAPException : public ModuleException
{
public:
LDAPException(const std::string& reason) : ModuleException(reason) { }
virtual ~LDAPException() throw() { }
};
struct LDAPModification
{
enum LDAPOperation
{
LDAP_ADD,
LDAP_DEL,
LDAP_REPLACE
};
LDAPOperation op;
std::string name;
std::vector<std::string> values;
};
typedef std::vector<LDAPModification> LDAPMods;
struct LDAPAttributes : public std::map<std::string, std::vector<std::string> >
{
size_t size(const std::string& attr) const
{
const std::vector<std::string>& array = this->getArray(attr);
return array.size();
}
const std::vector<std::string> keys() const
{
std::vector<std::string> k;
for (const_iterator it = this->begin(), it_end = this->end(); it != it_end; ++it)
k.push_back(it->first);
return k;
}
const std::string& get(const std::string& attr) const
{
const std::vector<std::string>& array = this->getArray(attr);
if (array.empty())
throw LDAPException("Empty attribute " + attr + " in LDAPResult::get");
return array[0];
}
const std::vector<std::string>& getArray(const std::string& attr) const
{
const_iterator it = this->find(attr);
if (it == this->end())
throw LDAPException("Unknown attribute " + attr + " in LDAPResult::getArray");
return it->second;
}
};
struct LDAPResult
{
std::vector<LDAPAttributes> messages;
std::string error;
enum QueryType
{
QUERY_UNKNOWN,
QUERY_BIND,
QUERY_SEARCH,
QUERY_ADD,
QUERY_DELETE,
QUERY_MODIFY,
QUERY_COMPARE
};
QueryType type;
LDAPQuery id;
LDAPResult()
: type(QUERY_UNKNOWN), id(-1)
{
}
size_t size() const
{
return this->messages.size();
}
bool empty() const
{
return this->messages.empty();
}
const LDAPAttributes& get(size_t sz) const
{
if (sz >= this->messages.size())
throw LDAPException("Index out of range");
return this->messages[sz];
}
const std::string& getError() const
{
return this->error;
}
};
class LDAPInterface
{
public:
ModuleRef creator;
LDAPInterface(Module* m) : creator(m) { }
virtual ~LDAPInterface() { }
virtual void OnResult(const LDAPResult& r) = 0;
virtual void OnError(const LDAPResult& err) = 0;
};
class LDAPProvider : public DataProvider
{
public:
LDAPProvider(Module* Creator, const std::string& Name)
: DataProvider(Creator, Name) { }
/** Attempt to bind to the LDAP server as a manager
* @param i The LDAPInterface the result is sent to
* @return The query ID
*/
virtual LDAPQuery BindAsManager(LDAPInterface *i) = 0;
/** Bind to LDAP
* @param i The LDAPInterface the result is sent to
* @param who The binddn
* @param pass The password
* @return The query ID
*/
virtual LDAPQuery Bind(LDAPInterface* i, const std::string& who, const std::string& pass) = 0;
/** Search ldap for the specified filter
* @param i The LDAPInterface the result is sent to
* @param base The base DN to search
* @param filter The filter to apply
* @return The query ID
*/
virtual LDAPQuery Search(LDAPInterface* i, const std::string& base, const std::string& filter) = 0;
/** Add an entry to LDAP
* @param i The LDAPInterface the result is sent to
* @param dn The dn of the entry to add
* @param attributes The attributes
* @return The query ID
*/
virtual LDAPQuery Add(LDAPInterface* i, const std::string& dn, LDAPMods& attributes) = 0;
/** Delete an entry from LDAP
* @param i The LDAPInterface the result is sent to
* @param dn The dn of the entry to delete
* @return The query ID
*/
virtual LDAPQuery Del(LDAPInterface* i, const std::string& dn) = 0;
/** Modify an existing entry in LDAP
* @param i The LDAPInterface the result is sent to
* @param base The base DN to modify
* @param attributes The attributes to modify
* @return The query ID
*/
virtual LDAPQuery Modify(LDAPInterface* i, const std::string& base, LDAPMods& attributes) = 0;
/** Compare an attribute in LDAP with our value
* @param i The LDAPInterface the result is sent to
* @param dn DN to use for comparing
* @param attr Attr of DN to compare with
* @param val value to compare attr of dn
* @return the query ID
*/
virtual LDAPQuery Compare(LDAPInterface* i, const std::string& dn, const std::string& attr, const std::string& val) = 0;
};
|
