← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to source4/torture/ldb/ldb.c

  • Committer: Chuck Short
  • Date: 2010-09-28 20:38:39 UTC
  • Revision ID: zulcss@ubuntu.com-20100928203839-pgjulytsi9ue63x1
Initial version

Show diffs side-by-side

added added

removed removed

Lines of Context:
source4/torture/ldb/ldb.c
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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
}