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_node.h"
23
24 #define NODE_COUNT 3
25
26 #define NODE1_ADDR "192.168.0.0"
27 #define NODE1_MASK "255.255.255.0"
28 #define NODE1_PROTO SEPOL_PROTO_IP4
29 #define NODE1_CONTEXT "system_u:object_r:first_node_t:s0"
30
31 #define NODE2_ADDR "2001:db8:85a3::8a2e:370:7334"
32 #define NODE2_MASK "2001:db8:85a3::8a2e:370:7334"
33 #define NODE2_PROTO SEPOL_PROTO_IP6
34 #define NODE2_CONTEXT "system_u:object_r:second_node_t:s0"
35
36 #define NODE3_ADDR "127.0.0.1"
37 #define NODE3_MASK "255.255.0.0"
38 #define NODE3_PROTO SEPOL_PROTO_IP4
39 #define NODE3_CONTEXT "system_u:object_r:third_node_t:s0"
40
41 /* node_record.h */
42 static void test_node_compare(void);
43 static void test_node_compare2(void);
44 static void test_node_key_create(void);
45 static void test_node_key_extract(void);
46 static void test_node_get_set_addr(void);
47 static void test_node_get_set_addr_bytes(void);
48 static void test_node_get_set_mask(void);
49 static void test_node_get_set_mask_bytes(void);
50 static void test_node_get_set_proto(void);
51 static void test_node_get_proto_str(void);
52 static void test_node_get_set_con(void);
53 static void test_node_create(void);
54 static void test_node_clone(void);
55
56 /* nodes_policy.h */
57 static void test_node_query(void);
58 static void test_node_exists(void);
59 static void test_node_count(void);
60 static void test_node_iterate(void);
61 static void test_node_list(void);
62
63 /* nodes_local.h */
64 static void test_node_modify_del_query_local(void);
65 static void test_node_exists_local(void);
66 static void test_node_count_local(void);
67 static void test_node_iterate_local(void);
68 static void test_node_list_local(void);
69
70 extern semanage_handle_t *sh;
71
node_test_init(void)72 int node_test_init(void)
73 {
74 if (create_test_store() < 0) {
75 fprintf(stderr, "Could not create test store\n");
76 return 1;
77 }
78
79 if (write_test_policy_from_file("test_node.policy") < 0) {
80 fprintf(stderr, "Could not write test policy\n");
81 return 1;
82 }
83
84 return 0;
85 }
86
node_test_cleanup(void)87 int node_test_cleanup(void)
88 {
89 if (destroy_test_store() < 0) {
90 fprintf(stderr, "Could destroy test store\n");
91 return 1;
92 }
93
94 return 0;
95 }
96
node_add_tests(CU_pSuite suite)97 int node_add_tests(CU_pSuite suite)
98 {
99 CU_add_test(suite, "node_compare", test_node_compare);
100 CU_add_test(suite, "node_compare2", test_node_compare2);
101 CU_add_test(suite, "node_key_create", test_node_key_create);
102 CU_add_test(suite, "node_key_extract", test_node_key_extract);
103 CU_add_test(suite, "node_get_set_addr", test_node_get_set_addr);
104 CU_add_test(suite, "node_get_set_addr_bytes",
105 test_node_get_set_addr_bytes);
106 CU_add_test(suite, "node_get_set_mask", test_node_get_set_mask);
107 CU_add_test(suite, "node_get_set_mask_bytes",
108 test_node_get_set_mask_bytes);
109 CU_add_test(suite, "node_get_set_proto", test_node_get_set_proto);
110 CU_add_test(suite, "node_get_proto_str", test_node_get_proto_str);
111 CU_add_test(suite, "node_get_set_con", test_node_get_set_con);
112 CU_add_test(suite, "node_create", test_node_create);
113 CU_add_test(suite, "node_clone", test_node_clone);
114
115 CU_add_test(suite, "node_query", test_node_query);
116 CU_add_test(suite, "node_exists", test_node_exists);
117 CU_add_test(suite, "node_count", test_node_count);
118 CU_add_test(suite, "node_iterate", test_node_iterate);
119 CU_add_test(suite, "node_list", test_node_list);
120
121 CU_add_test(suite, "node_modify_del_query_local",
122 test_node_modify_del_query_local);
123 CU_add_test(suite, "node_exists_local", test_node_exists_local);
124 CU_add_test(suite, "node_count_local", test_node_count_local);
125 CU_add_test(suite, "node_iterate_local", test_node_iterate_local);
126 CU_add_test(suite, "node_list_local", test_node_list_local);
127
128 return 0;
129 }
130
131 /* Helpers */
132
get_node_nth(int idx)133 static semanage_node_t *get_node_nth(int idx)
134 {
135 semanage_node_t **records;
136 semanage_node_t *node;
137 unsigned int count;
138
139 if (idx == I_NULL)
140 return NULL;
141
142 CU_ASSERT_FATAL(semanage_node_list(sh, &records, &count) >= 0);
143 CU_ASSERT_FATAL(count >= (unsigned int) idx + 1);
144
145 node = records[idx];
146
147 for (unsigned int i = 0; i < count; i++)
148 if (i != (unsigned int) idx)
149 semanage_node_free(records[i]);
150
151 free(records);
152
153 return node;
154 }
155
get_node_key_nth(int idx)156 static semanage_node_key_t *get_node_key_nth(int idx)
157 {
158 semanage_node_key_t *key;
159 semanage_node_t *node;
160 int res;
161
162 if (idx == I_NULL)
163 return NULL;
164
165 node = get_node_nth(idx);
166
167 res = semanage_node_key_extract(sh, node, &key);
168
169 CU_ASSERT_FATAL(res >= 0);
170 CU_ASSERT_PTR_NOT_NULL_FATAL(key);
171
172 semanage_node_free(node);
173
174 return key;
175 }
176
add_local_node(int idx)177 static void add_local_node(int idx)
178 {
179 semanage_node_t *node;
180 semanage_node_key_t *key = NULL;
181
182 node = get_node_nth(idx);
183
184 CU_ASSERT_FATAL(semanage_node_key_extract(sh, node, &key) >= 0);
185 CU_ASSERT_PTR_NOT_NULL_FATAL(key);
186
187 CU_ASSERT_FATAL(semanage_node_modify_local(sh, key, node) >= 0);
188
189 /* cleanup */
190 semanage_node_key_free(key);
191 semanage_node_free(node);
192 }
193
delete_local_node(int idx)194 static void delete_local_node(int idx)
195 {
196 semanage_node_key_t *key = NULL;
197
198 key = get_node_key_nth(idx);
199
200 CU_ASSERT_FATAL(semanage_node_del_local(sh, key) >= 0);
201
202 /* cleanup */
203 semanage_node_key_free(key);
204 }
205
206 /* Function semanage_node_compare */
test_node_compare(void)207 static void test_node_compare(void)
208 {
209 semanage_node_t *node = NULL;
210 semanage_node_key_t *key1 = NULL;
211 semanage_node_key_t *key2 = NULL;
212 int res = 42;
213
214 /* setup */
215 setup_handle(SH_CONNECT);
216 node = get_node_nth(I_FIRST);
217 key1 = get_node_key_nth(I_FIRST);
218 CU_ASSERT(semanage_node_key_create(sh, "192.168.0.1", "255.255.0.0",
219 SEMANAGE_PROTO_IP4, &key2) >= 0);
220 CU_ASSERT_PTR_NOT_NULL(key2);
221
222 /* test */
223 res = semanage_node_compare(node, key1);
224 CU_ASSERT(res == 0);
225 res = semanage_node_compare(node, key2);
226 CU_ASSERT(res != 0);
227
228 /* cleanup */
229 semanage_node_free(node);
230 semanage_node_key_free(key1);
231 semanage_node_key_free(key2);
232 cleanup_handle(SH_CONNECT);
233 }
234
235 /* Function semanage_node_compare2 */
test_node_compare2(void)236 static void test_node_compare2(void)
237 {
238 semanage_node_t *node1 = NULL;
239 semanage_node_t *node2 = NULL;
240 semanage_node_t *node3 = NULL;
241 int res = 42;
242
243 /* setup */
244 setup_handle(SH_CONNECT);
245 node1 = get_node_nth(I_FIRST);
246 node2 = get_node_nth(I_FIRST);
247 node3 = get_node_nth(I_SECOND);
248
249 /* test */
250 res = semanage_node_compare2(node1, node2);
251 CU_ASSERT(res == 0);
252 res = semanage_node_compare2(node1, node3);
253 CU_ASSERT(res != 0);
254
255 /* cleanup */
256 semanage_node_free(node1);
257 semanage_node_free(node2);
258 semanage_node_free(node3);
259 cleanup_handle(SH_CONNECT);
260 }
261
262 /* Function semanage_node_key_create */
test_node_key_create(void)263 static void test_node_key_create(void)
264 {
265 semanage_node_key_t *key = NULL;
266
267 /* setup */
268 setup_handle(SH_CONNECT);
269
270 /* test */
271 CU_ASSERT(semanage_node_key_create(sh, "127.0.0.1", "255.255.255.255",
272 SEMANAGE_PROTO_IP4, &key) >= 0);
273 CU_ASSERT_PTR_NOT_NULL(key);
274
275 /* cleanup */
276 semanage_node_key_free(key);
277 cleanup_handle(SH_CONNECT);
278 }
279
280 /* Function semanage_node_key_extract */
test_node_key_extract(void)281 static void test_node_key_extract(void)
282 {
283 semanage_node_t *node = NULL;
284 semanage_node_key_t *key = NULL;
285
286 /* setup */
287 setup_handle(SH_CONNECT);
288 node = get_node_nth(I_FIRST);
289
290 /* test */
291 CU_ASSERT(semanage_node_key_extract(sh, node, &key) >= 0);
292 CU_ASSERT_PTR_NOT_NULL(key);
293
294 /* cleanup */
295 semanage_node_free(node);
296 semanage_node_key_free(key);
297 cleanup_handle(SH_CONNECT);
298 }
299
300 /* Function semanage_node_get_addr, semanage_node_set_addr */
test_node_get_set_addr(void)301 static void test_node_get_set_addr(void)
302 {
303 semanage_node_t *node = NULL;
304 char *addr = NULL;
305
306 /* setup */
307 setup_handle(SH_CONNECT);
308 CU_ASSERT(semanage_node_create(sh, &node) >= 0);
309
310 /* test */
311 CU_ASSERT(semanage_node_set_addr(sh, node, SEMANAGE_PROTO_IP4,
312 "192.168.0.1") == 0);
313 CU_ASSERT(semanage_node_get_addr(sh, node, &addr) >= 0);
314 CU_ASSERT_PTR_NOT_NULL(addr);
315 assert(addr);
316 CU_ASSERT_STRING_EQUAL(addr, "192.168.0.1");
317
318 /* cleanup */
319 free(addr);
320 semanage_node_free(node);
321 cleanup_handle(SH_CONNECT);
322 }
323
324 /* Function semanage_node_get_addr_bytes, semanage_node_set_addr_bytes */
test_node_get_set_addr_bytes(void)325 static void test_node_get_set_addr_bytes(void)
326 {
327 semanage_node_t *node = NULL;
328 char addr1[] = { 192, 168, 0, 1 };
329 size_t addr1_size = sizeof(addr1);
330 char *addr2 = NULL;
331 size_t addr2_size = 0;
332
333 /* setup */
334 setup_handle(SH_CONNECT);
335 CU_ASSERT(semanage_node_create(sh, &node) >= 0);
336
337 /* test */
338 CU_ASSERT(semanage_node_set_addr_bytes(sh, node, addr1,
339 addr1_size) == 0);
340 CU_ASSERT(semanage_node_get_addr_bytes(sh, node, &addr2,
341 &addr2_size) >= 0);
342 CU_ASSERT_PTR_NOT_NULL(addr2);
343 assert(addr2);
344
345 for (size_t i = 0; i < addr2_size; i++)
346 CU_ASSERT(addr1[i] == addr2[i]);
347
348 /* cleanup */
349 free(addr2);
350 semanage_node_free(node);
351 cleanup_handle(SH_CONNECT);
352 }
353
354 /* Function semanage_node_get_mask, semanage_node_set_mask */
test_node_get_set_mask(void)355 static void test_node_get_set_mask(void)
356 {
357 semanage_node_t *node = NULL;
358 char *mask = NULL;
359
360 /* setup */
361 setup_handle(SH_CONNECT);
362 CU_ASSERT(semanage_node_create(sh, &node) >= 0);
363
364 /* test */
365 CU_ASSERT(semanage_node_set_mask(sh, node, SEMANAGE_PROTO_IP4,
366 "255.255.255.0") == 0);
367 CU_ASSERT(semanage_node_get_mask(sh, node, &mask) >= 0);
368 CU_ASSERT_PTR_NOT_NULL(mask);
369 assert(mask);
370 CU_ASSERT_STRING_EQUAL(mask, "255.255.255.0");
371
372 /* cleanup */
373 free(mask);
374 semanage_node_free(node);
375 cleanup_handle(SH_CONNECT);
376 }
377
378 /* Function semanage_node_get_mask_bytes, semanage_node_set_mask_bytes */
test_node_get_set_mask_bytes(void)379 static void test_node_get_set_mask_bytes(void)
380 {
381 semanage_node_t *node = NULL;
382 char mask1[] = { 255, 255, 255, 0 };
383 size_t mask1_size = sizeof(mask1);
384 char *mask2 = NULL;
385 size_t mask2_size = 0;
386
387 /* setup */
388 setup_handle(SH_CONNECT);
389 CU_ASSERT(semanage_node_create(sh, &node) >= 0);
390
391 /* test */
392 CU_ASSERT(semanage_node_set_mask_bytes(sh, node, mask1,
393 mask1_size) == 0);
394 CU_ASSERT(semanage_node_get_mask_bytes(sh, node, &mask2,
395 &mask2_size) >= 0);
396 CU_ASSERT_PTR_NOT_NULL(mask2);
397 assert(mask2);
398
399 for (size_t i = 0; i < mask2_size; i++)
400 CU_ASSERT(mask1[i] == mask2[i]);
401
402 /* cleanup */
403 free(mask2);
404 semanage_node_free(node);
405 cleanup_handle(SH_CONNECT);
406 }
407
408 /* Function semanage_node_get_proto, semanage_node_set_proto */
test_node_get_set_proto(void)409 static void test_node_get_set_proto(void)
410 {
411 semanage_node_t *node = NULL;
412
413 /* setup */
414 setup_handle(SH_CONNECT);
415 CU_ASSERT(semanage_node_create(sh, &node) >= 0);
416
417 /* test */
418 semanage_node_set_proto(node, SEMANAGE_PROTO_IP4);
419 CU_ASSERT(semanage_node_get_proto(node) == SEMANAGE_PROTO_IP4);
420
421 /* cleanup */
422 semanage_node_free(node);
423 cleanup_handle(SH_CONNECT);
424 }
425
426 /* Function semanage_node_get_proto_str */
test_node_get_proto_str(void)427 static void test_node_get_proto_str(void)
428 {
429 CU_ASSERT_STRING_EQUAL(semanage_node_get_proto_str(SEMANAGE_PROTO_IP4),
430 "ipv4");
431 CU_ASSERT_STRING_EQUAL(semanage_node_get_proto_str(SEMANAGE_PROTO_IP6),
432 "ipv6");
433 }
434
435 /* Function semanage_node_get_con, semanage_node_set_con */
test_node_get_set_con(void)436 static void test_node_get_set_con(void)
437 {
438 semanage_node_t *node = NULL;
439 semanage_context_t *con1 = NULL;
440 semanage_context_t *con2 = NULL;
441
442 /* setup */
443 setup_handle(SH_CONNECT);
444 CU_ASSERT(semanage_node_create(sh, &node) >= 0);
445 CU_ASSERT(semanage_context_from_string(sh,
446 "my_user_u:my_role_r:my_type_t:s0", &con1) >= 0);
447
448 /* test */
449 CU_ASSERT(semanage_node_set_con(sh, node, con1) == 0);
450 con2 = semanage_node_get_con(node);
451 CU_ASSERT_CONTEXT_EQUAL(con1, con2);
452
453 /* cleanup */
454 semanage_context_free(con1);
455 semanage_node_free(node);
456 cleanup_handle(SH_CONNECT);
457 }
458
459 /* Function semanage_node_create */
test_node_create(void)460 static void test_node_create(void)
461 {
462 semanage_node_t *node = NULL;
463 semanage_context_t *con = NULL;
464
465 /* setup */
466 setup_handle(SH_CONNECT);
467
468 /* test */
469 CU_ASSERT(semanage_node_create(sh, &node) >= 0);
470 CU_ASSERT(semanage_node_set_addr(sh, node, SEMANAGE_PROTO_IP4,
471 "127.0.0.1") >= 0);
472 CU_ASSERT(semanage_node_set_mask(sh, node, SEMANAGE_PROTO_IP4,
473 "255.255.255.0") >= 0);
474 semanage_node_set_proto(node, SEMANAGE_PROTO_IP4);
475 CU_ASSERT(semanage_context_from_string(sh, "user_u:role_r:type_t:s0",
476 &con) >= 0);
477 CU_ASSERT(semanage_node_set_con(sh, node, con) >= 0);
478
479 /* cleanup */
480 semanage_context_free(con);
481 semanage_node_free(node);
482 cleanup_handle(SH_CONNECT);
483 }
484
485 /* Function semanage_node_clone */
test_node_clone(void)486 static void test_node_clone(void)
487 {
488 semanage_node_t *node = NULL;
489 semanage_node_t *node_clone = NULL;
490 semanage_context_t *con = NULL;
491 semanage_context_t *con2 = NULL;
492 const char *addr1 = "127.0.0.1";
493 char *addr2 = NULL;
494 const char *mask1 = "255.255.255.0";
495 char *mask2 = NULL;
496
497 /* setup */
498 setup_handle(SH_CONNECT);
499 CU_ASSERT(semanage_node_create(sh, &node) >= 0);
500 CU_ASSERT(semanage_node_set_addr(sh, node, SEMANAGE_PROTO_IP4,
501 addr1) >= 0);
502 CU_ASSERT(semanage_node_set_mask(sh, node, SEMANAGE_PROTO_IP4,
503 mask1) >= 0);
504 semanage_node_set_proto(node, SEMANAGE_PROTO_IP4);
505 CU_ASSERT(semanage_context_from_string(sh, "user_u:role_r:type_t:s0",
506 &con) >= 0);
507 CU_ASSERT(semanage_node_set_con(sh, node, con) >= 0);
508
509 /* test */
510 CU_ASSERT(semanage_node_clone(sh, node, &node_clone) >= 0);
511
512 CU_ASSERT(semanage_node_get_addr(sh, node_clone, &addr2) >= 0);
513 CU_ASSERT_PTR_NOT_NULL(addr2);
514 assert(addr2);
515 CU_ASSERT_STRING_EQUAL(addr1, addr2);
516
517 CU_ASSERT(semanage_node_get_mask(sh, node_clone, &mask2) >= 0);
518 CU_ASSERT_PTR_NOT_NULL(mask2);
519 assert(mask2);
520 CU_ASSERT_STRING_EQUAL(mask1, mask2);
521
522 CU_ASSERT(semanage_node_get_proto(node_clone) == SEMANAGE_PROTO_IP4);
523
524 con2 = semanage_node_get_con(node_clone);
525 CU_ASSERT_CONTEXT_EQUAL(con, con2);
526
527 /* cleanup */
528 free(mask2);
529 free(addr2);
530 semanage_context_free(con);
531 semanage_node_free(node);
532 semanage_node_free(node_clone);
533 cleanup_handle(SH_CONNECT);
534 }
535
536 /* Function semanage_node_query */
test_node_query(void)537 static void test_node_query(void)
538 {
539 semanage_node_t *node = NULL;
540 semanage_node_t *node_exp = NULL;
541 semanage_node_key_t *key = NULL;
542 char *str = NULL;
543 char *str_exp = NULL;
544 semanage_context_t *con = NULL;
545 semanage_context_t *con_exp = NULL;
546
547 /* setup */
548 setup_handle(SH_CONNECT);
549 key = get_node_key_nth(I_FIRST);
550 node_exp = get_node_nth(I_FIRST);
551
552 /* test */
553 CU_ASSERT(semanage_node_query(sh, key, &node) >= 0);
554
555 CU_ASSERT(semanage_node_get_addr(sh, node, &str) >= 0);
556 CU_ASSERT(semanage_node_get_addr(sh, node_exp, &str_exp) >= 0);
557 CU_ASSERT_STRING_EQUAL(str, str_exp);
558 free(str);
559 free(str_exp);
560
561 CU_ASSERT(semanage_node_get_mask(sh, node, &str) >= 0);
562 CU_ASSERT(semanage_node_get_mask(sh, node_exp, &str_exp) >= 0);
563 CU_ASSERT_STRING_EQUAL(str, str_exp);
564 free(str);
565 free(str_exp);
566
567 CU_ASSERT(semanage_node_get_proto(node) ==
568 semanage_node_get_proto(node_exp));
569
570 con = semanage_node_get_con(node);
571 con_exp = semanage_node_get_con(node_exp);
572 CU_ASSERT_CONTEXT_EQUAL(con, con_exp);
573
574 /* cleanup */
575 semanage_node_key_free(key);
576 semanage_node_free(node_exp);
577 semanage_node_free(node);
578 cleanup_handle(SH_CONNECT);
579 }
580
581 /* Function semanage_node_exists */
test_node_exists(void)582 static void test_node_exists(void)
583 {
584 semanage_node_key_t *key1 = NULL;
585 semanage_node_key_t *key2 = NULL;
586 int resp = 42;
587
588 /* setup */
589 setup_handle(SH_CONNECT);
590 key1 = get_node_key_nth(I_FIRST);
591 CU_ASSERT(semanage_node_key_create(sh, "1.2.3.4", "255.255.0.0",
592 SEMANAGE_PROTO_IP4, &key2) >= 0);
593
594 /* test */
595 CU_ASSERT(semanage_node_exists(sh, key1, &resp) >= 0);
596 CU_ASSERT(resp);
597 CU_ASSERT(semanage_node_exists(sh, key2, &resp) >= 0);
598 CU_ASSERT(!resp);
599
600 /* cleanup */
601 semanage_node_key_free(key1);
602 semanage_node_key_free(key2);
603 cleanup_handle(SH_CONNECT);
604 }
605
606 /* Function semanage_node_count */
test_node_count(void)607 static void test_node_count(void)
608 {
609 unsigned int count = 42;
610
611 /* setup */
612 setup_handle(SH_CONNECT);
613
614 /* test */
615 CU_ASSERT(semanage_node_count(sh, &count) >= 0);
616 CU_ASSERT(count == NODE_COUNT);
617
618 /* cleanup */
619 cleanup_handle(SH_CONNECT);
620 }
621
622 /* Function semanage_node_iterate */
623 unsigned int counter_node_iterate = 0;
624
handler_node_iterate(const semanage_node_t * record,void * varg)625 static int handler_node_iterate(const semanage_node_t *record, void *varg)
626 {
627 counter_node_iterate++;
628 return 0;
629 }
630
test_node_iterate(void)631 static void test_node_iterate(void)
632 {
633 /* setup */
634 setup_handle(SH_CONNECT);
635
636 /* test */
637 semanage_node_iterate(sh, handler_node_iterate, NULL);
638 CU_ASSERT(counter_node_iterate == NODE_COUNT);
639
640 /* cleanup */
641 cleanup_handle(SH_CONNECT);
642 }
643
644 /* Function semanage_node_list */
test_node_list(void)645 static void test_node_list(void)
646 {
647 semanage_node_t **records = NULL;
648 unsigned int count = 42;
649
650 /* setup */
651 setup_handle(SH_CONNECT);
652
653 /* test */
654 CU_ASSERT(semanage_node_list(sh, &records, &count) >= 0);
655 CU_ASSERT(count == NODE_COUNT);
656
657 for (unsigned int i = 0; i < count; i++)
658 CU_ASSERT_PTR_NOT_NULL(records[i]);
659
660 for (unsigned int i = 0; i < count; i++)
661 semanage_node_free(records[i]);
662
663 free(records);
664
665 /* cleanup */
666 cleanup_handle(SH_CONNECT);
667 }
668
669 /* Function semanage_node_modify_local, semanage_node_del_local,
670 * semanage_node_query_local
671 */
test_node_modify_del_query_local(void)672 static void test_node_modify_del_query_local(void)
673 {
674 semanage_node_t *node;
675 semanage_node_t *node_local;
676 semanage_node_t *node_tmp;
677 semanage_node_key_t *key = NULL;
678 semanage_node_key_t *key_tmp = NULL;
679
680 /* setup */
681 setup_handle(SH_TRANS);
682 node = get_node_nth(I_FIRST);
683 CU_ASSERT(semanage_node_key_extract(sh, node, &key) >= 0);
684 CU_ASSERT_PTR_NOT_NULL(key);
685
686 /* add second record, so that semanage_node_compare2_qsort
687 * will be called
688 */
689 node_tmp = get_node_nth(I_FIRST);
690
691 CU_ASSERT(semanage_node_set_addr(sh, node_tmp, SEMANAGE_PROTO_IP4,
692 "10.0.0.1") >= 0);
693 CU_ASSERT(semanage_node_key_extract(sh, node_tmp, &key_tmp) >= 0);
694 CU_ASSERT_PTR_NOT_NULL(key_tmp);
695
696 /* test */
697 CU_ASSERT(semanage_node_modify_local(sh, key, node) >= 0);
698 CU_ASSERT(semanage_node_modify_local(sh, key_tmp, node_tmp) >= 0);
699
700 /* write changes to file */
701 helper_commit();
702 helper_begin_transaction();
703
704 CU_ASSERT(semanage_node_query_local(sh, key, &node_local) >= 0);
705 CU_ASSERT_PTR_NOT_NULL_FATAL(node_local);
706 semanage_node_free(node_local);
707
708 CU_ASSERT(semanage_node_del_local(sh, key) >= 0);
709 CU_ASSERT(semanage_node_del_local(sh, key_tmp) >= 0);
710
711 CU_ASSERT(semanage_node_query_local(sh, key, &node_local) < 0);
712
713 /* cleanup */
714 semanage_node_key_free(key_tmp);
715 semanage_node_key_free(key);
716 semanage_node_free(node);
717 semanage_node_free(node_tmp);
718 cleanup_handle(SH_TRANS);
719 }
720
721 /* Function semanage_node_exists_local */
test_node_exists_local(void)722 static void test_node_exists_local(void)
723 {
724 semanage_node_key_t *key1 = NULL;
725 semanage_node_key_t *key2 = NULL;
726 int resp = 42;
727
728 /* setup */
729 setup_handle(SH_TRANS);
730 add_local_node(I_FIRST);
731 key1 = get_node_key_nth(I_FIRST);
732 key2 = get_node_key_nth(I_SECOND);
733
734 /* test */
735 CU_ASSERT(semanage_node_exists_local(sh, key1, &resp) >= 0);
736 CU_ASSERT(resp);
737 CU_ASSERT(semanage_node_exists_local(sh, key2, &resp) >= 0);
738 CU_ASSERT(!resp);
739
740 /* cleanup */
741 CU_ASSERT(semanage_node_del_local(sh, key1) >= 0);
742 semanage_node_key_free(key1);
743 semanage_node_key_free(key2);
744 cleanup_handle(SH_TRANS);
745 }
746
747 /* Function semanage_node_count_local */
test_node_count_local(void)748 static void test_node_count_local(void)
749 {
750 unsigned int count = 42;
751
752 /* setup */
753 setup_handle(SH_TRANS);
754
755 /* test */
756 CU_ASSERT(semanage_node_count_local(sh, &count) >= 0);
757 CU_ASSERT(count == 0);
758
759 add_local_node(I_FIRST);
760 CU_ASSERT(semanage_node_count_local(sh, &count) >= 0);
761 CU_ASSERT(count == 1);
762
763 add_local_node(I_SECOND);
764 CU_ASSERT(semanage_node_count_local(sh, &count) >= 0);
765 CU_ASSERT(count == 2);
766
767 delete_local_node(I_SECOND);
768 CU_ASSERT(semanage_node_count_local(sh, &count) >= 0);
769 CU_ASSERT(count == 1);
770
771 delete_local_node(I_FIRST);
772 CU_ASSERT(semanage_node_count_local(sh, &count) >= 0);
773 CU_ASSERT(count == 0);
774
775 /* cleanup */
776 cleanup_handle(SH_TRANS);
777 }
778
779 /* Function semanage_node_iterate_local */
780 unsigned int counter_node_iterate_local = 0;
781
handler_node_iterate_local(const semanage_node_t * record,void * varg)782 static int handler_node_iterate_local(const semanage_node_t *record, void *varg)
783 {
784 counter_node_iterate_local++;
785 return 0;
786 }
787
test_node_iterate_local(void)788 static void test_node_iterate_local(void)
789 {
790 /* setup */
791 setup_handle(SH_TRANS);
792 add_local_node(I_FIRST);
793 add_local_node(I_SECOND);
794 add_local_node(I_THIRD);
795
796 /* test */
797 semanage_node_iterate_local(sh, handler_node_iterate_local, NULL);
798 CU_ASSERT(counter_node_iterate_local == 3);
799
800 /* cleanup */
801 delete_local_node(I_FIRST);
802 delete_local_node(I_SECOND);
803 delete_local_node(I_THIRD);
804 cleanup_handle(SH_TRANS);
805 }
806
807 /* Function semanage_node_list_local */
test_node_list_local(void)808 static void test_node_list_local(void)
809 {
810 semanage_node_t **records = NULL;
811 unsigned int count = 42;
812
813 /* setup */
814 setup_handle(SH_TRANS);
815 add_local_node(I_FIRST);
816 add_local_node(I_SECOND);
817 add_local_node(I_THIRD);
818
819 /* test */
820 CU_ASSERT(semanage_node_list_local(sh, &records, &count) >= 0);
821 CU_ASSERT(count == 3);
822
823 for (unsigned int i = 0; i < count; i++)
824 CU_ASSERT_PTR_NOT_NULL(records[i]);
825
826 /* cleanup */
827 for (unsigned int i = 0; i < count; i++)
828 semanage_node_free(records[i]);
829
830 free(records);
831
832 delete_local_node(I_FIRST);
833 delete_local_node(I_SECOND);
834 delete_local_node(I_THIRD);
835 cleanup_handle(SH_TRANS);
836 }
837