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_iface.h"
23
24 #define IFACE_COUNT 3
25
26 #define IFACE1_NAME "eth0"
27 #define IFACE1_IFCON "system_u:object_r:first_netif_t:s0"
28 #define IFACE1_MSGCON IFACE1_IFCON
29
30 #define IFACE2_NAME "eth1"
31 #define IFACE2_IFCON "system_u:object_r:second_netif_t:s0"
32 #define IFACE2_MSGCON IFACE2_IFCON
33
34 #define IFACE3_NAME "eth2"
35 #define IFACE3_IFCON "system_u:object_r:third_netif_t:s0"
36 #define IFACE3_MSGCON IFACE3_IFCON
37
38
39 /* iface_record.h */
40 static void test_iface_compare(void);
41 static void test_iface_compare2(void);
42 static void test_iface_key_create(void);
43 static void test_iface_key_extract(void);
44 static void test_iface_get_set_name(void);
45 static void test_iface_get_set_ifcon(void);
46 static void test_iface_get_set_msgcon(void);
47 static void test_iface_create(void);
48 static void test_iface_clone(void);
49
50 /* interfaces_policy.h */
51 static void test_iface_query(void);
52 static void test_iface_exists(void);
53 static void test_iface_count(void);
54 static void test_iface_iterate(void);
55 static void test_iface_list(void);
56
57 /* interfaces_local.h */
58 static void test_iface_modify_del_query_local(void);
59 static void test_iface_exists_local(void);
60 static void test_iface_count_local(void);
61 static void test_iface_iterate_local(void);
62 static void test_iface_list_local(void);
63
64 extern semanage_handle_t *sh;
65
iface_test_init(void)66 int iface_test_init(void)
67 {
68 if (create_test_store() < 0) {
69 fprintf(stderr, "Could not create test store\n");
70 return 1;
71 }
72
73 if (write_test_policy_from_file("test_iface.policy") < 0) {
74 fprintf(stderr, "Could not write test policy\n");
75 return 1;
76 }
77
78 return 0;
79 }
80
iface_test_cleanup(void)81 int iface_test_cleanup(void)
82 {
83 if (destroy_test_store() < 0) {
84 fprintf(stderr, "Could not destroy test store\n");
85 return 1;
86 }
87
88 return 0;
89 }
90
iface_add_tests(CU_pSuite suite)91 int iface_add_tests(CU_pSuite suite)
92 {
93 CU_add_test(suite, "iface_compare", test_iface_compare);
94 CU_add_test(suite, "iface_compare2", test_iface_compare2);
95 CU_add_test(suite, "iface_key_create", test_iface_key_create);
96 CU_add_test(suite, "iface_key_extract", test_iface_key_extract);
97 CU_add_test(suite, "iface_get_set_name", test_iface_get_set_name);
98 CU_add_test(suite, "iface_get_set_ifcon", test_iface_get_set_ifcon);
99 CU_add_test(suite, "iface_get_set_msgcon", test_iface_get_set_msgcon);
100 CU_add_test(suite, "iface_create)", test_iface_create);
101 CU_add_test(suite, "iface_clone);", test_iface_clone);
102
103 CU_add_test(suite, "iface_query", test_iface_query);
104 CU_add_test(suite, "iface_exists", test_iface_exists);
105 CU_add_test(suite, "iface_count", test_iface_count);
106 CU_add_test(suite, "iface_iterate", test_iface_iterate);
107 CU_add_test(suite, "iface_list", test_iface_list);
108
109 CU_add_test(suite, "iface_modify_del_query_local",
110 test_iface_modify_del_query_local);
111 CU_add_test(suite, "iface_exists_local", test_iface_exists_local);
112 CU_add_test(suite, "iface_count_local", test_iface_count_local);
113 CU_add_test(suite, "iface_iterate_local", test_iface_iterate_local);
114 CU_add_test(suite, "iface_list_local", test_iface_list_local);
115
116 return 0;
117 }
118
119 /* Helpers */
120
get_iface_nth(int idx)121 static semanage_iface_t *get_iface_nth(int idx)
122 {
123 int res;
124 semanage_iface_t **records;
125 semanage_iface_t *iface;
126 unsigned int count;
127
128 if (idx == I_NULL)
129 return NULL;
130
131 res = semanage_iface_list(sh, &records, &count);
132
133 CU_ASSERT_FATAL(res >= 0);
134 CU_ASSERT_FATAL(count >= (unsigned int) idx + 1);
135
136 iface = records[idx];
137
138 for (unsigned int i = 0; i < count; i++)
139 if (i != (unsigned int) idx)
140 semanage_iface_free(records[i]);
141
142 free(records);
143
144 return iface;
145 }
146
get_iface_key_nth(int idx)147 static semanage_iface_key_t *get_iface_key_nth(int idx)
148 {
149 semanage_iface_key_t *key;
150 semanage_iface_t *iface;
151 int res;
152
153 if (idx == I_NULL)
154 return NULL;
155
156 iface = get_iface_nth(idx);
157 res = semanage_iface_key_extract(sh, iface, &key);
158
159 CU_ASSERT_FATAL(res >= 0);
160 CU_ASSERT_PTR_NOT_NULL_FATAL(key);
161
162 /* cleanup */
163 semanage_iface_free(iface);
164
165 return key;
166 }
167
add_local_iface(int idx)168 static void add_local_iface(int idx)
169 {
170 semanage_iface_t *iface;
171 semanage_iface_key_t *key = NULL;
172
173 iface = get_iface_nth(idx);
174
175 CU_ASSERT_FATAL(semanage_iface_key_extract(sh, iface, &key) >= 0);
176 CU_ASSERT_PTR_NOT_NULL_FATAL(key);
177
178 CU_ASSERT_FATAL(semanage_iface_modify_local(sh, key, iface) >= 0);
179
180 /* cleanup */
181 semanage_iface_key_free(key);
182 semanage_iface_free(iface);
183 }
184
delete_local_iface(int idx)185 static void delete_local_iface(int idx)
186 {
187 semanage_iface_key_t *key = NULL;
188 key = get_iface_key_nth(idx);
189 CU_ASSERT_FATAL(semanage_iface_del_local(sh, key) >= 0);
190
191 /* cleanup */
192 semanage_iface_key_free(key);
193 }
194
195 /* Function semanage_iface_compare */
test_iface_compare(void)196 static void test_iface_compare(void)
197 {
198 semanage_iface_t *iface = NULL;
199 semanage_iface_key_t *key1 = NULL;
200 semanage_iface_key_t *key2 = NULL;
201 int res = 42;
202
203 /* setup */
204 setup_handle(SH_CONNECT);
205 iface = get_iface_nth(I_FIRST);
206 key1 = get_iface_key_nth(I_FIRST);
207 CU_ASSERT(semanage_iface_key_create(sh, "qwerty", &key2) >= 0);
208 CU_ASSERT_PTR_NOT_NULL(key2);
209
210 /* test */
211 res = semanage_iface_compare(iface, key1);
212 CU_ASSERT(res == 0);
213 res = semanage_iface_compare(iface, key2);
214 CU_ASSERT(res != 0);
215
216 /* cleanup */
217 semanage_iface_free(iface);
218 semanage_iface_key_free(key1);
219 semanage_iface_key_free(key2);
220 cleanup_handle(SH_CONNECT);
221 }
222
223 /* Function semanage_iface_compare2 */
test_iface_compare2(void)224 static void test_iface_compare2(void)
225 {
226 semanage_iface_t *iface1 = NULL;
227 semanage_iface_t *iface2 = NULL;
228 semanage_iface_t *iface3 = NULL;
229 int res = 42;
230
231 /* setup */
232 setup_handle(SH_CONNECT);
233 iface1 = get_iface_nth(I_FIRST);
234 iface2 = get_iface_nth(I_FIRST);
235 iface3 = get_iface_nth(I_SECOND);
236
237 /* test */
238 res = semanage_iface_compare2(iface1, iface2);
239 CU_ASSERT(res == 0);
240 res = semanage_iface_compare2(iface1, iface3);
241 CU_ASSERT(res != 0);
242
243 /* cleanup */
244 semanage_iface_free(iface1);
245 semanage_iface_free(iface2);
246 semanage_iface_free(iface3);
247 cleanup_handle(SH_CONNECT);
248 }
249
250 /* Function semanage_iface_create */
test_iface_key_create(void)251 static void test_iface_key_create(void)
252 {
253 semanage_iface_key_t *key = NULL;
254
255 /* setup */
256 setup_handle(SH_CONNECT);
257
258 /* test */
259 CU_ASSERT(semanage_iface_key_create(sh, "asdf", &key) >= 0);
260 CU_ASSERT_PTR_NOT_NULL(key);
261
262 /* cleanup */
263 semanage_iface_key_free(key);
264 cleanup_handle(SH_CONNECT);
265 }
266
267 /* Function semanage_iface_extract */
test_iface_key_extract(void)268 static void test_iface_key_extract(void)
269 {
270 semanage_iface_t *iface = NULL;
271 semanage_iface_key_t *key = NULL;
272
273 /* setup */
274 setup_handle(SH_CONNECT);
275 iface = get_iface_nth(I_FIRST);
276
277 /* test */
278 CU_ASSERT(semanage_iface_key_extract(sh, iface, &key) >= 0);
279 CU_ASSERT_PTR_NOT_NULL(key);
280
281 /* cleanup */
282 semanage_iface_free(iface);
283 semanage_iface_key_free(key);
284 cleanup_handle(SH_CONNECT);
285 }
286
287 /* Function semanage_iface_get_name, semanage_iface_set_name */
test_iface_get_set_name(void)288 static void test_iface_get_set_name(void)
289 {
290 semanage_iface_t *iface = NULL;
291
292 /* setup */
293 setup_handle(SH_CONNECT);
294 iface = get_iface_nth(I_FIRST);
295
296 /* test */
297 CU_ASSERT(semanage_iface_set_name(sh, iface, "my_asdf") == 0);
298 CU_ASSERT_STRING_EQUAL(semanage_iface_get_name(iface), "my_asdf");
299
300 /* cleanup */
301 semanage_iface_free(iface);
302 cleanup_handle(SH_CONNECT);
303 }
304
305 /* Function semanage_iface_get_ifcon, semanage_iface_set_ifcon */
test_iface_get_set_ifcon(void)306 static void test_iface_get_set_ifcon(void)
307 {
308 semanage_iface_t *iface = NULL;
309 semanage_context_t *con1 = NULL;
310 semanage_context_t *con2 = NULL;
311
312 /* setup */
313 setup_handle(SH_CONNECT);
314 iface = get_iface_nth(I_FIRST);
315 CU_ASSERT(semanage_context_from_string(sh,
316 "my_user_u:my_role_r:my_type_t:s0", &con1) >= 0);
317
318 /* test */
319 CU_ASSERT(semanage_iface_set_ifcon(sh, iface, con1) == 0);
320 con2 = semanage_iface_get_ifcon(iface);
321 CU_ASSERT_CONTEXT_EQUAL(con1, con2);
322
323 /* cleanup */
324 semanage_context_free(con1);
325 semanage_iface_free(iface);
326 cleanup_handle(SH_CONNECT);
327 }
328
329 /* Function semanage_iface_get_msgcon, semanage_iface_set_msgcon */
test_iface_get_set_msgcon(void)330 static void test_iface_get_set_msgcon(void)
331 {
332 semanage_iface_t *iface = NULL;
333 semanage_context_t *con1 = NULL;
334 semanage_context_t *con2 = NULL;
335
336 /* setup */
337 setup_handle(SH_CONNECT);
338 iface = get_iface_nth(I_FIRST);
339 CU_ASSERT(semanage_context_from_string(sh,
340 "my_user_u:my_role_r:my_type_t:s0", &con1) >= 0);
341
342 /* test */
343 CU_ASSERT(semanage_iface_set_msgcon(sh, iface, con1) == 0);
344 con2 = semanage_iface_get_msgcon(iface);
345 CU_ASSERT_CONTEXT_EQUAL(con1, con2);
346
347 /* cleanup */
348 semanage_context_free(con1);
349 semanage_iface_free(iface);
350 cleanup_handle(SH_CONNECT);
351 }
352
353 /* Function semanage_iface_create */
test_iface_create(void)354 static void test_iface_create(void)
355 {
356 semanage_iface_t *iface = NULL;
357 semanage_context_t *ifcon = NULL;
358 semanage_context_t *msgcon = NULL;
359
360 /* setup */
361 setup_handle(SH_CONNECT);
362
363 /* test */
364 CU_ASSERT(semanage_iface_create(sh, &iface) >= 0);
365 CU_ASSERT(semanage_iface_set_name(sh, iface, "asdf") >= 0);
366 CU_ASSERT(semanage_context_from_string(sh, "user_u:role_r:type_t:s0",
367 &ifcon) >= 0);
368 CU_ASSERT(semanage_iface_set_ifcon(sh, iface, ifcon) >= 0);
369 CU_ASSERT(semanage_context_from_string(sh, "user_u:role_r:type_t:s0",
370 &msgcon) >= 0);
371 CU_ASSERT(semanage_iface_set_msgcon(sh, iface, msgcon) >= 0);
372
373 /* cleanup */
374 semanage_context_free(msgcon);
375 semanage_context_free(ifcon);
376 semanage_iface_free(iface);
377 cleanup_handle(SH_CONNECT);
378 }
379
380 /* Function semanage_iface_clone */
test_iface_clone(void)381 static void test_iface_clone(void)
382 {
383 semanage_iface_t *iface = NULL;
384 semanage_iface_t *iface_clone = NULL;
385 semanage_context_t *ifcon = NULL;
386 semanage_context_t *ifcon2 = NULL;
387 semanage_context_t *msgcon = NULL;
388 semanage_context_t *msgcon2 = NULL;
389
390 /* setup */
391 setup_handle(SH_CONNECT);
392 CU_ASSERT(semanage_iface_create(sh, &iface) >= 0);
393 CU_ASSERT(semanage_iface_set_name(sh, iface, "asdf") >= 0);
394 CU_ASSERT(semanage_context_from_string(sh, "user_u:role_r:if_type_t:s0",
395 &ifcon) >= 0);
396 CU_ASSERT(semanage_iface_set_ifcon(sh, iface, ifcon) >= 0);
397 CU_ASSERT(semanage_context_from_string(sh, "user_u:role_r:msg_type_t:s0",
398 &msgcon) >= 0);
399 CU_ASSERT(semanage_iface_set_msgcon(sh, iface, msgcon) >= 0);
400
401 /* test */
402 CU_ASSERT(semanage_iface_clone(sh, iface, &iface_clone) >= 0);
403 CU_ASSERT_STRING_EQUAL(semanage_iface_get_name(iface_clone), "asdf");
404
405 ifcon2 = semanage_iface_get_ifcon(iface_clone);
406 CU_ASSERT_CONTEXT_EQUAL(ifcon, ifcon2);
407
408 msgcon2 = semanage_iface_get_msgcon(iface_clone);
409 CU_ASSERT_CONTEXT_EQUAL(msgcon, msgcon2);
410
411 /* cleanup */
412 semanage_context_free(msgcon);
413 semanage_context_free(ifcon);
414 semanage_iface_free(iface);
415 semanage_iface_free(iface_clone);
416 cleanup_handle(SH_CONNECT);
417 }
418
419 /* Function semanage_iface_query */
test_iface_query(void)420 static void test_iface_query(void)
421 {
422 semanage_iface_t *iface = NULL;
423 semanage_iface_t *iface_exp = NULL;
424 semanage_iface_key_t *key = NULL;
425 semanage_context_t *con = NULL;
426 semanage_context_t *con_exp = NULL;
427
428 /* setup */
429 setup_handle(SH_CONNECT);
430 key = get_iface_key_nth(I_FIRST);
431 iface_exp = get_iface_nth(I_FIRST);
432
433 /* test */
434 CU_ASSERT(semanage_iface_query(sh, key, &iface) >= 0);
435 CU_ASSERT_STRING_EQUAL(semanage_iface_get_name(iface),
436 semanage_iface_get_name(iface_exp));
437
438 con = semanage_iface_get_ifcon(iface);
439 con_exp = semanage_iface_get_ifcon(iface_exp);
440 CU_ASSERT_CONTEXT_EQUAL(con, con_exp);
441
442 con = semanage_iface_get_msgcon(iface);
443 con_exp = semanage_iface_get_msgcon(iface_exp);
444 CU_ASSERT_CONTEXT_EQUAL(con, con_exp);
445
446 /* cleanup */
447 semanage_iface_key_free(key);
448 semanage_iface_free(iface);
449 semanage_iface_free(iface_exp);
450 cleanup_handle(SH_CONNECT);
451 }
452
453 /* Function semanage_iface_exists */
test_iface_exists(void)454 static void test_iface_exists(void)
455 {
456 semanage_iface_key_t *key1 = NULL;
457 semanage_iface_key_t *key2 = NULL;
458 int resp = 42;
459
460 /* setup */
461 setup_handle(SH_CONNECT);
462 key1 = get_iface_key_nth(I_FIRST);
463 CU_ASSERT(semanage_iface_key_create(sh, "asdf", &key2) >= 0);
464
465 /* test */
466 CU_ASSERT(semanage_iface_exists(sh, key1, &resp) >= 0);
467 CU_ASSERT(resp);
468 CU_ASSERT(semanage_iface_exists(sh, key2, &resp) >= 0);
469 CU_ASSERT(!resp);
470
471 /* cleanup */
472 semanage_iface_key_free(key1);
473 semanage_iface_key_free(key2);
474 cleanup_handle(SH_CONNECT);
475 }
476
477 /* Function semanage_iface_count */
test_iface_count(void)478 static void test_iface_count(void)
479 {
480 unsigned int count = 42;
481
482 /* setup */
483 setup_handle(SH_CONNECT);
484
485 /* test */
486 CU_ASSERT(semanage_iface_count(sh, &count) >= 0);
487 CU_ASSERT(count == IFACE_COUNT);
488
489 /* cleanup */
490 cleanup_handle(SH_CONNECT);
491 }
492
493 /* Function semanage_iface_iterate */
494
495 unsigned int counter_iface_iterate = 0;
496
handler_iface_iterate(const semanage_iface_t * record,void * varg)497 static int handler_iface_iterate(const semanage_iface_t *record, void *varg)
498 {
499 counter_iface_iterate++;
500 return 0;
501 }
502
test_iface_iterate(void)503 static void test_iface_iterate(void)
504 {
505 /* setup */
506 setup_handle(SH_CONNECT);
507
508 /* test */
509 semanage_iface_iterate(sh, handler_iface_iterate, NULL);
510 CU_ASSERT(counter_iface_iterate == IFACE_COUNT);
511
512 /* cleanup */
513 cleanup_handle(SH_CONNECT);
514 }
515
516 /* Function semanage_iface_list */
test_iface_list(void)517 static void test_iface_list(void)
518 {
519 semanage_iface_t **records = NULL;
520 unsigned int count = 42;
521
522 /* setup */
523 setup_handle(SH_CONNECT);
524
525 /* test */
526 CU_ASSERT(semanage_iface_list(sh, &records, &count) >= 0);
527 CU_ASSERT(count == IFACE_COUNT);
528
529 for (unsigned int i = 0; i < count; i++)
530 CU_ASSERT_PTR_NOT_NULL(records[i]);
531
532 for (unsigned int i = 0; i < count; i++)
533 semanage_iface_free(records[i]);
534
535 free(records);
536
537 /* cleanup */
538 cleanup_handle(SH_CONNECT);
539 }
540
541 /* Function semanage_iface_modify_local, semanage_iface_del_local,
542 * semanage_iface_query_local
543 */
test_iface_modify_del_query_local(void)544 static void test_iface_modify_del_query_local(void)
545 {
546 semanage_iface_t *iface;
547 semanage_iface_t *iface_local;
548 semanage_iface_key_t *key = NULL;
549
550 /* setup */
551 setup_handle(SH_TRANS);
552 iface = get_iface_nth(I_FIRST);
553 CU_ASSERT(semanage_iface_key_extract(sh, iface, &key) >= 0);
554 CU_ASSERT_PTR_NOT_NULL(key);
555
556 /* test */
557 CU_ASSERT(semanage_iface_modify_local(sh, key, iface) >= 0);
558
559 /* write changes to file */
560 helper_commit();
561 helper_begin_transaction();
562
563 CU_ASSERT(semanage_iface_query_local(sh, key, &iface_local) >= 0);
564 CU_ASSERT_PTR_NOT_NULL_FATAL(iface_local);
565 semanage_iface_free(iface_local);
566
567 CU_ASSERT(semanage_iface_del_local(sh, key) >= 0);
568 CU_ASSERT(semanage_iface_query_local(sh, key, &iface_local) < 0);
569
570 /* cleanup */
571 semanage_iface_key_free(key);
572 semanage_iface_free(iface);
573 cleanup_handle(SH_TRANS);
574 }
575
576 /* Function semanage_iface_exists_local */
test_iface_exists_local(void)577 static void test_iface_exists_local(void)
578 {
579 semanage_iface_key_t *key1 = NULL;
580 semanage_iface_key_t *key2 = NULL;
581 int resp = 42;
582
583 /* setup */
584 setup_handle(SH_TRANS);
585 add_local_iface(I_FIRST);
586 key1 = get_iface_key_nth(I_FIRST);
587 key2 = get_iface_key_nth(I_SECOND);
588
589 /* test */
590 CU_ASSERT(semanage_iface_exists_local(sh, key1, &resp) >= 0);
591 CU_ASSERT(resp);
592 CU_ASSERT(semanage_iface_exists_local(sh, key2, &resp) >= 0);
593 CU_ASSERT(!resp);
594
595 /* cleanup */
596 CU_ASSERT(semanage_iface_del_local(sh, key1) >= 0);
597 semanage_iface_key_free(key1);
598 semanage_iface_key_free(key2);
599 cleanup_handle(SH_TRANS);
600 }
601
602 /* Function semanage_iface_count_local */
test_iface_count_local(void)603 static void test_iface_count_local(void)
604 {
605 unsigned int count = 42;
606
607 /* setup */
608 setup_handle(SH_TRANS);
609
610 /* test */
611 CU_ASSERT(semanage_iface_count_local(sh, &count) >= 0);
612 CU_ASSERT(count == 0);
613
614 add_local_iface(I_FIRST);
615 CU_ASSERT(semanage_iface_count_local(sh, &count) >= 0);
616 CU_ASSERT(count == 1);
617
618 add_local_iface(I_SECOND);
619 CU_ASSERT(semanage_iface_count_local(sh, &count) >= 0);
620 CU_ASSERT(count == 2);
621
622 delete_local_iface(I_SECOND);
623 CU_ASSERT(semanage_iface_count_local(sh, &count) >= 0);
624 CU_ASSERT(count == 1);
625
626 delete_local_iface(I_FIRST);
627 CU_ASSERT(semanage_iface_count_local(sh, &count) >= 0);
628 CU_ASSERT(count == 0);
629
630 /* cleanup */
631 cleanup_handle(SH_TRANS);
632 }
633
634 /* Function semanage_iface_iterate_local */
635 unsigned int counter_iface_iterate_local = 0;
636
handler_iface_iterate_local(const semanage_iface_t * record,void * varg)637 static int handler_iface_iterate_local(const semanage_iface_t *record, void *varg)
638 {
639 counter_iface_iterate_local++;
640 return 0;
641 }
642
test_iface_iterate_local(void)643 static void test_iface_iterate_local(void)
644 {
645 /* setup */
646 setup_handle(SH_TRANS);
647 add_local_iface(I_FIRST);
648 add_local_iface(I_SECOND);
649 add_local_iface(I_THIRD);
650
651 /* test */
652 semanage_iface_iterate_local(sh, handler_iface_iterate_local, NULL);
653 CU_ASSERT(counter_iface_iterate_local == 3);
654
655 /* cleanup */
656 delete_local_iface(I_FIRST);
657 delete_local_iface(I_SECOND);
658 delete_local_iface(I_THIRD);
659 cleanup_handle(SH_TRANS);
660 }
661
662 /* Function semanage_iface_list_local */
test_iface_list_local(void)663 static void test_iface_list_local(void)
664 {
665 semanage_iface_t **records = NULL;
666 unsigned int count = 42;
667
668 /* setup */
669 setup_handle(SH_TRANS);
670 add_local_iface(I_FIRST);
671 add_local_iface(I_SECOND);
672 add_local_iface(I_THIRD);
673
674 /* test */
675 CU_ASSERT(semanage_iface_list_local(sh, &records, &count) >= 0);
676 CU_ASSERT(count == 3);
677
678 for (unsigned int i = 0; i < count; i++)
679 CU_ASSERT_PTR_NOT_NULL(records[i]);
680
681 /* cleanup */
682 for (unsigned int i = 0; i < count; i++)
683 semanage_iface_free(records[i]);
684 free(records);
685
686 delete_local_iface(I_FIRST);
687 delete_local_iface(I_SECOND);
688 delete_local_iface(I_THIRD);
689 cleanup_handle(SH_TRANS);
690 }
691