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
,
215 LDB_REQ_SET_LOCATION(down_req
);
219 ret
= ldb_build_del_req(&down_req
,
220 ldb_module_get_ctx(ac
->module
), ac
->req
,
223 ac
, extended_final_callback
,
225 LDB_REQ_SET_LOCATION(down_req
);
228 ret
= ldb_build_rename_req(&down_req
,
229 ldb_module_get_ctx(ac
->module
), ac
->req
,
231 ac
->req
->op
.rename
.newdn
,
233 ac
, extended_final_callback
,
235 LDB_REQ_SET_LOCATION(down_req
);
238 return ldb_module_done(ac
->req
, NULL
, NULL
, LDB_ERR_OPERATIONS_ERROR
);
241 if (ret
!= LDB_SUCCESS
) {
242 return ldb_module_done(ac
->req
, NULL
, NULL
, ret
);
245 return ldb_next_request(ac
->module
, down_req
);
251 static int extended_dn_in_fix(struct ldb_module
*module
, struct ldb_request
*req
, struct ldb_dn
*dn
)
253 struct extended_search_context
*ac
;
254 struct ldb_request
*down_req
;
256 struct ldb_dn
*base_dn
= NULL
;
257 enum ldb_scope base_dn_scope
= LDB_SCOPE_BASE
;
258 const char *base_dn_filter
= NULL
;
259 const char * const *base_dn_attrs
= NULL
;
260 char *wellknown_object
= NULL
;
261 static const char *no_attr
[] = {
264 static const char *wkattr
[] = {
268 bool all_partitions
= false;
270 if (!ldb_dn_has_extended(dn
)) {
271 /* Move along there isn't anything to see here */
272 return ldb_next_request(module
, req
);
274 /* It looks like we need to map the DN */
275 const struct ldb_val
*sid_val
, *guid_val
, *wkguid_val
;
277 sid_val
= ldb_dn_get_extended_component(dn
, "SID");
278 guid_val
= ldb_dn_get_extended_component(dn
, "GUID");
279 wkguid_val
= ldb_dn_get_extended_component(dn
, "WKGUID");
282 all_partitions
= true;
283 base_dn
= ldb_get_default_basedn(ldb_module_get_ctx(module
));
284 base_dn_filter
= talloc_asprintf(req
, "(objectSid=%s)",
285 ldb_binary_encode(req
, *sid_val
));
286 if (!base_dn_filter
) {
287 return ldb_oom(ldb_module_get_ctx(module
));
289 base_dn_scope
= LDB_SCOPE_SUBTREE
;
290 base_dn_attrs
= no_attr
;
292 } else if (guid_val
) {
294 all_partitions
= true;
295 base_dn
= ldb_get_default_basedn(ldb_module_get_ctx(module
));
296 base_dn_filter
= talloc_asprintf(req
, "(objectGUID=%s)",
297 ldb_binary_encode(req
, *guid_val
));
298 if (!base_dn_filter
) {
299 return ldb_oom(ldb_module_get_ctx(module
));
301 base_dn_scope
= LDB_SCOPE_SUBTREE
;
302 base_dn_attrs
= no_attr
;
305 } else if (wkguid_val
) {
310 wkguid_dup
= talloc_strndup(req
, (char *)wkguid_val
->data
, wkguid_val
->length
);
312 p
= strchr(wkguid_dup
, ',');
314 return LDB_ERR_INVALID_DN_SYNTAX
;
320 wellknown_object
= talloc_asprintf(req
, "B:32:%s:", wkguid_dup
);
321 if (!wellknown_object
) {
322 return ldb_oom(ldb_module_get_ctx(module
));
327 base_dn
= ldb_dn_new(req
, ldb_module_get_ctx(module
), tail_str
);
328 talloc_free(wkguid_dup
);
330 return ldb_oom(ldb_module_get_ctx(module
));
332 base_dn_filter
= talloc_strdup(req
, "(objectClass=*)");
333 if (!base_dn_filter
) {
334 return ldb_oom(ldb_module_get_ctx(module
));
336 base_dn_scope
= LDB_SCOPE_BASE
;
337 base_dn_attrs
= wkattr
;
339 return LDB_ERR_INVALID_DN_SYNTAX
;
342 ac
= talloc_zero(req
, struct extended_search_context
);
344 return ldb_oom(ldb_module_get_ctx(module
));
349 ac
->basedn
= NULL
; /* Filled in if the search finds the DN by SID/GUID etc */
350 ac
->wellknown_object
= wellknown_object
;
352 /* If the base DN was an extended DN (perhaps a well known
353 * GUID) then search for that, so we can proceed with the original operation */
355 ret
= ldb_build_search_req(&down_req
,
356 ldb_module_get_ctx(module
), ac
,
362 ac
, extended_base_callback
,
364 LDB_REQ_SET_LOCATION(down_req
);
365 if (ret
!= LDB_SUCCESS
) {
366 return ldb_operr(ldb_module_get_ctx(module
));
369 if (all_partitions
) {
370 struct ldb_search_options_control
*control
;
371 control
= talloc(down_req
, struct ldb_search_options_control
);
372 control
->search_options
= 2;
373 ret
= ldb_request_replace_control(down_req
,
374 LDB_CONTROL_SEARCH_OPTIONS_OID
,
376 if (ret
!= LDB_SUCCESS
) {
377 ldb_oom(ldb_module_get_ctx(module
));
382 /* perform the search */
383 return ldb_next_request(module
, down_req
);
387 static int extended_dn_in_search(struct ldb_module
*module
, struct ldb_request
*req
)
389 return extended_dn_in_fix(module
, req
, req
->op
.search
.base
);
392 static int extended_dn_in_modify(struct ldb_module
*module
, struct ldb_request
*req
)
394 return extended_dn_in_fix(module
, req
, req
->op
.mod
.message
->dn
);
397 static int extended_dn_in_del(struct ldb_module
*module
, struct ldb_request
*req
)
399 return extended_dn_in_fix(module
, req
, req
->op
.del
.dn
);
402 static int extended_dn_in_rename(struct ldb_module
*module
, struct ldb_request
*req
)
404 return extended_dn_in_fix(module
, req
, req
->op
.rename
.olddn
);
407 _PUBLIC_
const struct ldb_module_ops ldb_extended_dn_in_module_ops
= {
408 .name
= "extended_dn_in",
409 .search
= extended_dn_in_search
,
410 .modify
= extended_dn_in_modify
,
411 .del
= extended_dn_in_del
,
412 .rename
= extended_dn_in_rename
,