1 /*
2 * Authors: Jan Zarsky <[email protected]>
3 *
4 * Copyright (C) 2019 Red Hat, Inc.
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include "utilities.h"
22 #include "test_bool.h"
23
24 #define BOOL_COUNT 3
25 #define BOOL1_NAME "first_bool"
26 #define BOOL1_VALUE 1
27 #define BOOL2_NAME "second_bool"
28 #define BOOL2_VALUE 0
29 #define BOOL3_NAME "third_bool"
30 #define BOOL3_VALUE 0
31 #define BOOL_NONEXISTENT "asdf"
32
33 /* boolean_record.h */
34 static void test_bool_key_create(void);
35 static void test_bool_key_extract(void);
36 static void test_bool_compare(void);
37 static void test_bool_compare2(void);
38 static void test_bool_get_set_name(void);
39 static void test_bool_get_set_value(void);
40 static void test_bool_create(void);
41 static void test_bool_clone(void);
42
43 /* booleans_policy.h */
44 static void test_bool_query(void);
45 static void test_bool_exists(void);
46 static void test_bool_count(void);
47 static void test_bool_iterate(void);
48 static void test_bool_list(void);
49
50 /* booleans_local.h */
51 static void test_bool_modify_del_local(void);
52 static void test_bool_query_local(void);
53 static void test_bool_exists_local(void);
54 static void test_bool_count_local(void);
55 static void test_bool_iterate_local(void);
56 static void test_bool_list_local(void);
57
58 extern semanage_handle_t *sh;
59
boolean_test_init(void)60 int boolean_test_init(void)
61 {
62 if (create_test_store() < 0) {
63 fprintf(stderr, "Could not create test store\n");
64 return 1;
65 }
66
67 if (write_test_policy_from_file("test_bool.policy") < 0) {
68 fprintf(stderr, "Could not write test policy\n");
69 return 1;
70 }
71
72 return 0;
73 }
74
boolean_test_cleanup(void)75 int boolean_test_cleanup(void)
76 {
77 if (destroy_test_store() < 0) {
78 fprintf(stderr, "Could not destroy test store\n");
79 return 1;
80 }
81
82 return 0;
83 }
84
boolean_add_tests(CU_pSuite suite)85 int boolean_add_tests(CU_pSuite suite)
86 {
87 CU_add_test(suite, "bool_key_create", test_bool_key_create);
88 CU_add_test(suite, "bool_key_extract", test_bool_key_extract);
89 CU_add_test(suite, "bool_compare", test_bool_compare);
90 CU_add_test(suite, "bool_compare2", test_bool_compare2);
91 CU_add_test(suite, "bool_get_set_name", test_bool_get_set_name);
92 CU_add_test(suite, "bool_get_set_value", test_bool_get_set_value);
93 CU_add_test(suite, "bool_create", test_bool_create);
94 CU_add_test(suite, "bool_clone", test_bool_clone);
95
96 CU_add_test(suite, "bool_query", test_bool_query);
97 CU_add_test(suite, "bool_exists", test_bool_exists);
98 CU_add_test(suite, "bool_count", test_bool_count);
99 CU_add_test(suite, "bool_iterate", test_bool_iterate);
100 CU_add_test(suite, "bool_list", test_bool_list);
101
102 CU_add_test(suite, "bool_modify_del_local", test_bool_modify_del_local);
103 CU_add_test(suite, "bool_query_local", test_bool_query_local);
104 CU_add_test(suite, "bool_exists_local", test_bool_exists_local);
105 CU_add_test(suite, "bool_count_local", test_bool_count_local);
106 CU_add_test(suite, "bool_iterate_local", test_bool_iterate_local);
107 CU_add_test(suite, "bool_list_local", test_bool_list_local);
108
109 return 0;
110 }
111
112 /* Helpers */
113
get_bool_nth(int idx)114 static semanage_bool_t *get_bool_nth(int idx)
115 {
116 int res;
117 semanage_bool_t **records;
118 semanage_bool_t *boolean;
119 unsigned int count;
120
121 if (idx == I_NULL)
122 return NULL;
123
124 res = semanage_bool_list(sh, &records, &count);
125
126 CU_ASSERT_FATAL(res >= 0);
127 CU_ASSERT_FATAL(count >= (unsigned int) idx + 1);
128
129 boolean = records[idx];
130
131 for (unsigned int i = 0; i < count; i++)
132 if (i != (unsigned int) idx)
133 semanage_bool_free(records[i]);
134
135 free(records);
136
137 return boolean;
138 }
139
get_bool_new(void)140 static semanage_bool_t *get_bool_new(void)
141 {
142 int res;
143 semanage_bool_t *boolean;
144
145 res = semanage_bool_create(sh, &boolean);
146
147 CU_ASSERT_FATAL(res >= 0);
148
149 return boolean;
150 }
151
get_bool_key_nth(int idx)152 static semanage_bool_key_t *get_bool_key_nth(int idx)
153 {
154 semanage_bool_key_t *key;
155 semanage_bool_t *boolean;
156 int res;
157
158 if (idx == I_NULL)
159 return NULL;
160
161 boolean = get_bool_nth(idx);
162
163 res = semanage_bool_key_extract(sh, boolean, &key);
164
165 CU_ASSERT_FATAL(res >= 0);
166 CU_ASSERT_PTR_NOT_NULL_FATAL(key);
167
168 semanage_bool_free(boolean);
169
170 return key;
171 }
172
get_bool_key_from_str(const char * str)173 static semanage_bool_key_t *get_bool_key_from_str(const char *str)
174 {
175 semanage_bool_key_t *key;
176 int res;
177
178 if (str == NULL)
179 return NULL;
180
181 res = semanage_bool_key_create(sh, str, &key);
182
183 CU_ASSERT_FATAL(res >= 0);
184 CU_ASSERT_PTR_NOT_NULL_FATAL(key);
185
186 return key;
187 }
188
add_local_bool(const char * name)189 static void add_local_bool(const char *name)
190 {
191 semanage_bool_t *boolean;
192 semanage_bool_key_t *key = NULL;
193
194 CU_ASSERT_PTR_NOT_NULL_FATAL(name);
195
196 CU_ASSERT_FATAL(semanage_bool_key_create(sh, name, &key) >= 0);
197 CU_ASSERT_PTR_NOT_NULL_FATAL(key);
198
199 CU_ASSERT_FATAL(semanage_bool_query(sh, key, &boolean) >= 0);
200 CU_ASSERT_PTR_NOT_NULL_FATAL(boolean);
201
202 CU_ASSERT_FATAL(semanage_bool_modify_local(sh, key, boolean) >= 0);
203
204 semanage_bool_key_free(key);
205 semanage_bool_free(boolean);
206 }
207
delete_local_bool(const char * name)208 static void delete_local_bool(const char *name)
209 {
210 semanage_bool_key_t *key = NULL;
211
212 CU_ASSERT_PTR_NOT_NULL_FATAL(name);
213
214 CU_ASSERT_FATAL(semanage_bool_key_create(sh, name, &key) >= 0);
215 CU_ASSERT_PTR_NOT_NULL_FATAL(key);
216
217 CU_ASSERT_FATAL(semanage_bool_del_local(sh, key) >= 0);
218
219 semanage_bool_key_free(key);
220 }
221
222 /* Function bool_key_create */
223
helper_bool_key_create(level_t level)224 static void helper_bool_key_create(level_t level)
225 {
226 semanage_bool_key_t *key = NULL;
227
228 setup_handle(level);
229
230 CU_ASSERT(semanage_bool_key_create(sh, "", &key) >= 0);
231 CU_ASSERT_PTR_NOT_NULL(key);
232
233 semanage_bool_key_free(key);
234
235 key = NULL;
236
237 CU_ASSERT(semanage_bool_key_create(sh, "testbool", &key) >= 0);
238 CU_ASSERT_PTR_NOT_NULL(key);
239
240 semanage_bool_key_free(key);
241
242 cleanup_handle(level);
243 }
244
test_bool_key_create(void)245 void test_bool_key_create(void)
246 {
247 helper_bool_key_create(SH_CONNECT);
248 helper_bool_key_create(SH_TRANS);
249 }
250
251 /* Function bool_key_extract */
252 #define SK_NULL 1
253 #define SK_NEW 2
254 #define SK_INDEX 3
255 #define SK_KEY_NULL 4
helper_bool_key_extract(level_t level,int mode)256 static void helper_bool_key_extract(level_t level, int mode)
257 {
258 semanage_bool_t *boolean = NULL;
259 semanage_bool_key_t *key = NULL;
260 int res;
261
262 setup_handle(level);
263
264 switch (mode) {
265 case SK_NULL:
266 boolean = NULL;
267 break;
268 case SK_NEW:
269 boolean = get_bool_new();
270 break;
271 case SK_INDEX:
272 boolean = get_bool_nth(0);
273 break;
274 case SK_KEY_NULL:
275 boolean = get_bool_nth(0);
276 break;
277 default:
278 CU_FAIL_FATAL("Invalid mode\n");
279 }
280
281 if (mode == SK_KEY_NULL)
282 res = semanage_bool_key_extract(sh, boolean, NULL);
283 else
284 res = semanage_bool_key_extract(sh, boolean, &key);
285
286 CU_ASSERT(res >= 0);
287
288 res = semanage_bool_compare(boolean, key);
289
290 CU_ASSERT(res == 0);
291
292 semanage_bool_key_free(key);
293 semanage_bool_free(boolean);
294
295 cleanup_handle(level);
296 }
297
test_bool_key_extract(void)298 void test_bool_key_extract(void)
299 {
300 helper_bool_key_extract(SH_CONNECT, SK_INDEX);
301 helper_bool_key_extract(SH_TRANS, SK_INDEX);
302 }
303 #undef SK_NULL
304 #undef SK_NEW
305 #undef SK_INDEX
306 #undef SK_KEY_NULL
307
308 /* Function bool_compare */
helper_bool_compare(level_t level,int bool_idx1,int bool_idx2)309 static void helper_bool_compare(level_t level, int bool_idx1, int bool_idx2)
310 {
311 semanage_bool_t *boolean;
312 semanage_bool_key_t *key;
313 int res;
314
315 setup_handle(level);
316
317 boolean = get_bool_nth(bool_idx1);
318 key = get_bool_key_nth(bool_idx2);
319
320 res = semanage_bool_compare(boolean, key);
321
322 if (bool_idx1 == bool_idx2) {
323 CU_ASSERT(res == 0);
324 } else {
325 CU_ASSERT(res != 0);
326 }
327
328 semanage_bool_free(boolean);
329 semanage_bool_key_free(key);
330 cleanup_handle(level);
331 }
332
test_bool_compare(void)333 static void test_bool_compare(void)
334 {
335 helper_bool_compare(SH_CONNECT, I_FIRST, I_FIRST);
336 helper_bool_compare(SH_CONNECT, I_FIRST, I_SECOND);
337 helper_bool_compare(SH_CONNECT, I_SECOND, I_FIRST);
338 helper_bool_compare(SH_CONNECT, I_SECOND, I_SECOND);
339
340 helper_bool_compare(SH_TRANS, I_FIRST, I_FIRST);
341 helper_bool_compare(SH_TRANS, I_FIRST, I_SECOND);
342 helper_bool_compare(SH_TRANS, I_SECOND, I_FIRST);
343 helper_bool_compare(SH_TRANS, I_SECOND, I_SECOND);
344 }
345
346 /* Function bool_compare2 */
helper_bool_compare2(level_t level,int bool_idx1,int bool_idx2)347 static void helper_bool_compare2(level_t level, int bool_idx1, int bool_idx2)
348 {
349 semanage_bool_t *bool1;
350 semanage_bool_t *bool2;
351 int res;
352
353 setup_handle(level);
354
355 bool1 = get_bool_nth(bool_idx1);
356 bool2 = get_bool_nth(bool_idx2);
357
358 res = semanage_bool_compare2(bool1, bool2);
359
360 if (bool_idx1 == bool_idx2) {
361 CU_ASSERT(res == 0);
362 } else {
363 CU_ASSERT(res != 0);
364 }
365
366 semanage_bool_free(bool1);
367 semanage_bool_free(bool2);
368 cleanup_handle(level);
369 }
370
test_bool_compare2(void)371 static void test_bool_compare2(void)
372 {
373 helper_bool_compare2(SH_CONNECT, I_FIRST, I_FIRST);
374 helper_bool_compare2(SH_CONNECT, I_FIRST, I_SECOND);
375 helper_bool_compare2(SH_CONNECT, I_SECOND, I_FIRST);
376 helper_bool_compare2(SH_CONNECT, I_SECOND, I_SECOND);
377
378 helper_bool_compare2(SH_TRANS, I_FIRST, I_FIRST);
379 helper_bool_compare2(SH_TRANS, I_FIRST, I_SECOND);
380 helper_bool_compare2(SH_TRANS, I_SECOND, I_FIRST);
381 helper_bool_compare2(SH_TRANS, I_SECOND, I_SECOND);
382 }
383
384 /* Function bool_get_name, bool_set_name */
helper_bool_get_set_name(level_t level,int bool_idx,const char * name)385 static void helper_bool_get_set_name(level_t level, int bool_idx, const char *name)
386 {
387 semanage_bool_t *boolean;
388 const char *new_name = NULL;
389
390 setup_handle(level);
391
392 boolean = get_bool_nth(bool_idx);
393
394 CU_ASSERT(semanage_bool_set_name(sh, boolean, name) >= 0);
395
396 new_name = semanage_bool_get_name(boolean);
397
398 CU_ASSERT_PTR_NOT_NULL(new_name);
399 /* Use assert to silence the clang analyzer */
400 assert(new_name);
401 CU_ASSERT_STRING_EQUAL(new_name, name);
402
403 semanage_bool_free(boolean);
404 cleanup_handle(level);
405 }
406
test_bool_get_set_name(void)407 static void test_bool_get_set_name(void)
408 {
409 helper_bool_get_set_name(SH_CONNECT, I_FIRST, "testbool");
410 helper_bool_get_set_name(SH_CONNECT, I_FIRST, "");
411 helper_bool_get_set_name(SH_CONNECT, I_SECOND, "testbool");
412 helper_bool_get_set_name(SH_CONNECT, I_SECOND, "");
413
414 helper_bool_get_set_name(SH_TRANS, I_FIRST, "testbool");
415 helper_bool_get_set_name(SH_TRANS, I_FIRST, "");
416 helper_bool_get_set_name(SH_TRANS, I_SECOND, "testbool");
417 helper_bool_get_set_name(SH_TRANS, I_SECOND, "");
418 }
419
420 /* Function bool_get_value, bool_set_value */
helper_bool_get_set_value(int bool_idx,int val)421 static void helper_bool_get_set_value(int bool_idx, int val)
422 {
423 semanage_bool_t *boolean;
424 int new_val = 0;
425
426 setup_handle(SH_CONNECT);
427 boolean = get_bool_nth(bool_idx);
428 cleanup_handle(SH_CONNECT);
429
430 semanage_bool_set_value(boolean, val);
431
432 new_val = semanage_bool_get_value(boolean);
433
434 CU_ASSERT(new_val == val);
435
436 semanage_bool_free(boolean);
437 }
438
test_bool_get_set_value(void)439 static void test_bool_get_set_value(void)
440 {
441 helper_bool_get_set_value(I_FIRST, 1);
442 helper_bool_get_set_value(I_FIRST, 0);
443 helper_bool_get_set_value(I_SECOND, 1);
444 helper_bool_get_set_value(I_SECOND, 0);
445 }
446
447 /* Function bool_create */
helper_bool_create(level_t level)448 static void helper_bool_create(level_t level)
449 {
450 semanage_bool_t *boolean;
451
452 setup_handle(level);
453
454 CU_ASSERT(semanage_bool_create(sh, &boolean) >= 0);
455
456 CU_ASSERT_PTR_NULL(semanage_bool_get_name(boolean));
457 CU_ASSERT(semanage_bool_get_value(boolean) == 0);
458
459 semanage_bool_free(boolean);
460
461 cleanup_handle(level);
462 }
463
test_bool_create(void)464 static void test_bool_create(void)
465 {
466 helper_bool_create(SH_HANDLE);
467 helper_bool_create(SH_CONNECT);
468 helper_bool_create(SH_TRANS);
469 }
470
471 /* Function bool_clone */
helper_bool_clone(level_t level,int bool_idx)472 static void helper_bool_clone(level_t level, int bool_idx)
473 {
474 semanage_bool_t *boolean;
475 semanage_bool_t *boolean_clone;
476 const char *str;
477 const char *str_clone;
478 int val;
479 int val_clone;
480
481 setup_handle(level);
482
483 boolean = get_bool_nth(bool_idx);
484
485 CU_ASSERT(semanage_bool_clone(sh, boolean, &boolean_clone) >= 0);
486
487 str = semanage_bool_get_name(boolean);
488 str_clone = semanage_bool_get_name(boolean_clone);
489
490 CU_ASSERT_STRING_EQUAL(str, str_clone);
491
492 val = semanage_bool_get_value(boolean);
493 val_clone = semanage_bool_get_value(boolean_clone);
494
495 CU_ASSERT_EQUAL(val, val_clone);
496
497 semanage_bool_free(boolean_clone);
498 semanage_bool_free(boolean);
499
500 cleanup_handle(level);
501 }
502
test_bool_clone(void)503 static void test_bool_clone(void)
504 {
505 helper_bool_clone(SH_CONNECT, I_FIRST);
506 helper_bool_clone(SH_CONNECT, I_SECOND);
507
508 helper_bool_clone(SH_TRANS, I_FIRST);
509 helper_bool_clone(SH_TRANS, I_SECOND);
510 }
511
512 /* Function bool_query */
helper_bool_query(level_t level,const char * bool_str,int exp_res)513 static void helper_bool_query(level_t level, const char *bool_str, int exp_res)
514 {
515 semanage_bool_key_t *key;
516 semanage_bool_t *resp = (void *) 42;
517
518 setup_handle(level);
519
520 key = get_bool_key_from_str(bool_str);
521
522 CU_ASSERT(semanage_bool_query(sh, key, &resp) >= 0);
523
524 if (exp_res >= 0) {
525 const char *name = semanage_bool_get_name(resp);
526 CU_ASSERT_STRING_EQUAL(name, bool_str);
527 } else {
528 CU_ASSERT_PTR_NULL(resp);
529 }
530
531 semanage_bool_free(resp);
532 semanage_bool_key_free(key);
533
534 cleanup_handle(level);
535 }
536
test_bool_query(void)537 static void test_bool_query(void)
538 {
539 helper_bool_query(SH_CONNECT, BOOL1_NAME, 1);
540 helper_bool_query(SH_CONNECT, BOOL2_NAME, 1);
541 helper_bool_query(SH_CONNECT, BOOL_NONEXISTENT, -1);
542
543 helper_bool_query(SH_TRANS, BOOL1_NAME, 1);
544 helper_bool_query(SH_TRANS, BOOL2_NAME, 1);
545 helper_bool_query(SH_TRANS, BOOL_NONEXISTENT, -1);
546 }
547
548 /* Function bool_exists */
helper_bool_exists(level_t level,const char * bool_str,int exp_resp)549 static void helper_bool_exists(level_t level, const char *bool_str, int exp_resp)
550 {
551 semanage_bool_key_t *key;
552 int resp;
553
554 setup_handle(level);
555
556 key = get_bool_key_from_str(bool_str);
557
558 CU_ASSERT(semanage_bool_exists(sh, key, &resp) >= 0);
559 CU_ASSERT(resp == exp_resp);
560
561 semanage_bool_key_free(key);
562
563 cleanup_handle(level);
564 }
565
test_bool_exists(void)566 static void test_bool_exists(void)
567 {
568 helper_bool_exists(SH_CONNECT, BOOL1_NAME, 1);
569 helper_bool_exists(SH_CONNECT, BOOL2_NAME, 1);
570 helper_bool_exists(SH_CONNECT, BOOL_NONEXISTENT, 0);
571
572 helper_bool_exists(SH_TRANS, BOOL1_NAME, 1);
573 helper_bool_exists(SH_TRANS, BOOL2_NAME, 1);
574 helper_bool_exists(SH_TRANS, BOOL_NONEXISTENT, 0);
575 }
576
577 /* Function bool_count */
test_bool_count(void)578 static void test_bool_count(void)
579 {
580 unsigned int resp;
581
582 /* handle */
583 setup_handle(SH_HANDLE);
584 CU_ASSERT(semanage_bool_count(sh, &resp) < 0);
585 CU_ASSERT(semanage_bool_count(sh, NULL) < 0);
586 cleanup_handle(SH_HANDLE);
587
588 /* connect */
589 resp = 0;
590 setup_handle(SH_CONNECT);
591 CU_ASSERT(semanage_bool_count(sh, &resp) >= 0);
592 CU_ASSERT(resp == BOOL_COUNT);
593 cleanup_handle(SH_CONNECT);
594
595 /* trans */
596 resp = 0;
597 setup_handle(SH_TRANS);
598 CU_ASSERT(semanage_bool_count(sh, &resp) >= 0);
599 CU_ASSERT(resp == BOOL_COUNT);
600 cleanup_handle(SH_TRANS);
601 }
602
603 /* Function bool_iterate */
604 unsigned int counter_bool_iterate = 0;
605
handler_bool_iterate(const semanage_bool_t * record,void * varg)606 static int handler_bool_iterate(const semanage_bool_t *record, void *varg)
607 {
608 counter_bool_iterate++;
609 return 0;
610 }
611
helper_bool_iterate_invalid(void)612 static void helper_bool_iterate_invalid(void)
613 {
614 setup_handle(SH_HANDLE);
615 CU_ASSERT(semanage_bool_iterate(sh, &handler_bool_iterate, NULL) < 0);
616 CU_ASSERT(semanage_bool_iterate(sh, NULL, NULL) < 0);
617 cleanup_handle(SH_HANDLE);
618 }
619
helper_bool_iterate(level_t level)620 static void helper_bool_iterate(level_t level)
621 {
622 setup_handle(level);
623 counter_bool_iterate = 0;
624 CU_ASSERT(semanage_bool_iterate(sh, &handler_bool_iterate, NULL) >= 0);
625 CU_ASSERT(counter_bool_iterate == BOOL_COUNT);
626 cleanup_handle(level);
627 }
628
test_bool_iterate(void)629 static void test_bool_iterate(void)
630 {
631 helper_bool_iterate_invalid();
632 helper_bool_iterate(SH_CONNECT);
633 helper_bool_iterate(SH_TRANS);
634 }
635
636 /* Function bool_list */
helper_bool_list_invalid(void)637 static void helper_bool_list_invalid(void)
638 {
639 semanage_bool_t **records;
640 unsigned int count;
641
642 setup_handle(SH_HANDLE);
643
644 CU_ASSERT(semanage_bool_list(sh, &records, &count) < 0);
645 CU_ASSERT(semanage_bool_list(sh, NULL, &count) < 0);
646 CU_ASSERT(semanage_bool_list(sh, &records, NULL) < 0);
647
648 cleanup_handle(SH_HANDLE);
649 }
650
helper_bool_list(level_t level)651 static void helper_bool_list(level_t level)
652 {
653 semanage_bool_t **records;
654 unsigned int count;
655
656 setup_handle(level);
657
658 CU_ASSERT(semanage_bool_list(sh, &records, &count) >= 0);
659 CU_ASSERT(count == BOOL_COUNT);
660
661 for (unsigned int i = 0; i < count; i++)
662 CU_ASSERT_PTR_NOT_NULL(records[i]);
663
664 for (unsigned int i = 0; i < count; i++)
665 semanage_bool_free(records[i]);
666
667 free(records);
668
669 cleanup_handle(level);
670 }
671
test_bool_list(void)672 static void test_bool_list(void)
673 {
674 helper_bool_list_invalid();
675 helper_bool_list(SH_CONNECT);
676 helper_bool_list(SH_TRANS);
677 }
678
679 /* Function bool_modify_local, bool_del_local */
helper_bool_modify_del_local(level_t level,const char * name,int old_val,int exp_res)680 static void helper_bool_modify_del_local(level_t level, const char *name,
681 int old_val, int exp_res)
682 {
683 semanage_bool_t *boolean;
684 semanage_bool_t *boolean_local = NULL;
685 semanage_bool_key_t *key = NULL;
686 int res;
687 int new_val;
688
689 /* setup */
690 setup_handle(level);
691
692 CU_ASSERT(semanage_bool_key_create(sh, name, &key) >= 0);
693 CU_ASSERT_PTR_NOT_NULL(key);
694
695 CU_ASSERT(semanage_bool_query(sh, key, &boolean) >= 0);
696 CU_ASSERT_PTR_NOT_NULL(boolean);
697
698 new_val = !old_val;
699 semanage_bool_set_value(boolean, new_val);
700
701 /* test */
702 res = semanage_bool_modify_local(sh, key, boolean);
703
704 if (exp_res < 0) {
705 CU_ASSERT(res < 0);
706 } else {
707 CU_ASSERT(res >= 0);
708
709 /* write changes to file */
710 if (level == SH_TRANS) {
711 helper_commit();
712 helper_begin_transaction();
713 }
714
715 CU_ASSERT(semanage_bool_query_local(sh, key,
716 &boolean_local) >= 0);
717 CU_ASSERT(semanage_bool_compare2(boolean_local, boolean) == 0);
718 semanage_bool_free(boolean_local);
719
720 CU_ASSERT(semanage_bool_del_local(sh, key) >= 0);
721 CU_ASSERT(semanage_bool_query_local(sh, key,
722 &boolean_local) < 0);
723 }
724
725 /* cleanup */
726 semanage_bool_key_free(key);
727 semanage_bool_free(boolean);
728
729 cleanup_handle(level);
730 }
731
test_bool_modify_del_local(void)732 static void test_bool_modify_del_local(void)
733 {
734 helper_bool_modify_del_local(SH_CONNECT, BOOL1_NAME, BOOL1_VALUE, -1);
735 helper_bool_modify_del_local(SH_CONNECT, BOOL2_NAME, BOOL2_VALUE, -1);
736 helper_bool_modify_del_local(SH_TRANS, BOOL1_NAME, BOOL1_VALUE, 1);
737 helper_bool_modify_del_local(SH_TRANS, BOOL2_NAME, BOOL2_VALUE, 1);
738 }
739
740 /* Function bool_query_local */
test_bool_query_local(void)741 static void test_bool_query_local(void)
742 {
743 semanage_bool_key_t *key = NULL;
744 semanage_bool_t *resp = NULL;
745
746 /* connect */
747 setup_handle(SH_CONNECT);
748 CU_ASSERT(semanage_bool_key_create(sh, BOOL1_NAME, &key) >= 0);
749 CU_ASSERT_PTR_NOT_NULL(key);
750
751 CU_ASSERT(semanage_bool_query_local(sh, key, &resp) < 0);
752 CU_ASSERT_PTR_NULL(resp);
753
754 cleanup_handle(SH_CONNECT);
755
756 /* transaction */
757 setup_handle(SH_TRANS);
758 semanage_bool_key_free(key);
759 CU_ASSERT(semanage_bool_key_create(sh, BOOL1_NAME, &key) >= 0);
760 CU_ASSERT_PTR_NOT_NULL(key);
761
762 CU_ASSERT(semanage_bool_query_local(sh, key, &resp) < 0);
763 CU_ASSERT_PTR_NULL(resp);
764 semanage_bool_free(resp);
765
766 add_local_bool(BOOL1_NAME);
767 CU_ASSERT(semanage_bool_query_local(sh, key, &resp) >= 0);
768 CU_ASSERT_PTR_NOT_NULL(resp);
769 semanage_bool_free(resp);
770
771 semanage_bool_key_free(key);
772 CU_ASSERT(semanage_bool_key_create(sh, BOOL2_NAME, &key) >= 0);
773 CU_ASSERT_PTR_NOT_NULL(key);
774
775 add_local_bool(BOOL2_NAME);
776 CU_ASSERT(semanage_bool_query_local(sh, key, &resp) >= 0);
777 CU_ASSERT_PTR_NOT_NULL(resp);
778 semanage_bool_free(resp);
779
780 /* cleanup */
781 semanage_bool_key_free(key);
782 delete_local_bool(BOOL1_NAME);
783 delete_local_bool(BOOL2_NAME);
784 cleanup_handle(SH_TRANS);
785 }
786
787 /* Function bool_exists_local */
test_bool_exists_local(void)788 static void test_bool_exists_local(void)
789 {
790 int resp = -1;
791 semanage_bool_key_t *key;
792
793 /* setup */
794 setup_handle(SH_TRANS);
795 CU_ASSERT(semanage_bool_key_create(sh, BOOL1_NAME, &key) >= 0);
796 CU_ASSERT_PTR_NOT_NULL(key);
797
798 /* test */
799 CU_ASSERT(semanage_bool_exists_local(sh, key, &resp) >= 0);
800 CU_ASSERT(resp == 0);
801
802 add_local_bool(BOOL1_NAME);
803 resp = -1;
804 CU_ASSERT(semanage_bool_exists_local(sh, key, &resp) >= 0);
805 CU_ASSERT(resp == 1);
806
807 delete_local_bool(BOOL1_NAME);
808 resp = -1;
809 CU_ASSERT(semanage_bool_exists_local(sh, key, &resp) >= 0);
810 CU_ASSERT(resp == 0);
811
812 /* cleanup */
813 semanage_bool_key_free(key);
814 cleanup_handle(SH_TRANS);
815 }
816
817 /* Function bool_count_local */
test_bool_count_local(void)818 static void test_bool_count_local(void)
819 {
820 unsigned int resp;
821 unsigned int init_count;
822
823 /* handle */
824 setup_handle(SH_HANDLE);
825 CU_ASSERT(semanage_bool_count_local(sh, &resp) < 0);
826 cleanup_handle(SH_HANDLE);
827
828 /* connect */
829 setup_handle(SH_CONNECT);
830 CU_ASSERT(semanage_bool_count_local(sh, &resp) >= 0);
831 cleanup_handle(SH_CONNECT);
832
833 /* transaction */
834 setup_handle(SH_TRANS);
835
836 CU_ASSERT(semanage_bool_count_local(sh, &resp) >= 0);
837 init_count = resp;
838
839 add_local_bool(BOOL1_NAME);
840 CU_ASSERT(semanage_bool_count_local(sh, &resp) >= 0);
841 CU_ASSERT(resp == init_count + 1);
842
843 add_local_bool(BOOL2_NAME);
844 CU_ASSERT(semanage_bool_count_local(sh, &resp) >= 0);
845 CU_ASSERT(resp == init_count + 2);
846
847 delete_local_bool(BOOL2_NAME);
848 CU_ASSERT(semanage_bool_count_local(sh, &resp) >= 0);
849 CU_ASSERT(resp == init_count + 1);
850
851 delete_local_bool(BOOL1_NAME);
852 CU_ASSERT(semanage_bool_count_local(sh, &resp) >= 0);
853 CU_ASSERT(resp == init_count);
854
855 /* cleanup */
856 cleanup_handle(SH_TRANS);
857 }
858
859 /* Function bool_iterate_local */
860 unsigned int counter_bool_iterate_local = 0;
861
handler_bool_iterate_local(const semanage_bool_t * record,void * varg)862 static int handler_bool_iterate_local(const semanage_bool_t *record, void *varg)
863 {
864 counter_bool_iterate_local++;
865 return 0;
866 }
867
test_bool_iterate_local(void)868 static void test_bool_iterate_local(void)
869 {
870 unsigned int init_count;
871
872 /* handle */
873 setup_handle(SH_HANDLE);
874 CU_ASSERT(semanage_bool_iterate_local(sh, &handler_bool_iterate_local,
875 NULL) < 0);
876 cleanup_handle(SH_HANDLE);
877
878 /* connect */
879 setup_handle(SH_CONNECT);
880
881 counter_bool_iterate_local = 0;
882 CU_ASSERT(semanage_bool_iterate_local(sh, &handler_bool_iterate_local,
883 NULL) >= 0);
884 init_count = counter_bool_iterate_local;
885
886 cleanup_handle(SH_CONNECT);
887
888 /* transaction */
889 setup_handle(SH_TRANS);
890
891 counter_bool_iterate_local = 0;
892 CU_ASSERT(semanage_bool_iterate_local(sh, &handler_bool_iterate_local,
893 NULL) >= 0);
894 CU_ASSERT(counter_bool_iterate_local == init_count);
895
896 add_local_bool(BOOL1_NAME);
897 counter_bool_iterate_local = 0;
898 CU_ASSERT(semanage_bool_iterate_local(sh, &handler_bool_iterate_local,
899 NULL) >= 0);
900 CU_ASSERT(counter_bool_iterate_local == init_count + 1);
901
902 add_local_bool(BOOL2_NAME);
903 counter_bool_iterate_local = 0;
904 CU_ASSERT(semanage_bool_iterate_local(sh, &handler_bool_iterate_local,
905 NULL) >= 0);
906 CU_ASSERT(counter_bool_iterate_local == init_count + 2);
907
908 /* cleanup */
909 delete_local_bool(BOOL1_NAME);
910 delete_local_bool(BOOL2_NAME);
911 cleanup_handle(SH_TRANS);
912 }
913
914 /* Function bool_list_local */
test_bool_list_local(void)915 static void test_bool_list_local(void)
916 {
917 semanage_bool_t **records;
918 unsigned int count;
919 unsigned int init_count;
920
921 /* handle */
922 setup_handle(SH_HANDLE);
923
924 CU_ASSERT(semanage_bool_list_local(sh, &records, &count) < 0);
925 CU_ASSERT(semanage_bool_list_local(sh, NULL, &count) < 0);
926 CU_ASSERT(semanage_bool_list_local(sh, &records, NULL) < 0);
927
928 cleanup_handle(SH_HANDLE);
929
930 /* connect */
931 setup_handle(SH_CONNECT);
932
933 CU_ASSERT(semanage_bool_list_local(sh, &records, &count) >= 0);
934 init_count = count;
935
936 cleanup_handle(SH_CONNECT);
937
938 /* transaction */
939 setup_handle(SH_TRANS);
940
941 CU_ASSERT(semanage_bool_list_local(sh, &records, &count) >= 0);
942 CU_ASSERT(count == init_count);
943
944 add_local_bool(BOOL1_NAME);
945 CU_ASSERT(semanage_bool_list_local(sh, &records, &count) >= 0);
946 CU_ASSERT(count == init_count + 1);
947 CU_ASSERT_PTR_NOT_NULL(records[0]);
948 semanage_bool_free(records[0]);
949 free(records);
950
951 add_local_bool(BOOL2_NAME);
952 CU_ASSERT(semanage_bool_list_local(sh, &records, &count) >= 0);
953 CU_ASSERT(count == init_count + 2);
954 CU_ASSERT_PTR_NOT_NULL(records[0]);
955 CU_ASSERT_PTR_NOT_NULL(records[1]);
956 semanage_bool_free(records[0]);
957 semanage_bool_free(records[1]);
958 free(records);
959
960 /* cleanup */
961 delete_local_bool(BOOL1_NAME);
962 delete_local_bool(BOOL2_NAME);
963 cleanup_handle(SH_TRANS);
964 }
965