4 Copyright (C) Simo Sorce 2005-2008
5 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2007-2008
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 * Component: ldb extended dn control module
26 * Description: this module interprets DNs of the form <SID=S-1-2-4456> into normal DNs.
33 #include "ldb/include/ldb.h"
34 #include "ldb/include/ldb_errors.h"
35 #include "ldb/include/ldb_module.h"
38 TODO: if relax is not set then we need to reject the fancy RMD_* and
39 DELETED extended DN codes
43 struct extended_search_context {
44 struct ldb_module *module;
45 struct ldb_request *req;
46 struct ldb_dn *basedn;
47 char *wellknown_object;
51 /* An extra layer of indirection because LDB does not allow the original request to be altered */
53 static int extended_final_callback(struct ldb_request *req, struct ldb_reply *ares)
55 int ret = LDB_ERR_OPERATIONS_ERROR;
56 struct extended_search_context *ac;
57 ac = talloc_get_type(req->context, struct extended_search_context);
59 if (ares->error != LDB_SUCCESS) {
60 ret = ldb_module_done(ac->req, ares->controls,
61 ares->response, ares->error);
66 ret = ldb_module_send_entry(ac->req, ares->message, ares->controls);
68 case LDB_REPLY_REFERRAL:
70 ret = ldb_module_send_referral(ac->req, ares->referral);
74 ret = ldb_module_done(ac->req, ares->controls,
75 ares->response, ares->error);
82 static int extended_base_callback(struct ldb_request *req, struct ldb_reply *ares)
84 struct extended_search_context *ac;
85 struct ldb_request *down_req;
86 struct ldb_message_element *el;
91 const char *found = NULL;
93 ac = talloc_get_type(req->context, struct extended_search_context);
96 return ldb_module_done(ac->req, NULL, NULL,
97 LDB_ERR_OPERATIONS_ERROR);
99 if (ares->error != LDB_SUCCESS) {
100 return ldb_module_done(ac->req, ares->controls,
101 ares->response, ares->error);
104 switch (ares->type) {
105 case LDB_REPLY_ENTRY:
106 if (!ac->wellknown_object) {
107 ac->basedn = talloc_steal(ac, ares->message->dn);
111 wkn_len = strlen(ac->wellknown_object);
113 el = ldb_msg_find_element(ares->message, "wellKnownObjects");
119 for (i=0; i < el->num_values; i++) {
120 valstr = talloc_strndup(ac,
121 (const char *)el->values[i].data,
122 el->values[i].length);
124 ldb_oom(ldb_module_get_ctx(ac->module));
125 return ldb_module_done(ac->req, NULL, NULL,
126 LDB_ERR_OPERATIONS_ERROR);
129 if (strncasecmp(valstr, ac->wellknown_object, wkn_len) != 0) {
134 found = &valstr[wkn_len];
142 ac->basedn = ldb_dn_new(ac, ldb_module_get_ctx(ac->module), found);
145 ldb_oom(ldb_module_get_ctx(ac->module));
146 return ldb_module_done(ac->req, NULL, NULL,
147 LDB_ERR_OPERATIONS_ERROR);
152 case LDB_REPLY_REFERRAL:
158 const char *str = talloc_asprintf(req, "Base-DN '%s' not found",
159 ldb_dn_get_extended_linearized(req, ac->req->op.search.base, 1));
160 ldb_set_errstring(ldb_module_get_ctx(ac->module), str);
161 return ldb_module_done(ac->req, NULL, NULL,
162 LDB_ERR_NO_SUCH_OBJECT);
165 switch (ac->req->operation) {
167 ret = ldb_build_search_req_ex(&down_req,
168 ldb_module_get_ctx(ac->module), ac->req,
170 ac->req->op.search.scope,
171 ac->req->op.search.tree,
172 ac->req->op.search.attrs,
174 ac, extended_final_callback,
176 LDB_REQ_SET_LOCATION(down_req);
180 struct ldb_message *add_msg = ldb_msg_copy_shallow(ac, ac->req->op.add.message);
182 ldb_oom(ldb_module_get_ctx(ac->module));
183 return ldb_module_done(ac->req, NULL, NULL,
184 LDB_ERR_OPERATIONS_ERROR);
187 add_msg->dn = ac->basedn;
189 ret = ldb_build_add_req(&down_req,
190 ldb_module_get_ctx(ac->module), ac->req,
193 ac, extended_final_callback,
195 LDB_REQ_SET_LOCATION(down_req);
200 struct ldb_message *mod_msg = ldb_msg_copy_shallow(ac, ac->req->op.mod.message);
202 ldb_oom(ldb_module_get_ctx(ac->module));
203 return ldb_module_done(ac->req, NULL, NULL,
204 LDB_ERR_OPERATIONS_ERROR);
207 mod_msg->dn = ac->basedn;
209 ret = ldb_build_mod_req(&down_req,
210 ldb_module_get_ctx(ac->module), ac->req,
213 ac, extended_final_callback,
218 ret = ldb_build_del_req(&down_req,
219 ldb_module_get_ctx(ac->module), ac->req,
222 ac, extended_final_callback,
226 ret = ldb_build_rename_req(&down_req,
227 ldb_module_get_ctx(ac->module), ac->req,
229 ac->req->op.rename.newdn,
231 ac, extended_final_callback,
235 return ldb_module_done(ac->req, NULL, NULL, LDB_ERR_OPERATIONS_ERROR);
238 if (ret != LDB_SUCCESS) {
239 return ldb_module_done(ac->req, NULL, NULL, ret);
242 return ldb_next_request(ac->module, down_req);
248 static int extended_dn_in_fix(struct ldb_module *module, struct ldb_request *req, struct ldb_dn *dn)
250 struct extended_search_context *ac;
251 struct ldb_request *down_req;
253 struct ldb_dn *base_dn = NULL;
254 enum ldb_scope base_dn_scope = LDB_SCOPE_BASE;
255 const char *base_dn_filter = NULL;
256 const char * const *base_dn_attrs = NULL;
257 char *wellknown_object = NULL;
258 static const char *no_attr[] = {
261 static const char *wkattr[] = {
265 bool all_partitions = false;
267 if (!ldb_dn_has_extended(dn)) {
268 /* Move along there isn't anything to see here */
269 return ldb_next_request(module, req);
271 /* It looks like we need to map the DN */
272 const struct ldb_val *sid_val, *guid_val, *wkguid_val;
274 sid_val = ldb_dn_get_extended_component(dn, "SID");
275 guid_val = ldb_dn_get_extended_component(dn, "GUID");
276 wkguid_val = ldb_dn_get_extended_component(dn, "WKGUID");
279 all_partitions = true;
280 base_dn = ldb_get_default_basedn(ldb_module_get_ctx(module));
281 base_dn_filter = talloc_asprintf(req, "(objectSid=%s)",
282 ldb_binary_encode(req, *sid_val));
283 if (!base_dn_filter) {
284 return ldb_oom(ldb_module_get_ctx(module));
286 base_dn_scope = LDB_SCOPE_SUBTREE;
287 base_dn_attrs = no_attr;
289 } else if (guid_val) {
291 all_partitions = true;
292 base_dn = ldb_get_default_basedn(ldb_module_get_ctx(module));
293 base_dn_filter = talloc_asprintf(req, "(objectGUID=%s)",
294 ldb_binary_encode(req, *guid_val));
295 if (!base_dn_filter) {
296 return ldb_oom(ldb_module_get_ctx(module));
298 base_dn_scope = LDB_SCOPE_SUBTREE;
299 base_dn_attrs = no_attr;
302 } else if (wkguid_val) {
307 wkguid_dup = talloc_strndup(req, (char *)wkguid_val->data, wkguid_val->length);
309 p = strchr(wkguid_dup, ',');
311 return LDB_ERR_INVALID_DN_SYNTAX;
317 wellknown_object = talloc_asprintf(req, "B:32:%s:", wkguid_dup);
318 if (!wellknown_object) {
319 return ldb_oom(ldb_module_get_ctx(module));
324 base_dn = ldb_dn_new(req, ldb_module_get_ctx(module), tail_str);
325 talloc_free(wkguid_dup);
327 return ldb_oom(ldb_module_get_ctx(module));
329 base_dn_filter = talloc_strdup(req, "(objectClass=*)");
330 if (!base_dn_filter) {
331 return ldb_oom(ldb_module_get_ctx(module));
333 base_dn_scope = LDB_SCOPE_BASE;
334 base_dn_attrs = wkattr;
336 return LDB_ERR_INVALID_DN_SYNTAX;
339 ac = talloc_zero(req, struct extended_search_context);
341 return ldb_oom(ldb_module_get_ctx(module));
346 ac->basedn = NULL; /* Filled in if the search finds the DN by SID/GUID etc */
347 ac->wellknown_object = wellknown_object;
349 /* If the base DN was an extended DN (perhaps a well known
350 * GUID) then search for that, so we can proceed with the original operation */
352 ret = ldb_build_search_req(&down_req,
353 ldb_module_get_ctx(module), ac,
359 ac, extended_base_callback,
361 if (ret != LDB_SUCCESS) {
362 return ldb_operr(ldb_module_get_ctx(module));
365 if (all_partitions) {
366 struct ldb_search_options_control *control;
367 control = talloc(down_req, struct ldb_search_options_control);
368 control->search_options = 2;
369 ret = ldb_request_add_control(down_req,
370 LDB_CONTROL_SEARCH_OPTIONS_OID,
372 if (ret != LDB_SUCCESS) {
373 ldb_oom(ldb_module_get_ctx(module));
378 /* perform the search */
379 return ldb_next_request(module, down_req);
383 static int extended_dn_in_search(struct ldb_module *module, struct ldb_request *req)
385 return extended_dn_in_fix(module, req, req->op.search.base);
388 static int extended_dn_in_modify(struct ldb_module *module, struct ldb_request *req)
390 return extended_dn_in_fix(module, req, req->op.mod.message->dn);
393 static int extended_dn_in_del(struct ldb_module *module, struct ldb_request *req)
395 return extended_dn_in_fix(module, req, req->op.del.dn);
398 static int extended_dn_in_rename(struct ldb_module *module, struct ldb_request *req)
400 return extended_dn_in_fix(module, req, req->op.rename.olddn);
403 _PUBLIC_ const struct ldb_module_ops ldb_extended_dn_in_module_ops = {
404 .name = "extended_dn_in",
405 .search = extended_dn_in_search,
406 .modify = extended_dn_in_modify,
407 .del = extended_dn_in_del,
408 .rename = extended_dn_in_rename,