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