/* [<][>][^][v][top][bottom][index][help] */
DEFINITIONS
This source file includes following definitions.
- torture_ldb_attrs
- torture_ldb_dn_attrs
- torture_ldb_dn_extended
- torture_ldb_dn
- torture_ldb_dn_invalid_extended
- torture_ldb_init
1 /*
2 Unix SMB/CIFS implementation.
3
4 Test LDB attribute functions
5
6 Copyright (C) Andrew Bartlet <abartlet@samba.org> 2008
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "lib/events/events.h"
24 #include "lib/ldb/include/ldb.h"
25 #include "lib/ldb/include/ldb_errors.h"
26 #include "lib/ldb-samba/ldif_handlers.h"
27 #include "ldb_wrap.h"
28 #include "dsdb/samdb/samdb.h"
29 #include "param/param.h"
30 #include "torture/smbtorture.h"
31 #include "torture/ldb/proto.h"
32
33 static const char *sid = "S-1-5-21-4177067393-1453636373-93818737";
34 static const char *hex_sid = "01040000000000051500000081FDF8F815BBA456718F9705";
35 static const char *guid = "975ac5fa-35d9-431d-b86a-845bcd34fff9";
36 static const char *guid2 = "{975ac5fa-35d9-431d-b86a-845bcd34fff9}";
37 static const char *hex_guid = "FAC55A97D9351D43B86A845BCD34FFF9";
38
39 static bool torture_ldb_attrs(struct torture_context *torture)
/* [<][>][^][v][top][bottom][index][help] */
40 {
41 TALLOC_CTX *mem_ctx = talloc_new(torture);
42 struct ldb_context *ldb;
43 const struct ldb_schema_attribute *attr;
44 struct ldb_val string_sid_blob, binary_sid_blob;
45 struct ldb_val string_guid_blob, string_guid_blob2, binary_guid_blob;
46
47 DATA_BLOB sid_blob = strhex_to_data_blob(mem_ctx, hex_sid);
48 DATA_BLOB guid_blob = strhex_to_data_blob(mem_ctx, hex_guid);
49
50 torture_assert(torture,
51 ldb = ldb_init(mem_ctx, torture->ev),
52 "Failed to init ldb");
53
54 torture_assert_int_equal(torture,
55 ldb_register_samba_handlers(ldb), 0,
56 "Failed to register Samba handlers");
57
58 ldb_set_utf8_fns(ldb, NULL, wrap_casefold);
59
60 /* Test SID behaviour */
61 torture_assert(torture, attr = ldb_schema_attribute_by_name(ldb, "objectSid"),
62 "Failed to get objectSid schema attribute");
63
64 string_sid_blob = data_blob_string_const(sid);
65
66 torture_assert_int_equal(torture,
67 attr->syntax->ldif_read_fn(ldb, mem_ctx,
68 &string_sid_blob, &binary_sid_blob), 0,
69 "Failed to parse string SID");
70
71 torture_assert_data_blob_equal(torture, binary_sid_blob, sid_blob,
72 "Read SID into blob form failed");
73
74 torture_assert_int_equal(torture,
75 attr->syntax->ldif_read_fn(ldb, mem_ctx,
76 &sid_blob, &binary_sid_blob), -1,
77 "Should have failed to parse binary SID");
78
79 torture_assert_int_equal(torture,
80 attr->syntax->ldif_write_fn(ldb, mem_ctx, &binary_sid_blob, &string_sid_blob), 0,
81 "Failed to parse binary SID");
82
83 torture_assert_data_blob_equal(torture,
84 string_sid_blob, data_blob_string_const(sid),
85 "Write SID into string form failed");
86
87 torture_assert_int_equal(torture,
88 attr->syntax->comparison_fn(ldb, mem_ctx, &binary_sid_blob, &string_sid_blob), 0,
89 "Failed to compare binary and string SID");
90
91 torture_assert_int_equal(torture,
92 attr->syntax->comparison_fn(ldb, mem_ctx, &string_sid_blob, &binary_sid_blob), 0,
93 "Failed to compare string and binary binary SID");
94
95 torture_assert_int_equal(torture,
96 attr->syntax->comparison_fn(ldb, mem_ctx, &string_sid_blob, &string_sid_blob), 0,
97 "Failed to compare string and string SID");
98
99 torture_assert_int_equal(torture,
100 attr->syntax->comparison_fn(ldb, mem_ctx, &binary_sid_blob, &binary_sid_blob), 0,
101 "Failed to compare binary and binary SID");
102
103 torture_assert(torture, attr->syntax->comparison_fn(ldb, mem_ctx, &guid_blob, &binary_sid_blob) != 0,
104 "Failed to distinguish binary GUID and binary SID");
105
106
107 /* Test GUID behaviour */
108 torture_assert(torture, attr = ldb_schema_attribute_by_name(ldb, "objectGUID"),
109 "Failed to get objectGUID schema attribute");
110
111 string_guid_blob = data_blob_string_const(guid);
112
113 torture_assert_int_equal(torture,
114 attr->syntax->ldif_read_fn(ldb, mem_ctx,
115 &string_guid_blob, &binary_guid_blob), 0,
116 "Failed to parse string GUID");
117
118 torture_assert_data_blob_equal(torture, binary_guid_blob, guid_blob,
119 "Read GUID into blob form failed");
120
121 string_guid_blob2 = data_blob_string_const(guid2);
122
123 torture_assert_int_equal(torture,
124 attr->syntax->ldif_read_fn(ldb, mem_ctx,
125 &string_guid_blob2, &binary_guid_blob), 0,
126 "Failed to parse string GUID");
127
128 torture_assert_data_blob_equal(torture, binary_guid_blob, guid_blob,
129 "Read GUID into blob form failed");
130
131 torture_assert_int_equal(torture,
132 attr->syntax->ldif_read_fn(ldb, mem_ctx,
133 &guid_blob, &binary_guid_blob), 0,
134 "Failed to parse binary GUID");
135
136 torture_assert_data_blob_equal(torture, binary_guid_blob, guid_blob,
137 "Read GUID into blob form failed");
138
139 torture_assert_int_equal(torture,
140 attr->syntax->ldif_write_fn(ldb, mem_ctx, &binary_guid_blob, &string_guid_blob), 0,
141 "Failed to print binary GUID as string");
142
143 torture_assert_data_blob_equal(torture, string_sid_blob, data_blob_string_const(sid),
144 "Write SID into string form failed");
145
146 torture_assert_int_equal(torture,
147 attr->syntax->comparison_fn(ldb, mem_ctx, &binary_guid_blob, &string_guid_blob), 0,
148 "Failed to compare binary and string GUID");
149
150 torture_assert_int_equal(torture,
151 attr->syntax->comparison_fn(ldb, mem_ctx, &string_guid_blob, &binary_guid_blob), 0,
152 "Failed to compare string and binary binary GUID");
153
154 torture_assert_int_equal(torture,
155 attr->syntax->comparison_fn(ldb, mem_ctx, &string_guid_blob, &string_guid_blob), 0,
156 "Failed to compare string and string GUID");
157
158 torture_assert_int_equal(torture,
159 attr->syntax->comparison_fn(ldb, mem_ctx, &binary_guid_blob, &binary_guid_blob), 0,
160 "Failed to compare binary and binary GUID");
161
162
163
164 talloc_free(mem_ctx);
165 return true;
166 }
167
168 static bool torture_ldb_dn_attrs(struct torture_context *torture)
/* [<][>][^][v][top][bottom][index][help] */
169 {
170 TALLOC_CTX *mem_ctx = talloc_new(torture);
171 struct ldb_context *ldb;
172 const struct ldb_dn_extended_syntax *attr;
173 struct ldb_val string_sid_blob, binary_sid_blob;
174 struct ldb_val string_guid_blob, binary_guid_blob;
175 struct ldb_val hex_sid_blob, hex_guid_blob;
176
177 DATA_BLOB sid_blob = strhex_to_data_blob(mem_ctx, hex_sid);
178 DATA_BLOB guid_blob = strhex_to_data_blob(mem_ctx, hex_guid);
179
180 torture_assert(torture,
181 ldb = ldb_init(mem_ctx, torture->ev),
182 "Failed to init ldb");
183
184 torture_assert_int_equal(torture,
185 ldb_register_samba_handlers(ldb), 0,
186 "Failed to register Samba handlers");
187
188 ldb_set_utf8_fns(ldb, NULL, wrap_casefold);
189
190 /* Test SID behaviour */
191 torture_assert(torture, attr = ldb_dn_extended_syntax_by_name(ldb, "SID"),
192 "Failed to get SID DN syntax");
193
194 string_sid_blob = data_blob_string_const(sid);
195
196 torture_assert_int_equal(torture,
197 attr->read_fn(ldb, mem_ctx,
198 &string_sid_blob, &binary_sid_blob), 0,
199 "Failed to parse string SID");
200
201 torture_assert_data_blob_equal(torture, binary_sid_blob, sid_blob,
202 "Read SID into blob form failed");
203
204 hex_sid_blob = data_blob_string_const(hex_sid);
205
206 torture_assert_int_equal(torture,
207 attr->read_fn(ldb, mem_ctx,
208 &hex_sid_blob, &binary_sid_blob), 0,
209 "Failed to parse HEX SID");
210
211 torture_assert_data_blob_equal(torture, binary_sid_blob, sid_blob,
212 "Read SID into blob form failed");
213
214 torture_assert_int_equal(torture,
215 attr->read_fn(ldb, mem_ctx,
216 &sid_blob, &binary_sid_blob), -1,
217 "Should have failed to parse binary SID");
218
219 torture_assert_int_equal(torture,
220 attr->write_hex_fn(ldb, mem_ctx, &sid_blob, &hex_sid_blob), 0,
221 "Failed to parse binary SID");
222
223 torture_assert_data_blob_equal(torture,
224 hex_sid_blob, data_blob_string_const(hex_sid),
225 "Write SID into HEX string form failed");
226
227 torture_assert_int_equal(torture,
228 attr->write_clear_fn(ldb, mem_ctx, &sid_blob, &string_sid_blob), 0,
229 "Failed to parse binary SID");
230
231 torture_assert_data_blob_equal(torture,
232 string_sid_blob, data_blob_string_const(sid),
233 "Write SID into clear string form failed");
234
235
236 /* Test GUID behaviour */
237 torture_assert(torture, attr = ldb_dn_extended_syntax_by_name(ldb, "GUID"),
238 "Failed to get GUID DN syntax");
239
240 string_guid_blob = data_blob_string_const(guid);
241
242 torture_assert_int_equal(torture,
243 attr->read_fn(ldb, mem_ctx,
244 &string_guid_blob, &binary_guid_blob), 0,
245 "Failed to parse string GUID");
246
247 torture_assert_data_blob_equal(torture, binary_guid_blob, guid_blob,
248 "Read GUID into blob form failed");
249
250 hex_guid_blob = data_blob_string_const(hex_guid);
251
252 torture_assert_int_equal(torture,
253 attr->read_fn(ldb, mem_ctx,
254 &hex_guid_blob, &binary_guid_blob), 0,
255 "Failed to parse HEX GUID");
256
257 torture_assert_data_blob_equal(torture, binary_guid_blob, guid_blob,
258 "Read GUID into blob form failed");
259
260 torture_assert_int_equal(torture,
261 attr->read_fn(ldb, mem_ctx,
262 &guid_blob, &binary_guid_blob), -1,
263 "Should have failed to parse binary GUID");
264
265 torture_assert_int_equal(torture,
266 attr->write_hex_fn(ldb, mem_ctx, &guid_blob, &hex_guid_blob), 0,
267 "Failed to parse binary GUID");
268
269 torture_assert_data_blob_equal(torture,
270 hex_guid_blob, data_blob_string_const(hex_guid),
271 "Write GUID into HEX string form failed");
272
273 torture_assert_int_equal(torture,
274 attr->write_clear_fn(ldb, mem_ctx, &guid_blob, &string_guid_blob), 0,
275 "Failed to parse binary GUID");
276
277 torture_assert_data_blob_equal(torture,
278 string_guid_blob, data_blob_string_const(guid),
279 "Write GUID into clear string form failed");
280
281
282
283 talloc_free(mem_ctx);
284 return true;
285 }
286
287 static bool torture_ldb_dn_extended(struct torture_context *torture)
/* [<][>][^][v][top][bottom][index][help] */
288 {
289 TALLOC_CTX *mem_ctx = talloc_new(torture);
290 struct ldb_context *ldb;
291 struct ldb_dn *dn, *dn2;
292
293 DATA_BLOB sid_blob = strhex_to_data_blob(mem_ctx, hex_sid);
294 DATA_BLOB guid_blob = strhex_to_data_blob(mem_ctx, hex_guid);
295
296 const char *dn_str = "cn=admin,cn=users,dc=samba,dc=org";
297
298 torture_assert(torture,
299 ldb = ldb_init(mem_ctx, torture->ev),
300 "Failed to init ldb");
301
302 torture_assert_int_equal(torture,
303 ldb_register_samba_handlers(ldb), 0,
304 "Failed to register Samba handlers");
305
306 ldb_set_utf8_fns(ldb, NULL, wrap_casefold);
307
308 /* Check behaviour of a normal DN */
309 torture_assert(torture,
310 dn = ldb_dn_new(mem_ctx, ldb, dn_str),
311 "Failed to create a 'normal' DN");
312
313 torture_assert(torture,
314 ldb_dn_validate(dn),
315 "Failed to validate 'normal' DN");
316
317 torture_assert(torture, ldb_dn_has_extended(dn) == false,
318 "Should not find plain DN to be 'extended'");
319
320 torture_assert(torture, ldb_dn_get_extended_component(dn, "SID") == NULL,
321 "Should not find an SID on plain DN");
322
323 torture_assert(torture, ldb_dn_get_extended_component(dn, "GUID") == NULL,
324 "Should not find an GUID on plain DN");
325
326 torture_assert(torture, ldb_dn_get_extended_component(dn, "WKGUID") == NULL,
327 "Should not find an WKGUID on plain DN");
328
329 /* Now make an extended DN */
330 torture_assert(torture,
331 dn = ldb_dn_new_fmt(mem_ctx, ldb, "<GUID=%s>;<SID=%s>;%s",
332 guid, sid, dn_str),
333 "Failed to create an 'extended' DN");
334
335 torture_assert(torture,
336 dn2 = ldb_dn_copy(mem_ctx, dn),
337 "Failed to copy the 'extended' DN");
338 talloc_free(dn);
339 dn = dn2;
340
341 torture_assert(torture,
342 ldb_dn_validate(dn),
343 "Failed to validate 'extended' DN");
344
345 torture_assert(torture, ldb_dn_has_extended(dn) == true,
346 "Should find extended DN to be 'extended'");
347
348 torture_assert(torture, ldb_dn_get_extended_component(dn, "SID") != NULL,
349 "Should find an SID on extended DN");
350
351 torture_assert(torture, ldb_dn_get_extended_component(dn, "GUID") != NULL,
352 "Should find an GUID on extended DN");
353
354 torture_assert_data_blob_equal(torture, *ldb_dn_get_extended_component(dn, "SID"), sid_blob,
355 "Extended DN SID incorect");
356
357 torture_assert_data_blob_equal(torture, *ldb_dn_get_extended_component(dn, "GUID"), guid_blob,
358 "Extended DN GUID incorect");
359
360 torture_assert_str_equal(torture, ldb_dn_get_linearized(dn), dn_str,
361 "linearized DN incorrect");
362
363 torture_assert_str_equal(torture, ldb_dn_get_casefold(dn), strupper_talloc(mem_ctx, dn_str),
364 "casefolded DN incorrect");
365
366 torture_assert_str_equal(torture, ldb_dn_get_component_name(dn, 0), "cn",
367 "componet zero incorrect");
368
369 torture_assert_data_blob_equal(torture, *ldb_dn_get_component_val(dn, 0), data_blob_string_const("admin"),
370 "componet zero incorrect");
371
372 torture_assert_str_equal(torture, ldb_dn_get_extended_linearized(mem_ctx, dn, 1),
373 talloc_asprintf(mem_ctx, "<GUID=%s>;<SID=%s>;%s",
374 guid, sid, dn_str),
375 "Clear extended linearized DN incorrect");
376
377 torture_assert_str_equal(torture, ldb_dn_get_extended_linearized(mem_ctx, dn, 0),
378 talloc_asprintf(mem_ctx, "<GUID=%s>;<SID=%s>;%s",
379 hex_guid, hex_sid, dn_str),
380 "HEX extended linearized DN incorrect");
381
382 torture_assert(torture, ldb_dn_remove_child_components(dn, 1) == true,
383 "Failed to remove DN child");
384
385 torture_assert(torture, ldb_dn_has_extended(dn) == false,
386 "Extended DN flag should be cleared after child element removal");
387
388 torture_assert(torture, ldb_dn_get_extended_component(dn, "SID") == NULL,
389 "Should not find an SID on DN");
390
391 torture_assert(torture, ldb_dn_get_extended_component(dn, "GUID") == NULL,
392 "Should not find an GUID on DN");
393
394
395 /* TODO: test setting these in the other order, and ensure it still comes out 'GUID first' */
396 torture_assert_int_equal(torture, ldb_dn_set_extended_component(dn, "GUID", &guid_blob), 0,
397 "Failed to set a GUID on DN");
398
399 torture_assert_int_equal(torture, ldb_dn_set_extended_component(dn, "SID", &sid_blob), 0,
400 "Failed to set a SID on DN");
401
402 torture_assert_data_blob_equal(torture, *ldb_dn_get_extended_component(dn, "SID"), sid_blob,
403 "Extended DN SID incorect");
404
405 torture_assert_data_blob_equal(torture, *ldb_dn_get_extended_component(dn, "GUID"), guid_blob,
406 "Extended DN GUID incorect");
407
408 torture_assert_str_equal(torture, ldb_dn_get_linearized(dn), "cn=users,dc=samba,dc=org",
409 "linearized DN incorrect");
410
411 torture_assert_str_equal(torture, ldb_dn_get_extended_linearized(mem_ctx, dn, 1),
412 talloc_asprintf(mem_ctx, "<GUID=%s>;<SID=%s>;%s",
413 guid, sid, "cn=users,dc=samba,dc=org"),
414 "Clear extended linearized DN incorrect");
415
416 torture_assert_str_equal(torture, ldb_dn_get_extended_linearized(mem_ctx, dn, 0),
417 talloc_asprintf(mem_ctx, "<GUID=%s>;<SID=%s>;%s",
418 hex_guid, hex_sid, "cn=users,dc=samba,dc=org"),
419 "HEX extended linearized DN incorrect");
420
421 /* Now check a 'just GUID' DN (clear format) */
422 torture_assert(torture,
423 dn = ldb_dn_new_fmt(mem_ctx, ldb, "<GUID=%s>",
424 guid),
425 "Failed to create an 'extended' DN");
426
427 torture_assert(torture,
428 ldb_dn_validate(dn),
429 "Failed to validate 'extended' DN");
430
431 torture_assert(torture, ldb_dn_has_extended(dn) == true,
432 "Should find extended DN to be 'extended'");
433
434 torture_assert(torture, ldb_dn_get_extended_component(dn, "SID") == NULL,
435 "Should not find an SID on this DN");
436
437 torture_assert_int_equal(torture, ldb_dn_get_comp_num(dn), 0,
438 "Should not find an 'normal' componet on this DN");
439
440 torture_assert(torture, ldb_dn_get_extended_component(dn, "GUID") != NULL,
441 "Should find an GUID on this DN");
442
443 torture_assert_data_blob_equal(torture, *ldb_dn_get_extended_component(dn, "GUID"), guid_blob,
444 "Extended DN GUID incorect");
445
446 torture_assert_str_equal(torture, ldb_dn_get_linearized(dn), "",
447 "linearized DN incorrect");
448
449 torture_assert_str_equal(torture, ldb_dn_get_extended_linearized(mem_ctx, dn, 1),
450 talloc_asprintf(mem_ctx, "<GUID=%s>",
451 guid),
452 "Clear extended linearized DN incorrect");
453
454 torture_assert_str_equal(torture, ldb_dn_get_extended_linearized(mem_ctx, dn, 0),
455 talloc_asprintf(mem_ctx, "<GUID=%s>",
456 hex_guid),
457 "HEX extended linearized DN incorrect");
458
459 /* Now check a 'just GUID' DN (HEX format) */
460 torture_assert(torture,
461 dn = ldb_dn_new_fmt(mem_ctx, ldb, "<GUID=%s>",
462 hex_guid),
463 "Failed to create an 'extended' DN");
464
465 torture_assert(torture,
466 ldb_dn_validate(dn),
467 "Failed to validate 'extended' DN");
468
469 torture_assert(torture, ldb_dn_has_extended(dn) == true,
470 "Should find extended DN to be 'extended'");
471
472 torture_assert(torture, ldb_dn_get_extended_component(dn, "SID") == NULL,
473 "Should not find an SID on this DN");
474
475 torture_assert(torture, ldb_dn_get_extended_component(dn, "GUID") != NULL,
476 "Should find an GUID on this DN");
477
478 torture_assert_data_blob_equal(torture, *ldb_dn_get_extended_component(dn, "GUID"), guid_blob,
479 "Extended DN GUID incorect");
480
481 torture_assert_str_equal(torture, ldb_dn_get_linearized(dn), "",
482 "linearized DN incorrect");
483
484 /* Now check a 'just SID' DN (clear format) */
485 torture_assert(torture,
486 dn = ldb_dn_new_fmt(mem_ctx, ldb, "<SID=%s>",
487 sid),
488 "Failed to create an 'extended' DN");
489
490 torture_assert(torture,
491 ldb_dn_validate(dn),
492 "Failed to validate 'extended' DN");
493
494 torture_assert(torture, ldb_dn_has_extended(dn) == true,
495 "Should find extended DN to be 'extended'");
496
497 torture_assert(torture, ldb_dn_get_extended_component(dn, "GUID") == NULL,
498 "Should not find an SID on this DN");
499
500 torture_assert(torture, ldb_dn_get_extended_component(dn, "SID") != NULL,
501 "Should find an SID on this DN");
502
503 torture_assert_data_blob_equal(torture, *ldb_dn_get_extended_component(dn, "SID"), sid_blob,
504 "Extended DN SID incorect");
505
506 torture_assert_str_equal(torture, ldb_dn_get_linearized(dn), "",
507 "linearized DN incorrect");
508
509 torture_assert_str_equal(torture, ldb_dn_get_extended_linearized(mem_ctx, dn, 1),
510 talloc_asprintf(mem_ctx, "<SID=%s>",
511 sid),
512 "Clear extended linearized DN incorrect");
513
514 torture_assert_str_equal(torture, ldb_dn_get_extended_linearized(mem_ctx, dn, 0),
515 talloc_asprintf(mem_ctx, "<SID=%s>",
516 hex_sid),
517 "HEX extended linearized DN incorrect");
518
519 /* Now check a 'just SID' DN (HEX format) */
520 torture_assert(torture,
521 dn = ldb_dn_new_fmt(mem_ctx, ldb, "<SID=%s>",
522 hex_sid),
523 "Failed to create an 'extended' DN");
524
525 torture_assert(torture,
526 ldb_dn_validate(dn),
527 "Failed to validate 'extended' DN");
528
529 torture_assert(torture, ldb_dn_has_extended(dn) == true,
530 "Should find extended DN to be 'extended'");
531
532 torture_assert(torture, ldb_dn_get_extended_component(dn, "GUID") == NULL,
533 "Should not find an SID on this DN");
534
535 torture_assert(torture, ldb_dn_get_extended_component(dn, "SID") != NULL,
536 "Should find an SID on this DN");
537
538 torture_assert_data_blob_equal(torture, *ldb_dn_get_extended_component(dn, "SID"), sid_blob,
539 "Extended DN SID incorect");
540
541 torture_assert_str_equal(torture, ldb_dn_get_linearized(dn), "",
542 "linearized DN incorrect");
543
544 talloc_free(mem_ctx);
545 return true;
546 }
547
548
549 static bool torture_ldb_dn(struct torture_context *torture)
/* [<][>][^][v][top][bottom][index][help] */
550 {
551 TALLOC_CTX *mem_ctx = talloc_new(torture);
552 struct ldb_context *ldb;
553 struct ldb_dn *dn;
554 struct ldb_dn *child_dn;
555 struct ldb_dn *typo_dn;
556
557 torture_assert(torture,
558 ldb = ldb_init(mem_ctx, torture->ev),
559 "Failed to init ldb");
560
561 torture_assert_int_equal(torture,
562 ldb_register_samba_handlers(ldb), 0,
563 "Failed to register Samba handlers");
564
565 ldb_set_utf8_fns(ldb, NULL, wrap_casefold);
566
567 /* Check behaviour of a normal DN */
568 torture_assert(torture,
569 dn = ldb_dn_new(mem_ctx, ldb, NULL),
570 "Failed to create a NULL DN");
571
572 torture_assert(torture,
573 ldb_dn_validate(dn),
574 "Failed to validate NULL DN");
575
576 torture_assert(torture,
577 ldb_dn_add_base_fmt(dn, "dc=org"),
578 "Failed to add base DN");
579
580 torture_assert(torture,
581 ldb_dn_add_child_fmt(dn, "dc=samba"),
582 "Failed to add base DN");
583
584 torture_assert_str_equal(torture, ldb_dn_get_linearized(dn), "dc=samba,dc=org",
585 "linearized DN incorrect");
586
587 torture_assert_str_equal(torture, ldb_dn_get_extended_linearized(mem_ctx, dn, 0), "dc=samba,dc=org",
588 "extended linearized DN incorrect");
589
590 /* Check child DN comparisons */
591 torture_assert(torture,
592 child_dn = ldb_dn_new(mem_ctx, ldb, "CN=users,DC=SAMBA,DC=org"),
593 "Failed to create child DN");
594
595 torture_assert(torture,
596 ldb_dn_compare(dn, child_dn) != 0,
597 "Comparison on dc=samba,dc=org and CN=users,DC=SAMBA,DC=org should != 0");
598
599 torture_assert(torture,
600 ldb_dn_compare_base(child_dn, dn) != 0,
601 "Base Comparison of CN=users,DC=SAMBA,DC=org and dc=samba,dc=org should != 0");
602
603 torture_assert(torture,
604 ldb_dn_compare_base(dn, child_dn) == 0,
605 "Base Comparison on dc=samba,dc=org and CN=users,DC=SAMBA,DC=org should == 0");
606
607 /* Check comparisons with a truncated DN */
608 torture_assert(torture,
609 typo_dn = ldb_dn_new(mem_ctx, ldb, "c=samba,dc=org"),
610 "Failed to create 'typo' DN");
611
612 torture_assert(torture,
613 ldb_dn_compare(dn, typo_dn) != 0,
614 "Comparison on dc=samba,dc=org and c=samba,dc=org should != 0");
615
616 torture_assert(torture,
617 ldb_dn_compare_base(typo_dn, dn) != 0,
618 "Base Comparison of c=samba,dc=org and dc=samba,dc=org should != 0");
619
620 torture_assert(torture,
621 ldb_dn_compare_base(dn, typo_dn) != 0,
622 "Base Comparison on dc=samba,dc=org and c=samba,dc=org should != 0");
623
624 talloc_free(mem_ctx);
625 return true;
626 }
627
628 static bool torture_ldb_dn_invalid_extended(struct torture_context *torture)
/* [<][>][^][v][top][bottom][index][help] */
629 {
630 TALLOC_CTX *mem_ctx = talloc_new(torture);
631 struct ldb_context *ldb;
632 struct ldb_dn *dn;
633
634 const char *dn_str = "cn=admin,cn=users,dc=samba,dc=org";
635
636 torture_assert(torture,
637 ldb = ldb_init(mem_ctx, torture->ev),
638 "Failed to init ldb");
639
640 torture_assert_int_equal(torture,
641 ldb_register_samba_handlers(ldb), 0,
642 "Failed to register Samba handlers");
643
644 ldb_set_utf8_fns(ldb, NULL, wrap_casefold);
645
646 /* Check behaviour of a normal DN */
647 torture_assert(torture,
648 dn = ldb_dn_new(mem_ctx, ldb, "samba,dc=org"),
649 "Failed to create a 'normal' invalid DN");
650
651 torture_assert(torture,
652 ldb_dn_validate(dn) == false,
653 "should have failed to validate 'normal' invalid DN");
654
655 /* Now make an extended DN */
656 torture_assert(torture,
657 dn = ldb_dn_new_fmt(mem_ctx, ldb, "<PID=%s>;%s",
658 sid, dn_str),
659 "Failed to create an invalid 'extended' DN");
660
661 torture_assert(torture,
662 ldb_dn_validate(dn) == false,
663 "should have failed to validate 'extended' DN");
664
665 torture_assert(torture,
666 dn = ldb_dn_new_fmt(mem_ctx, ldb, "<GUID=%s>%s",
667 sid, dn_str),
668 "Failed to create an invalid 'extended' DN");
669
670 torture_assert(torture,
671 ldb_dn_validate(dn) == false,
672 "should have failed to validate 'extended' DN");
673
674 torture_assert(torture,
675 dn = ldb_dn_new_fmt(mem_ctx, ldb, "<GUID=%s>;",
676 sid),
677 "Failed to create an invalid 'extended' DN");
678
679 torture_assert(torture,
680 ldb_dn_validate(dn) == false,
681 "should have failed to validate 'extended' DN");
682
683 torture_assert(torture,
684 dn = ldb_dn_new_fmt(mem_ctx, ldb, "<GUID=%s>;",
685 hex_sid),
686 "Failed to create an invalid 'extended' DN");
687
688 torture_assert(torture,
689 ldb_dn_validate(dn) == false,
690 "should have failed to validate 'extended' DN");
691
692 torture_assert(torture,
693 dn = ldb_dn_new_fmt(mem_ctx, ldb, "<SID=%s>;",
694 hex_guid),
695 "Failed to create an invalid 'extended' DN");
696
697 torture_assert(torture,
698 ldb_dn_validate(dn) == false,
699 "should have failed to validate 'extended' DN");
700
701 torture_assert(torture,
702 dn = ldb_dn_new_fmt(mem_ctx, ldb, "<SID=%s>;",
703 guid),
704 "Failed to create an invalid 'extended' DN");
705
706 torture_assert(torture,
707 ldb_dn_validate(dn) == false,
708 "should have failed to validate 'extended' DN");
709
710 torture_assert(torture,
711 dn = ldb_dn_new_fmt(mem_ctx, ldb, "<GUID=>"),
712 "Failed to create an invalid 'extended' DN");
713
714 torture_assert(torture,
715 ldb_dn_validate(dn) == false,
716 "should have failed to validate 'extended' DN");
717
718 return true;
719 }
720
721 NTSTATUS torture_ldb_init(void)
/* [<][>][^][v][top][bottom][index][help] */
722 {
723 struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "LDB");
724 torture_suite_add_simple_test(suite, "ATTRS", torture_ldb_attrs);
725 torture_suite_add_simple_test(suite, "DN-ATTRS", torture_ldb_dn_attrs);
726 torture_suite_add_simple_test(suite, "DN-EXTENDED", torture_ldb_dn_extended);
727 torture_suite_add_simple_test(suite, "DN-INVALID-EXTENDED", torture_ldb_dn_invalid_extended);
728 torture_suite_add_simple_test(suite, "DN", torture_ldb_dn);
729
730 suite->description = talloc_strdup(suite, "LDB (samba-specific behaviour) tests");
731
732 torture_register_suite(suite);
733
734 return NT_STATUS_OK;
735 }