Branch data Line data Source code
1 : : /*
2 : : SSSD - Test for idmap library
3 : :
4 : : Authors:
5 : : Sumit Bose <sbose@redhat.com>
6 : :
7 : : Copyright (C) 2012 Red Hat
8 : :
9 : : This program is free software; you can redistribute it and/or modify
10 : : it under the terms of the GNU General Public License as published by
11 : : the Free Software Foundation; either version 3 of the License, or
12 : : (at your option) any later version.
13 : :
14 : : This program is distributed in the hope that it will be useful,
15 : : but WITHOUT ANY WARRANTY; without even the implied warranty of
16 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 : : GNU General Public License for more details.
18 : :
19 : : You should have received a copy of the GNU General Public License
20 : : along with this program. If not, see <http://www.gnu.org/licenses/>.
21 : : */
22 : :
23 : : #include <check.h>
24 : :
25 : : #include "lib/idmap/sss_idmap.h"
26 : : #include "lib/idmap/sss_idmap_private.h"
27 : : #include "tests/common.h"
28 : :
29 : : #define IDMAP_RANGE_MIN 1234
30 : : #define IDMAP_RANGE_MAX 9876
31 : :
32 : : const char test_sid[] = "S-1-5-21-2127521184-1604012920-1887927527-72713";
33 : : uint8_t test_bin_sid[] = {0x01, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x15,
34 : : 0x00, 0x00, 0x00, 0xA0, 0x65, 0xCF, 0x7E, 0x78, 0x4B,
35 : : 0x9B, 0x5F, 0xE7, 0x7C, 0x87, 0x70, 0x09, 0x1C, 0x01,
36 : : 0x00};
37 : : size_t test_bin_sid_length = sizeof(test_bin_sid);
38 : :
39 : : struct dom_sid test_smb_sid = {1, 5, {0, 0, 0, 0, 0, 5}, {21, 2127521184, 1604012920, 1887927527, 72713, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
40 : :
41 : : const char large_sid[] = "S-1-5-21-1-2-4294967295-1000";
42 : : const char too_large_sid[] = "S-1-5-21-1-2-4294967296-1000";
43 : :
44 : : struct sss_idmap_ctx *idmap_ctx;
45 : :
46 : 82 : static void *idmap_talloc(size_t size, void *pvt)
47 : : {
48 : 82 : return talloc_size(pvt, size);
49 : : }
50 : :
51 : 65 : static void idmap_talloc_free(void *ptr, void *pvt)
52 : : {
53 : 65 : talloc_free(ptr);
54 : 65 : }
55 : :
56 : :
57 : 17 : void idmap_ctx_setup(void)
58 : : {
59 : : enum idmap_error_code err;
60 : :
61 : 17 : err = sss_idmap_init(idmap_talloc, global_talloc_context, idmap_talloc_free,
62 : : &idmap_ctx);
63 : :
64 : 17 : fail_unless(err == IDMAP_SUCCESS, "sss_idmap_init failed.");
65 : 17 : fail_unless(idmap_ctx != NULL, "sss_idmap_init returned NULL.");
66 : 17 : }
67 : :
68 : 17 : void idmap_ctx_teardown(void)
69 : : {
70 : : enum idmap_error_code err;
71 : :
72 : 17 : err = sss_idmap_free(idmap_ctx);
73 : 17 : fail_unless(err == IDMAP_SUCCESS, "sss_idmap_free failed.");
74 : 17 : }
75 : :
76 : 7 : void idmap_add_domain_setup(void)
77 : : {
78 : : enum idmap_error_code err;
79 : 7 : struct sss_idmap_range range = {IDMAP_RANGE_MIN, IDMAP_RANGE_MAX};
80 : :
81 : 7 : err = sss_idmap_add_domain(idmap_ctx, "test.dom", "S-1-5-21-1-2-3", &range);
82 : 7 : fail_unless(err == IDMAP_SUCCESS, "sss_idmap_add_domain failed.");
83 : 7 : }
84 : :
85 : 1 : START_TEST(idmap_test_is_domain_sid)
86 : : {
87 : : size_t c;
88 : 1 : const char *invalid[] = { "abc",
89 : : "S-1-2-3-4-5-6",
90 : : "S-1-5-21-1",
91 : : "S-1-5-21-1-2-123456789012345678",
92 : : "S-1-5-21-1+2+3",
93 : : "S-1-5-21-a-b-c",
94 : : "S-1-5-21-1-2-3-4",
95 : : NULL };
96 : :
97 : 1 : fail_if(is_domain_sid(NULL), "is_domain_sid() returned true for [NULL]");
98 [ + + ]: 8 : for (c = 0; invalid[c] != NULL; c++) {
99 : 7 : fail_if(is_domain_sid(invalid[c]),
100 : : "is_domain_sid() returned true for [%s]", invalid[c]);
101 : : }
102 : :
103 : 1 : fail_unless(is_domain_sid("S-1-5-21-1-2-3"),
104 : : "is_domain_sid() returned true for [S-1-5-21-1-2-3]");
105 : : }
106 : 1 : END_TEST
107 : :
108 : 1 : START_TEST(idmap_test_init_malloc)
109 : : {
110 : : enum idmap_error_code err;
111 : 1 : struct sss_idmap_ctx *ctx = NULL;
112 : :
113 : 1 : err = sss_idmap_init(NULL, NULL, NULL, &ctx);
114 : :
115 : 1 : fail_unless(err == IDMAP_SUCCESS, "sss_idmap_init failed.");
116 : 1 : fail_unless(ctx != NULL, "sss_idmap_init returned NULL.");
117 : :
118 : 1 : err = sss_idmap_free(ctx);
119 : 1 : fail_unless(err == IDMAP_SUCCESS, "sss_idmap_free failed.");
120 : : }
121 : 1 : END_TEST
122 : :
123 : 1 : START_TEST(idmap_test_init_talloc)
124 : : {
125 : : enum idmap_error_code err;
126 : 1 : struct sss_idmap_ctx *ctx = NULL;
127 : :
128 : 1 : err = sss_idmap_init(idmap_talloc, global_talloc_context, idmap_talloc_free,
129 : : &ctx);
130 : :
131 : 1 : fail_unless(err == IDMAP_SUCCESS, "sss_idmap_init failed.");
132 : 1 : fail_unless(ctx != NULL, "sss_idmap_init returned NULL.");
133 : :
134 : 1 : err = sss_idmap_free(ctx);
135 : 1 : fail_unless(err == IDMAP_SUCCESS, "sss_idmap_free failed.");
136 : : }
137 : 1 : END_TEST
138 : :
139 : 1 : START_TEST(idmap_test_add_domain)
140 : : {
141 : 1 : idmap_add_domain_setup();
142 : : }
143 : 1 : END_TEST
144 : :
145 : 1 : START_TEST(idmap_test_sid2uid)
146 : : {
147 : : enum idmap_error_code err;
148 : : uint32_t id;
149 : :
150 : 1 : err = sss_idmap_sid_to_unix(idmap_ctx, "S-1-5-21-1-2-3333-1000", &id);
151 : 1 : fail_unless(err == IDMAP_NO_DOMAIN, "sss_idmap_sid_to_unix did not detect "
152 : : "unknown domain");
153 : :
154 : 1 : err = sss_idmap_sid_to_unix(idmap_ctx, "S-1-5-21-1-2-3-10000", &id);
155 : 1 : fail_unless(err == IDMAP_NO_RANGE, "sss_idmap_sid_to_unix did not detect "
156 : : "RID out of range");
157 : :
158 : 1 : err = sss_idmap_sid_to_unix(idmap_ctx, "S-1-5-21-1-2-3-1000", &id);
159 : 1 : fail_unless(err == IDMAP_SUCCESS, "sss_idmap_sid_to_unix failed.");
160 : 1 : fail_unless(id == (1000 + IDMAP_RANGE_MIN),
161 : : "sss_idmap_sid_to_unix returned wrong id, "
162 : : "got [%d], expected [%d].", id, 1000 + IDMAP_RANGE_MIN);
163 : : }
164 : 1 : END_TEST
165 : :
166 : 1 : START_TEST(idmap_test_bin_sid2uid)
167 : : {
168 : : enum idmap_error_code err;
169 : : uint32_t id;
170 : 1 : uint8_t *bin_sid = NULL;
171 : : size_t length;
172 : :
173 : 1 : err = sss_idmap_sid_to_bin_sid(idmap_ctx, "S-1-5-21-1-2-3-1000",
174 : : &bin_sid, &length);
175 : 1 : fail_unless(err == IDMAP_SUCCESS, "Failed to convert SID to binary SID");
176 : :
177 : 1 : err = sss_idmap_bin_sid_to_unix(idmap_ctx, bin_sid, length , &id);
178 : 1 : fail_unless(err == IDMAP_SUCCESS, "sss_idmap_bin_sid_to_unix failed.");
179 : 1 : fail_unless(id == (1000 + IDMAP_RANGE_MIN),
180 : : "sss_idmap_bin_sid_to_unix returned wrong id, "
181 : : "got [%d], expected [%d].", id, 1000 + IDMAP_RANGE_MIN);
182 : :
183 : 1 : talloc_free(bin_sid);
184 : : }
185 : 1 : END_TEST
186 : :
187 : 1 : START_TEST(idmap_test_dom_sid2uid)
188 : : {
189 : : enum idmap_error_code err;
190 : : uint32_t id;
191 : 1 : struct sss_dom_sid *dom_sid = NULL;
192 : :
193 : 1 : err = sss_idmap_sid_to_dom_sid(idmap_ctx, "S-1-5-21-1-2-3-1000", &dom_sid);
194 : 1 : fail_unless(err == IDMAP_SUCCESS, "Failed to convert SID to SID structure");
195 : :
196 : 1 : err = sss_idmap_dom_sid_to_unix(idmap_ctx, dom_sid, &id);
197 : 1 : fail_unless(err == IDMAP_SUCCESS, "sss_idmap_dom_sid_to_unix failed.");
198 : 1 : fail_unless(id == (1000 + IDMAP_RANGE_MIN),
199 : : "sss_idmap_dom_sid_to_unix returned wrong id, "
200 : : "got [%d], expected [%d].", id, 1000 + IDMAP_RANGE_MIN);
201 : :
202 : 1 : talloc_free(dom_sid);
203 : : }
204 : 1 : END_TEST
205 : :
206 : 1 : START_TEST(idmap_test_uid2sid)
207 : : {
208 : : enum idmap_error_code err;
209 : : char *sid;
210 : :
211 : 1 : err = sss_idmap_unix_to_sid(idmap_ctx, 10000, &sid);
212 : 1 : fail_unless(err == IDMAP_NO_DOMAIN, "sss_idmap_unix_to_sid did not detect "
213 : : "id out of range");
214 : :
215 : 1 : err = sss_idmap_unix_to_sid(idmap_ctx, 2234, &sid);
216 : 1 : fail_unless(err == IDMAP_SUCCESS, "sss_idmap_unix_to_sid failed.");
217 : 1 : fail_unless(strcmp(sid, "S-1-5-21-1-2-3-1000") == 0,
218 : : "sss_idmap_unix_to_sid returned wrong SID, "
219 : : "expected [%s], got [%s].", "S-1-5-21-1-2-3-1000", sid);
220 : :
221 : 1 : talloc_free(sid);
222 : : }
223 : 1 : END_TEST
224 : :
225 : 1 : START_TEST(idmap_test_uid2dom_sid)
226 : : {
227 : : enum idmap_error_code err;
228 : 1 : struct sss_dom_sid *dom_sid = NULL;
229 : 1 : char *sid = NULL;
230 : :
231 : 1 : err = sss_idmap_unix_to_dom_sid(idmap_ctx, 10000, &dom_sid);
232 : 1 : fail_unless(err == IDMAP_NO_DOMAIN, "sss_idmap_unix_to_dom_sid did not detect "
233 : : "id out of range");
234 : :
235 : 1 : err = sss_idmap_unix_to_dom_sid(idmap_ctx, 2234, &dom_sid);
236 : 1 : fail_unless(err == IDMAP_SUCCESS, "sss_idmap_unix_to_dom_sid failed.");
237 : :
238 : 1 : err = sss_idmap_dom_sid_to_sid(idmap_ctx, dom_sid, &sid);
239 : 1 : fail_unless(err == IDMAP_SUCCESS, "sss_idmap_dom_sid_to_sid failed.");
240 : :
241 : 1 : fail_unless(strcmp(sid, "S-1-5-21-1-2-3-1000") == 0,
242 : : "sss_idmap_unix_to_dom_sid returned wrong SID, "
243 : : "expected [%s], got [%s].", "S-1-5-21-1-2-3-1000", sid);
244 : :
245 : 1 : talloc_free(sid);
246 : 1 : talloc_free(dom_sid);
247 : : }
248 : 1 : END_TEST
249 : :
250 : 1 : START_TEST(idmap_test_uid2bin_sid)
251 : : {
252 : : enum idmap_error_code err;
253 : 1 : uint8_t *bin_sid = NULL;
254 : : size_t length;
255 : 1 : char *sid = NULL;
256 : :
257 : 1 : err = sss_idmap_unix_to_bin_sid(idmap_ctx, 10000, &bin_sid, &length);
258 : 1 : fail_unless(err == IDMAP_NO_DOMAIN, "sss_idmap_unix_to_bin_sid did not detect "
259 : : "id out of range");
260 : :
261 : 1 : err = sss_idmap_unix_to_bin_sid(idmap_ctx, 2234, &bin_sid, &length);
262 : 1 : fail_unless(err == IDMAP_SUCCESS, "sss_idmap_unix_to_bin_sid failed.");
263 : :
264 : 1 : err = sss_idmap_bin_sid_to_sid(idmap_ctx, bin_sid, length, &sid);
265 : 1 : fail_unless(err == IDMAP_SUCCESS, "sss_idmap_bin_sid_to_sid failed.");
266 : :
267 : 1 : fail_unless(strcmp(sid, "S-1-5-21-1-2-3-1000") == 0,
268 : : "sss_idmap_unix_to_bin_sid returned wrong SID, "
269 : : "expected [%s], got [%s].", "S-1-5-21-1-2-3-1000", sid);
270 : :
271 : 1 : talloc_free(sid);
272 : 1 : talloc_free(bin_sid);
273 : : }
274 : 1 : END_TEST
275 : :
276 : 1 : START_TEST(idmap_test_bin_sid2dom_sid)
277 : : {
278 : 1 : struct sss_dom_sid *dom_sid = NULL;
279 : : enum idmap_error_code err;
280 : 1 : uint8_t *new_bin_sid = NULL;
281 : : size_t new_bin_sid_length;
282 : :
283 : 1 : err = sss_idmap_bin_sid_to_dom_sid(idmap_ctx, test_bin_sid,
284 : : test_bin_sid_length, &dom_sid);
285 : :
286 : 1 : fail_unless(err == IDMAP_SUCCESS,
287 : : "Failed to convert binary SID to struct sss_dom_sid.");
288 : :
289 : 1 : err = sss_idmap_dom_sid_to_bin_sid(idmap_ctx, dom_sid, &new_bin_sid,
290 : : &new_bin_sid_length);
291 : 1 : fail_unless(err == IDMAP_SUCCESS,
292 : : "Failed to convert struct sss_dom_sid to binary SID.");
293 : :
294 : 1 : fail_unless(new_bin_sid_length == test_bin_sid_length,
295 : : "Length of binary SIDs do not match.");
296 : 1 : fail_unless(memcmp(test_bin_sid, new_bin_sid, test_bin_sid_length) == 0,
297 : : "Binary SIDs do not match.");
298 : :
299 : 1 : talloc_free(dom_sid);
300 : 1 : talloc_free(new_bin_sid);
301 : : }
302 : 1 : END_TEST
303 : :
304 : 1 : START_TEST(idmap_test_sid2dom_sid)
305 : : {
306 : 1 : struct sss_dom_sid *dom_sid = NULL;
307 : : enum idmap_error_code err;
308 : 1 : char *new_sid = NULL;
309 : :
310 : 1 : err = sss_idmap_sid_to_dom_sid(idmap_ctx, "S-1-5-21-1-2-3-1000", &dom_sid);
311 : :
312 : 1 : fail_unless(err == IDMAP_SUCCESS,
313 : : "Failed to convert SID string to struct sss_dom_sid.");
314 : :
315 : 1 : err = sss_idmap_dom_sid_to_sid(idmap_ctx, dom_sid, &new_sid);
316 : 1 : fail_unless(err == IDMAP_SUCCESS,
317 : : "Failed to convert struct sss_dom_sid to SID string.");
318 : :
319 : 1 : fail_unless(new_sid != NULL, "SID string not set");
320 : 1 : fail_unless(strlen("S-1-5-21-1-2-3-1000") == strlen(new_sid),
321 : : "Length of SID strings do not match.");
322 : 1 : fail_unless(strcmp("S-1-5-21-1-2-3-1000", new_sid) == 0,
323 : : "SID strings do not match.");
324 : :
325 : 1 : talloc_free(dom_sid);
326 : 1 : talloc_free(new_sid);
327 : : }
328 : 1 : END_TEST
329 : :
330 : 1 : START_TEST(idmap_test_large_and_too_large_sid)
331 : : {
332 : 1 : struct sss_dom_sid *dom_sid = NULL;
333 : : enum idmap_error_code err;
334 : 1 : char *new_sid = NULL;
335 : :
336 : 1 : err = sss_idmap_sid_to_dom_sid(idmap_ctx, large_sid, &dom_sid);
337 : :
338 : 1 : fail_unless(err == IDMAP_SUCCESS,
339 : : "Failed to convert SID string with a UINT32_MAX component "
340 : : "to struct sss_dom_sid.");
341 : :
342 : 1 : err = sss_idmap_dom_sid_to_sid(idmap_ctx, dom_sid, &new_sid);
343 : 1 : fail_unless(err == IDMAP_SUCCESS,
344 : : "Failed to convert struct sss_dom_sid to SID string.");
345 : :
346 : 1 : fail_unless(new_sid != NULL, "SID string not set");
347 : 1 : fail_unless(strlen(large_sid) == strlen(new_sid),
348 : : "Length of SID strings do not match.");
349 : 1 : fail_unless(strcmp(large_sid, new_sid) == 0,
350 : : "SID strings do not match, expected [%s], got [%s]",
351 : : large_sid, new_sid);
352 : :
353 : 1 : err = sss_idmap_sid_to_dom_sid(idmap_ctx, too_large_sid, &dom_sid);
354 : 1 : fail_unless(err == IDMAP_SID_INVALID,
355 : : "Trying to convert a SID with a too large component "
356 : : "did not return IDMAP_SID_INVALID");
357 : :
358 : 1 : talloc_free(dom_sid);
359 : 1 : talloc_free(new_sid);
360 : : }
361 : 1 : END_TEST
362 : :
363 : 1 : START_TEST(idmap_test_sid2bin_sid)
364 : : {
365 : : enum idmap_error_code err;
366 : : size_t length;
367 : 1 : uint8_t *bin_sid = NULL;
368 : :
369 : 1 : err = sss_idmap_sid_to_bin_sid(idmap_ctx, test_sid, &bin_sid, &length);
370 : 1 : fail_unless(err == IDMAP_SUCCESS,
371 : : "Failed to convert SID string to binary sid.");
372 : 1 : fail_unless(length == test_bin_sid_length,
373 : : "Size of binary SIDs do not match, got [%d], expected [%d]",
374 : : length, test_bin_sid_length);
375 : 1 : fail_unless(memcmp(bin_sid, test_bin_sid, test_bin_sid_length) == 0,
376 : : "Binary SIDs do not match");
377 : :
378 : 1 : talloc_free(bin_sid);
379 : : }
380 : 1 : END_TEST
381 : :
382 : 1 : START_TEST(idmap_test_bin_sid2sid)
383 : : {
384 : : enum idmap_error_code err;
385 : 1 : char *sid = NULL;
386 : :
387 : 1 : err = sss_idmap_bin_sid_to_sid(idmap_ctx, test_bin_sid, test_bin_sid_length,
388 : : &sid);
389 : 1 : fail_unless(err == IDMAP_SUCCESS,
390 : : "Failed to convert binary SID to SID string.");
391 : 1 : fail_unless(strcmp(sid, test_sid) == 0, "SID strings do not match, "
392 : : "expected [%s], get [%s]",
393 : : test_sid, sid);
394 : :
395 : 1 : talloc_free(sid);
396 : : }
397 : 1 : END_TEST
398 : :
399 : 1 : START_TEST(idmap_test_smb_sid2dom_sid)
400 : : {
401 : 1 : struct sss_dom_sid *dom_sid = NULL;
402 : : enum idmap_error_code err;
403 : 1 : struct dom_sid *new_smb_sid = NULL;
404 : :
405 : 1 : err = sss_idmap_smb_sid_to_dom_sid(idmap_ctx, &test_smb_sid, &dom_sid);
406 : 1 : fail_unless(err == IDMAP_SUCCESS,
407 : : "Failed to convert samba dom_sid to struct sss_dom_sid.");
408 : :
409 : 1 : err = sss_idmap_dom_sid_to_smb_sid(idmap_ctx, dom_sid, &new_smb_sid);
410 : 1 : fail_unless(err == IDMAP_SUCCESS,
411 : : "Failed to convert struct sss_dom_sid to samba dom_sid.");
412 : :
413 : 1 : fail_unless(memcmp(&test_smb_sid, new_smb_sid, sizeof(struct dom_sid)) == 0,
414 : : "Samba dom_sid-s do not match.");
415 : :
416 : 1 : talloc_free(dom_sid);
417 : 1 : talloc_free(new_smb_sid);
418 : : }
419 : 1 : END_TEST
420 : :
421 : 1 : START_TEST(idmap_test_smb_sid2bin_sid)
422 : : {
423 : : enum idmap_error_code err;
424 : : size_t length;
425 : 1 : uint8_t *bin_sid = NULL;
426 : :
427 : 1 : err = sss_idmap_smb_sid_to_bin_sid(idmap_ctx, &test_smb_sid,
428 : : &bin_sid, &length);
429 : 1 : fail_unless(err == IDMAP_SUCCESS,
430 : : "Failed to convert samba dom_sid to binary sid.");
431 : 1 : fail_unless(length == test_bin_sid_length,
432 : : "Size of binary SIDs do not match, got [%d], expected [%d]",
433 : : length, test_bin_sid_length);
434 : 1 : fail_unless(memcmp(bin_sid, test_bin_sid, test_bin_sid_length) == 0,
435 : : "Binary SIDs do not match.");
436 : :
437 : 1 : talloc_free(bin_sid);
438 : : }
439 : 1 : END_TEST
440 : :
441 : 1 : START_TEST(idmap_test_bin_sid2smb_sid)
442 : : {
443 : : enum idmap_error_code err;
444 : 1 : struct dom_sid *smb_sid = NULL;
445 : :
446 : 1 : err = sss_idmap_bin_sid_to_smb_sid(idmap_ctx, test_bin_sid,
447 : : test_bin_sid_length, &smb_sid);
448 : 1 : fail_unless(err == IDMAP_SUCCESS,
449 : : "Failed to convert binary sid to samba dom_sid.");
450 : 1 : fail_unless(memcmp(&test_smb_sid, smb_sid, sizeof(struct dom_sid)) == 0,
451 : : "Samba dom_sid structs do not match.");
452 : :
453 : 1 : talloc_free(smb_sid);
454 : : }
455 : 1 : END_TEST
456 : :
457 : 1 : START_TEST(idmap_test_smb_sid2sid)
458 : : {
459 : : enum idmap_error_code err;
460 : 1 : char *sid = NULL;
461 : :
462 : 1 : err = sss_idmap_smb_sid_to_sid(idmap_ctx, &test_smb_sid, &sid);
463 : 1 : fail_unless(err == IDMAP_SUCCESS,
464 : : "Failed to convert samba dom_sid to sid string.");
465 : 1 : fail_unless(strcmp(sid, test_sid) == 0, "SID strings do not match, "
466 : : "expected [%s], get [%s]",
467 : : test_sid, sid);
468 : :
469 : 1 : talloc_free(sid);
470 : : }
471 : 1 : END_TEST
472 : :
473 : 1 : START_TEST(idmap_test_sid2smb_sid)
474 : : {
475 : : enum idmap_error_code err;
476 : 1 : struct dom_sid *smb_sid = NULL;
477 : :
478 : 1 : err = sss_idmap_sid_to_smb_sid(idmap_ctx, test_sid, &smb_sid);
479 : 1 : fail_unless(err == IDMAP_SUCCESS,
480 : : "Failed to convert binary sid to samba dom_sid.");
481 : 1 : fail_unless(memcmp(&test_smb_sid, smb_sid, sizeof(struct dom_sid)) == 0,
482 : : "Samba dom_sid structs do not match.");
483 : :
484 : 1 : talloc_free(smb_sid);
485 : : }
486 : 1 : END_TEST
487 : :
488 : :
489 : 21 : Suite *idmap_test_suite (void)
490 : : {
491 : 21 : Suite *s = suite_create ("IDMAP");
492 : :
493 : 21 : TCase *tc_init = tcase_create("IDMAP init tests");
494 : 21 : tcase_add_checked_fixture(tc_init,
495 : : leak_check_setup,
496 : : leak_check_teardown);
497 : :
498 : 21 : tcase_add_test(tc_init, idmap_test_init_malloc);
499 : 21 : tcase_add_test(tc_init, idmap_test_init_talloc);
500 : 21 : tcase_add_test(tc_init, idmap_test_is_domain_sid);
501 : :
502 : 21 : suite_add_tcase(s, tc_init);
503 : :
504 : 21 : TCase *tc_dom = tcase_create("IDMAP domain tests");
505 : 21 : tcase_add_checked_fixture(tc_dom,
506 : : leak_check_setup,
507 : : leak_check_teardown);
508 : 21 : tcase_add_checked_fixture(tc_dom,
509 : : idmap_ctx_setup,
510 : : idmap_ctx_teardown);
511 : :
512 : 21 : tcase_add_test(tc_dom, idmap_test_add_domain);
513 : :
514 : 21 : suite_add_tcase(s, tc_dom);
515 : :
516 : 21 : TCase *tc_conv = tcase_create("IDMAP SID conversion tests");
517 : 21 : tcase_add_checked_fixture(tc_conv,
518 : : leak_check_setup,
519 : : leak_check_teardown);
520 : 21 : tcase_add_checked_fixture(tc_conv,
521 : : idmap_ctx_setup,
522 : : idmap_ctx_teardown);
523 : :
524 : 21 : tcase_add_test(tc_conv, idmap_test_bin_sid2dom_sid);
525 : 21 : tcase_add_test(tc_conv, idmap_test_sid2dom_sid);
526 : 21 : tcase_add_test(tc_conv, idmap_test_sid2bin_sid);
527 : 21 : tcase_add_test(tc_conv, idmap_test_bin_sid2sid);
528 : 21 : tcase_add_test(tc_conv, idmap_test_smb_sid2dom_sid);
529 : 21 : tcase_add_test(tc_conv, idmap_test_smb_sid2bin_sid);
530 : 21 : tcase_add_test(tc_conv, idmap_test_bin_sid2smb_sid);
531 : 21 : tcase_add_test(tc_conv, idmap_test_smb_sid2sid);
532 : 21 : tcase_add_test(tc_conv, idmap_test_sid2smb_sid);
533 : 21 : tcase_add_test(tc_conv, idmap_test_large_and_too_large_sid);
534 : :
535 : 21 : suite_add_tcase(s, tc_conv);
536 : :
537 : 21 : TCase *tc_map = tcase_create("IDMAP mapping tests");
538 : 21 : tcase_add_checked_fixture(tc_map,
539 : : leak_check_setup,
540 : : leak_check_teardown);
541 : 21 : tcase_add_checked_fixture(tc_map,
542 : : idmap_ctx_setup,
543 : : idmap_ctx_teardown);
544 : 21 : tcase_add_checked_fixture(tc_map,
545 : : idmap_add_domain_setup,
546 : : NULL);
547 : :
548 : 21 : tcase_add_test(tc_map, idmap_test_sid2uid);
549 : 21 : tcase_add_test(tc_map, idmap_test_bin_sid2uid);
550 : 21 : tcase_add_test(tc_map, idmap_test_dom_sid2uid);
551 : 21 : tcase_add_test(tc_map, idmap_test_uid2sid);
552 : 21 : tcase_add_test(tc_map, idmap_test_uid2dom_sid);
553 : 21 : tcase_add_test(tc_map, idmap_test_uid2bin_sid);
554 : :
555 : 21 : suite_add_tcase(s, tc_map);
556 : :
557 : 21 : return s;
558 : : }
559 : 21 : int main(int argc, const char *argv[])
560 : : {
561 : : int number_failed;
562 : :
563 : 21 : tests_set_cwd();
564 : :
565 : 21 : Suite *s = idmap_test_suite();
566 : 21 : SRunner *sr = srunner_create(s);
567 : :
568 : : /* If CK_VERBOSITY is set, use that, otherwise it defaults to CK_NORMAL */
569 : 21 : srunner_run_all(sr, CK_ENV);
570 : 1 : number_failed = srunner_ntests_failed (sr);
571 : 1 : srunner_free (sr);
572 : :
573 : 1 : return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
574 : : }
|
