blob: 5debd0d5359c8159c5ce07afdaab19f41553f977 [file] [log] [blame] [edit]
/*
* Copyright 2011 Tresys Technology, LLC. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY TRESYS TECHNOLOGY, LLC ``AS IS'' AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
* EVENT SHALL TRESYS TECHNOLOGY, LLC OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* The views and conclusions contained in the software and documentation are those
* of the authors and should not be interpreted as representing official policies,
* either expressed or implied, of Tresys Technology, LLC.
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "cil_internal.h"
#include "cil_log.h"
#include "cil_mem.h"
#include "cil_tree.h"
#include "cil_list.h"
#include "cil_symtab.h"
#include "cil_copy_ast.h"
#include "cil_build_ast.h"
#include "cil_strpool.h"
struct cil_args_copy {
struct cil_tree_node *dest;
struct cil_db *db;
};
void cil_copy_list(struct cil_list *data, struct cil_list **copy)
{
struct cil_list *new;
struct cil_list_item *orig_item;
cil_list_init(&new, data->flavor);
cil_list_for_each(orig_item, data) {
switch (orig_item->flavor) {
case CIL_STRING:
cil_list_append(new, CIL_STRING, orig_item->data);
break;
case CIL_LIST: {
struct cil_list *new_sub = NULL;
cil_copy_list((struct cil_list*)orig_item->data, &new_sub);
cil_list_append(new, CIL_LIST, new_sub);
break;
}
case CIL_PARAM: {
struct cil_param *po = orig_item->data;
struct cil_param *pn;
cil_param_init(&pn);
pn->str = po->str;
pn->flavor = po->flavor;
cil_list_append(new, CIL_PARAM, pn);
}
break;
default:
cil_list_append(new, orig_item->flavor, orig_item->data);
break;
}
}
*copy = new;
}
int cil_copy_node(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
char *new = NULL;
if (data != NULL) {
new = data;
}
*copy = new;
return SEPOL_OK;
}
int cil_copy_block(__attribute__((unused)) struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_block *orig = data;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
cil_symtab_get_datum(symtab, key, &datum);
if (datum == NULL) {
struct cil_block *new;
cil_block_init(&new);
*copy = new;
} else {
*copy = datum;;
}
return SEPOL_OK;
}
int cil_copy_blockabstract(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_blockabstract *orig = data;
struct cil_blockabstract *new = NULL;
cil_blockabstract_init(&new);
new->block_str = orig->block_str;
*copy = new;
return SEPOL_OK;
}
int cil_copy_blockinherit(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_blockinherit *orig = data;
struct cil_blockinherit *new = NULL;
cil_blockinherit_init(&new);
new->block_str = orig->block_str;
new->block = orig->block;
*copy = new;
return SEPOL_OK;
}
int cil_copy_policycap(__attribute__((unused)) struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_policycap *orig = data;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
cil_symtab_get_datum(symtab, key, &datum);
if (datum == NULL) {
struct cil_policycap *new;
cil_policycap_init(&new);
*copy = new;
} else {
*copy = datum;
}
return SEPOL_OK;
}
int cil_copy_perm(__attribute__((unused)) struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_perm *orig = data;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
cil_symtab_get_datum(symtab, key, &datum);
if (datum == NULL) {
struct cil_perm *new;
cil_perm_init(&new);
*copy = new;
} else {
*copy = datum;
}
return SEPOL_OK;
}
void cil_copy_classperms(struct cil_classperms *orig, struct cil_classperms **new)
{
cil_classperms_init(new);
(*new)->class_str = orig->class_str;
cil_copy_list(orig->perm_strs, &((*new)->perm_strs));
}
void cil_copy_classperms_set(struct cil_classperms_set *orig, struct cil_classperms_set **new)
{
cil_classperms_set_init(new);
(*new)->set_str = orig->set_str;
}
void cil_copy_classperms_list(struct cil_list *orig, struct cil_list **new)
{
struct cil_list_item *orig_item;
if (orig == NULL) {
return;
}
cil_list_init(new, CIL_LIST_ITEM);
cil_list_for_each(orig_item, orig) {
if (orig_item->flavor == CIL_CLASSPERMS) {
struct cil_classperms *cp;
cil_copy_classperms(orig_item->data, &cp);
cil_list_append(*new, CIL_CLASSPERMS, cp);
} else {
struct cil_classperms_set *cp_set;
cil_copy_classperms_set(orig_item->data, &cp_set);
cil_list_append(*new, CIL_CLASSPERMS_SET, cp_set);
}
}
}
int cil_copy_classmapping(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_classmapping *orig = data;
struct cil_classmapping *new = NULL;
cil_classmapping_init(&new);
new->map_class_str = orig->map_class_str;
new->map_perm_str = orig->map_perm_str;
cil_copy_classperms_list(orig->classperms, &new->classperms);
*copy = new;
return SEPOL_OK;
}
int cil_copy_class(__attribute__((unused)) struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_class *orig = data;
struct cil_class *new = NULL;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
cil_symtab_get_datum(symtab, key, &datum);
if (datum != NULL) {
cil_log(CIL_INFO, "cil_copy_class: class cannot be redefined\n");
return SEPOL_ERR;
}
cil_class_init(&new);
new->common = NULL;
*copy = new;
return SEPOL_OK;
}
int cil_copy_classorder(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_classorder *orig = data;
struct cil_classorder *new = NULL;
cil_classorder_init(&new);
if (orig->class_list_str != NULL) {
cil_copy_list(orig->class_list_str, &new->class_list_str);
}
*copy = new;
return SEPOL_OK;
}
int cil_copy_classpermission(__attribute__((unused)) struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_classpermission *orig = data;
struct cil_classpermission *new = NULL;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
if (key != NULL) {
cil_symtab_get_datum(symtab, key, &datum);
if (datum != NULL) {
cil_log(CIL_INFO, "classpermission cannot be redefined\n");
return SEPOL_ERR;
}
}
cil_classpermission_init(&new);
cil_copy_classperms_list(orig->classperms, &new->classperms);
*copy = new;
return SEPOL_OK;
}
int cil_copy_classpermissionset(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_classpermissionset *orig = data;
struct cil_classpermissionset *new = NULL;
cil_classpermissionset_init(&new);
new->set_str = orig->set_str;
cil_copy_classperms_list(orig->classperms, &new->classperms);
*copy = new;
return SEPOL_OK;
}
int cil_copy_classcommon(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_classcommon *orig = data;
struct cil_classcommon *new = NULL;
cil_classcommon_init(&new);
new->class_str = orig->class_str;
new->common_str = orig->common_str;
*copy = new;
return SEPOL_OK;
}
int cil_copy_sid(__attribute__((unused)) struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_sid *orig = data;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
cil_symtab_get_datum(symtab, key, &datum);
if (datum == NULL) {
struct cil_sid *new;
cil_sid_init(&new);
*copy = new;
} else {
*copy = datum;
}
return SEPOL_OK;
}
int cil_copy_sidcontext(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_sidcontext *orig = data;
struct cil_sidcontext *new = NULL;
cil_sidcontext_init(&new);
if (orig->context_str != NULL) {
new->context_str = orig->context_str;
} else {
cil_context_init(&new->context);
cil_copy_fill_context(db, orig->context, new->context);
}
*copy = new;
return SEPOL_OK;
}
int cil_copy_sidorder(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_sidorder *orig = data;
struct cil_sidorder *new = NULL;
cil_sidorder_init(&new);
if (orig->sid_list_str != NULL) {
cil_copy_list(orig->sid_list_str, &new->sid_list_str);
}
*copy = new;
return SEPOL_OK;
}
int cil_copy_user(__attribute__((unused)) struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_user *orig = data;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
cil_symtab_get_datum(symtab, key, &datum);
if (datum == NULL) {
struct cil_user *new;
cil_user_init(&new);
*copy = new;
} else {
*copy = datum;
}
return SEPOL_OK;
}
int cil_copy_userattribute(__attribute__((unused)) struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_userattribute *orig = data;
struct cil_userattribute *new = NULL;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
cil_symtab_get_datum(symtab, key, &datum);
if (datum == NULL) {
cil_userattribute_init(&new);
*copy = new;
} else {
*copy = datum;
}
return SEPOL_OK;
}
int cil_copy_userattributeset(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_userattributeset *orig = data;
struct cil_userattributeset *new = NULL;
cil_userattributeset_init(&new);
new->attr_str = orig->attr_str;
cil_copy_expr(db, orig->str_expr, &new->str_expr);
cil_copy_expr(db, orig->datum_expr, &new->datum_expr);
*copy = new;
return SEPOL_OK;
}
int cil_copy_userrole(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_userrole *orig = data;
struct cil_userrole *new = NULL;
cil_userrole_init(&new);
new->user_str = orig->user_str;
new->role_str = orig->role_str;
*copy = new;
return SEPOL_OK;
}
int cil_copy_userlevel(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_userlevel *orig = data;
struct cil_userlevel *new = NULL;
cil_userlevel_init(&new);
new->user_str = orig->user_str;
if (orig->level_str != NULL) {
new->level_str = orig->level_str;
} else {
cil_copy_fill_level(db, orig->level, &new->level);
}
*copy = new;
return SEPOL_OK;
}
int cil_copy_userrange(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_userrange *orig = data;
struct cil_userrange *new = NULL;
cil_userrange_init(&new);
new->user_str = orig->user_str;
if (orig->range_str != NULL) {
new->range_str = orig->range_str;
} else {
cil_levelrange_init(&new->range);
cil_copy_fill_levelrange(db, orig->range, new->range);
}
*copy = new;
return SEPOL_OK;
}
int cil_copy_userprefix(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_userprefix *orig = data;
struct cil_userprefix *new = NULL;
cil_userprefix_init(&new);
new->user_str = orig->user_str;
new->prefix_str = orig->prefix_str;
*copy = new;
return SEPOL_OK;
}
int cil_copy_role(__attribute__((unused)) struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_role *orig = data;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
cil_symtab_get_datum(symtab, key, &datum);
if (datum == NULL) {
struct cil_role *new;
cil_role_init(&new);
*copy = new;
} else {
*copy = datum;
}
return SEPOL_OK;
}
int cil_copy_roletype(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_roletype *orig = data;
struct cil_roletype *new = NULL;
cil_roletype_init(&new);
new->role_str = orig->role_str;
new->type_str = orig->type_str;
*copy = new;
return SEPOL_OK;
}
int cil_copy_roleattribute(__attribute__((unused)) struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_roleattribute *orig = data;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
cil_symtab_get_datum(symtab, key, &datum);
if (datum == NULL) {
struct cil_roleattribute *new;
cil_roleattribute_init(&new);
*copy = new;
} else {
*copy = datum;
}
return SEPOL_OK;
}
int cil_copy_roleattributeset(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_roleattributeset *orig = data;
struct cil_roleattributeset *new = NULL;
cil_roleattributeset_init(&new);
new->attr_str = orig->attr_str;
cil_copy_expr(db, orig->str_expr, &new->str_expr);
cil_copy_expr(db, orig->datum_expr, &new->datum_expr);
*copy = new;
return SEPOL_OK;
}
int cil_copy_roleallow(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_roleallow *orig = data;
struct cil_roleallow *new = NULL;
cil_roleallow_init(&new);
new->src_str = orig->src_str;
new->tgt_str = orig->tgt_str;
*copy = new;
return SEPOL_OK;
}
int cil_copy_type(__attribute__((unused)) struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_type *orig = data;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
cil_symtab_get_datum(symtab, key, &datum);
if (datum == NULL) {
struct cil_type *new;
cil_type_init(&new);
*copy = new;
} else {
*copy = datum;
}
return SEPOL_OK;
}
int cil_copy_typepermissive(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_typepermissive *orig = data;
struct cil_typepermissive *new = NULL;
cil_typepermissive_init(&new);
new->type_str = orig->type_str;
*copy = new;
return SEPOL_OK;
}
int cil_copy_typeattribute(__attribute__((unused)) struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_typeattribute *orig = data;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
cil_symtab_get_datum(symtab, key, &datum);
if (datum == NULL) {
struct cil_typeattribute *new;
cil_typeattribute_init(&new);
*copy = new;
} else {
*copy = datum;
}
return SEPOL_OK;
}
int cil_copy_typeattributeset(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_typeattributeset *orig = data;
struct cil_typeattributeset *new = NULL;
cil_typeattributeset_init(&new);
new->attr_str = orig->attr_str;
cil_copy_expr(db, orig->str_expr, &new->str_expr);
cil_copy_expr(db, orig->datum_expr, &new->datum_expr);
*copy = new;
return SEPOL_OK;
}
int cil_copy_alias(__attribute__((unused)) struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_alias *orig = data;
struct cil_alias *new = NULL;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
cil_symtab_get_datum(symtab, key, &datum);
if (datum != NULL) {
cil_log(CIL_INFO, "cil_copy_alias: alias cannot be redefined\n");
return SEPOL_ERR;
}
cil_alias_init(&new);
*copy = new;
return SEPOL_OK;
}
int cil_copy_aliasactual(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused))symtab_t *symtab)
{
struct cil_aliasactual *orig = data;
struct cil_aliasactual *new = NULL;
cil_aliasactual_init(&new);
new->alias_str = orig->alias_str;
new->actual_str = orig->actual_str;
*copy = new;
return SEPOL_OK;
}
int cil_copy_roletransition(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_roletransition *orig = data;
struct cil_roletransition *new = NULL;
cil_roletransition_init(&new);
new->src_str = orig->src_str;
new->tgt_str = orig->tgt_str;
new->obj_str = orig->obj_str;
new->result_str = orig->result_str;
*copy = new;
return SEPOL_OK;
}
int cil_copy_nametypetransition(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_nametypetransition *orig = data;
struct cil_nametypetransition *new = NULL;
cil_nametypetransition_init(&new);
new->src_str = orig->src_str;
new->tgt_str = orig->tgt_str;
new->obj_str = orig->obj_str;
new->name_str = orig->name_str;
new->result_str = orig->result_str;
*copy = new;
return SEPOL_OK;
}
int cil_copy_rangetransition(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_rangetransition *orig = data;
struct cil_rangetransition *new = NULL;
cil_rangetransition_init(&new);
new->src_str = orig->src_str;
new->exec_str = orig->exec_str;
new->obj_str = orig->obj_str;
if (orig->range_str != NULL) {
new->range_str = orig->range_str;
} else {
cil_levelrange_init(&new->range);
cil_copy_fill_levelrange(db, orig->range, new->range);
}
*copy = new;
return SEPOL_OK;
}
int cil_copy_bool(__attribute__((unused)) struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_bool *orig = data;
struct cil_bool *new = NULL;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
cil_symtab_get_datum(symtab, key, &datum);
if (datum != NULL) {
cil_log(CIL_INFO, "cil_copy_bool: boolean cannot be redefined\n");
return SEPOL_ERR;
}
cil_bool_init(&new);
new->value = orig->value;
*copy = new;
return SEPOL_OK;
}
int cil_copy_tunable(__attribute__((unused)) struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_tunable *orig = data;
struct cil_tunable *new = NULL;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
cil_symtab_get_datum(symtab, key, &datum);
if (datum != NULL) {
cil_log(CIL_INFO, "cil_copy_tunable: tunable cannot be redefined\n");
return SEPOL_ERR;
}
cil_tunable_init(&new);
new->value = orig->value;
*copy = new;
return SEPOL_OK;
}
void cil_copy_fill_permissionx(struct cil_db *db, struct cil_permissionx *orig, struct cil_permissionx *new)
{
new->kind = orig->kind;
new->obj_str = orig->obj_str;
cil_copy_expr(db, orig->expr_str, &new->expr_str);
}
int cil_copy_avrule(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_avrule *orig = data;
struct cil_avrule *new = NULL;
cil_avrule_init(&new);
new->is_extended = orig->is_extended;
new->rule_kind = orig->rule_kind;
new->src_str = orig->src_str;
new->tgt_str = orig->tgt_str;
if (!new->is_extended) {
cil_copy_classperms_list(orig->perms.classperms, &new->perms.classperms);
} else {
if (new->perms.x.permx_str != NULL) {
new->perms.x.permx_str = orig->perms.x.permx_str;
} else {
cil_permissionx_init(&new->perms.x.permx);
cil_copy_fill_permissionx(db, orig->perms.x.permx, new->perms.x.permx);
}
}
*copy = new;
return SEPOL_OK;
}
int cil_copy_permissionx(struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_permissionx *orig = data;
struct cil_permissionx *new = NULL;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
cil_symtab_get_datum(symtab, key, &datum);
if (datum != NULL) {
cil_log(CIL_INFO, "cil_copy_permissionx: permissionx cannot be redefined\n");
return SEPOL_ERR;
}
cil_permissionx_init(&new);
cil_copy_fill_permissionx(db, orig, new);
*copy = new;
return SEPOL_OK;
}
int cil_copy_type_rule(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_type_rule *orig = data;
struct cil_type_rule *new = NULL;
cil_type_rule_init(&new);
new->rule_kind = orig->rule_kind;
new->src_str = orig->src_str;
new->tgt_str = orig->tgt_str;
new->obj_str = orig->obj_str;
new->result_str = orig->result_str;
*copy = new;
return SEPOL_OK;
}
int cil_copy_sens(__attribute__((unused)) struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_sens *orig = data;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
cil_symtab_get_datum(symtab, key, &datum);
if (datum == NULL) {
struct cil_sens *new;
cil_sens_init(&new);
*copy = new;
} else {
*copy = datum;
}
return SEPOL_OK;
}
int cil_copy_cat(__attribute__((unused)) struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_cat *orig = data;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
cil_symtab_get_datum(symtab, key, &datum);
if (datum == NULL) {
struct cil_cat *new;
cil_cat_init(&new);
*copy = new;
} else {
*copy = datum;
}
return SEPOL_OK;
}
void cil_copy_cats(struct cil_db *db, struct cil_cats *orig, struct cil_cats **new)
{
cil_cats_init(new);
cil_copy_expr(db, orig->str_expr, &(*new)->str_expr);
cil_copy_expr(db, orig->datum_expr, &(*new)->datum_expr);
}
int cil_copy_catset(struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_catset *orig = data;
struct cil_catset *new = NULL;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
cil_symtab_get_datum(symtab, key, &datum);
if (datum != NULL) {
cil_log(CIL_INFO, "cil_copy_catset: categoryset cannot be redefined\n");
return SEPOL_ERR;
}
cil_catset_init(&new);
cil_copy_cats(db, orig->cats, &new->cats);
*copy = new;
return SEPOL_OK;
}
int cil_copy_senscat(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_senscat *orig = data;
struct cil_senscat *new = NULL;
cil_senscat_init(&new);
new->sens_str = orig->sens_str;
cil_copy_cats(db, orig->cats, &new->cats);
*copy = new;
return SEPOL_OK;
}
int cil_copy_catorder(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_catorder *orig = data;
struct cil_catorder *new = NULL;
cil_catorder_init(&new);
if (orig->cat_list_str != NULL) {
cil_copy_list(orig->cat_list_str, &new->cat_list_str);
}
*copy = new;
return SEPOL_OK;
}
int cil_copy_sensitivityorder(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_sensorder *orig = data;
struct cil_sensorder *new = NULL;
cil_sensorder_init(&new);
if (orig->sens_list_str != NULL) {
cil_copy_list(orig->sens_list_str, &new->sens_list_str);
}
*copy = new;
return SEPOL_OK;
}
void cil_copy_fill_level(struct cil_db *db, struct cil_level *orig, struct cil_level **new)
{
cil_level_init(new);
(*new)->sens_str = orig->sens_str;
if (orig->cats != NULL) {
cil_copy_cats(db, orig->cats, &(*new)->cats);
}
}
int cil_copy_level(struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_level *orig = data;
struct cil_level *new = NULL;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
if (key != NULL) {
cil_symtab_get_datum(symtab, key, &datum);
if (datum != NULL) {
cil_log(CIL_INFO, "cil_copy_level: level cannot be redefined\n");
return SEPOL_ERR;
}
}
cil_copy_fill_level(db, orig, &new);
*copy = new;
return SEPOL_OK;
}
void cil_copy_fill_levelrange(struct cil_db *db, struct cil_levelrange *data, struct cil_levelrange *new)
{
if (data->low_str != NULL) {
new->low_str = data->low_str;
} else {
cil_copy_fill_level(db, data->low, &new->low);
}
if (data->high_str != NULL) {
new->high_str = data->high_str;
} else {
cil_copy_fill_level(db, data->high, &new->high);
}
}
int cil_copy_levelrange(struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_levelrange *orig = data;
struct cil_levelrange *new = NULL;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
if (key != NULL) {
cil_symtab_get_datum(symtab, key, &datum);
if (datum != NULL) {
cil_log(CIL_INFO, "cil_copy_levelrange: levelrange cannot be redefined\n");
return SEPOL_ERR;
}
}
cil_levelrange_init(&new);
cil_copy_fill_levelrange(db, orig, new);
*copy = new;
return SEPOL_OK;
}
void cil_copy_fill_context(struct cil_db *db, struct cil_context *data, struct cil_context *new)
{
new->user_str = data->user_str;
new->role_str = data->role_str;
new->type_str = data->type_str;
if (data->range_str != NULL) {
new->range_str = data->range_str;
} else {
cil_levelrange_init(&new->range);
cil_copy_fill_levelrange(db, data->range, new->range);
}
}
int cil_copy_context(struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_context *orig = data;
struct cil_context *new = NULL;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
if (key != NULL) {
cil_symtab_get_datum(symtab, key, &datum);
if (datum != NULL) {
cil_log(CIL_INFO, "cil_copy_context: context cannot be redefined\n");
return SEPOL_ERR;
}
}
cil_context_init(&new);
cil_copy_fill_context(db, orig, new);
*copy = new;
return SEPOL_OK;
}
int cil_copy_netifcon(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_netifcon *orig = data;
struct cil_netifcon *new = NULL;
cil_netifcon_init(&new);
new->interface_str = orig->interface_str;
if (orig->if_context_str != NULL) {
new->if_context_str = orig->if_context_str;
} else {
cil_context_init(&new->if_context);
cil_copy_fill_context(db, orig->if_context, new->if_context);
}
if (orig->packet_context_str != NULL) {
new->packet_context_str = orig->packet_context_str;
} else {
cil_context_init(&new->packet_context);
cil_copy_fill_context(db, orig->packet_context, new->packet_context);
}
*copy = new;
return SEPOL_OK;
}
int cil_copy_genfscon(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_genfscon *orig = data;
struct cil_genfscon *new = NULL;
cil_genfscon_init(&new);
new->fs_str = orig->fs_str;
new->path_str = orig->path_str;
if (orig->context_str != NULL) {
new->context_str = orig->context_str;
} else {
cil_context_init(&new->context);
cil_copy_fill_context(db, orig->context, new->context);
}
*copy = new;
return SEPOL_OK;
}
int cil_copy_filecon(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_filecon *orig = data;
struct cil_filecon *new = NULL;
cil_filecon_init(&new);
new->path_str = orig->path_str;
new->type = orig->type;
if (orig->context_str != NULL) {
new->context_str = orig->context_str;
} else if (orig->context != NULL) {
cil_context_init(&new->context);
cil_copy_fill_context(db, orig->context, new->context);
}
*copy = new;
return SEPOL_OK;
}
int cil_copy_nodecon(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_nodecon *orig = data;
struct cil_nodecon *new = NULL;
cil_nodecon_init(&new);
if (orig->addr_str != NULL) {
new->addr_str = orig->addr_str;
} else {
cil_ipaddr_init(&new->addr);
cil_copy_fill_ipaddr(orig->addr, new->addr);
}
if (orig->mask_str != NULL) {
new->mask_str = orig->mask_str;
} else {
cil_ipaddr_init(&new->mask);
cil_copy_fill_ipaddr(orig->mask, new->mask);
}
if (orig->context_str != NULL) {
new->context_str = orig->context_str;
} else {
cil_context_init(&new->context);
cil_copy_fill_context(db, orig->context, new->context);
}
*copy = new;
return SEPOL_OK;
}
int cil_copy_portcon(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_portcon *orig = data;
struct cil_portcon *new = NULL;
cil_portcon_init(&new);
new->proto = orig->proto;
new->port_low = orig->port_low;
new->port_high = orig->port_high;
if (orig->context_str != NULL) {
new->context_str = orig->context_str;
} else {
cil_context_init(&new->context);
cil_copy_fill_context(db, orig->context, new->context);
}
*copy = new;
return SEPOL_OK;
}
int cil_copy_pirqcon(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_pirqcon *orig = data;
struct cil_pirqcon *new = NULL;
cil_pirqcon_init(&new);
new->pirq = orig->pirq;
if (orig->context_str != NULL) {
new->context_str = orig->context_str;
} else {
cil_context_init(&new->context);
cil_copy_fill_context(db, orig->context, new->context);
}
*copy = new;
return SEPOL_OK;
}
int cil_copy_iomemcon(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_iomemcon *orig = data;
struct cil_iomemcon *new = NULL;
cil_iomemcon_init(&new);
new->iomem_low = orig->iomem_low;
new->iomem_high = orig->iomem_high;
if (orig->context_str != NULL) {
new->context_str = orig->context_str;
} else {
cil_context_init(&new->context);
cil_copy_fill_context(db, orig->context, new->context);
}
*copy = new;
return SEPOL_OK;
}
int cil_copy_ioportcon(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_ioportcon *orig = data;
struct cil_ioportcon *new = NULL;
cil_ioportcon_init(&new);
new->ioport_low = orig->ioport_low;
new->ioport_high = orig->ioport_high;
if (orig->context_str != NULL) {
new->context_str = orig->context_str;
} else {
cil_context_init(&new->context);
cil_copy_fill_context(db, orig->context, new->context);
}
*copy = new;
return SEPOL_OK;
}
int cil_copy_pcidevicecon(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_pcidevicecon *orig = data;
struct cil_pcidevicecon *new = NULL;
cil_pcidevicecon_init(&new);
new->dev = orig->dev;
if (orig->context_str != NULL) {
new->context_str = orig->context_str;
} else {
cil_context_init(&new->context);
cil_copy_fill_context(db, orig->context, new->context);
}
*copy = new;
return SEPOL_OK;
}
int cil_copy_devicetreecon(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_devicetreecon *orig = data;
struct cil_devicetreecon *new = NULL;
cil_devicetreecon_init(&new);
new->path = orig->path;
if (orig->context_str != NULL) {
new->context_str = orig->context_str;
} else {
cil_context_init(&new->context);
cil_copy_fill_context(db, orig->context, new->context);
}
*copy = new;
return SEPOL_OK;
}
int cil_copy_fsuse(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_fsuse *orig = data;
struct cil_fsuse *new = NULL;
cil_fsuse_init(&new);
new->type = orig->type;
new->fs_str = orig->fs_str;
if (orig->context_str != NULL) {
new->context_str = orig->context_str;
} else {
cil_context_init(&new->context);
cil_copy_fill_context(db, orig->context, new->context);
}
*copy = new;
return SEPOL_OK;
}
int cil_copy_expr(struct cil_db *db, struct cil_list *orig, struct cil_list **new)
{
struct cil_list_item *curr;
if (orig == NULL) {
*new = NULL;
return SEPOL_OK;
}
cil_list_init(new, orig->flavor);
cil_list_for_each(curr, orig) {
switch (curr->flavor) {
case CIL_LIST: {
struct cil_list *sub_list;
cil_copy_expr(db, curr->data, &sub_list);
cil_list_append(*new, CIL_LIST, sub_list);
break;
}
case CIL_STRING:
cil_list_append(*new, CIL_STRING, curr->data);
break;
case CIL_DATUM:
cil_list_append(*new, curr->flavor, curr->data);
break;
case CIL_OP:
cil_list_append(*new, curr->flavor, curr->data);
break;
case CIL_CONS_OPERAND:
cil_list_append(*new, curr->flavor, curr->data);
break;
default:
cil_log(CIL_INFO, "Unknown flavor %d in expression being copied\n",curr->flavor);
cil_list_append(*new, curr->flavor, curr->data);
break;
}
}
return SEPOL_OK;
}
int cil_copy_constrain(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_constrain *orig = data;
struct cil_constrain *new = NULL;
cil_constrain_init(&new);
cil_copy_classperms_list(orig->classperms, &new->classperms);
cil_copy_expr(db, orig->str_expr, &new->str_expr);
cil_copy_expr(db, orig->datum_expr, &new->datum_expr);
*copy = new;
return SEPOL_OK;
}
int cil_copy_validatetrans(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_validatetrans *orig = data;
struct cil_validatetrans *new = NULL;
cil_validatetrans_init(&new);
new->class_str = orig->class_str;
cil_copy_expr(db, orig->str_expr, &new->str_expr);
cil_copy_expr(db, orig->datum_expr, &new->datum_expr);
*copy = new;
return SEPOL_OK;
}
int cil_copy_call(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_call *orig = data;
struct cil_call *new = NULL;
int rc = SEPOL_ERR;
cil_call_init(&new);
new->macro_str = orig->macro_str;
new->macro = orig->macro;
if (orig->args_tree != NULL) {
cil_tree_init(&new->args_tree);
rc = cil_copy_ast(db, orig->args_tree->root, new->args_tree->root);
if (rc != SEPOL_OK) {
goto exit;
}
}
new->copied = orig->copied;
*copy = new;
return SEPOL_OK;
exit:
cil_destroy_call(new);
return rc;
}
int cil_copy_macro(__attribute__((unused)) struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_macro *orig = data;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
cil_symtab_get_datum(symtab, key, &datum);
if (datum == NULL) {
struct cil_macro *new;
cil_macro_init(&new);
if (orig->params != NULL) {
cil_copy_list(orig->params, &new->params);
}
*copy = new;
} else {
struct cil_list_item *curr_orig = NULL;
struct cil_list_item *curr_new = NULL;
struct cil_param *param_orig = NULL;
struct cil_param *param_new = NULL;
if (((struct cil_macro*)datum)->params != NULL) {
curr_new = ((struct cil_macro*)datum)->params->head;
}
if (orig->params != NULL) {
curr_orig = orig->params->head;
}
if (curr_orig != NULL && curr_new != NULL) {
while (curr_orig != NULL) {
if (curr_new == NULL) {
goto exit;
}
param_orig = (struct cil_param*)curr_orig->data;
param_new = (struct cil_param*)curr_new->data;
if (param_orig->str != param_new->str) {
goto exit;
} else if (param_orig->flavor != param_new->flavor) {
goto exit;
}
curr_orig = curr_orig->next;
curr_new = curr_new->next;
}
if (curr_new != NULL) {
goto exit;
}
} else if (!(curr_orig == NULL && curr_new == NULL)) {
goto exit;
}
*copy = datum;
}
return SEPOL_OK;
exit:
cil_log(CIL_INFO, "cil_copy_macro: macro cannot be redefined\n");
return SEPOL_ERR;
}
int cil_copy_optional(__attribute__((unused)) struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_optional *orig = data;
char *key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
cil_symtab_get_datum(symtab, key, &datum);
if (datum == NULL) {
struct cil_optional *new;
cil_optional_init(&new);
*copy = new;
} else {
*copy = datum;
}
return SEPOL_OK;
}
void cil_copy_fill_ipaddr(struct cil_ipaddr *data, struct cil_ipaddr *new)
{
new->family = data->family;
memcpy(&new->ip, &data->ip, sizeof(data->ip));
}
int cil_copy_ipaddr(__attribute__((unused)) struct cil_db *db, void *data, void **copy, symtab_t *symtab)
{
struct cil_ipaddr *orig = data;
struct cil_ipaddr *new = NULL;
char * key = orig->datum.name;
struct cil_symtab_datum *datum = NULL;
cil_symtab_get_datum(symtab, key, &datum);
if (datum != NULL) {
cil_log(CIL_INFO, "cil_copy_ipaddr: ipaddress cannot be redefined\n");
return SEPOL_ERR;
}
cil_ipaddr_init(&new);
cil_copy_fill_ipaddr(orig, new);
*copy = new;
return SEPOL_OK;
}
int cil_copy_condblock(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_condblock *orig = data;
struct cil_condblock *new = *copy;
cil_condblock_init(&new);
new->flavor = orig->flavor;
*copy = new;
return SEPOL_OK;
}
int cil_copy_boolif(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_booleanif *orig = data;
struct cil_booleanif *new = NULL;
cil_boolif_init(&new);
cil_copy_expr(db, orig->str_expr, &new->str_expr);
cil_copy_expr(db, orig->datum_expr, &new->datum_expr);
new->preserved_tunable = orig->preserved_tunable;
*copy = new;
return SEPOL_OK;
}
int cil_copy_tunif(struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_tunableif *orig = data;
struct cil_tunableif *new = NULL;
cil_tunif_init(&new);
cil_copy_expr(db, orig->str_expr, &new->str_expr);
cil_copy_expr(db, orig->datum_expr, &new->datum_expr);
*copy = new;
return SEPOL_OK;
}
int cil_copy_default(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_default *orig = data;
struct cil_default *new = NULL;
cil_default_init(&new);
new->flavor = orig->flavor;
if (orig->class_strs != NULL) {
cil_copy_list(orig->class_strs, &new->class_strs);
}
new->object = orig->object;
*copy = new;
return SEPOL_OK;
}
int cil_copy_defaultrange(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_defaultrange *orig = data;
struct cil_defaultrange *new = NULL;
cil_defaultrange_init(&new);
if (orig->class_strs != NULL) {
cil_copy_list(orig->class_strs, &new->class_strs);
}
new->object_range = orig->object_range;
*copy = new;
return SEPOL_OK;
}
int cil_copy_handleunknown(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_handleunknown *orig = data;
struct cil_handleunknown *new = NULL;
cil_handleunknown_init(&new);
new->handle_unknown = orig->handle_unknown;
*copy = new;
return SEPOL_OK;
}
int cil_copy_mls(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_mls *orig = data;
struct cil_mls *new = NULL;
cil_mls_init(&new);
new->value = orig->value;
*copy = new;
return SEPOL_OK;
}
int cil_copy_bounds(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_bounds *orig = data;
struct cil_bounds *new = NULL;
cil_bounds_init(&new);
new->parent_str = orig->parent_str;
new->child_str = orig->child_str;
*copy = new;
return SEPOL_OK;
}
int cil_copy_src_info(__attribute__((unused)) struct cil_db *db, void *data, void **copy, __attribute__((unused)) symtab_t *symtab)
{
struct cil_src_info *orig = data;
struct cil_src_info *new = NULL;
cil_src_info_init(&new);
new->is_cil = orig->is_cil;
new->path = orig->path;
*copy = new;
return SEPOL_OK;
}
int __cil_copy_node_helper(struct cil_tree_node *orig, __attribute__((unused)) uint32_t *finished, void *extra_args)
{
int rc = SEPOL_ERR;
struct cil_tree_node *parent = NULL;
struct cil_tree_node *new = NULL;
struct cil_db *db = NULL;
struct cil_args_copy *args = NULL;
struct cil_tree_node *namespace = NULL;
struct cil_param *param = NULL;
enum cil_sym_index sym_index = CIL_SYM_UNKNOWN;
symtab_t *symtab = NULL;
void *data = NULL;
int (*copy_func)(struct cil_db *db, void *data, void **copy, symtab_t *symtab) = NULL;
struct cil_blockinherit *blockinherit = NULL;
if (orig == NULL || extra_args == NULL) {
goto exit;
}
args = extra_args;
parent = args->dest;
db = args->db;
switch (orig->flavor) {
case CIL_BLOCK:
copy_func = &cil_copy_block;
break;
case CIL_BLOCKABSTRACT:
copy_func = &cil_copy_blockabstract;
break;
case CIL_BLOCKINHERIT:
copy_func = &cil_copy_blockinherit;
break;
case CIL_POLICYCAP:
copy_func = &cil_copy_policycap;
break;
case CIL_PERM:
case CIL_MAP_PERM:
copy_func = &cil_copy_perm;
break;
case CIL_CLASSMAPPING:
copy_func = &cil_copy_classmapping;
break;
case CIL_CLASS:
case CIL_COMMON:
case CIL_MAP_CLASS:
copy_func = &cil_copy_class;
break;
case CIL_CLASSORDER:
copy_func = &cil_copy_classorder;
break;
case CIL_CLASSPERMISSION:
copy_func = &cil_copy_classpermission;
break;
case CIL_CLASSPERMISSIONSET:
copy_func = &cil_copy_classpermissionset;
break;
case CIL_CLASSCOMMON:
copy_func = &cil_copy_classcommon;
break;
case CIL_SID:
copy_func = &cil_copy_sid;
break;
case CIL_SIDCONTEXT:
copy_func = &cil_copy_sidcontext;
break;
case CIL_SIDORDER:
copy_func = &cil_copy_sidorder;
break;
case CIL_USER:
copy_func = &cil_copy_user;
break;
case CIL_USERATTRIBUTE:
copy_func = &cil_copy_userattribute;
break;
case CIL_USERATTRIBUTESET:
copy_func = &cil_copy_userattributeset;
break;
case CIL_USERROLE:
copy_func = &cil_copy_userrole;
break;
case CIL_USERLEVEL:
copy_func = &cil_copy_userlevel;
break;
case CIL_USERRANGE:
copy_func = &cil_copy_userrange;
break;
case CIL_USERBOUNDS:
copy_func = &cil_copy_bounds;
break;
case CIL_USERPREFIX:
copy_func = &cil_copy_userprefix;
break;
case CIL_ROLE:
copy_func = &cil_copy_role;
break;
case CIL_ROLETYPE:
copy_func = &cil_copy_roletype;
break;
case CIL_ROLEBOUNDS:
copy_func = &cil_copy_bounds;
break;
case CIL_ROLEATTRIBUTE:
copy_func = &cil_copy_roleattribute;
break;
case CIL_ROLEATTRIBUTESET:
copy_func = &cil_copy_roleattributeset;
break;
case CIL_ROLEALLOW:
copy_func = &cil_copy_roleallow;
break;
case CIL_TYPE:
copy_func = &cil_copy_type;
break;
case CIL_TYPEBOUNDS:
copy_func = &cil_copy_bounds;
break;
case CIL_TYPEPERMISSIVE:
copy_func = cil_copy_typepermissive;
break;
case CIL_TYPEATTRIBUTE:
copy_func = &cil_copy_typeattribute;
break;
case CIL_TYPEATTRIBUTESET:
copy_func = &cil_copy_typeattributeset;
break;
case CIL_TYPEALIAS:
copy_func = &cil_copy_alias;
break;
case CIL_TYPEALIASACTUAL:
copy_func = &cil_copy_aliasactual;
break;
case CIL_ROLETRANSITION:
copy_func = &cil_copy_roletransition;
break;
case CIL_NAMETYPETRANSITION:
copy_func = &cil_copy_nametypetransition;
break;
case CIL_RANGETRANSITION:
copy_func = &cil_copy_rangetransition;
break;
case CIL_TUNABLE:
copy_func = &cil_copy_tunable;
break;
case CIL_BOOL:
copy_func = &cil_copy_bool;
break;
case CIL_AVRULE:
case CIL_AVRULEX:
copy_func = &cil_copy_avrule;
break;
case CIL_PERMISSIONX:
copy_func = &cil_copy_permissionx;
break;
case CIL_TYPE_RULE:
copy_func = &cil_copy_type_rule;
break;
case CIL_SENS:
copy_func = &cil_copy_sens;
break;
case CIL_SENSALIAS:
copy_func = &cil_copy_alias;
break;
case CIL_SENSALIASACTUAL:
copy_func = &cil_copy_aliasactual;
break;
case CIL_CAT:
copy_func = &cil_copy_cat;
break;
case CIL_CATALIAS:
copy_func = &cil_copy_alias;
break;
case CIL_CATALIASACTUAL:
copy_func = &cil_copy_aliasactual;
break;
case CIL_CATSET:
copy_func = &cil_copy_catset;
break;
case CIL_SENSCAT:
copy_func = &cil_copy_senscat;
break;
case CIL_CATORDER:
copy_func = &cil_copy_catorder;
break;
case CIL_SENSITIVITYORDER:
copy_func = &cil_copy_sensitivityorder;
break;
case CIL_LEVEL:
copy_func = &cil_copy_level;
break;
case CIL_LEVELRANGE:
copy_func = &cil_copy_levelrange;
break;
case CIL_CONTEXT:
copy_func = &cil_copy_context;
break;
case CIL_NETIFCON:
copy_func = &cil_copy_netifcon;
break;
case CIL_GENFSCON:
copy_func = &cil_copy_genfscon;
break;
case CIL_FILECON:
copy_func = &cil_copy_filecon;
break;
case CIL_NODECON:
copy_func = &cil_copy_nodecon;
break;
case CIL_PORTCON:
copy_func = &cil_copy_portcon;
break;
case CIL_PIRQCON:
copy_func = &cil_copy_pirqcon;
break;
case CIL_IOMEMCON:
copy_func = &cil_copy_iomemcon;
break;
case CIL_IOPORTCON:
copy_func = &cil_copy_ioportcon;
break;
case CIL_PCIDEVICECON:
copy_func = &cil_copy_pcidevicecon;
break;
case CIL_DEVICETREECON:
copy_func = &cil_copy_devicetreecon;
break;
case CIL_FSUSE:
copy_func = &cil_copy_fsuse;
break;
case CIL_CONSTRAIN:
case CIL_MLSCONSTRAIN:
copy_func = &cil_copy_constrain;
break;
case CIL_VALIDATETRANS:
case CIL_MLSVALIDATETRANS:
copy_func = &cil_copy_validatetrans;
break;
case CIL_CALL:
copy_func = &cil_copy_call;
break;
case CIL_MACRO:
copy_func = &cil_copy_macro;
break;
case CIL_NODE:
copy_func = &cil_copy_node;
break;
case CIL_OPTIONAL:
copy_func = &cil_copy_optional;
break;
case CIL_IPADDR:
copy_func = &cil_copy_ipaddr;
break;
case CIL_CONDBLOCK:
copy_func = &cil_copy_condblock;
break;
case CIL_BOOLEANIF:
copy_func = &cil_copy_boolif;
break;
case CIL_TUNABLEIF:
copy_func = &cil_copy_tunif;
break;
case CIL_DEFAULTUSER:
case CIL_DEFAULTROLE:
case CIL_DEFAULTTYPE:
copy_func = &cil_copy_default;
break;
case CIL_DEFAULTRANGE:
copy_func = &cil_copy_defaultrange;
break;
case CIL_HANDLEUNKNOWN:
copy_func = &cil_copy_handleunknown;
break;
case CIL_MLS:
copy_func = &cil_copy_mls;
break;
case CIL_SRC_INFO:
copy_func = &cil_copy_src_info;
break;
default:
goto exit;
}
if (orig->flavor >= CIL_MIN_DECLARATIVE) {
rc = cil_flavor_to_symtab_index(orig->flavor, &sym_index);
if (rc != SEPOL_OK) {
goto exit;
}
rc = cil_get_symtab(parent, &symtab, sym_index);
if (rc != SEPOL_OK) {
goto exit;
}
}
rc = (*copy_func)(db, orig->data, &data, symtab);
if (rc == SEPOL_OK) {
cil_tree_node_init(&new);
new->parent = parent;
new->line = orig->line;
new->hll_line = orig->hll_line;
new->flavor = orig->flavor;
new->data = data;
if (orig->flavor >= CIL_MIN_DECLARATIVE) {
rc = cil_symtab_insert(symtab, ((struct cil_symtab_datum*)orig->data)->name, ((struct cil_symtab_datum*)data), new);
namespace = new;
while (namespace->flavor != CIL_MACRO && namespace->flavor != CIL_BLOCK && namespace->flavor != CIL_ROOT) {
namespace = namespace->parent;
}
if (namespace->flavor == CIL_MACRO) {
struct cil_macro *macro = namespace->data;
struct cil_list *param_list = macro->params;
if (param_list != NULL) {
struct cil_list_item *item;
cil_list_for_each(item, param_list) {
param = item->data;
if (param->flavor == new->flavor) {
if (param->str == ((struct cil_symtab_datum*)new->data)->name) {
cil_tree_log(orig, CIL_ERR, "%s %s shadows a macro parameter", cil_node_to_string(new), ((struct cil_symtab_datum*)orig->data)->name);
cil_tree_log(namespace, CIL_ERR, "Note: macro declaration");
rc = SEPOL_ERR;
goto exit;
}
}
}
}
}
}
if (new->flavor == CIL_BLOCKINHERIT) {
blockinherit = new->data;
// if a blockinherit statement is copied before blockinherit are
// resolved (like in an in-statement), the block will not have been
// resolved yet, so there's nothing to append yet. This is fine,
// the copied blockinherit statement will be handled later, as if
// it wasn't in an in-statement
if (blockinherit->block != NULL) {
cil_list_append(blockinherit->block->bi_nodes, CIL_NODE, new);
}
}
if (parent->cl_head == NULL) {
parent->cl_head = new;
parent->cl_tail = new;
} else {
parent->cl_tail->next = new;
parent->cl_tail = new;
}
if (orig->cl_head != NULL) {
args->dest = new;
}
} else {
goto exit;
}
return SEPOL_OK;
exit:
cil_tree_node_destroy(&new);
return rc;
}
int __cil_copy_last_child_helper(__attribute__((unused)) struct cil_tree_node *orig, void *extra_args)
{
struct cil_tree_node *node = NULL;
struct cil_args_copy *args = NULL;
args = extra_args;
node = args->dest;
if (node->flavor != CIL_ROOT) {
args->dest = node->parent;
}
return SEPOL_OK;
}
// dest is the parent node to copy into
// if the copy is for a call to a macro, dest should be a pointer to the call
int cil_copy_ast(struct cil_db *db, struct cil_tree_node *orig, struct cil_tree_node *dest)
{
int rc = SEPOL_ERR;
struct cil_args_copy extra_args;
extra_args.dest = dest;
extra_args.db = db;
rc = cil_tree_walk(orig, __cil_copy_node_helper, NULL, __cil_copy_last_child_helper, &extra_args);
if (rc != SEPOL_OK) {
cil_log(CIL_INFO, "cil_tree_walk failed, rc: %d\n", rc);
goto exit;
}
return SEPOL_OK;
exit:
return rc;
}