?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert "s4:prefer "samdb_*_dn" basedn calls over the "ldb_get_*_dn" functions"
[Samba/gebeck_regimport.git] / source4 / torture / drs / unit / prefixmap_tests.c
blob4282e26a6c7814637e89719760f999b17a1a61ce
1 /*
2 Unix SMB/CIFS implementation.
3
4 DRSUAPI prefixMap unit tests
5
6 Copyright (C) Kamen Mazdrashki <kamen.mazdrashki@postpath.com> 2009
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 "system/filesys.h"
24 #include "torture/smbtorture.h"
25 #include "dsdb/samdb/samdb.h"
26 #include "torture/rpc/drsuapi.h"
27 #include "torture/drs/proto.h"
28 #include "param/param.h"
29
30
31 /**
32 * Private data to be shared among all test in Test case
33 */
34 struct drsut_prefixmap_data {
35 struct dsdb_schema_prefixmap *pfm_new;
36 struct dsdb_schema_prefixmap *pfm_full;
37
38 /* default schemaInfo value to test with */
39 const char *schi_default_str;
40 struct dsdb_schema_info *schi_default;
41
42 struct ldb_context *ldb_ctx;
43 };
44
45 /**
46 * Test-oid data structure
47 */
48 struct drsut_pfm_oid_data {
49 uint32_t id;
50 const char *bin_oid;
51 const char *oid_prefix;
52 };
53
54 /**
55 * Default prefixMap initialization data
56 */
57 static const struct drsut_pfm_oid_data _prefixmap_test_new_data[] = {
58 {.id=0x00000000, .bin_oid="5504", .oid_prefix="2.5.4"},
59 {.id=0x00000001, .bin_oid="5506", .oid_prefix="2.5.6"},
60 {.id=0x00000002, .bin_oid="2A864886F7140102", .oid_prefix="1.2.840.113556.1.2"},
61 {.id=0x00000003, .bin_oid="2A864886F7140103", .oid_prefix="1.2.840.113556.1.3"},
62 {.id=0x00000004, .bin_oid="6086480165020201", .oid_prefix="2.16.840.1.101.2.2.1"},
63 {.id=0x00000005, .bin_oid="6086480165020203", .oid_prefix="2.16.840.1.101.2.2.3"},
64 {.id=0x00000006, .bin_oid="6086480165020105", .oid_prefix="2.16.840.1.101.2.1.5"},
65 {.id=0x00000007, .bin_oid="6086480165020104", .oid_prefix="2.16.840.1.101.2.1.4"},
66 {.id=0x00000008, .bin_oid="5505", .oid_prefix="2.5.5"},
67 {.id=0x00000009, .bin_oid="2A864886F7140104", .oid_prefix="1.2.840.113556.1.4"},
68 {.id=0x0000000A, .bin_oid="2A864886F7140105", .oid_prefix="1.2.840.113556.1.5"},
69 {.id=0x00000013, .bin_oid="0992268993F22C64", .oid_prefix="0.9.2342.19200300.100"},
70 {.id=0x00000014, .bin_oid="6086480186F84203", .oid_prefix="2.16.840.1.113730.3"},
71 {.id=0x00000015, .bin_oid="0992268993F22C6401", .oid_prefix="0.9.2342.19200300.100.1"},
72 {.id=0x00000016, .bin_oid="6086480186F8420301", .oid_prefix="2.16.840.1.113730.3.1"},
73 {.id=0x00000017, .bin_oid="2A864886F7140105B658", .oid_prefix="1.2.840.113556.1.5.7000"},
74 {.id=0x00000018, .bin_oid="5515", .oid_prefix="2.5.21"},
75 {.id=0x00000019, .bin_oid="5512", .oid_prefix="2.5.18"},
76 {.id=0x0000001A, .bin_oid="5514", .oid_prefix="2.5.20"},
77 };
78
79 /**
80 * Data to be used for creating full prefix map for testing
81 */
82 static const struct drsut_pfm_oid_data _prefixmap_full_map_data[] = {
83 {.id=0x00000000, .bin_oid="0x5504", .oid_prefix="2.5.4"},
84 {.id=0x00000001, .bin_oid="0x5506", .oid_prefix="2.5.6"},
85 {.id=0x00000002, .bin_oid="0x2A864886F7140102", .oid_prefix="1.2.840.113556.1.2"},
86 {.id=0x00000003, .bin_oid="0x2A864886F7140103", .oid_prefix="1.2.840.113556.1.3"},
87 {.id=0x00000004, .bin_oid="0x6086480165020201", .oid_prefix="2.16.840.1.101.2.2.1"},
88 {.id=0x00000005, .bin_oid="0x6086480165020203", .oid_prefix="2.16.840.1.101.2.2.3"},
89 {.id=0x00000006, .bin_oid="0x6086480165020105", .oid_prefix="2.16.840.1.101.2.1.5"},
90 {.id=0x00000007, .bin_oid="0x6086480165020104", .oid_prefix="2.16.840.1.101.2.1.4"},
91 {.id=0x00000008, .bin_oid="0x5505", .oid_prefix="2.5.5"},
92 {.id=0x00000009, .bin_oid="0x2A864886F7140104", .oid_prefix="1.2.840.113556.1.4"},
93 {.id=0x0000000a, .bin_oid="0x2A864886F7140105", .oid_prefix="1.2.840.113556.1.5"},
94 {.id=0x00000013, .bin_oid="0x0992268993F22C64", .oid_prefix="0.9.2342.19200300.100"},
95 {.id=0x00000014, .bin_oid="0x6086480186F84203", .oid_prefix="2.16.840.1.113730.3"},
96 {.id=0x00000015, .bin_oid="0x0992268993F22C6401", .oid_prefix="0.9.2342.19200300.100.1"},
97 {.id=0x00000016, .bin_oid="0x6086480186F8420301", .oid_prefix="2.16.840.1.113730.3.1"},
98 {.id=0x00000017, .bin_oid="0x2A864886F7140105B658", .oid_prefix="1.2.840.113556.1.5.7000"},
99 {.id=0x00000018, .bin_oid="0x5515", .oid_prefix="2.5.21"},
100 {.id=0x00000019, .bin_oid="0x5512", .oid_prefix="2.5.18"},
101 {.id=0x0000001a, .bin_oid="0x5514", .oid_prefix="2.5.20"},
102 {.id=0x0000000b, .bin_oid="0x2A864886F71401048204", .oid_prefix="1.2.840.113556.1.4.260"},
103 {.id=0x0000000c, .bin_oid="0x2A864886F714010538", .oid_prefix="1.2.840.113556.1.5.56"},
104 {.id=0x0000000d, .bin_oid="0x2A864886F71401048206", .oid_prefix="1.2.840.113556.1.4.262"},
105 {.id=0x0000000e, .bin_oid="0x2A864886F714010539", .oid_prefix="1.2.840.113556.1.5.57"},
106 {.id=0x0000000f, .bin_oid="0x2A864886F71401048207", .oid_prefix="1.2.840.113556.1.4.263"},
107 {.id=0x00000010, .bin_oid="0x2A864886F71401053A", .oid_prefix="1.2.840.113556.1.5.58"},
108 {.id=0x00000011, .bin_oid="0x2A864886F714010549", .oid_prefix="1.2.840.113556.1.5.73"},
109 {.id=0x00000012, .bin_oid="0x2A864886F71401048231", .oid_prefix="1.2.840.113556.1.4.305"},
110 {.id=0x0000001b, .bin_oid="0x2B060104018B3A6577", .oid_prefix="1.3.6.1.4.1.1466.101.119"},
111 {.id=0x0000001c, .bin_oid="0x6086480186F8420302", .oid_prefix="2.16.840.1.113730.3.2"},
112 {.id=0x0000001d, .bin_oid="0x2B06010401817A01", .oid_prefix="1.3.6.1.4.1.250.1"},
113 {.id=0x0000001e, .bin_oid="0x2A864886F70D0109", .oid_prefix="1.2.840.113549.1.9"},
114 {.id=0x0000001f, .bin_oid="0x0992268993F22C6404", .oid_prefix="0.9.2342.19200300.100.4"},
115 {.id=0x00000020, .bin_oid="0x2A864886F714010617", .oid_prefix="1.2.840.113556.1.6.23"},
116 {.id=0x00000021, .bin_oid="0x2A864886F71401061201", .oid_prefix="1.2.840.113556.1.6.18.1"},
117 {.id=0x00000022, .bin_oid="0x2A864886F71401061202", .oid_prefix="1.2.840.113556.1.6.18.2"},
118 {.id=0x00000023, .bin_oid="0x2A864886F71401060D03", .oid_prefix="1.2.840.113556.1.6.13.3"},
119 {.id=0x00000024, .bin_oid="0x2A864886F71401060D04", .oid_prefix="1.2.840.113556.1.6.13.4"},
120 {.id=0x00000025, .bin_oid="0x2B0601010101", .oid_prefix="1.3.6.1.1.1.1"},
121 {.id=0x00000026, .bin_oid="0x2B0601010102", .oid_prefix="1.3.6.1.1.1.2"},
122 {.id=0x000003ed, .bin_oid="0x2A864886F7140104B65866", .oid_prefix="1.2.840.113556.1.4.7000.102"},
123 {.id=0x00000428, .bin_oid="0x2A864886F7140105B6583E", .oid_prefix="1.2.840.113556.1.5.7000.62"},
124 {.id=0x0000044c, .bin_oid="0x2A864886F7140104B6586683", .oid_prefix="1.2.840.113556.1.4.7000.102:0x83"},
125 {.id=0x0000044f, .bin_oid="0x2A864886F7140104B6586681", .oid_prefix="1.2.840.113556.1.4.7000.102:0x81"},
126 {.id=0x0000047d, .bin_oid="0x2A864886F7140105B6583E81", .oid_prefix="1.2.840.113556.1.5.7000.62:0x81"},
127 {.id=0x00000561, .bin_oid="0x2A864886F7140105B6583E83", .oid_prefix="1.2.840.113556.1.5.7000.62:0x83"},
128 {.id=0x000007d1, .bin_oid="0x2A864886F71401061401", .oid_prefix="1.2.840.113556.1.6.20.1"},
129 {.id=0x000007e1, .bin_oid="0x2A864886F71401061402", .oid_prefix="1.2.840.113556.1.6.20.2"},
130 {.id=0x00001b86, .bin_oid="0x2A817A", .oid_prefix="1.2.250"},
131 {.id=0x00001c78, .bin_oid="0x2A817A81", .oid_prefix="1.2.250:0x81"},
132 {.id=0x00001c7b, .bin_oid="0x2A817A8180", .oid_prefix="1.2.250:0x8180"},
133 };
134
135
136 /**
137 * OID-to-ATTID mappings to be used for testing
138 */
139 static const struct {
140 const char *oid;
141 uint32_t id;
142 uint32_t attid;
143 } _prefixmap_test_data[] = {
144 {.oid="2.5.4.0", .id=0x00000000, .attid=0x000000},
145 {.oid="2.5.4.42", .id=0x00000000, .attid=0x00002a},
146 {.oid="1.2.840.113556.1.2.1", .id=0x00000002, .attid=0x020001},
147 {.oid="1.2.840.113556.1.2.13", .id=0x00000002, .attid=0x02000d},
148 {.oid="1.2.840.113556.1.2.281", .id=0x00000002, .attid=0x020119},
149 {.oid="1.2.840.113556.1.4.125", .id=0x00000009, .attid=0x09007d},
150 {.oid="1.2.840.113556.1.4.146", .id=0x00000009, .attid=0x090092},
151 {.oid="1.2.250.1", .id=0x00001b86, .attid=0x1b860001},
152 {.oid="1.2.250.130", .id=0x00001b86, .attid=0x1b860082},
153 {.oid="1.2.250.16386", .id=0x00001c78, .attid=0x1c788002},
154 {.oid="1.2.250.2097154", .id=0x00001c7b, .attid=0x1c7b8002},
155 };
156
157
158 /**
159 * Creates dsdb_schema_prefixmap based on predefined data
160 *
161 */
162 static WERROR _drsut_prefixmap_new(const struct drsut_pfm_oid_data *_pfm_init_data, uint32_t count,
163 TALLOC_CTX *mem_ctx, struct dsdb_schema_prefixmap **_pfm)
164 {
165 uint32_t i;
166 struct dsdb_schema_prefixmap *pfm;
167
168 pfm = talloc(mem_ctx, struct dsdb_schema_prefixmap);
169 W_ERROR_HAVE_NO_MEMORY(pfm);
170
171 pfm->length = count;
172 pfm->prefixes = talloc_array(pfm, struct dsdb_schema_prefixmap_oid, pfm->length);
173 if (!pfm->prefixes) {
174 talloc_free(pfm);
175 return WERR_NOMEM;
176 }
177
178 for (i = 0; i < pfm->length; i++) {
179 pfm->prefixes[i].id = _pfm_init_data[i].id;
180 pfm->prefixes[i].bin_oid = strhex_to_data_blob(pfm, _pfm_init_data[i].bin_oid);
181 if (!pfm->prefixes[i].bin_oid.data) {
182 talloc_free(pfm);
183 return WERR_NOMEM;
184 }
185 }
186
187 *_pfm = pfm;
188
189 return WERR_OK;
190 }
191
192 static bool _torture_drs_pfm_compare_same(struct torture_context *tctx,
193 const struct dsdb_schema_prefixmap *pfm_left,
194 const struct dsdb_schema_prefixmap *pfm_right,
195 bool quiet)
196 {
197 uint32_t i;
198 char *err_msg = NULL;
199
200 if (pfm_left->length != pfm_right->length) {
201 err_msg = talloc_asprintf(tctx, "prefixMaps differ in size; left = %d, right = %d",
202 pfm_left->length, pfm_right->length);
203 goto failed;
204 }
205
206 for (i = 0; i < pfm_left->length; i++) {
207 struct dsdb_schema_prefixmap_oid *entry_left = &pfm_left->prefixes[i];
208 struct dsdb_schema_prefixmap_oid *entry_right = &pfm_right->prefixes[i];
209
210 if (entry_left->id != entry_right->id) {
211 err_msg = talloc_asprintf(tctx, "Different IDs for index=%d", i);
212 goto failed;
213 }
214 if (data_blob_cmp(&entry_left->bin_oid, &entry_right->bin_oid)) {
215 err_msg = talloc_asprintf(tctx, "Different bin_oid for index=%d", i);
216 goto failed;
217 }
218 }
219
220 return true;
221
222 failed:
223 if (!quiet) {
224 torture_comment(tctx, "_torture_drs_pfm_compare_same: %s", err_msg);
225 }
226 talloc_free(err_msg);
227
228 return false;
229 }
230
231 /*
232 * Tests dsdb_schema_pfm_new()
233 */
234 static bool torture_drs_unit_pfm_new(struct torture_context *tctx, struct drsut_prefixmap_data *priv)
235 {
236 WERROR werr;
237 bool bret;
238 TALLOC_CTX *mem_ctx;
239 struct dsdb_schema_prefixmap *pfm = NULL;
240
241 mem_ctx = talloc_new(priv);
242
243 /* create new prefix map */
244 werr = dsdb_schema_pfm_new(mem_ctx, &pfm);
245 torture_assert_werr_ok(tctx, werr, "dsdb_schema_pfm_new() failed!");
246 torture_assert(tctx, pfm != NULL, "NULL prefixMap created!");
247 torture_assert(tctx, pfm->length > 0, "Empty prefixMap created!");
248 torture_assert(tctx, pfm->prefixes != NULL, "No prefixes for newly created prefixMap!");
249
250 /* compare newly created prefixMap with template one */
251 bret = _torture_drs_pfm_compare_same(tctx, priv->pfm_new, pfm, false);
252
253 talloc_free(mem_ctx);
254
255 return bret;
256 }
257
258 /**
259 * Tests dsdb_schema_pfm_make_attid() using full prefixMap.
260 * In this test we know exactly which ATTID and prefixMap->ID
261 * should be returned, i.e. no prefixMap entries should be added.
262 */
263 static bool torture_drs_unit_pfm_make_attid_full_map(struct torture_context *tctx, struct drsut_prefixmap_data *priv)
264 {
265 WERROR werr;
266 uint32_t i, count;
267 uint32_t attid;
268 char *err_msg;
269
270 count = ARRAY_SIZE(_prefixmap_test_data);
271 for (i = 0; i < count; i++) {
272 werr = dsdb_schema_pfm_make_attid(priv->pfm_full, _prefixmap_test_data[i].oid, &attid);
273 /* prepare error message */
274 err_msg = talloc_asprintf(priv, "dsdb_schema_pfm_make_attid() failed with %s",
275 _prefixmap_test_data[i].oid);
276 torture_assert(tctx, err_msg, "Unexpected: Have no memory!");
277 /* verify result and returned ATTID */
278 torture_assert_werr_ok(tctx, werr, err_msg);
279 torture_assert_int_equal(tctx, attid, _prefixmap_test_data[i].attid, err_msg);
280 /* reclaim memory for prepared error message */
281 talloc_free(err_msg);
282 }
283
284 return true;
285 }
286
287 /**
288 * Tests dsdb_schema_pfm_make_attid() using initially small prefixMap.
289 * In this test we don't know exactly which ATTID and prefixMap->ID
290 * should be returned, but we can verify lo-word of ATTID.
291 * This test verifies implementation branch when a new
292 * prefix should be added into prefixMap.
293 */
294 static bool torture_drs_unit_pfm_make_attid_small_map(struct torture_context *tctx, struct drsut_prefixmap_data *priv)
295 {
296 WERROR werr;
297 uint32_t i, j;
298 uint32_t idx;
299 uint32_t attid, attid_2;
300 char *err_msg;
301 struct dsdb_schema_prefixmap *pfm = NULL;
302 TALLOC_CTX *mem_ctx;
303
304 mem_ctx = talloc_new(priv);
305
306 /* create new prefix map */
307 werr = dsdb_schema_pfm_new(mem_ctx, &pfm);
308 torture_assert_werr_ok(tctx, werr, "dsdb_schema_pfm_new() failed!");
309 torture_assert(tctx, pfm != NULL, "NULL prefixMap created!");
310 torture_assert(tctx, pfm->length > 0, "Empty prefixMap created!");
311 torture_assert(tctx, pfm->prefixes != NULL, "No prefixes for newly created prefixMap!");
312
313 /* make some ATTIDs and check result */
314 for (i = 0; i < ARRAY_SIZE(_prefixmap_test_data); i++) {
315 werr = dsdb_schema_pfm_make_attid(pfm, _prefixmap_test_data[i].oid, &attid);
316
317 /* prepare error message */
318 err_msg = talloc_asprintf(mem_ctx, "dsdb_schema_pfm_make_attid() failed with %s",
319 _prefixmap_test_data[i].oid);
320 torture_assert(tctx, err_msg, "Unexpected: Have no memory!");
321
322 /* verify result and returned ATTID */
323 torture_assert_werr_ok(tctx, werr, err_msg);
324 /* verify ATTID lo-word */
325 torture_assert_int_equal(tctx, attid & 0xFFFF, _prefixmap_test_data[i].attid & 0xFFFF, err_msg);
326
327 /* try again, this time verify for whole ATTID */
328 werr = dsdb_schema_pfm_make_attid(pfm, _prefixmap_test_data[i].oid, &attid_2);
329 torture_assert_werr_ok(tctx, werr, err_msg);
330 torture_assert_int_equal(tctx, attid_2, attid, err_msg);
331
332 /* reclaim memory for prepared error message */
333 talloc_free(err_msg);
334
335 /* check there is such an index in modified prefixMap */
336 idx = (attid >> 16);
337 for (j = 0; j < pfm->length; j++) {
338 if (pfm->prefixes[j].id == idx)
339 break;
340 }
341 if (j >= pfm->length) {
342 torture_result(tctx, TORTURE_FAIL, __location__": No prefix for ATTID=0x%08X", attid);
343 return false;
344 }
345
346 }
347
348 talloc_free(mem_ctx);
349
350 return true;
351 }
352
353 /**
354 * Tests dsdb_schema_pfm_oid_from_attid() using full prefixMap.
355 */
356 static bool torture_drs_unit_pfm_oid_from_attid(struct torture_context *tctx, struct drsut_prefixmap_data *priv)
357 {
358 WERROR werr;
359 uint32_t i, count;
360 char *err_msg;
361 const char *oid;
362
363 count = ARRAY_SIZE(_prefixmap_test_data);
364 for (i = 0; i < count; i++) {
365 oid = NULL;
366 werr = dsdb_schema_pfm_oid_from_attid(priv->pfm_full, _prefixmap_test_data[i].attid,
367 priv, &oid);
368 /* prepare error message */
369 err_msg = talloc_asprintf(priv, "dsdb_schema_pfm_oid_from_attid() failed with 0x%08X",
370 _prefixmap_test_data[i].attid);
371 torture_assert(tctx, err_msg, "Unexpected: Have no memory!");
372 /* verify result and returned ATTID */
373 torture_assert_werr_ok(tctx, werr, err_msg);
374 torture_assert(tctx, oid, "dsdb_schema_pfm_oid_from_attid() returned NULL OID!!!");
375 torture_assert_str_equal(tctx, oid, _prefixmap_test_data[i].oid, err_msg);
376 /* reclaim memory for prepared error message */
377 talloc_free(err_msg);
378 /* free memory for OID */
379 talloc_free(discard_const(oid));
380 }
381
382 return true;
383 }
384
385 /**
386 * Tests dsdb_schema_pfm_oid_from_attid() for handling
387 * correctly different type of attid values.
388 * See: MS-ADTS, 3.1.1.2.6 ATTRTYP
389 */
390 static bool torture_drs_unit_pfm_oid_from_attid_check_attid(struct torture_context *tctx,
391 struct drsut_prefixmap_data *priv)
392 {
393 WERROR werr;
394 const char *oid;
395
396 /* Test with valid prefixMap attid */
397 werr = dsdb_schema_pfm_oid_from_attid(priv->pfm_full, 0x00000000, tctx, &oid);
398 torture_assert_werr_ok(tctx, werr, "Testing prefixMap type attid = 0x0000000");
399
400 /* Test with attid in msDS-IntId range */
401 werr = dsdb_schema_pfm_oid_from_attid(priv->pfm_full, 0x80000000, tctx, &oid);
402 torture_assert_werr_equal(tctx, werr, WERR_INVALID_PARAMETER,
403 "Testing msDS-IntId type attid = 0x80000000");
404 werr = dsdb_schema_pfm_oid_from_attid(priv->pfm_full, 0xBFFFFFFF, tctx, &oid);
405 torture_assert_werr_equal(tctx, werr, WERR_INVALID_PARAMETER,
406 "Testing msDS-IntId type attid = 0xBFFFFFFF");
407
408 /* Test with attid in RESERVED range */
409 werr = dsdb_schema_pfm_oid_from_attid(priv->pfm_full, 0xC0000000, tctx, &oid);
410 torture_assert_werr_equal(tctx, werr, WERR_INVALID_PARAMETER,
411 "Testing RESERVED type attid = 0xC0000000");
412 werr = dsdb_schema_pfm_oid_from_attid(priv->pfm_full, 0xFFFEFFFF, tctx, &oid);
413 torture_assert_werr_equal(tctx, werr, WERR_INVALID_PARAMETER,
414 "Testing RESERVED type attid = 0xFFFEFFFF");
415
416 /* Test with attid in INTERNAL range */
417 werr = dsdb_schema_pfm_oid_from_attid(priv->pfm_full, 0xFFFF0000, tctx, &oid);
418 torture_assert_werr_equal(tctx, werr, WERR_INVALID_PARAMETER,
419 "Testing INTERNAL type attid = 0xFFFF0000");
420 werr = dsdb_schema_pfm_oid_from_attid(priv->pfm_full, 0xFFFFFFFF, tctx, &oid);
421 torture_assert_werr_equal(tctx, werr, WERR_INVALID_PARAMETER,
422 "Testing INTERNAL type attid = 0xFFFFFFFF");
423
424 return true;
425 }
426
427 /**
428 * Test Schema prefixMap conversions to/from drsuapi prefixMap
429 * representation.
430 */
431 static bool torture_drs_unit_pfm_to_from_drsuapi(struct torture_context *tctx, struct drsut_prefixmap_data *priv)
432 {
433 WERROR werr;
434 const char *schema_info;
435 struct dsdb_schema_prefixmap *pfm;
436 struct drsuapi_DsReplicaOIDMapping_Ctr *ctr;
437 TALLOC_CTX *mem_ctx;
438
439 mem_ctx = talloc_new(tctx);
440 torture_assert(tctx, mem_ctx, "Unexpected: Have no memory!");
441
442 /* convert Schema_prefixMap to drsuapi_prefixMap */
443 werr = dsdb_drsuapi_pfm_from_schema_pfm(priv->pfm_full, priv->schi_default_str, mem_ctx, &ctr);
444 torture_assert_werr_ok(tctx, werr, "dsdb_drsuapi_pfm_from_schema_pfm() failed");
445 torture_assert(tctx, ctr && ctr->mappings, "drsuapi_prefixMap not constructed correctly");
446 torture_assert_int_equal(tctx, ctr->num_mappings, priv->pfm_full->length + 1,
447 "drs_mappings count does not match");
448 /* look for schema_info entry - it should be the last one */
449 schema_info = hex_encode_talloc(mem_ctx,
450 ctr->mappings[ctr->num_mappings - 1].oid.binary_oid,
451 ctr->mappings[ctr->num_mappings - 1].oid.length);
452 torture_assert_str_equal(tctx,
453 schema_info,
454 priv->schi_default_str,
455 "schema_info not stored correctly or not last entry");
456
457 /* compare schema_prefixMap and drsuapi_prefixMap */
458 werr = dsdb_schema_pfm_contains_drsuapi_pfm(priv->pfm_full, ctr);
459 torture_assert_werr_ok(tctx, werr, "dsdb_schema_pfm_contains_drsuapi_pfm() failed");
460
461 /* convert back drsuapi_prefixMap to schema_prefixMap */
462 werr = dsdb_schema_pfm_from_drsuapi_pfm(ctr, true, mem_ctx, &pfm, &schema_info);
463 torture_assert_werr_ok(tctx, werr, "dsdb_schema_pfm_from_drsuapi_pfm() failed");
464 torture_assert_str_equal(tctx, schema_info, priv->schi_default_str, "Fetched schema_info is different");
465
466 /* compare against the original */
467 if (!_torture_drs_pfm_compare_same(tctx, priv->pfm_full, pfm, true)) {
468 talloc_free(mem_ctx);
469 return false;
470 }
471
472 /* test conversion with partial drsuapi_prefixMap */
473 ctr->num_mappings--;
474 werr = dsdb_schema_pfm_from_drsuapi_pfm(ctr, false, mem_ctx, &pfm, NULL);
475 torture_assert_werr_ok(tctx, werr, "dsdb_schema_pfm_from_drsuapi_pfm() failed");
476 /* compare against the original */
477 if (!_torture_drs_pfm_compare_same(tctx, priv->pfm_full, pfm, false)) {
478 talloc_free(mem_ctx);
479 return false;
480 }
481
482 talloc_free(mem_ctx);
483 return true;
484 }
485
486
487 /**
488 * Test Schema prefixMap conversions to/from ldb_val
489 * blob representation.
490 */
491 static bool torture_drs_unit_pfm_to_from_ldb_val(struct torture_context *tctx, struct drsut_prefixmap_data *priv)
492 {
493 WERROR werr;
494 const char *schema_info;
495 struct dsdb_schema *schema;
496 struct ldb_val pfm_ldb_val;
497 struct ldb_val schema_info_ldb_val;
498 TALLOC_CTX *mem_ctx;
499
500 mem_ctx = talloc_new(tctx);
501 torture_assert(tctx, mem_ctx, "Unexpected: Have no memory!");
502
503 schema = dsdb_new_schema(mem_ctx, lp_iconv_convenience(tctx->lp_ctx));
504 torture_assert(tctx, schema, "Unexpected: failed to allocate schema object");
505
506 /* set priv->pfm_full as prefixMap for new schema object */
507 schema->prefixmap = priv->pfm_full;
508 schema->schema_info = priv->schi_default_str;
509
510 /* convert schema_prefixMap to ldb_val blob */
511 werr = dsdb_get_oid_mappings_ldb(schema, mem_ctx, &pfm_ldb_val, &schema_info_ldb_val);
512 torture_assert_werr_ok(tctx, werr, "dsdb_get_oid_mappings_ldb() failed");
513 torture_assert(tctx, pfm_ldb_val.data && pfm_ldb_val.length,
514 "pfm_ldb_val not constructed correctly");
515 torture_assert(tctx, schema_info_ldb_val.data && schema_info_ldb_val.length,
516 "schema_info_ldb_val not constructed correctly");
517 /* look for schema_info entry - it should be the last one */
518 schema_info = hex_encode_talloc(mem_ctx,
519 schema_info_ldb_val.data,
520 schema_info_ldb_val.length);
521 torture_assert_str_equal(tctx,
522 schema_info,
523 priv->schi_default_str,
524 "schema_info not stored correctly or not last entry");
525
526 /* convert pfm_ldb_val back to schema_prefixMap */
527 schema->prefixmap = NULL;
528 schema->schema_info = NULL;
529 werr = dsdb_load_oid_mappings_ldb(schema, &pfm_ldb_val, &schema_info_ldb_val);
530 torture_assert_werr_ok(tctx, werr, "dsdb_load_oid_mappings_ldb() failed");
531 /* compare against the original */
532 if (!_torture_drs_pfm_compare_same(tctx, schema->prefixmap, priv->pfm_full, false)) {
533 talloc_free(mem_ctx);
534 return false;
535 }
536
537 talloc_free(mem_ctx);
538 return true;
539 }
540
541 /**
542 * Test read/write in ldb implementation
543 */
544 static bool torture_drs_unit_pfm_read_write_ldb(struct torture_context *tctx, struct drsut_prefixmap_data *priv)
545 {
546 WERROR werr;
547 struct dsdb_schema *schema;
548 struct dsdb_schema_prefixmap *pfm;
549 TALLOC_CTX *mem_ctx;
550
551 mem_ctx = talloc_new(tctx);
552 torture_assert(tctx, mem_ctx, "Unexpected: Have no memory!");
553
554 /* makeup a dsdb_schema to test with */
555 schema = dsdb_new_schema(mem_ctx, lp_iconv_convenience(tctx->lp_ctx));
556 torture_assert(tctx, schema, "Unexpected: failed to allocate schema object");
557 /* set priv->pfm_full as prefixMap for new schema object */
558 schema->prefixmap = priv->pfm_full;
559 schema->schema_info = priv->schi_default_str;
560
561 /* write prfixMap to ldb */
562 werr = dsdb_write_prefixes_from_schema_to_ldb(mem_ctx, priv->ldb_ctx, schema);
563 torture_assert_werr_ok(tctx, werr, "dsdb_write_prefixes_from_schema_to_ldb() failed");
564
565 /* read from ldb what we have written */
566 werr = dsdb_read_prefixes_from_ldb(priv->ldb_ctx, mem_ctx, &pfm);
567 torture_assert_werr_ok(tctx, werr, "dsdb_read_prefixes_from_ldb() failed");
568
569 /* compare data written/read */
570 if (!_torture_drs_pfm_compare_same(tctx, schema->prefixmap, priv->pfm_full, false)) {
571 torture_fail(tctx, "prefixMap read/write in LDB is not consistent");
572 }
573
574 talloc_free(mem_ctx);
575
576 return true;
577 }
578
579 /**
580 * Test rdsdb_create_prefix_mapping
581 */
582 static bool torture_drs_unit_dsdb_create_prefix_mapping(struct torture_context *tctx, struct drsut_prefixmap_data *priv)
583 {
584 WERROR werr;
585 uint32_t i;
586 struct dsdb_schema *schema;
587 TALLOC_CTX *mem_ctx;
588 const struct {
589 const char *oid;
590 uint32_t attid;
591 bool exists; /* if this prefix already exists or should be added */
592 } _test_data[] = {
593 {.oid="2.5.4.0", .attid=0x00000000, true},
594 {.oid="2.5.4.42", .attid=0x0000002a, true},
595 {.oid="1.2.840.113556.1.2.1", .attid=0x00020001, true},
596 {.oid="1.2.840.113556.1.2.13", .attid=0x0002000d, true},
597 {.oid="1.2.840.113556.1.2.281", .attid=0x00020119, true},
598 {.oid="1.2.840.113556.1.4.125", .attid=0x0009007d, true},
599 {.oid="1.2.840.113556.1.4.146", .attid=0x00090092, true},
600 {.oid="1.2.250.1", .attid=0x1b860001, false},
601 {.oid="1.2.250.16386", .attid=0x1c788002, false},
602 {.oid="1.2.250.2097154", .attid=0x1c7b8002, false},
603 };
604
605 mem_ctx = talloc_new(tctx);
606 torture_assert(tctx, mem_ctx, "Unexpected: Have no memory!");
607
608 /* makeup a dsdb_schema to test with */
609 schema = dsdb_new_schema(mem_ctx, lp_iconv_convenience(tctx->lp_ctx));
610 torture_assert(tctx, schema, "Unexpected: failed to allocate schema object");
611 /* set priv->pfm_full as prefixMap for new schema object */
612 schema->schema_info = priv->schi_default_str;
613 werr = _drsut_prefixmap_new(_prefixmap_test_new_data, ARRAY_SIZE(_prefixmap_test_new_data),
614 schema, &schema->prefixmap);
615 torture_assert_werr_ok(tctx, werr, "_drsut_prefixmap_new() failed");
616 /* write prfixMap to ldb */
617 werr = dsdb_write_prefixes_from_schema_to_ldb(mem_ctx, priv->ldb_ctx, schema);
618 torture_assert_werr_ok(tctx, werr, "dsdb_write_prefixes_from_schema_to_ldb() failed");
619
620 for (i = 0; i < ARRAY_SIZE(_test_data); i++) {
621 struct dsdb_schema_prefixmap *pfm_ldb;
622 struct dsdb_schema_prefixmap *pfm_prev;
623
624 /* add ref to prefixMap so we can use it later */
625 pfm_prev = talloc_reference(schema, schema->prefixmap);
626
627 /* call dsdb_create_prefix_mapping() and check result accordingly */
628 werr = dsdb_create_prefix_mapping(priv->ldb_ctx, schema, _test_data[i].oid);
629 torture_assert_werr_ok(tctx, werr, "dsdb_create_prefix_mapping() failed");
630
631 /* verify pfm has been altered or not if needed */
632 if (_test_data[i].exists) {
633 torture_assert(tctx, pfm_prev == schema->prefixmap,
634 "schema->prefixmap has been reallocated!");
635 if (!_torture_drs_pfm_compare_same(tctx, pfm_prev, schema->prefixmap, true)) {
636 torture_fail(tctx, "schema->prefixmap has changed");
637 }
638 } else {
639 torture_assert(tctx, pfm_prev != schema->prefixmap,
640 "schema->prefixmap should be reallocated!");
641 if (_torture_drs_pfm_compare_same(tctx, pfm_prev, schema->prefixmap, true)) {
642 torture_fail(tctx, "schema->prefixmap should be changed");
643 }
644 }
645
646 /* read from ldb what we have written */
647 werr = dsdb_read_prefixes_from_ldb(priv->ldb_ctx, mem_ctx, &pfm_ldb);
648 torture_assert_werr_ok(tctx, werr, "dsdb_read_prefixes_from_ldb() failed");
649 /* compare data written/read */
650 if (!_torture_drs_pfm_compare_same(tctx, schema->prefixmap, pfm_ldb, true)) {
651 torture_fail(tctx, "schema->prefixmap and pfm in LDB are different");
652 }
653 /* free mem for pfm read from LDB */
654 talloc_free(pfm_ldb);
655
656 /* release prefixMap pointer */
657 talloc_unlink(schema, pfm_prev);
658 }
659
660 talloc_free(mem_ctx);
661
662 return true;
663 }
664
665 /**
666 * Prepare temporary LDB and opens it
667 */
668 static bool torture_drs_unit_ldb_setup(struct torture_context *tctx, struct drsut_prefixmap_data *priv)
669 {
670 int ldb_err;
671 char *ldb_url;
672 bool bret = true;
673 TALLOC_CTX* mem_ctx;
674 char *tempdir;
675 NTSTATUS status;
676
677 mem_ctx = talloc_new(priv);
678
679 status = torture_temp_dir(tctx, "drs_", &tempdir);
680 torture_assert_ntstatus_ok(tctx, status, "creating temp dir");
681
682 ldb_url = talloc_asprintf(priv, "%s/drs_test.ldb", tempdir);
683
684 /* create LDB */
685 priv->ldb_ctx = ldb_init(priv, tctx->ev);
686 ldb_err = ldb_connect(priv->ldb_ctx, ldb_url, 0, NULL);
687 torture_assert_int_equal_goto(tctx, ldb_err, LDB_SUCCESS, bret, DONE, "ldb_connect() failed");
688
689 /* set some schemaNamingContext */
690 ldb_err = ldb_set_opaque(priv->ldb_ctx,
691 "schemaNamingContext",
692 ldb_dn_new(priv->ldb_ctx, priv->ldb_ctx, "CN=Schema,CN=Config"));
693 torture_assert_int_equal_goto(tctx, ldb_err, LDB_SUCCESS, bret, DONE, "ldb_set_opaque() failed");
694
695 /* add prefixMap attribute so tested layer could work properly */
696 {
697 struct ldb_message *msg = ldb_msg_new(mem_ctx);
698 msg->dn = ldb_get_schema_basedn(priv->ldb_ctx);
699 ldb_err = ldb_msg_add_string(msg, "prefixMap", "prefixMap");
700 torture_assert_int_equal_goto(tctx, ldb_err, LDB_SUCCESS, bret, DONE,
701 "ldb_msg_add_empty() failed");
702
703 ldb_err = ldb_add(priv->ldb_ctx, msg);
704 torture_assert_int_equal_goto(tctx, ldb_err, LDB_SUCCESS, bret, DONE, "ldb_add() failed");
705 }
706
707 DONE:
708 talloc_free(mem_ctx);
709 return bret;
710 }
711
712 /*
713 * Setup/Teardown for test case
714 */
715 static bool torture_drs_unit_prefixmap_setup(struct torture_context *tctx, struct drsut_prefixmap_data **_priv)
716 {
717 WERROR werr;
718 DATA_BLOB blob;
719 struct drsut_prefixmap_data *priv;
720
721 priv = *_priv = talloc_zero(tctx, struct drsut_prefixmap_data);
722 torture_assert(tctx, priv != NULL, "Not enough memory");
723
724 werr = _drsut_prefixmap_new(_prefixmap_test_new_data, ARRAY_SIZE(_prefixmap_test_new_data),
725 tctx, &priv->pfm_new);
726 torture_assert_werr_ok(tctx, werr, "failed to create pfm_new");
727
728 werr = _drsut_prefixmap_new(_prefixmap_full_map_data, ARRAY_SIZE(_prefixmap_full_map_data),
729 tctx, &priv->pfm_full);
730 torture_assert_werr_ok(tctx, werr, "failed to create pfm_test");
731
732 torture_assert(tctx, drsut_schemainfo_new(tctx, &priv->schi_default),
733 "drsut_schemainfo_new() failed");
734
735 werr = dsdb_blob_from_schema_info(priv->schi_default, priv, &blob);
736 torture_assert_werr_ok(tctx, werr, "dsdb_blob_from_schema_info() failed");
737
738 priv->schi_default_str = data_blob_hex_string_upper(priv, &blob);
739
740 /* create temporary LDB and populate with data */
741 if (!torture_drs_unit_ldb_setup(tctx, priv)) {
742 return false;
743 }
744
745 return true;
746 }
747
748 static bool torture_drs_unit_prefixmap_teardown(struct torture_context *tctx, struct drsut_prefixmap_data *priv)
749 {
750 talloc_free(priv);
751
752 return true;
753 }
754
755 /**
756 * Test case initialization for
757 * DRS-UNIT.prefixMap
758 */
759 struct torture_tcase * torture_drs_unit_prefixmap(struct torture_suite *suite)
760 {
761 typedef bool (*pfn_setup)(struct torture_context *, void **);
762 typedef bool (*pfn_teardown)(struct torture_context *, void *);
763 typedef bool (*pfn_run)(struct torture_context *, void *);
764
765 struct torture_tcase * tc = torture_suite_add_tcase(suite, "prefixMap");
766
767 torture_tcase_set_fixture(tc,
768 (pfn_setup)torture_drs_unit_prefixmap_setup,
769 (pfn_teardown)torture_drs_unit_prefixmap_teardown);
770
771 tc->description = talloc_strdup(tc, "Unit tests for DRSUAPI::prefixMap implementation");
772
773 torture_tcase_add_simple_test(tc, "new", (pfn_run)torture_drs_unit_pfm_new);
774
775 torture_tcase_add_simple_test(tc, "make_attid_full_map", (pfn_run)torture_drs_unit_pfm_make_attid_full_map);
776 torture_tcase_add_simple_test(tc, "make_attid_small_map", (pfn_run)torture_drs_unit_pfm_make_attid_small_map);
777 torture_tcase_add_simple_test(tc, "oid_from_attid_full_map", (pfn_run)torture_drs_unit_pfm_oid_from_attid);
778 torture_tcase_add_simple_test(tc, "oid_from_attid_check_attid",
779 (pfn_run)torture_drs_unit_pfm_oid_from_attid_check_attid);
780
781 torture_tcase_add_simple_test(tc, "pfm_to_from_drsuapi", (pfn_run)torture_drs_unit_pfm_to_from_drsuapi);
782
783 torture_tcase_add_simple_test(tc, "pfm_to_from_ldb_val", (pfn_run)torture_drs_unit_pfm_to_from_ldb_val);
784
785 torture_tcase_add_simple_test(tc, "pfm_read_write_ldb", (pfn_run)torture_drs_unit_pfm_read_write_ldb);
786
787 torture_tcase_add_simple_test(tc, "dsdb_create_prefix_mapping", (pfn_run)torture_drs_unit_dsdb_create_prefix_mapping);
788
789 return tc;
790 }
reg import