1/* 2 * Copyright 2011 Tresys Technology, LLC. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are met: 6 * 7 * 1. Redistributions of source code must retain the above copyright notice, 8 * this list of conditions and the following disclaimer. 9 * 10 * 2. Redistributions in binary form must reproduce the above copyright notice, 11 * this list of conditions and the following disclaimer in the documentation 12 * and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY TRESYS TECHNOLOGY, LLC ``AS IS'' AND ANY EXPRESS 15 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 16 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 17 * EVENT SHALL TRESYS TECHNOLOGY, LLC OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 18 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 19 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 21 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 22 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 23 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 24 * 25 * The views and conclusions contained in the software and documentation are those 26 * of the authors and should not be interpreted as representing official policies, 27 * either expressed or implied, of Tresys Technology, LLC. 28 */ 29 30#include "CuTest.h" 31#include "CilTest.h" 32 33#include "../../src/cil_internal.h" 34#include "../../src/cil_copy_ast.h" 35#include "../../src/cil_build_ast.h" 36#include "../../src/cil_resolve_ast.h" 37 38#define CIL_TEST_SYM_SIZE 1 39 40int __cil_copy_node_helper(struct cil_tree_node *orig, uint32_t *finished, void *extra_args); 41 42struct cil_args_copy { 43 struct cil_tree_node *dest; 44 struct cil_db *db; 45}; 46 47struct cil_args_copy *gen_copy_args(struct cil_tree_node *node, struct cil_db *db) 48{ 49 struct cil_args_copy *args = cil_malloc(sizeof(*args)); 50 args->dest = node; 51 args->db = db; 52 53 return args; 54} 55 56void test_cil_copy_list(CuTest *tc) { 57 char *line[] = {"(", "foo1", "foo2", ")", NULL}; 58 59 struct cil_tree *test_tree; 60 struct cil_list *cil_l; 61 62 gen_test_tree(&test_tree, line); 63 cil_list_init(&cil_l); 64 65 cil_set_to_list(test_tree->root->cl_head, cil_l, 1); 66 67 struct cil_list *copy_list; 68 cil_list_init(©_list); 69 70 int rc =cil_copy_list(cil_l, ©_list); 71 CuAssertIntEquals(tc, rc, SEPOL_OK); 72 CuAssertStrEquals(tc, copy_list->head->data, cil_l->head->data); 73 CuAssertStrEquals(tc, copy_list->head->next->data, cil_l->head->next->data); 74 CuAssertIntEquals(tc, copy_list->head->flavor, cil_l->head->flavor); 75 CuAssertIntEquals(tc, copy_list->head->next->flavor, cil_l->head->next->flavor); 76} 77 78void test_cil_copy_list_sublist(CuTest *tc) { 79 char *line[] = {"(", "foo1", "foo2", "(", "foo3", ")", ")", NULL}; 80 81 struct cil_tree *test_tree; 82 struct cil_list *cil_l; 83 84 gen_test_tree(&test_tree, line); 85 cil_list_init(&cil_l); 86 87 cil_set_to_list(test_tree->root->cl_head, cil_l, 1); 88 89 struct cil_list *copy_list; 90 cil_list_init(©_list); 91 92 int rc = cil_copy_list(cil_l, ©_list); 93 CuAssertIntEquals(tc, rc, SEPOL_OK); 94 CuAssertStrEquals(tc, copy_list->head->data, cil_l->head->data); 95 CuAssertStrEquals(tc, copy_list->head->next->data, cil_l->head->next->data); 96 CuAssertStrEquals(tc, ((struct cil_list *)copy_list->head->next->next->data)->head->data, ((struct cil_list *)cil_l->head->next->next->data)->head->data); 97 CuAssertIntEquals(tc, copy_list->head->flavor, cil_l->head->flavor); 98 CuAssertIntEquals(tc, copy_list->head->next->flavor, cil_l->head->next->flavor); 99 CuAssertIntEquals(tc, ((struct cil_list *)copy_list->head->next->next->data)->head->flavor, ((struct cil_list *)cil_l->head->next->next->data)->head->flavor); 100} 101 102void test_cil_copy_list_sublist_extra(CuTest *tc) { 103 char *line[] = {"(", "foo1", "foo2", "(", "foo3", ")", "foo4", ")", NULL}; 104 105 struct cil_tree *test_tree; 106 struct cil_list *cil_l; 107 108 gen_test_tree(&test_tree, line); 109 cil_list_init(&cil_l); 110 111 cil_set_to_list(test_tree->root->cl_head, cil_l, 1); 112 113 struct cil_list *copy_list; 114 cil_list_init(©_list); 115 116 int rc = cil_copy_list(cil_l, ©_list); 117 CuAssertIntEquals(tc, rc, SEPOL_OK); 118 CuAssertStrEquals(tc, copy_list->head->data, cil_l->head->data); 119 CuAssertStrEquals(tc, copy_list->head->next->data, cil_l->head->next->data); 120 CuAssertStrEquals(tc, ((struct cil_list *)copy_list->head->next->next->data)->head->data, ((struct cil_list *)cil_l->head->next->next->data)->head->data); 121 CuAssertStrEquals(tc, copy_list->head->next->next->next->data, cil_l->head->next->next->next->data); 122 CuAssertIntEquals(tc, copy_list->head->flavor, cil_l->head->flavor); 123 CuAssertIntEquals(tc, copy_list->head->next->flavor, cil_l->head->next->flavor); 124 CuAssertIntEquals(tc, ((struct cil_list *)copy_list->head->next->next->data)->head->flavor, ((struct cil_list *)cil_l->head->next->next->data)->head->flavor); 125 CuAssertIntEquals(tc, copy_list->head->next->next->next->flavor, cil_l->head->next->next->next->flavor); 126} 127 128void test_cil_copy_list_orignull_neg(CuTest *tc) { 129 char *line[] = {"(", "foo1", "foo2", ")", NULL}; 130 131 struct cil_tree *test_tree; 132 struct cil_list *cil_l = NULL; 133 134 gen_test_tree(&test_tree, line); 135 136 struct cil_list *copy_list; 137 cil_list_init(©_list); 138 139 int rc = cil_copy_list(cil_l, ©_list); 140 CuAssertIntEquals(tc, rc, SEPOL_ERR); 141 CuAssertPtrEquals(tc, copy_list->head, NULL); 142} 143 144void test_cil_copy_block(CuTest *tc) { 145 char *line[] = {"(", "block", "a", "(", "type", "log", ")", ")", NULL}; 146 147 struct cil_tree *test_tree; 148 gen_test_tree(&test_tree, line); 149 150 struct cil_tree_node *test_ast_node; 151 cil_tree_node_init(&test_ast_node); 152 153 struct cil_db *test_db; 154 cil_db_init(&test_db); 155 156 test_ast_node->parent = test_db->ast->root; 157 test_ast_node->line = 1; 158 159 cil_gen_block(test_db, test_tree->root->cl_head->cl_head, test_ast_node, 0); 160 161 struct cil_tree_node *test_copy; 162 cil_tree_node_init(&test_copy); 163 164 symtab_t sym; 165 symtab_init(&sym, cil_sym_sizes[CIL_SYM_ARRAY_BLOCK][CIL_SYM_BLOCKS]); 166 167 int rc = cil_copy_block(test_db, test_ast_node->data, &test_copy->data, &sym); 168 CuAssertIntEquals(tc, rc, SEPOL_OK); 169} 170 171void test_cil_copy_perm(CuTest *tc) { 172 char *line[] = {"(", "class", "foo", "(", "read", "write", "open", ")", ")", NULL}; 173 174 struct cil_tree *test_tree; 175 gen_test_tree(&test_tree, line); 176 177 struct cil_tree_node *test_ast_node; 178 cil_tree_node_init(&test_ast_node); 179 180 struct cil_db *test_db; 181 cil_db_init(&test_db); 182 183 struct cil_class *new_node; 184 cil_class_init(&new_node); 185 186 struct cil_tree_node *new_tree_node; 187 cil_tree_node_init(&new_tree_node); 188 new_tree_node->data = new_node; 189 new_tree_node->flavor = CIL_CLASS; 190 191 test_ast_node->parent = new_tree_node; 192 test_ast_node->line = 1; 193 194 struct cil_tree_node *test_copy; 195 cil_tree_node_init(&test_copy); 196 197 symtab_t sym; 198 symtab_init(&sym, CIL_CLASS_SYM_SIZE); 199 200 cil_gen_perm(test_db, test_tree->root->cl_head->cl_head->next->next->cl_head, test_ast_node); 201 int rc = cil_copy_perm(test_db, test_ast_node->data, &test_copy->data, &sym); 202 CuAssertIntEquals(tc, rc, SEPOL_OK); 203 cil_gen_perm(test_db, test_tree->root->cl_head->cl_head->next->next->cl_head->next, test_ast_node); 204 rc = cil_copy_perm(test_db, test_ast_node->data, &test_copy->data, &sym); 205 CuAssertIntEquals(tc, rc, SEPOL_OK); 206 cil_gen_perm(test_db, test_tree->root->cl_head->cl_head->next->next->cl_head->next->next, test_ast_node); 207 rc = cil_copy_perm(test_db, test_ast_node->data, &test_copy->data, &sym); 208 CuAssertIntEquals(tc, rc, SEPOL_OK); 209 210} 211 212void test_cil_copy_class(CuTest *tc) { 213 char *line[] = {"(", "class", "file", "(", "read", "write", "open", ")", ")", NULL}; 214 215 struct cil_tree *test_tree; 216 gen_test_tree(&test_tree, line); 217 218 struct cil_tree_node *test_ast_node; 219 cil_tree_node_init(&test_ast_node); 220 221 struct cil_db *test_db; 222 cil_db_init(&test_db); 223 224 test_ast_node->parent = test_db->ast->root; 225 test_ast_node->line = 1; 226 227 cil_gen_class(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 228 229 struct cil_tree_node *test_copy; 230 cil_tree_node_init(&test_copy); 231 232 symtab_t sym; 233 symtab_init(&sym, CIL_CLASS_SYM_SIZE); 234 235 int rc = cil_copy_class(test_db, test_ast_node->data, &test_copy->data, &sym); 236 CuAssertIntEquals(tc, rc, SEPOL_OK); 237} 238 239void test_cil_copy_common(CuTest *tc) { 240 char *line[] = {"(", "common", "test", "(", "read", "write", ")", ")", NULL}; 241 242 struct cil_tree *test_tree; 243 gen_test_tree(&test_tree, line); 244 245 struct cil_tree_node *test_ast_node; 246 cil_tree_node_init(&test_ast_node); 247 248 struct cil_db *test_db; 249 cil_db_init(&test_db); 250 251 test_ast_node->parent = test_db->ast->root; 252 test_ast_node->line = 1; 253 254 cil_gen_common(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 255 256 struct cil_tree_node *test_copy; 257 cil_tree_node_init(&test_copy); 258 259 symtab_t sym; 260 symtab_init(&sym, CIL_CLASS_SYM_SIZE); 261 262 int rc = cil_copy_common(test_db, test_ast_node->data, &test_copy->data, &sym); 263 CuAssertIntEquals(tc, rc, SEPOL_OK); 264} 265 266void test_cil_copy_classcommon(CuTest *tc) { 267 char *line[] = {"(", "classcommon", "file", "file", NULL}; 268 269 struct cil_tree *test_tree; 270 gen_test_tree(&test_tree, line); 271 272 struct cil_tree_node *test_ast_node; 273 cil_tree_node_init(&test_ast_node); 274 275 struct cil_db *test_db; 276 cil_db_init(&test_db); 277 278 char *test_key = test_tree->root->cl_head->cl_head->next->data; 279 struct cil_class *test_cls; 280 cil_class_init(&test_cls); 281 282 test_ast_node->parent = test_db->ast->root; 283 test_ast_node->line = 1; 284 285 cil_symtab_insert(&test_db->symtab[CIL_SYM_CLASSES], (hashtab_key_t)test_key, (struct cil_symtab_datum*)test_cls, test_ast_node); 286 287 test_ast_node->data = test_cls; 288 test_ast_node->flavor = CIL_CLASS; 289 290 cil_gen_classcommon(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 291 292 struct cil_classcommon *test_copy; 293 cil_classcommon_init(&test_copy); 294 295 symtab_t sym; 296 symtab_init(&sym, CIL_CLASS_SYM_SIZE); 297 298 int rc = cil_copy_classcommon(test_db, test_ast_node->data, (void**)&test_copy, &sym); 299 CuAssertIntEquals(tc, rc, SEPOL_OK); 300 CuAssertStrEquals(tc, ((struct cil_classcommon *)test_ast_node->data)->class_str, test_copy->class_str); 301 CuAssertStrEquals(tc, ((struct cil_classcommon *)test_ast_node->data)->common_str, test_copy->common_str); 302} 303 304void test_cil_copy_sid(CuTest *tc) { 305 char *line[] = {"(", "sid", "test", ")", NULL}; 306 307 struct cil_tree *test_tree; 308 gen_test_tree(&test_tree, line); 309 310 struct cil_tree_node *test_ast_node; 311 cil_tree_node_init(&test_ast_node); 312 313 struct cil_db *test_db; 314 cil_db_init(&test_db); 315 316 test_ast_node->parent = test_db->ast->root; 317 test_ast_node->line = 1; 318 319 cil_gen_sid(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 320 321 struct cil_tree_node *test_copy; 322 cil_tree_node_init(&test_copy); 323 324 symtab_t sym; 325 symtab_init(&sym, CIL_TEST_SYM_SIZE); 326 327 int rc = cil_copy_sid(test_db, test_ast_node->data, &test_copy->data, &sym); 328 CuAssertIntEquals(tc, rc, SEPOL_OK); 329} 330 331void test_cil_copy_sidcontext(CuTest *tc) { 332 char *line[] = {"(", "sidcontext", "test", "(", "blah_u", "blah_r", "blah_t", "(", "low", "high", ")", ")", ")", NULL}; 333 334 struct cil_tree *test_tree; 335 gen_test_tree(&test_tree, line); 336 337 struct cil_tree_node *test_ast_node; 338 cil_tree_node_init(&test_ast_node); 339 340 struct cil_db *test_db; 341 cil_db_init(&test_db); 342 343 test_ast_node->parent = test_db->ast->root; 344 test_ast_node->line = 1; 345 346 cil_gen_sidcontext(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 347 348 struct cil_tree_node *test_copy; 349 cil_tree_node_init(&test_copy); 350 351 symtab_t sym; 352 symtab_init(&sym, CIL_TEST_SYM_SIZE); 353 354 int rc = cil_copy_sidcontext(test_db, test_ast_node->data, &test_copy->data, &sym); 355 CuAssertIntEquals(tc, rc, SEPOL_OK); 356 CuAssertStrEquals(tc, ((struct cil_user *)test_copy->data)->datum.name, 357 ((struct cil_user *)test_ast_node->data)->datum.name); 358} 359 360void test_cil_copy_user(CuTest *tc) { 361 char *line[] = {"(", "user", "sysadm", ")", NULL}; 362 363 struct cil_tree *test_tree; 364 gen_test_tree(&test_tree, line); 365 366 struct cil_tree_node *test_ast_node; 367 cil_tree_node_init(&test_ast_node); 368 369 struct cil_db *test_db; 370 cil_db_init(&test_db); 371 372 test_ast_node->parent = test_db->ast->root; 373 test_ast_node->line = 1; 374 375 cil_gen_user(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 376 377 struct cil_tree_node *test_copy; 378 cil_tree_node_init(&test_copy); 379 380 symtab_t sym; 381 symtab_init(&sym, CIL_TEST_SYM_SIZE); 382 383 int rc = cil_copy_user(test_db, test_ast_node->data, &test_copy->data, &sym); 384 CuAssertIntEquals(tc, rc, SEPOL_OK); 385} 386 387void test_cil_copy_role(CuTest *tc) { 388 char *line[] = {"(", "role", "role_r", ")", NULL}; 389 390 struct cil_tree *test_tree; 391 gen_test_tree(&test_tree, line); 392 393 struct cil_tree_node *test_ast_node; 394 cil_tree_node_init(&test_ast_node); 395 396 struct cil_db *test_db; 397 cil_db_init(&test_db); 398 399 test_ast_node->parent = test_db->ast->root; 400 test_ast_node->line = 1; 401 402 cil_gen_role(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 403 404 struct cil_tree_node *test_copy; 405 cil_tree_node_init(&test_copy); 406 407 symtab_t sym; 408 symtab_init(&sym, CIL_TEST_SYM_SIZE); 409 410 int rc = cil_copy_role(test_db, test_ast_node->data, &test_copy->data, &sym); 411 CuAssertIntEquals(tc, rc, SEPOL_OK); 412} 413 414void test_cil_copy_userrole(CuTest *tc) { 415 char *line[] = {"(", "userrole", "staff_u", "staff_r", ")", NULL}; 416 417 struct cil_tree *test_tree; 418 gen_test_tree(&test_tree, line); 419 420 struct cil_tree_node *test_ast_node; 421 cil_tree_node_init(&test_ast_node); 422 423 struct cil_db *test_db; 424 cil_db_init(&test_db); 425 426 test_ast_node->parent = test_db->ast->root; 427 test_ast_node->line = 1; 428 429 cil_gen_userrole(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 430 431 struct cil_userrole *test_copy; 432 cil_userrole_init(&test_copy); 433 434 symtab_t sym; 435 symtab_init(&sym, CIL_TEST_SYM_SIZE); 436 437 int rc = cil_copy_userrole(test_db, test_ast_node->data, (void**)&test_copy, &sym); 438 CuAssertIntEquals(tc, rc, SEPOL_OK); 439 CuAssertStrEquals(tc, ((struct cil_userrole *)test_ast_node->data)->user_str, test_copy->user_str); 440 CuAssertStrEquals(tc, ((struct cil_userrole *)test_ast_node->data)->role_str, test_copy->role_str); 441} 442 443void test_cil_copy_type(CuTest *tc) { 444 char *line[] = {"(", "type", "test", ")", NULL}; 445 446 struct cil_tree *test_tree; 447 gen_test_tree(&test_tree, line); 448 449 struct cil_tree_node *test_ast_node; 450 cil_tree_node_init(&test_ast_node); 451 452 struct cil_db *test_db; 453 cil_db_init(&test_db); 454 455 test_ast_node->parent = test_db->ast->root; 456 test_ast_node->line = 1; 457 458 cil_gen_type(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 459 460 struct cil_tree_node *test_copy; 461 cil_tree_node_init(&test_copy); 462 463 symtab_t sym; 464 symtab_init(&sym, CIL_TEST_SYM_SIZE); 465 466 int rc = cil_copy_type(test_db, test_ast_node->data, &test_copy->data, &sym); 467 CuAssertIntEquals(tc, rc, SEPOL_OK); 468} 469 470void test_cil_copy_typealias(CuTest *tc) { 471 char *line[] = {"(", "typealias", ".test.type", "type_t", ")", "(", "type", "test", ")", NULL}; 472 473 struct cil_tree *test_tree; 474 gen_test_tree(&test_tree, line); 475 476 struct cil_tree_node *test_ast_node; 477 cil_tree_node_init(&test_ast_node); 478 479 struct cil_db *test_db; 480 cil_db_init(&test_db); 481 482 test_ast_node->parent = test_db->ast->root; 483 test_ast_node->line = 1; 484 485 cil_gen_typealias(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 486 487 struct cil_tree_node *test_copy; 488 cil_tree_node_init(&test_copy); 489 490 symtab_t sym; 491 symtab_init(&sym, CIL_TEST_SYM_SIZE); 492 493 int rc = cil_copy_typealias(test_db, test_ast_node->data, &test_copy->data, &sym); 494 CuAssertIntEquals(tc, rc, SEPOL_OK); 495} 496 497void test_cil_copy_typeattribute(CuTest *tc) { 498 char *line[] = {"(", "typettribute", "type_t", ")", NULL}; 499 500 struct cil_tree *test_tree; 501 gen_test_tree(&test_tree, line); 502 503 struct cil_tree_node *test_ast_node; 504 cil_tree_node_init(&test_ast_node); 505 506 struct cil_db *test_db; 507 cil_db_init(&test_db); 508 509 test_ast_node->parent = test_db->ast->root; 510 test_ast_node->line = 1; 511 512 cil_gen_typeattribute(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 513 514 struct cil_tree_node *test_copy; 515 cil_tree_node_init(&test_copy); 516 517 symtab_t sym; 518 symtab_init(&sym, CIL_TEST_SYM_SIZE); 519 520 int rc = cil_copy_typeattribute(test_db, test_ast_node->data, &test_copy->data, &sym); 521 CuAssertIntEquals(tc, rc, SEPOL_OK); 522} 523 524void test_cil_copy_bool(CuTest *tc) { 525 char *line[] = {"(", "boolean", "foo", "true", ")", NULL}; 526 527 struct cil_tree *test_tree; 528 gen_test_tree(&test_tree, line); 529 530 struct cil_tree_node *test_ast_node; 531 cil_tree_node_init(&test_ast_node); 532 533 struct cil_db *test_db; 534 cil_db_init(&test_db); 535 536 test_ast_node->parent = test_db->ast->root; 537 test_ast_node->line = 1; 538 539 cil_gen_bool(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_BOOL); 540 541 struct cil_tree_node *test_copy; 542 cil_tree_node_init(&test_copy); 543 544 symtab_t sym; 545 symtab_init(&sym, CIL_TEST_SYM_SIZE); 546 547 int rc = cil_copy_bool(test_db, test_ast_node->data, &test_copy->data, &sym); 548 CuAssertIntEquals(tc, rc, SEPOL_OK); 549 CuAssertIntEquals(tc, ((struct cil_bool *)test_copy->data)->value, 550 ((struct cil_bool *)test_ast_node->data)->value); 551} 552 553void test_cil_copy_type_rule(CuTest *tc) { 554 char *line[] = {"(", "typetransition", "foo", "bar", "file", "foobar", ")", NULL}; 555 556 struct cil_tree *test_tree; 557 gen_test_tree(&test_tree, line); 558 559 struct cil_tree_node *test_ast_node; 560 cil_tree_node_init(&test_ast_node); 561 562 struct cil_db *test_db; 563 cil_db_init(&test_db); 564 565 test_ast_node->parent = test_db->ast->root; 566 test_ast_node->line = 1; 567 568 cil_gen_type_rule(test_tree->root->cl_head->cl_head, test_ast_node, CIL_TYPE_TRANSITION); 569 570 struct cil_type_rule *test_copy; 571 cil_type_rule_init(&test_copy); 572 573 symtab_t sym; 574 symtab_init(&sym, CIL_TEST_SYM_SIZE); 575 576 int rc = cil_copy_type_rule(test_db, test_ast_node->data, (void**)&test_copy, &sym); 577 CuAssertIntEquals(tc, rc, SEPOL_OK); 578 CuAssertIntEquals(tc, ((struct cil_type_rule *)test_ast_node->data)->rule_kind, test_copy->rule_kind); 579 CuAssertStrEquals(tc, ((struct cil_type_rule *)test_ast_node->data)->src_str, test_copy->src_str); 580 CuAssertStrEquals(tc, ((struct cil_type_rule *)test_ast_node->data)->tgt_str, test_copy->tgt_str); 581 CuAssertStrEquals(tc, ((struct cil_type_rule *)test_ast_node->data)->obj_str, test_copy->obj_str); 582} 583 584void test_cil_copy_avrule(CuTest *tc) { 585 char *line[] = {"(", "allow", "test", "foo", "(", "bar", "(", "read", "write", ")", ")", ")", NULL}; 586 587 struct cil_tree *test_tree; 588 gen_test_tree(&test_tree, line); 589 590 struct cil_tree_node *test_ast_node; 591 cil_tree_node_init(&test_ast_node); 592 593 struct cil_db *test_db; 594 cil_db_init(&test_db); 595 596 test_ast_node->parent = test_db->ast->root; 597 test_ast_node->line = 1; 598 599 struct cil_tree_node *test_current; 600 test_current = test_tree->root->cl_head->cl_head; 601 602 cil_gen_avrule(test_current, test_ast_node, CIL_AVRULE_ALLOWED); 603 604 struct cil_avrule *test_copy; 605 cil_avrule_init(&test_copy); 606 607 symtab_t sym; 608 symtab_init(&sym, CIL_TEST_SYM_SIZE); 609 610 int rc = cil_copy_avrule(test_db, test_ast_node->data, (void**)&test_copy, &sym); 611 CuAssertIntEquals(tc, rc, SEPOL_OK); 612 CuAssertIntEquals(tc, ((struct cil_avrule *)test_ast_node->data)->rule_kind, test_copy->rule_kind); 613 CuAssertStrEquals(tc, ((struct cil_avrule *)test_ast_node->data)->src_str, test_copy->src_str); 614 CuAssertStrEquals(tc, ((struct cil_avrule *)test_ast_node->data)->tgt_str, test_copy->tgt_str); 615 CuAssertStrEquals(tc, ((struct cil_avrule *)test_ast_node->data)->classpermset->class_str, test_copy->classpermset->class_str); 616 CuAssertIntEquals(tc, ((struct cil_avrule *)test_ast_node->data)->classpermset->permset->perms_list_str->head->flavor, test_copy->classpermset->permset->perms_list_str->head->flavor); 617 CuAssertStrEquals(tc, (char*)((struct cil_avrule *)test_ast_node->data)->classpermset->permset->perms_list_str->head->data, (char*)test_copy->classpermset->permset->perms_list_str->head->data); 618 CuAssertIntEquals(tc, ((struct cil_avrule *)test_ast_node->data)->classpermset->permset->perms_list_str->head->next->flavor, test_copy->classpermset->permset->perms_list_str->head->next->flavor); 619 CuAssertStrEquals(tc, (char*)((struct cil_avrule *)test_ast_node->data)->classpermset->permset->perms_list_str->head->next->data, (char*)test_copy->classpermset->permset->perms_list_str->head->next->data); 620} 621 622void test_cil_copy_sens(CuTest *tc) { 623 char *line[] = {"(", "sensitivity", "s0", ")", NULL}; 624 625 struct cil_tree *test_tree; 626 gen_test_tree(&test_tree, line); 627 628 struct cil_db *test_db; 629 cil_db_init(&test_db); 630 631 struct cil_tree_node *test_ast_node; 632 cil_tree_node_init(&test_ast_node); 633 634 test_ast_node->parent = test_db->ast->root; 635 test_ast_node->line = 1; 636 637 cil_gen_sensitivity(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 638 639 struct cil_tree_node *test_copy; 640 cil_tree_node_init(&test_copy); 641 642 symtab_t sym; 643 symtab_init(&sym, CIL_TEST_SYM_SIZE); 644 645 int rc = cil_copy_sens(test_db, test_ast_node->data, &test_copy->data, &sym); 646 CuAssertIntEquals(tc, rc, SEPOL_OK); 647} 648 649void test_cil_copy_sensalias(CuTest *tc) { 650 char *line[] = {"(", "sensitivityalias", "s0", "alias", ")", NULL}; 651 652 struct cil_tree *test_tree; 653 gen_test_tree(&test_tree, line); 654 655 struct cil_db *test_db; 656 cil_db_init(&test_db); 657 658 struct cil_tree_node *test_ast_node; 659 cil_tree_node_init(&test_ast_node); 660 661 test_ast_node->parent = test_db->ast->root; 662 test_ast_node->line = 1; 663 664 cil_gen_sensalias(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 665 666 struct cil_tree_node *test_copy; 667 cil_tree_node_init(&test_copy); 668 669 symtab_t sym; 670 symtab_init(&sym, CIL_TEST_SYM_SIZE); 671 672 int rc = cil_copy_sensalias(test_db, test_ast_node->data, &test_copy->data, &sym); 673 CuAssertIntEquals(tc, rc, SEPOL_OK); 674 CuAssertStrEquals(tc, ((struct cil_sensalias *)test_copy->data)->sens_str, 675 ((struct cil_sensalias *)test_ast_node->data)->sens_str); 676} 677 678void test_cil_copy_cat(CuTest *tc) { 679 char *line[] = {"(", "category", "c0", ")", NULL}; 680 681 struct cil_tree *test_tree; 682 gen_test_tree(&test_tree, line); 683 684 struct cil_db *test_db; 685 cil_db_init(&test_db); 686 687 struct cil_tree_node *test_ast_node; 688 cil_tree_node_init(&test_ast_node); 689 690 test_ast_node->parent = test_db->ast->root; 691 test_ast_node->line = 1; 692 693 cil_gen_category(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 694 695 struct cil_tree_node *test_copy; 696 cil_tree_node_init(&test_copy); 697 698 symtab_t sym; 699 symtab_init(&sym, CIL_TEST_SYM_SIZE); 700 701 int rc = cil_copy_cat(test_db, test_ast_node->data, &test_copy->data, &sym); 702 CuAssertIntEquals(tc, rc, SEPOL_OK); 703} 704 705void test_cil_copy_catalias(CuTest *tc) { 706 char *line[] = {"(", "categoryalias", "c0", "red", ")", NULL}; 707 708 struct cil_tree *test_tree; 709 gen_test_tree(&test_tree, line); 710 711 struct cil_db *test_db; 712 cil_db_init(&test_db); 713 714 struct cil_tree_node *test_ast_node; 715 cil_tree_node_init(&test_ast_node); 716 717 test_ast_node->parent = test_db->ast->root; 718 test_ast_node->line = 1; 719 720 cil_gen_catalias(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 721 722 struct cil_tree_node *test_copy; 723 cil_tree_node_init(&test_copy); 724 725 symtab_t sym; 726 symtab_init(&sym, CIL_TEST_SYM_SIZE); 727 728 int rc = cil_copy_catalias(test_db, test_ast_node->data, &test_copy->data, &sym); 729 CuAssertIntEquals(tc, rc, SEPOL_OK); 730 CuAssertStrEquals(tc, ((struct cil_catalias *)test_copy->data)->cat_str, 731 ((struct cil_catalias *)test_ast_node->data)->cat_str); 732} 733 734void test_cil_copy_senscat(CuTest *tc) { 735 char *line[] = {"(", "sensitivity", "s0", ")", 736 "(", "sensitivity", "s1", ")", 737 "(", "dominance", "(", "s0", "s1", ")", ")", 738 "(", "category", "c0", ")", 739 "(", "category", "c255", ")", 740 "(", "categoryorder", "(", "c0", "c255", ")", ")", 741 "(", "sensitivitycategory", "s1", "(", "c0", "c255", ")", ")", NULL}; 742 743 struct cil_tree *test_tree; 744 gen_test_tree(&test_tree, line); 745 746 struct cil_tree_node *test_ast_node; 747 cil_tree_node_init(&test_ast_node); 748 749 struct cil_db *test_db; 750 cil_db_init(&test_db); 751 752 test_ast_node->parent = test_db->ast->root; 753 test_ast_node->line = 1; 754 755 cil_gen_senscat(test_db, test_tree->root->cl_head->next->next->next->next->next->next->cl_head, test_ast_node); 756 757 struct cil_senscat *test_copy; 758 cil_senscat_init(&test_copy); 759 760 symtab_t sym; 761 symtab_init(&sym, CIL_TEST_SYM_SIZE); 762 763 int rc = cil_copy_senscat(test_db, test_ast_node->data, (void**)&test_copy, &sym); 764 CuAssertIntEquals(tc, rc, SEPOL_OK); 765 CuAssertStrEquals(tc, ((struct cil_senscat *)test_ast_node->data)->sens_str, test_copy->sens_str); 766 CuAssertStrEquals(tc, (char*)((struct cil_senscat *)test_ast_node->data)->catset->cat_list_str->head->data, 767 (char*)test_copy->catset->cat_list_str->head->data); 768 CuAssertStrEquals(tc, (char*)((struct cil_senscat *)test_ast_node->data)->catset->cat_list_str->head->next->data, 769 (char*)test_copy->catset->cat_list_str->head->next->data); 770} 771 772void test_cil_copy_catorder(CuTest *tc) { 773 char *line[] = {"(", "category", "c0", ")", 774 "(", "category", "c255", ")", 775 "(", "categoryorder", "(", "c0", "c255", ")", ")", NULL}; 776 777 struct cil_tree *test_tree; 778 gen_test_tree(&test_tree, line); 779 780 struct cil_db *test_db; 781 cil_db_init(&test_db); 782 783 struct cil_tree_node *test_ast_node; 784 cil_tree_node_init(&test_ast_node); 785 786 test_ast_node->parent = test_db->ast->root; 787 test_ast_node->line = 1; 788 789 cil_gen_catorder(test_db, test_tree->root->cl_head->next->next->cl_head, test_ast_node); 790 791 struct cil_catorder *test_copy; 792 cil_catorder_init(&test_copy); 793 794 symtab_t sym; 795 symtab_init(&sym, CIL_TEST_SYM_SIZE); 796 797 int rc = cil_copy_catorder(test_db, test_ast_node->data, (void**)&test_copy, &sym); 798 CuAssertIntEquals(tc, rc, SEPOL_OK); 799 CuAssertStrEquals(tc, (char*)((struct cil_catorder *)test_ast_node->data)->cat_list_str->head->data, (char*)test_copy->cat_list_str->head->data); 800 CuAssertStrEquals(tc, (char*)((struct cil_catorder *)test_ast_node->data)->cat_list_str->head->next->data, (char*)test_copy->cat_list_str->head->next->data); 801} 802 803void test_cil_copy_dominance(CuTest *tc) { 804 char *line[] = {"(", "sensitivity", "s0", ")", 805 "(", "sensitivity", "s1", ")", 806 "(", "sensitivity", "s2", ")", 807 "(", "dominance", "(", "s0", "s1", ")", ")", NULL}; 808 809 struct cil_tree *test_tree; 810 gen_test_tree(&test_tree, line); 811 812 struct cil_tree_node *test_ast_node; 813 cil_tree_node_init(&test_ast_node); 814 815 struct cil_db *test_db; 816 cil_db_init(&test_db); 817 818 test_ast_node->parent = test_db->ast->root; 819 test_ast_node->line = 1; 820 821 cil_gen_dominance(test_db, test_tree->root->cl_head->next->next->next->cl_head, test_ast_node); 822 823 struct cil_sens_dominates *test_copy; 824 cil_sens_dominates_init(&test_copy); 825 826 symtab_t sym; 827 symtab_init(&sym, CIL_TEST_SYM_SIZE); 828 829 int rc = cil_copy_dominance(test_db, test_ast_node->data, (void**)&test_copy, &sym); 830 CuAssertIntEquals(tc, rc, SEPOL_OK); 831 CuAssertStrEquals(tc, (char*)((struct cil_sens_dominates *)test_ast_node->data)->sens_list_str->head->data, (char*)test_copy->sens_list_str->head->data); 832 CuAssertStrEquals(tc, (char*)((struct cil_sens_dominates *)test_ast_node->data)->sens_list_str->head->next->data, (char*)test_copy->sens_list_str->head->next->data); 833} 834 835void test_cil_copy_level(CuTest *tc) { 836 char *line[] = {"(", "level", "low", "(", "s0", "(", "c1", ")", ")", ")", NULL}; 837 838 struct cil_tree *test_tree; 839 gen_test_tree(&test_tree, line); 840 841 struct cil_tree_node *test_ast_node; 842 cil_tree_node_init(&test_ast_node); 843 844 struct cil_db *test_db; 845 cil_db_init(&test_db); 846 847 test_ast_node->parent = test_db->ast->root; 848 test_ast_node->line = 1; 849 850 cil_gen_level(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 851 852 struct cil_tree_node *test_copy; 853 cil_tree_node_init(&test_copy); 854 855 symtab_t sym; 856 symtab_init(&sym, CIL_TEST_SYM_SIZE); 857 858 int rc = cil_copy_level(test_db, test_ast_node->data, &test_copy->data, &sym); 859 CuAssertIntEquals(tc, rc, SEPOL_OK); 860} 861 862void test_cil_copy_fill_level(CuTest *tc) { 863 char *line[] = {"(", "level", "low", "(", "s0", "(", "c1", ")", ")", ")", NULL}; 864 865 struct cil_tree *test_tree; 866 gen_test_tree(&test_tree, line); 867 868 struct cil_tree_node *test_ast_node; 869 cil_tree_node_init(&test_ast_node); 870 871 struct cil_db *test_db; 872 cil_db_init(&test_db); 873 874 test_ast_node->parent = test_db->ast->root; 875 test_ast_node->line = 1; 876 877 cil_gen_level(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 878 879 struct cil_tree_node *test_copy; 880 cil_tree_node_init(&test_copy); 881 cil_level_init((struct cil_level**)&test_copy->data); 882 883 symtab_t sym; 884 symtab_init(&sym, CIL_TEST_SYM_SIZE); 885 886 int rc = cil_copy_fill_level((struct cil_level*)test_ast_node->data, (struct cil_level*)test_copy->data); 887 CuAssertIntEquals(tc, rc, SEPOL_OK); 888 CuAssertStrEquals(tc, ((struct cil_level *)test_copy->data)->sens_str, 889 ((struct cil_level *)test_ast_node->data)->sens_str); 890} 891 892void test_cil_copy_context(CuTest *tc) { 893 char *line[] = {"(", "context", "packet_default", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")", NULL}; 894 895 struct cil_tree *test_tree; 896 gen_test_tree(&test_tree, line); 897 898 struct cil_tree_node *test_ast_node; 899 cil_tree_node_init(&test_ast_node); 900 901 struct cil_db *test_db; 902 cil_db_init(&test_db); 903 904 test_ast_node->parent = test_db->ast->root; 905 test_ast_node->line = 1; 906 907 cil_gen_context(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 908 909 struct cil_tree_node *test_copy; 910 cil_tree_node_init(&test_copy); 911 912 symtab_t sym; 913 symtab_init(&sym, CIL_TEST_SYM_SIZE); 914 915 int rc = cil_copy_context(test_db, test_ast_node->data, &test_copy->data, &sym); 916 CuAssertIntEquals(tc, rc, SEPOL_OK); 917} 918 919void test_cil_copy_netifcon(CuTest *tc) { 920 char *line[] = {"(", "netifcon", "eth0", "if_default", "packet_default", ")", NULL}; 921 922 struct cil_tree *test_tree; 923 gen_test_tree(&test_tree, line); 924 925 struct cil_tree_node *test_ast_node; 926 cil_tree_node_init(&test_ast_node); 927 928 struct cil_db *test_db; 929 cil_db_init(&test_db); 930 931 test_ast_node->parent = test_db->ast->root; 932 test_ast_node->line = 1; 933 934 cil_gen_netifcon(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 935 936 struct cil_netifcon *test_copy; 937 938 symtab_t sym; 939 symtab_init(&sym, CIL_TEST_SYM_SIZE); 940 941 int rc = cil_copy_netifcon(test_db, test_ast_node->data, (void**)&test_copy, &sym); 942 CuAssertIntEquals(tc, rc, SEPOL_OK); 943 CuAssertStrEquals(tc, test_copy->interface_str, 944 ((struct cil_netifcon *)test_ast_node->data)->interface_str); 945 CuAssertStrEquals(tc, test_copy->if_context_str, 946 ((struct cil_netifcon *)test_ast_node->data)->if_context_str); 947 CuAssertStrEquals(tc, test_copy->packet_context_str, 948 ((struct cil_netifcon *)test_ast_node->data)->packet_context_str); 949} 950 951void test_cil_copy_netifcon_nested(CuTest *tc) { 952 char *line[] = {"(", "netifcon", "eth1", 953 "(", "system_u", "object_r", "netif_t", "(", "low", "high", ")", ")", 954 "(", "system_u", "object_r", "netif_t", "(", "low", "high", ")", ")", ")", NULL}; 955 956 struct cil_tree *test_tree; 957 gen_test_tree(&test_tree, line); 958 959 struct cil_tree_node *test_ast_node; 960 cil_tree_node_init(&test_ast_node); 961 962 struct cil_db *test_db; 963 cil_db_init(&test_db); 964 965 test_ast_node->parent = test_db->ast->root; 966 test_ast_node->line = 1; 967 968 cil_gen_netifcon(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 969 970 struct cil_netifcon *test_copy; 971 972 symtab_t sym; 973 symtab_init(&sym, CIL_TEST_SYM_SIZE); 974 975 int rc = cil_copy_netifcon(test_db, test_ast_node->data, (void**)&test_copy, &sym); 976 CuAssertIntEquals(tc, rc, SEPOL_OK); 977 CuAssertStrEquals(tc, test_copy->interface_str, 978 ((struct cil_netifcon *)test_ast_node->data)->interface_str); 979 CuAssertStrEquals(tc, test_copy->if_context_str, 980 ((struct cil_netifcon *)test_ast_node->data)->if_context_str); 981 CuAssertStrEquals(tc, test_copy->packet_context_str, 982 ((struct cil_netifcon *)test_ast_node->data)->packet_context_str); 983 CuAssertStrEquals(tc, test_copy->packet_context->user_str, 984 ((struct cil_netifcon *)test_ast_node->data)->packet_context->user_str); 985 CuAssertStrEquals(tc, test_copy->packet_context->role_str, 986 ((struct cil_netifcon *)test_ast_node->data)->packet_context->role_str); 987 CuAssertStrEquals(tc, test_copy->packet_context->type_str, 988 ((struct cil_netifcon *)test_ast_node->data)->packet_context->type_str); 989 CuAssertStrEquals(tc, test_copy->packet_context->range_str, 990 ((struct cil_netifcon *)test_ast_node->data)->packet_context->range_str); 991} 992 993void test_cil_copy_fill_context(CuTest *tc) { 994 char *line[] = {"(", "context", "packet_default", "(", "system_u", "object_r", "etc_t", "range", ")", ")", NULL}; 995 996 struct cil_tree *test_tree; 997 gen_test_tree(&test_tree, line); 998 999 struct cil_tree_node *test_ast_node; 1000 cil_tree_node_init(&test_ast_node); 1001 1002 struct cil_db *test_db; 1003 cil_db_init(&test_db); 1004 1005 test_ast_node->parent = test_db->ast->root; 1006 test_ast_node->line = 1; 1007 1008 cil_gen_context(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1009 1010 struct cil_tree_node *test_copy; 1011 cil_tree_node_init(&test_copy); 1012 cil_context_init((struct cil_context**)&test_copy->data); 1013 1014 symtab_t sym; 1015 symtab_init(&sym, CIL_TEST_SYM_SIZE); 1016 1017 int rc = cil_copy_fill_context((struct cil_context*)test_ast_node->data, (struct cil_context*)test_copy->data); 1018 CuAssertIntEquals(tc, rc, SEPOL_OK); 1019 CuAssertStrEquals(tc, ((struct cil_context *)test_copy->data)->user_str, 1020 ((struct cil_context *)test_ast_node->data)->user_str); 1021 CuAssertStrEquals(tc, ((struct cil_context *)test_copy->data)->role_str, 1022 ((struct cil_context *)test_ast_node->data)->role_str); 1023 CuAssertStrEquals(tc, ((struct cil_context *)test_copy->data)->type_str, 1024 ((struct cil_context *)test_ast_node->data)->type_str); 1025 CuAssertStrEquals(tc, ((struct cil_context *)test_copy->data)->range_str, 1026 ((struct cil_context *)test_ast_node->data)->range_str); 1027} 1028 1029void test_cil_copy_fill_context_anonrange(CuTest *tc) { 1030 char *line[] = {"(", "context", "packet_default", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")", NULL}; 1031 1032 struct cil_tree *test_tree; 1033 gen_test_tree(&test_tree, line); 1034 1035 struct cil_tree_node *test_ast_node; 1036 cil_tree_node_init(&test_ast_node); 1037 1038 struct cil_db *test_db; 1039 cil_db_init(&test_db); 1040 1041 test_ast_node->parent = test_db->ast->root; 1042 test_ast_node->line = 1; 1043 1044 cil_gen_context(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1045 1046 struct cil_tree_node *test_copy; 1047 cil_tree_node_init(&test_copy); 1048 cil_context_init((struct cil_context**)&test_copy->data); 1049 1050 symtab_t sym; 1051 symtab_init(&sym, CIL_TEST_SYM_SIZE); 1052 1053 int rc = cil_copy_fill_context((struct cil_context*)test_ast_node->data, (struct cil_context*)test_copy->data); 1054 CuAssertIntEquals(tc, rc, SEPOL_OK); 1055 CuAssertStrEquals(tc, ((struct cil_context *)test_copy->data)->user_str, 1056 ((struct cil_context *)test_ast_node->data)->user_str); 1057 CuAssertStrEquals(tc, ((struct cil_context *)test_copy->data)->role_str, 1058 ((struct cil_context *)test_ast_node->data)->role_str); 1059 CuAssertStrEquals(tc, ((struct cil_context *)test_copy->data)->type_str, 1060 ((struct cil_context *)test_ast_node->data)->type_str); 1061 CuAssertStrEquals(tc, ((struct cil_context *)test_copy->data)->range_str, 1062 ((struct cil_context *)test_ast_node->data)->range_str); 1063} 1064 1065void test_cil_copy_call(CuTest *tc) { 1066 char *line[] = {"(", "call", "mm", "(", "foo", ")", ")", NULL}; 1067 1068 struct cil_tree *test_tree; 1069 gen_test_tree(&test_tree, line); 1070 1071 struct cil_tree_node *test_ast_node; 1072 cil_tree_node_init(&test_ast_node); 1073 1074 struct cil_db *test_db; 1075 cil_db_init(&test_db); 1076 1077 test_ast_node->parent = test_db->ast->root; 1078 test_ast_node->line = 1; 1079 1080 cil_gen_call(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1081 1082 struct cil_call *test_copy; 1083 1084 symtab_t sym; 1085 symtab_init(&sym, CIL_TEST_SYM_SIZE); 1086 1087 int rc = cil_copy_call(test_db, test_ast_node->data, (void**)&test_copy, &sym); 1088 CuAssertIntEquals(tc, rc, SEPOL_OK); 1089 CuAssertStrEquals(tc, test_copy->macro_str, ((struct cil_call *)test_ast_node->data)->macro_str); 1090} 1091 1092void test_cil_copy_optional(CuTest *tc) { 1093 char *line[] = {"(", "optional", "opt", "(", "allow", "foo", "bar", "(", "file", "(", "read", ")", ")", ")", ")", NULL}; 1094 1095 struct cil_tree *test_tree; 1096 gen_test_tree(&test_tree, line); 1097 1098 struct cil_tree_node *test_ast_node; 1099 cil_tree_node_init(&test_ast_node); 1100 1101 struct cil_db *test_db; 1102 cil_db_init(&test_db); 1103 1104 test_ast_node->parent = test_db->ast->root; 1105 test_ast_node->line = 1; 1106 1107 cil_gen_optional(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1108 1109 struct cil_tree_node *test_copy; 1110 cil_tree_node_init(&test_copy); 1111 1112 symtab_t sym; 1113 symtab_init(&sym, CIL_TEST_SYM_SIZE); 1114 1115 int rc = cil_copy_optional(test_db, test_ast_node->data, &test_copy->data, &sym); 1116 CuAssertIntEquals(tc, rc, SEPOL_OK); 1117} 1118 1119void test_cil_copy_nodecon(CuTest *tc) { 1120 char *line[] = {"(", "nodecon", "ipaddr", "ipaddr", "con", ")", NULL}; 1121 1122 struct cil_tree *test_tree; 1123 gen_test_tree(&test_tree, line); 1124 1125 struct cil_tree_node *test_ast_node; 1126 cil_tree_node_init(&test_ast_node); 1127 1128 struct cil_db *test_db; 1129 cil_db_init(&test_db); 1130 1131 test_ast_node->parent = test_db->ast->root; 1132 test_ast_node->line = 1; 1133 1134 cil_gen_nodecon(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1135 1136 struct cil_nodecon *test_copy; 1137 1138 symtab_t sym; 1139 symtab_init(&sym, CIL_TEST_SYM_SIZE); 1140 1141 int rc = cil_copy_nodecon(test_db, test_ast_node->data, (void**)&test_copy, &sym); 1142 CuAssertIntEquals(tc, rc, SEPOL_OK); 1143 CuAssertStrEquals(tc, test_copy->addr_str, 1144 ((struct cil_nodecon *)test_ast_node->data)->addr_str); 1145 CuAssertStrEquals(tc, test_copy->mask_str, 1146 ((struct cil_nodecon *)test_ast_node->data)->mask_str); 1147 CuAssertStrEquals(tc, test_copy->context_str, 1148 ((struct cil_nodecon *)test_ast_node->data)->context_str); 1149} 1150 1151void test_cil_copy_nodecon_anon(CuTest *tc) { 1152 char *line[] = {"(", "nodecon", "(", "192.168.1.1", ")", "(", "192.168.1.1", ")", "(", "user", "role", "type", "(", "low", "high", ")", ")", ")", NULL}; 1153 1154 struct cil_tree *test_tree; 1155 gen_test_tree(&test_tree, line); 1156 1157 struct cil_tree_node *test_ast_node; 1158 cil_tree_node_init(&test_ast_node); 1159 1160 struct cil_db *test_db; 1161 cil_db_init(&test_db); 1162 1163 test_ast_node->parent = test_db->ast->root; 1164 test_ast_node->line = 1; 1165 1166 cil_gen_nodecon(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1167 1168 struct cil_nodecon *test_copy; 1169 1170 symtab_t sym; 1171 symtab_init(&sym, CIL_TEST_SYM_SIZE); 1172 1173 int rc = cil_copy_nodecon(test_db, test_ast_node->data, (void**)&test_copy, &sym); 1174 CuAssertIntEquals(tc, rc, SEPOL_OK); 1175 CuAssertStrEquals(tc, test_copy->addr_str, 1176 ((struct cil_nodecon *)test_ast_node->data)->addr_str); 1177 CuAssertStrEquals(tc, test_copy->mask_str, 1178 ((struct cil_nodecon *)test_ast_node->data)->mask_str); 1179 CuAssertStrEquals(tc, test_copy->context_str, 1180 ((struct cil_nodecon *)test_ast_node->data)->context_str); 1181} 1182 1183void test_cil_copy_fill_ipaddr(CuTest *tc) { 1184 char *line[] = {"(", "ipaddr", "ip", "192.168.1.1", ")", NULL}; 1185 1186 struct cil_tree *test_tree; 1187 gen_test_tree(&test_tree, line); 1188 1189 struct cil_tree_node *test_ast_node; 1190 cil_tree_node_init(&test_ast_node); 1191 1192 struct cil_db *test_db; 1193 cil_db_init(&test_db); 1194 1195 test_ast_node->parent = test_db->ast->root; 1196 test_ast_node->line = 1; 1197 1198 cil_gen_ipaddr(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1199 1200 symtab_t sym; 1201 symtab_init(&sym, CIL_TEST_SYM_SIZE); 1202 1203 struct cil_ipaddr *new; 1204 cil_ipaddr_init(&new); 1205 struct cil_ipaddr *old; 1206 cil_ipaddr_init(&new); 1207 1208 old = (struct cil_ipaddr*)test_ast_node->data; 1209 int rc = cil_copy_fill_ipaddr(old, new); 1210 CuAssertIntEquals(tc, rc, SEPOL_OK); 1211 1212 CuAssertIntEquals(tc, old->family, new->family); 1213} 1214 1215void test_cil_copy_ipaddr(CuTest *tc) { 1216 char *line[] = {"(", "ipaddr", "ip", "192.168.1.1", ")", NULL}; 1217 1218 struct cil_tree *test_tree; 1219 gen_test_tree(&test_tree, line); 1220 1221 struct cil_tree_node *test_ast_node; 1222 cil_tree_node_init(&test_ast_node); 1223 1224 struct cil_db *test_db; 1225 cil_db_init(&test_db); 1226 1227 test_ast_node->parent = test_db->ast->root; 1228 test_ast_node->line = 1; 1229 1230 cil_gen_ipaddr(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1231 1232 struct cil_tree_node *test_copy; 1233 cil_tree_node_init(&test_copy); 1234 1235 symtab_t sym; 1236 symtab_init(&sym, CIL_TEST_SYM_SIZE); 1237 1238 int rc = cil_copy_ipaddr(test_db, test_ast_node->data, &test_copy->data, &sym); 1239 CuAssertIntEquals(tc, rc, SEPOL_OK); 1240} 1241 1242void test_cil_copy_conditional(CuTest *tc) { 1243 char *line[] = {"(", "booleanif", "(", "and", "foo", "bar", ")", 1244 "(", "true", 1245 "(", "allow", "foo", "bar", "(", "file", "(", "read", ")", ")", ")", ")", ")", NULL}; 1246 1247 struct cil_tree *test_tree; 1248 gen_test_tree(&test_tree, line); 1249 1250 struct cil_tree_node *test_ast_node; 1251 cil_tree_node_init(&test_ast_node); 1252 1253 struct cil_db *test_db; 1254 cil_db_init(&test_db); 1255 1256 test_ast_node->parent = test_db->ast->root; 1257 test_ast_node->line = 1; 1258 1259 cil_gen_boolif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1260 1261 struct cil_list_item *curr_old; 1262 curr_old = ((struct cil_booleanif*)test_ast_node->data)->expr_stack->head; 1263 1264 struct cil_conditional *cond_new; 1265 1266 symtab_t sym; 1267 symtab_init(&sym, CIL_TEST_SYM_SIZE); 1268 1269 int rc = cil_copy_conditional(test_db, curr_old->data, (void**)&cond_new, &sym); 1270 CuAssertIntEquals(tc, rc, SEPOL_OK); 1271 1272 CuAssertStrEquals(tc, ((struct cil_conditional*)curr_old->data)->str, cond_new->str); 1273 CuAssertIntEquals(tc, ((struct cil_conditional*)curr_old->data)->flavor, cond_new->flavor); 1274} 1275 1276void test_cil_copy_boolif(CuTest *tc) { 1277 char *line[] = {"(", "booleanif", "(", "and", "foo", "bar", ")", 1278 "(", "true", 1279 "(", "allow", "foo", "bar", "(", "file", "(", "read", ")", ")", ")", ")", ")", NULL}; 1280 1281 struct cil_tree *test_tree; 1282 gen_test_tree(&test_tree, line); 1283 1284 struct cil_tree_node *test_ast_node; 1285 cil_tree_node_init(&test_ast_node); 1286 1287 struct cil_db *test_db; 1288 cil_db_init(&test_db); 1289 1290 test_ast_node->parent = test_db->ast->root; 1291 test_ast_node->line = 1; 1292 1293 cil_gen_boolif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1294 1295 struct cil_booleanif *test_copy; 1296 1297 symtab_t sym; 1298 symtab_init(&sym, CIL_TEST_SYM_SIZE); 1299 1300 int rc = cil_copy_boolif(test_db, test_ast_node->data, (void**)&test_copy, &sym); 1301 CuAssertIntEquals(tc, rc, SEPOL_OK); 1302} 1303 1304void test_cil_copy_constrain(CuTest *tc) { 1305 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "l2", "h2", ")", ")", NULL}; 1306 1307 struct cil_tree *test_tree; 1308 gen_test_tree(&test_tree, line); 1309 1310 struct cil_tree_node *test_ast_node; 1311 cil_tree_node_init(&test_ast_node); 1312 1313 struct cil_db *test_db; 1314 cil_db_init(&test_db); 1315 1316 test_ast_node->parent = test_db->ast->root; 1317 test_ast_node->line = 1; 1318 1319 cil_gen_constrain(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_MLSCONSTRAIN); 1320 1321 struct cil_constrain *test_copy; 1322 1323 symtab_t sym; 1324 symtab_init(&sym, CIL_TEST_SYM_SIZE); 1325 1326 int rc = cil_copy_constrain(test_db, test_ast_node->data, (void**)&test_copy, &sym); 1327 CuAssertIntEquals(tc, rc, SEPOL_OK); 1328 CuAssertStrEquals(tc, ((struct cil_constrain*)test_copy)->classpermset->class_str, ((struct cil_constrain *)test_ast_node->data)->classpermset->class_str); 1329} 1330/* 1331void test_cil_copy_ast(CuTest *tc) { 1332 char *line[] = {"(", "mlsconstrain", "(", "file", "dir", ")", "(", "create", "relabelto", ")", "(", "eq", "l2", "h2", ")", ")", NULL}; 1333 1334 struct cil_tree *test_tree; 1335 gen_test_tree(&test_tree, line); 1336 1337 struct cil_tree_node *test_ast_node; 1338 cil_tree_node_init(&test_ast_node); 1339 1340 struct cil_db *test_db; 1341 cil_db_init(&test_db); 1342 1343 test_ast_node->parent = test_db->ast->root; 1344 test_ast_node->line = 1; 1345 1346 cil_gen_constrain(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_MLSCONSTRAIN); 1347 1348 struct cil_tree_node *test_current; 1349 test_current = test_tree->root->cl_head->cl_head; 1350 1351 struct cil_constrain *test_copy; 1352 cil_constrain_init(&test_copy); 1353 cil_list_init(&test_copy->expr); 1354 1355 int rc = cil_copy_ast(((struct cil_constrain *)test_ast_node->data)->expr, test_copy->expr); 1356 CuAssertIntEquals(tc, rc, SEPOL_OK); 1357} 1358 1359void test_cil_copy_ast_neg(CuTest *tc) { 1360 char *line[] = {"(", "mlsconstrain", ")", NULL}; 1361 1362 struct cil_tree *test_tree; 1363 gen_test_tree(&test_tree, line); 1364 1365 struct cil_tree_node *test_ast_node; 1366 cil_tree_node_init(&test_ast_node); 1367 1368 struct cil_db *test_db; 1369 cil_db_init(&test_db); 1370 1371 test_ast_node->parent = test_db->ast->root; 1372 test_ast_node->line = 1; 1373 1374 cil_gen_constrain(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_MLSCONSTRAIN); 1375 1376 struct cil_tree_node *test_current; 1377 test_current = test_tree->root->cl_head->cl_head; 1378 1379 struct cil_constrain *test_copy; 1380 cil_constrain_init(&test_copy); 1381 cil_list_init(&test_copy->expr); 1382 1383 int rc = cil_copy_ast(((struct cil_constrain *)test_ast_node->data)->expr, test_copy->expr); 1384 CuAssertIntEquals(tc, rc, SEPOL_ERR); 1385} 1386*/ 1387/* node_helper functions */ 1388 1389void test_cil_copy_node_helper_block(CuTest *tc) { 1390 char *line[] = {"(", "block", "a", "(", "type", "log", ")", ")", NULL}; 1391 1392 struct cil_tree *test_tree; 1393 gen_test_tree(&test_tree, line); 1394 1395 struct cil_db *test_db; 1396 cil_db_init(&test_db); 1397 1398 struct cil_db *test_db2; 1399 cil_db_init(&test_db2); 1400 1401 uint32_t finished = 0; 1402 1403 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 1404 1405 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1406 1407 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1408 CuAssertIntEquals(tc, finished, 0); 1409 CuAssertIntEquals(tc, SEPOL_OK, rc); 1410} 1411 1412void test_cil_copy_node_helper_block_merge(CuTest *tc) { 1413 char *line[] = {"(", "block", "a", "(", "type", "log", ")", ")", NULL}; 1414 1415 struct cil_tree *test_tree; 1416 gen_test_tree(&test_tree, line); 1417 1418 struct cil_db *test_db; 1419 cil_db_init(&test_db); 1420 1421 uint32_t finished = 0; 1422 1423 struct cil_args_copy *extra_args = gen_copy_args(test_db->ast->root, test_db); 1424 1425 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1426 1427 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1428 CuAssertIntEquals(tc, finished, 0); 1429 CuAssertIntEquals(tc, SEPOL_OK, rc); 1430} 1431 1432void test_cil_copy_node_helper_perm(CuTest *tc) { 1433 char *line[] = {"(", "class", "foo", "(", "read", "write", "open", ")", ")", NULL}; 1434 1435 struct cil_tree *test_tree; 1436 gen_test_tree(&test_tree, line); 1437 1438 struct cil_db *test_db; 1439 cil_db_init(&test_db); 1440 1441 struct cil_db *test_db2; 1442 cil_db_init(&test_db2); 1443 1444 uint32_t finished = 0; 1445 1446 struct cil_class *test_class; 1447 cil_class_init(&test_class); 1448 1449 struct cil_tree_node *parent_node; 1450 cil_tree_node_init(&parent_node); 1451 parent_node->flavor = CIL_CLASS; 1452 parent_node->data = test_class; 1453 struct cil_tree_node *root; 1454 cil_tree_node_init(&root); 1455 root->flavor = CIL_ROOT; 1456 parent_node->parent = root; 1457 1458 struct cil_args_copy *extra_args = gen_copy_args(parent_node, test_db2); 1459 1460 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1461 1462 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head->cl_head, &finished, extra_args); 1463 CuAssertIntEquals(tc, finished, 0); 1464 CuAssertIntEquals(tc, SEPOL_OK, rc); 1465} 1466 1467void test_cil_copy_node_helper_perm_neg(CuTest *tc) { 1468 char *line[] = {"(", "class", "foo", "(", "read", "write", "open", ")", ")", NULL}; 1469 1470 struct cil_tree *test_tree; 1471 gen_test_tree(&test_tree, line); 1472 1473 struct cil_db *test_db; 1474 cil_db_init(&test_db); 1475 1476 uint32_t finished = 0; 1477 1478 struct cil_args_copy *extra_args = gen_copy_args(test_db->ast->root, test_db); 1479 1480 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1481 1482 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head->cl_head, &finished, extra_args); 1483 CuAssertIntEquals(tc, finished, 0); 1484 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1485} 1486 1487void test_cil_copy_node_helper_class(CuTest *tc) { 1488 char *line[] = {"(", "class", "file", "(", "read", "write", "open", ")", ")", NULL}; 1489 1490 struct cil_tree *test_tree; 1491 gen_test_tree(&test_tree, line); 1492 1493 struct cil_db *test_db; 1494 cil_db_init(&test_db); 1495 1496 struct cil_db *test_db2; 1497 cil_db_init(&test_db2); 1498 1499 uint32_t finished = 0; 1500 1501 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 1502 1503 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1504 1505 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1506 CuAssertIntEquals(tc, finished, 0); 1507 CuAssertIntEquals(tc, SEPOL_OK, rc); 1508} 1509 1510void test_cil_copy_node_helper_class_dup_neg(CuTest *tc) { 1511 char *line[] = {"(", "class", "test", "(", "read", "write", ")", ")", NULL}; 1512 1513 struct cil_tree *test_tree; 1514 gen_test_tree(&test_tree, line); 1515 1516 struct cil_db *test_db; 1517 cil_db_init(&test_db); 1518 1519 uint32_t finished = 0; 1520 1521 struct cil_args_copy *extra_args = gen_copy_args(test_db->ast->root, test_db); 1522 1523 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1524 1525 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1526 CuAssertIntEquals(tc, finished, 0); 1527 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1528} 1529 1530void test_cil_copy_node_helper_common(CuTest *tc) { 1531 char *line[] = {"(", "common", "test", "(", "read", "write", ")", ")", NULL}; 1532 1533 struct cil_tree *test_tree; 1534 gen_test_tree(&test_tree, line); 1535 1536 struct cil_db *test_db; 1537 cil_db_init(&test_db); 1538 1539 struct cil_db *test_db2; 1540 cil_db_init(&test_db2); 1541 1542 uint32_t finished = 0; 1543 1544 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 1545 1546 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1547 1548 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1549 CuAssertIntEquals(tc, finished, 0); 1550 CuAssertIntEquals(tc, SEPOL_OK, rc); 1551} 1552 1553void test_cil_copy_node_helper_common_dup_neg(CuTest *tc) { 1554 char *line[] = {"(", "class", "file", "(", "read", "write", "open", ")", ")", NULL}; 1555 1556 struct cil_tree *test_tree; 1557 gen_test_tree(&test_tree, line); 1558 1559 struct cil_db *test_db; 1560 cil_db_init(&test_db); 1561 1562 uint32_t finished = 0; 1563 1564 struct cil_args_copy *extra_args = gen_copy_args(test_db->ast->root, test_db); 1565 1566 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1567 1568 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1569 CuAssertIntEquals(tc, finished, 0); 1570 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1571} 1572 1573void test_cil_copy_node_helper_classcommon(CuTest *tc) { 1574 char *line[] = {"(", "classcommon", "file", "file", NULL}; 1575 1576 struct cil_tree *test_tree; 1577 gen_test_tree(&test_tree, line); 1578 1579 struct cil_db *test_db; 1580 cil_db_init(&test_db); 1581 1582 struct cil_db *test_db2; 1583 cil_db_init(&test_db2); 1584 1585 uint32_t finished = 0; 1586 1587 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 1588 1589 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1590 1591 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1592 CuAssertIntEquals(tc, finished, 0); 1593 CuAssertIntEquals(tc, SEPOL_OK, rc); 1594} 1595 1596void test_cil_copy_node_helper_sid(CuTest *tc) { 1597 char *line[] = {"(", "sid", "test", ")", NULL}; 1598 1599 struct cil_tree *test_tree; 1600 gen_test_tree(&test_tree, line); 1601 1602 struct cil_db *test_db; 1603 cil_db_init(&test_db); 1604 1605 struct cil_db *test_db2; 1606 cil_db_init(&test_db2); 1607 1608 uint32_t finished = 0; 1609 1610 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 1611 1612 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1613 1614 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1615 CuAssertIntEquals(tc, finished, 0); 1616 CuAssertIntEquals(tc, SEPOL_OK, rc); 1617} 1618 1619void test_cil_copy_node_helper_sid_merge(CuTest *tc) { 1620 char *line[] = {"(", "sid", "test", ")", NULL}; 1621 1622 struct cil_tree *test_tree; 1623 gen_test_tree(&test_tree, line); 1624 1625 struct cil_db *test_db; 1626 cil_db_init(&test_db); 1627 1628 uint32_t finished = 0; 1629 1630 struct cil_args_copy *extra_args = gen_copy_args(test_db->ast->root, test_db); 1631 1632 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1633 1634 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1635 CuAssertIntEquals(tc, finished, 0); 1636 CuAssertIntEquals(tc, SEPOL_OK, rc); 1637} 1638 1639void test_cil_copy_node_helper_sidcontext(CuTest *tc) { 1640 char *line[] = {"(", "sidcontext", "test", "(", "blah_u", "blah_r", "blah_t", "(", "low", "high", ")", ")", ")", NULL}; 1641 1642 struct cil_tree *test_tree; 1643 gen_test_tree(&test_tree, line); 1644 1645 struct cil_db *test_db; 1646 cil_db_init(&test_db); 1647 1648 struct cil_db *test_db2; 1649 cil_db_init(&test_db2); 1650 1651 uint32_t finished = 0; 1652 1653 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 1654 1655 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1656 1657 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1658 CuAssertIntEquals(tc, finished, 0); 1659 CuAssertIntEquals(tc, SEPOL_OK, rc); 1660} 1661 1662void test_cil_copy_node_helper_user(CuTest *tc) { 1663 char *line[] = {"(", "user", "sysadm", ")", NULL}; 1664 1665 struct cil_tree *test_tree; 1666 gen_test_tree(&test_tree, line); 1667 1668 struct cil_db *test_db; 1669 cil_db_init(&test_db); 1670 1671 struct cil_db *test_db2; 1672 cil_db_init(&test_db2); 1673 1674 uint32_t finished = 0; 1675 1676 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 1677 1678 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1679 1680 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1681 CuAssertIntEquals(tc, finished, 0); 1682 CuAssertIntEquals(tc, SEPOL_OK, rc); 1683} 1684 1685void test_cil_copy_node_helper_user_merge(CuTest *tc) { 1686 char *line[] = {"(", "user", "sysadm", ")", NULL}; 1687 1688 struct cil_tree *test_tree; 1689 gen_test_tree(&test_tree, line); 1690 1691 struct cil_db *test_db; 1692 cil_db_init(&test_db); 1693 1694 uint32_t finished = 0; 1695 1696 struct cil_args_copy *extra_args = gen_copy_args(test_db->ast->root, test_db); 1697 1698 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1699 1700 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1701 CuAssertIntEquals(tc, finished, 0); 1702 CuAssertIntEquals(tc, SEPOL_OK, rc); 1703} 1704 1705void test_cil_copy_node_helper_role(CuTest *tc) { 1706 char *line[] = {"(", "role", "role_r", ")", NULL}; 1707 1708 struct cil_tree *test_tree; 1709 gen_test_tree(&test_tree, line); 1710 1711 struct cil_db *test_db; 1712 cil_db_init(&test_db); 1713 1714 struct cil_db *test_db2; 1715 cil_db_init(&test_db2); 1716 1717 uint32_t finished = 0; 1718 1719 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 1720 1721 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1722 1723 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1724 CuAssertIntEquals(tc, finished, 0); 1725 CuAssertIntEquals(tc, SEPOL_OK, rc); 1726} 1727 1728void test_cil_copy_node_helper_role_merge(CuTest *tc) { 1729 char *line[] = {"(", "role", "role_r", ")", NULL}; 1730 1731 struct cil_tree *test_tree; 1732 gen_test_tree(&test_tree, line); 1733 1734 struct cil_db *test_db; 1735 cil_db_init(&test_db); 1736 1737 uint32_t finished = 0; 1738 1739 struct cil_args_copy *extra_args = gen_copy_args(test_db->ast->root, test_db); 1740 1741 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1742 1743 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1744 CuAssertIntEquals(tc, finished, 0); 1745 CuAssertIntEquals(tc, SEPOL_OK, rc); 1746} 1747 1748void test_cil_copy_node_helper_userrole(CuTest *tc) { 1749 char *line[] = {"(", "userrole", "staff_u", "staff_r", ")", NULL}; 1750 1751 struct cil_tree *test_tree; 1752 gen_test_tree(&test_tree, line); 1753 1754 struct cil_db *test_db; 1755 cil_db_init(&test_db); 1756 1757 struct cil_db *test_db2; 1758 cil_db_init(&test_db2); 1759 1760 uint32_t finished = 0; 1761 1762 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 1763 1764 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1765 1766 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1767 CuAssertIntEquals(tc, finished, 0); 1768 CuAssertIntEquals(tc, SEPOL_OK, rc); 1769} 1770 1771void test_cil_copy_node_helper_type(CuTest *tc) { 1772 char *line[] = {"(", "type", "type_t", ")", NULL}; 1773 1774 struct cil_tree *test_tree; 1775 gen_test_tree(&test_tree, line); 1776 1777 struct cil_db *test_db; 1778 cil_db_init(&test_db); 1779 1780 struct cil_db *test_db2; 1781 cil_db_init(&test_db2); 1782 1783 uint32_t finished = 0; 1784 1785 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 1786 1787 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1788 1789 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1790 CuAssertIntEquals(tc, finished, 0); 1791 CuAssertIntEquals(tc, SEPOL_OK, rc); 1792} 1793 1794void test_cil_copy_node_helper_type_merge(CuTest *tc) { 1795 char *line[] = {"(", "type", "type_t", ")", NULL}; 1796 1797 struct cil_tree *test_tree; 1798 gen_test_tree(&test_tree, line); 1799 1800 struct cil_db *test_db; 1801 cil_db_init(&test_db); 1802 1803 uint32_t finished = 0; 1804 1805 struct cil_args_copy *extra_args = gen_copy_args(test_db->ast->root, test_db); 1806 1807 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1808 1809 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1810 CuAssertIntEquals(tc, finished, 0); 1811 CuAssertIntEquals(tc, SEPOL_OK, rc); 1812} 1813 1814void test_cil_copy_node_helper_typeattribute(CuTest *tc) { 1815 char *line[] = {"(", "typeattribute", "bar", ")", NULL}; 1816 1817 struct cil_tree *test_tree; 1818 gen_test_tree(&test_tree, line); 1819 1820 struct cil_db *test_db; 1821 cil_db_init(&test_db); 1822 1823 struct cil_db *test_db2; 1824 cil_db_init(&test_db2); 1825 1826 uint32_t finished = 0; 1827 1828 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 1829 1830 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1831 1832 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1833 CuAssertIntEquals(tc, finished, 0); 1834 CuAssertIntEquals(tc, SEPOL_OK, rc); 1835} 1836 1837void test_cil_copy_node_helper_typeattribute_merge(CuTest *tc) { 1838 char *line[] = {"(", "typeattribute", "bar", ")", NULL}; 1839 1840 struct cil_tree *test_tree; 1841 gen_test_tree(&test_tree, line); 1842 1843 struct cil_db *test_db; 1844 cil_db_init(&test_db); 1845 1846 uint32_t finished = 0; 1847 1848 struct cil_args_copy *extra_args = gen_copy_args(test_db->ast->root, test_db); 1849 1850 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1851 1852 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1853 CuAssertIntEquals(tc, finished, 0); 1854 CuAssertIntEquals(tc, SEPOL_OK, rc); 1855} 1856 1857void test_cil_copy_node_helper_typealias(CuTest *tc) { 1858 char *line[] = {"(", "typealias", ".test.type", "type_t", ")", "(", "type", "test", ")", NULL}; 1859 1860 struct cil_tree *test_tree; 1861 gen_test_tree(&test_tree, line); 1862 1863 struct cil_db *test_db; 1864 cil_db_init(&test_db); 1865 1866 struct cil_db *test_db2; 1867 cil_db_init(&test_db2); 1868 1869 uint32_t finished = 0; 1870 1871 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 1872 1873 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1874 1875 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1876 CuAssertIntEquals(tc, finished, 0); 1877 CuAssertIntEquals(tc, SEPOL_OK, rc); 1878} 1879 1880void test_cil_copy_node_helper_typealias_dup_neg(CuTest *tc) { 1881 char *line[] = {"(", "typealias", ".test.type", "type_t", ")", "(", "type", "test", ")", NULL}; 1882 1883 struct cil_tree *test_tree; 1884 gen_test_tree(&test_tree, line); 1885 1886 struct cil_db *test_db; 1887 cil_db_init(&test_db); 1888 1889 uint32_t finished = 0; 1890 1891 struct cil_args_copy *extra_args = gen_copy_args(test_db->ast->root, test_db); 1892 1893 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1894 1895 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1896 CuAssertIntEquals(tc, finished, 0); 1897 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1898} 1899 1900void test_cil_copy_node_helper_bool(CuTest *tc) { 1901 char *line[] = {"(", "boolean", "foo", "true", ")", NULL}; 1902 1903 struct cil_tree *test_tree; 1904 gen_test_tree(&test_tree, line); 1905 1906 struct cil_db *test_db; 1907 cil_db_init(&test_db); 1908 1909 struct cil_db *test_db2; 1910 cil_db_init(&test_db2); 1911 1912 uint32_t finished = 0; 1913 1914 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 1915 1916 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1917 1918 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1919 CuAssertIntEquals(tc, finished, 0); 1920 CuAssertIntEquals(tc, SEPOL_OK, rc); 1921} 1922 1923void test_cil_copy_node_helper_bool_dup_neg(CuTest *tc) { 1924 char *line[] = {"(", "boolean", "foo", "true", ")", NULL}; 1925 1926 struct cil_tree *test_tree; 1927 gen_test_tree(&test_tree, line); 1928 1929 struct cil_db *test_db; 1930 cil_db_init(&test_db); 1931 1932 uint32_t finished = 0; 1933 1934 struct cil_args_copy *extra_args = gen_copy_args(test_db->ast->root, test_db); 1935 1936 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1937 1938 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1939 CuAssertIntEquals(tc, finished, 0); 1940 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1941} 1942 1943void test_cil_copy_node_helper_avrule(CuTest *tc) { 1944 char *line[] = {"(", "allow", "test", "foo", "(", "file", "(", "read", "write", ")", ")", ")", NULL}; 1945 1946 struct cil_tree *test_tree; 1947 gen_test_tree(&test_tree, line); 1948 1949 struct cil_db *test_db; 1950 cil_db_init(&test_db); 1951 1952 struct cil_db *test_db2; 1953 cil_db_init(&test_db2); 1954 1955 uint32_t finished = 0; 1956 1957 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 1958 1959 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1960 1961 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1962 CuAssertIntEquals(tc, finished, 0); 1963 CuAssertIntEquals(tc, SEPOL_OK, rc); 1964} 1965 1966void test_cil_copy_node_helper_type_rule(CuTest *tc) { 1967 char *line[] = {"(", "typetransition", "foo", "bar", "file", "foobar", ")", NULL}; 1968 1969 struct cil_tree *test_tree; 1970 gen_test_tree(&test_tree, line); 1971 1972 struct cil_db *test_db; 1973 cil_db_init(&test_db); 1974 1975 struct cil_db *test_db2; 1976 cil_db_init(&test_db2); 1977 1978 uint32_t finished = 0; 1979 1980 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 1981 1982 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 1983 1984 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 1985 CuAssertIntEquals(tc, finished, 0); 1986 CuAssertIntEquals(tc, SEPOL_OK, rc); 1987} 1988 1989void test_cil_copy_node_helper_sens(CuTest *tc) { 1990 char *line[] = {"(", "sensitivity", "s0", ")", NULL}; 1991 1992 struct cil_tree *test_tree; 1993 gen_test_tree(&test_tree, line); 1994 1995 struct cil_db *test_db; 1996 cil_db_init(&test_db); 1997 1998 struct cil_db *test_db2; 1999 cil_db_init(&test_db2); 2000 2001 uint32_t finished = 0; 2002 2003 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 2004 2005 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2006 2007 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 2008 CuAssertIntEquals(tc, finished, 0); 2009 CuAssertIntEquals(tc, SEPOL_OK, rc); 2010} 2011 2012void test_cil_copy_node_helper_sens_merge(CuTest *tc) { 2013 char *line[] = {"(", "sensitivity", "s0", ")", NULL}; 2014 2015 struct cil_tree *test_tree; 2016 gen_test_tree(&test_tree, line); 2017 2018 struct cil_db *test_db; 2019 cil_db_init(&test_db); 2020 2021 uint32_t finished = 0; 2022 2023 struct cil_args_copy *extra_args = gen_copy_args(test_db->ast->root, test_db); 2024 2025 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2026 2027 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 2028 CuAssertIntEquals(tc, finished, 0); 2029 CuAssertIntEquals(tc, SEPOL_OK, rc); 2030} 2031 2032void test_cil_copy_node_helper_sensalias(CuTest *tc) { 2033 char *line[] = {"(", "sensitivityalias", "s0", "alias", ")", NULL}; 2034 2035 struct cil_tree *test_tree; 2036 gen_test_tree(&test_tree, line); 2037 2038 struct cil_db *test_db; 2039 cil_db_init(&test_db); 2040 2041 struct cil_db *test_db2; 2042 cil_db_init(&test_db2); 2043 2044 uint32_t finished = 0; 2045 2046 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 2047 2048 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2049 2050 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 2051 CuAssertIntEquals(tc, finished, 0); 2052 CuAssertIntEquals(tc, SEPOL_OK, rc); 2053} 2054 2055void test_cil_copy_node_helper_sensalias_dup_neg(CuTest *tc) { 2056 char *line[] = {"(", "sensitivityalias", "s0", "alias", ")", NULL}; 2057 2058 struct cil_tree *test_tree; 2059 gen_test_tree(&test_tree, line); 2060 2061 struct cil_db *test_db; 2062 cil_db_init(&test_db); 2063 2064 uint32_t finished = 0; 2065 2066 struct cil_args_copy *extra_args = gen_copy_args(test_db->ast->root, test_db); 2067 2068 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2069 2070 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 2071 CuAssertIntEquals(tc, finished, 0); 2072 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2073} 2074 2075void test_cil_copy_node_helper_cat(CuTest *tc) { 2076 char *line[] = {"(", "category", "c0", ")", NULL}; 2077 2078 struct cil_tree *test_tree; 2079 gen_test_tree(&test_tree, line); 2080 2081 struct cil_db *test_db; 2082 cil_db_init(&test_db); 2083 2084 struct cil_db *test_db2; 2085 cil_db_init(&test_db2); 2086 2087 uint32_t finished = 0; 2088 2089 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 2090 2091 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2092 2093 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 2094 CuAssertIntEquals(tc, finished, 0); 2095 CuAssertIntEquals(tc, SEPOL_OK, rc); 2096} 2097 2098void test_cil_copy_node_helper_cat_merge(CuTest *tc) { 2099 char *line[] = {"(", "category", "c0", ")", NULL}; 2100 2101 struct cil_tree *test_tree; 2102 gen_test_tree(&test_tree, line); 2103 2104 struct cil_db *test_db; 2105 cil_db_init(&test_db); 2106 2107 uint32_t finished = 0; 2108 2109 struct cil_args_copy *extra_args = gen_copy_args(test_db->ast->root, test_db); 2110 2111 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2112 2113 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 2114 CuAssertIntEquals(tc, finished, 0); 2115 CuAssertIntEquals(tc, SEPOL_OK, rc); 2116} 2117 2118void test_cil_copy_node_helper_catalias(CuTest *tc) { 2119 char *line[] = {"(", "categoryalias", "c0", "red", ")", NULL}; 2120 2121 struct cil_tree *test_tree; 2122 gen_test_tree(&test_tree, line); 2123 2124 struct cil_db *test_db; 2125 cil_db_init(&test_db); 2126 2127 struct cil_db *test_db2; 2128 cil_db_init(&test_db2); 2129 2130 uint32_t finished = 0; 2131 2132 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 2133 2134 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2135 2136 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 2137 CuAssertIntEquals(tc, finished, 0); 2138 CuAssertIntEquals(tc, SEPOL_OK, rc); 2139} 2140 2141void test_cil_copy_node_helper_catalias_dup_neg(CuTest *tc) { 2142 char *line[] = {"(", "categoryalias", "c0", "red", ")", NULL}; 2143 2144 struct cil_tree *test_tree; 2145 gen_test_tree(&test_tree, line); 2146 2147 struct cil_db *test_db; 2148 cil_db_init(&test_db); 2149 2150 uint32_t finished = 0; 2151 2152 struct cil_args_copy *extra_args = gen_copy_args(test_db->ast->root, test_db); 2153 2154 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2155 2156 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 2157 CuAssertIntEquals(tc, finished, 0); 2158 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2159} 2160 2161void test_cil_copy_node_helper_senscat(CuTest *tc) { 2162 char *line[] = {"(", "sensitivity", "s0", ")", 2163 "(", "sensitivity", "s1", ")", 2164 "(", "dominance", "(", "s0", "s1", ")", ")", 2165 "(", "category", "c0", ")", 2166 "(", "category", "c255", ")", 2167 "(", "categoryorder", "(", "c0", "c255", ")", ")", 2168 "(", "sensitivitycategory", "s1", "(", "c0", "c255", ")", ")", NULL}; 2169 2170 struct cil_tree *test_tree; 2171 gen_test_tree(&test_tree, line); 2172 2173 struct cil_db *test_db; 2174 cil_db_init(&test_db); 2175 2176 struct cil_db *test_db2; 2177 cil_db_init(&test_db2); 2178 2179 uint32_t finished = 0; 2180 2181 struct cil_senscat *test_senscat; 2182 cil_senscat_init(&test_senscat); 2183 2184 struct cil_tree_node *parent_node; 2185 cil_tree_node_init(&parent_node); 2186 parent_node->flavor = CIL_SENSCAT; 2187 parent_node->data = test_senscat; 2188 2189 struct cil_args_copy *extra_args = gen_copy_args(parent_node, test_db2); 2190 2191 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2192 2193 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next, &finished, extra_args); 2194 CuAssertIntEquals(tc, finished, 0); 2195 CuAssertIntEquals(tc, SEPOL_OK, rc); 2196} 2197 2198void test_cil_copy_node_helper_catorder(CuTest *tc) { 2199 char *line[] = {"(", "category", "c0", ")", 2200 "(", "category", "c255", ")", 2201 "(", "categoryorder", "(", "c0", "c255", ")", ")", NULL}; 2202 2203 struct cil_tree *test_tree; 2204 gen_test_tree(&test_tree, line); 2205 2206 struct cil_db *test_db; 2207 cil_db_init(&test_db); 2208 2209 struct cil_db *test_db2; 2210 cil_db_init(&test_db2); 2211 2212 uint32_t finished = 0; 2213 2214 struct cil_catorder *test_catorder; 2215 cil_catorder_init(&test_catorder); 2216 2217 struct cil_tree_node *parent_node; 2218 cil_tree_node_init(&parent_node); 2219 parent_node->flavor = CIL_CATORDER; 2220 parent_node->data = test_catorder; 2221 2222 struct cil_args_copy *extra_args = gen_copy_args(parent_node, test_db2); 2223 2224 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2225 2226 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head->next->next, &finished, extra_args); 2227 CuAssertIntEquals(tc, finished, 0); 2228 CuAssertIntEquals(tc, SEPOL_OK, rc); 2229} 2230 2231void test_cil_copy_node_helper_dominance(CuTest *tc) { 2232 char *line[] = {"(", "sensitivity", "s0", ")", 2233 "(", "sensitivity", "s1", ")", 2234 "(", "sensitivity", "s2", ")", 2235 "(", "dominance", "(", "s0", "s1", ")", ")", NULL}; 2236 2237 struct cil_tree *test_tree; 2238 gen_test_tree(&test_tree, line); 2239 2240 struct cil_db *test_db; 2241 cil_db_init(&test_db); 2242 2243 struct cil_db *test_db2; 2244 cil_db_init(&test_db2); 2245 2246 uint32_t finished = 0; 2247 2248 struct cil_sens *test_sens; 2249 cil_sens_init(&test_sens); 2250 2251 struct cil_tree_node *parent_node; 2252 cil_tree_node_init(&parent_node); 2253 parent_node->flavor = CIL_SENS; 2254 parent_node->data = test_sens; 2255 2256 struct cil_args_copy *extra_args = gen_copy_args(parent_node, test_db2); 2257 2258 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2259 2260 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, extra_args); 2261 CuAssertIntEquals(tc, finished, 0); 2262 CuAssertIntEquals(tc, SEPOL_OK, rc); 2263} 2264 2265void test_cil_copy_node_helper_level(CuTest *tc) { 2266 char *line[] = {"(", "level", "low", "(", "s0", "(", "c1", ")", ")", ")", NULL}; 2267 2268 struct cil_tree *test_tree; 2269 gen_test_tree(&test_tree, line); 2270 2271 struct cil_db *test_db; 2272 cil_db_init(&test_db); 2273 2274 struct cil_db *test_db2; 2275 cil_db_init(&test_db2); 2276 2277 uint32_t finished = 0; 2278 2279 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 2280 2281 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2282 2283 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 2284 CuAssertIntEquals(tc, finished, 0); 2285 CuAssertIntEquals(tc, SEPOL_OK, rc); 2286} 2287 2288void test_cil_copy_node_helper_level_dup_neg(CuTest *tc) { 2289 char *line[] = {"(", "level", "low", "(", "s0", "(", "c1", ")", ")", ")", NULL}; 2290 2291 struct cil_tree *test_tree; 2292 gen_test_tree(&test_tree, line); 2293 2294 struct cil_db *test_db; 2295 cil_db_init(&test_db); 2296 2297 uint32_t finished = 0; 2298 2299 struct cil_args_copy *extra_args = gen_copy_args(test_db->ast->root, test_db); 2300 2301 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2302 2303 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 2304 CuAssertIntEquals(tc, finished, 0); 2305 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2306} 2307 2308void test_cil_copy_node_helper_context(CuTest *tc) { 2309 char *line[] = {"(", "context", "packet_default", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")", NULL}; 2310 2311 struct cil_tree *test_tree; 2312 gen_test_tree(&test_tree, line); 2313 2314 struct cil_db *test_db; 2315 cil_db_init(&test_db); 2316 2317 struct cil_db *test_db2; 2318 cil_db_init(&test_db2); 2319 2320 uint32_t finished = 0; 2321 2322 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 2323 2324 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2325 2326 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 2327 CuAssertIntEquals(tc, finished, 0); 2328 CuAssertIntEquals(tc, SEPOL_OK, rc); 2329} 2330 2331void test_cil_copy_node_helper_context_dup_neg(CuTest *tc) { 2332 char *line[] = {"(", "context", "packet_default", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")", NULL}; 2333 2334 struct cil_tree *test_tree; 2335 gen_test_tree(&test_tree, line); 2336 2337 struct cil_db *test_db; 2338 cil_db_init(&test_db); 2339 2340 uint32_t finished = 0; 2341 2342 struct cil_args_copy *extra_args = gen_copy_args(test_db->ast->root, test_db); 2343 2344 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2345 2346 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 2347 CuAssertIntEquals(tc, finished, 0); 2348 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2349} 2350 2351void test_cil_copy_node_helper_netifcon(CuTest *tc) { 2352 char *line[] = {"(", "netifcon", "eth0", "if_default", "packet_default", ")", NULL}; 2353 2354 struct cil_tree *test_tree; 2355 gen_test_tree(&test_tree, line); 2356 2357 struct cil_db *test_db; 2358 cil_db_init(&test_db); 2359 2360 struct cil_db *test_db2; 2361 cil_db_init(&test_db2); 2362 2363 uint32_t finished = 0; 2364 2365 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 2366 2367 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2368 2369 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 2370 CuAssertIntEquals(tc, finished, 0); 2371 CuAssertIntEquals(tc, SEPOL_OK, rc); 2372} 2373 2374void test_cil_copy_node_helper_call(CuTest *tc) { 2375 char *line[] = {"(", "call", "mm", "(", "foo", ")", ")", NULL}; 2376 2377 struct cil_tree *test_tree; 2378 gen_test_tree(&test_tree, line); 2379 2380 struct cil_db *test_db; 2381 cil_db_init(&test_db); 2382 2383 struct cil_db *test_db2; 2384 cil_db_init(&test_db2); 2385 2386 uint32_t finished = 0; 2387 2388 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 2389 2390 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2391 2392 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 2393 CuAssertIntEquals(tc, finished, 0); 2394 CuAssertIntEquals(tc, SEPOL_OK, rc); 2395} 2396 2397void test_cil_copy_node_helper_optional(CuTest *tc) { 2398 char *line[] = {"(", "optional", "opt", "(", "allow", "foo", "bar", "(", "file", "(", "read", ")", ")", ")", ")", NULL}; 2399 2400 struct cil_tree *test_tree; 2401 gen_test_tree(&test_tree, line); 2402 2403 struct cil_db *test_db; 2404 cil_db_init(&test_db); 2405 2406 struct cil_db *test_db2; 2407 cil_db_init(&test_db2); 2408 2409 uint32_t finished = 0; 2410 2411 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 2412 2413 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2414 2415 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 2416 CuAssertIntEquals(tc, finished, 0); 2417 CuAssertIntEquals(tc, SEPOL_OK, rc); 2418} 2419 2420void test_cil_copy_node_helper_optional_merge(CuTest *tc) { 2421 char *line[] = {"(", "optional", "opt", "(", "allow", "foo", "bar", "(", "file", "(", "read", ")", ")", ")", ")", NULL}; 2422 2423 struct cil_tree *test_tree; 2424 gen_test_tree(&test_tree, line); 2425 2426 struct cil_db *test_db; 2427 cil_db_init(&test_db); 2428 2429 uint32_t finished = 0; 2430 2431 struct cil_args_copy *extra_args = gen_copy_args(test_db->ast->root, test_db); 2432 2433 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2434 2435 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 2436 CuAssertIntEquals(tc, finished, 0); 2437 CuAssertIntEquals(tc, SEPOL_OK, rc); 2438} 2439 2440void test_cil_copy_node_helper_ipaddr(CuTest *tc) { 2441 char *line[] = {"(", "ipaddr", "ip", "192.168.1.1", ")", NULL}; 2442 2443 struct cil_tree *test_tree; 2444 gen_test_tree(&test_tree, line); 2445 2446 struct cil_db *test_db; 2447 cil_db_init(&test_db); 2448 2449 struct cil_db *test_db2; 2450 cil_db_init(&test_db2); 2451 2452 uint32_t finished = 0; 2453 2454 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 2455 2456 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2457 2458 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 2459 CuAssertIntEquals(tc, finished, 0); 2460 CuAssertIntEquals(tc, SEPOL_OK, rc); 2461} 2462 2463void test_cil_copy_node_helper_ipaddr_dup_neg(CuTest *tc) { 2464 char *line[] = {"(", "ipaddr", "ip", "192.168.1.1", ")", NULL}; 2465 2466 struct cil_tree *test_tree; 2467 gen_test_tree(&test_tree, line); 2468 2469 struct cil_db *test_db; 2470 cil_db_init(&test_db); 2471 2472 uint32_t finished = 0; 2473 2474 struct cil_args_copy *extra_args = gen_copy_args(test_db->ast->root, test_db); 2475 2476 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2477 2478 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 2479 CuAssertIntEquals(tc, finished, 0); 2480 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2481} 2482 2483void test_cil_copy_node_helper_boolif(CuTest *tc) { 2484 char *line[] = {"(", "booleanif", "(", "and", "foo", "bar", ")", 2485 "(", "true", 2486 "(", "allow", "foo", "bar", "(", "file", "(", "read", ")", ")", ")", ")", ")", NULL}; 2487 2488 struct cil_tree *test_tree; 2489 gen_test_tree(&test_tree, line); 2490 2491 struct cil_db *test_db; 2492 cil_db_init(&test_db); 2493 2494 struct cil_db *test_db2; 2495 cil_db_init(&test_db2); 2496 2497 uint32_t finished = 0; 2498 2499 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 2500 2501 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2502 2503 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 2504 CuAssertIntEquals(tc, finished, 0); 2505 CuAssertIntEquals(tc, SEPOL_OK, rc); 2506} 2507 2508void test_cil_copy_node_helper_mlsconstrain(CuTest *tc) { 2509 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "l1", "l2", ")", ")", NULL}; 2510 2511 struct cil_tree *test_tree; 2512 gen_test_tree(&test_tree, line); 2513 2514 struct cil_db *test_db; 2515 cil_db_init(&test_db); 2516 2517 struct cil_db *test_db2; 2518 cil_db_init(&test_db2); 2519 2520 uint32_t finished = 0; 2521 2522 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 2523 2524 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2525 2526 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 2527 CuAssertIntEquals(tc, finished, 0); 2528 CuAssertIntEquals(tc, SEPOL_OK, rc); 2529} 2530 2531void test_cil_copy_node_helper_orignull_neg(CuTest *tc) { 2532 char *line[] = {"(", ")", NULL}; 2533 2534 struct cil_tree *test_tree; 2535 gen_test_tree(&test_tree, line); 2536 2537 struct cil_db *test_db; 2538 cil_db_init(&test_db); 2539 2540 struct cil_db *test_db2; 2541 cil_db_init(&test_db2); 2542 2543 uint32_t finished = 0; 2544 2545 struct cil_args_copy *extra_args = gen_copy_args(test_db2->ast->root, test_db2); 2546 2547 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 2548 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2549} 2550 2551void test_cil_copy_node_helper_extraargsnull_neg(CuTest *tc) { 2552 char *line[] = {"(", "mlsconstrain", "(", "file", "dir", ")", "(", "create", "relabelto", ")", "(", "eq", "l1", "l2", ")", ")", NULL}; 2553 2554 struct cil_tree *test_tree; 2555 gen_test_tree(&test_tree, line); 2556 2557 struct cil_db *test_db; 2558 cil_db_init(&test_db); 2559 2560 struct cil_db *test_db2; 2561 cil_db_init(&test_db2); 2562 2563 struct cil_args_copy *extra_args = NULL; 2564 2565 uint32_t finished = 0; 2566 2567 cil_build_ast(test_db, test_tree->root, test_db->ast->root); 2568 2569 int rc = __cil_copy_node_helper(test_db->ast->root->cl_head, &finished, extra_args); 2570 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2571} 2572