/*

 * 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 <sepol/policydb/policydb.h>

#include <sepol/policydb/symtab.h>

#include "cil_internal.h"

#include "cil_flavor.h"

#include "cil_log.h"

#include "cil_mem.h"

#include "cil_tree.h"

#include "cil_list.h"

#include "cil_symtab.h"

#include "cil_build_ast.h"

#include "cil_parser.h"

#include "cil_build_ast.h"

#include "cil_resolve_ast.h"

#include "cil_fqn.h"

#include "cil_post.h"

#include "cil_binary.h"

#include "cil_policy.h"

#include "cil_strpool.h"

#include "cil_write_ast.h"

const int cil_sym_sizes[CIL_SYM_ARRAY_NUM][CIL_SYM_NUM] = {

  {64, 64, 64, 1 << 13, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64},

  {8, 8, 8, 32, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},

  {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},

  {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},

  {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}

};

char *CIL_KEY_CONS_T1;

char *CIL_KEY_CONS_T2;

char *CIL_KEY_CONS_T3;

char *CIL_KEY_CONS_R1;

char *CIL_KEY_CONS_R2;

char *CIL_KEY_CONS_R3;

char *CIL_KEY_CONS_U1;

char *CIL_KEY_CONS_U2;

char *CIL_KEY_CONS_U3;

char *CIL_KEY_CONS_L1;

char *CIL_KEY_CONS_L2;

char *CIL_KEY_CONS_H1;

char *CIL_KEY_CONS_H2;

char *CIL_KEY_AND;

char *CIL_KEY_OR;

char *CIL_KEY_NOT;

char *CIL_KEY_EQ;

char *CIL_KEY_NEQ;

char *CIL_KEY_CONS_DOM;

char *CIL_KEY_CONS_DOMBY;

char *CIL_KEY_CONS_INCOMP;

char *CIL_KEY_CONDTRUE;

char *CIL_KEY_CONDFALSE;

char *CIL_KEY_SELF;

char *CIL_KEY_NOTSELF;

char *CIL_KEY_OTHER;

char *CIL_KEY_OBJECT_R;

char *CIL_KEY_STAR;

char *CIL_KEY_TCP;

char *CIL_KEY_UDP;

char *CIL_KEY_DCCP;

char *CIL_KEY_SCTP;

char *CIL_KEY_AUDITALLOW;

char *CIL_KEY_TUNABLEIF;

char *CIL_KEY_ALLOW;

char *CIL_KEY_DONTAUDIT;

char *CIL_KEY_TYPETRANSITION;

char *CIL_KEY_TYPECHANGE;

char *CIL_KEY_CALL;

char *CIL_KEY_TUNABLE;

char *CIL_KEY_XOR;

char *CIL_KEY_ALL;

char *CIL_KEY_RANGE;

char *CIL_KEY_GLOB;

char *CIL_KEY_FILE;

char *CIL_KEY_DIR;

char *CIL_KEY_CHAR;

char *CIL_KEY_BLOCK;

char *CIL_KEY_SOCKET;

char *CIL_KEY_PIPE;

char *CIL_KEY_SYMLINK;

char *CIL_KEY_ANY;

char *CIL_KEY_XATTR;

char *CIL_KEY_TASK;

char *CIL_KEY_TRANS;

char *CIL_KEY_TYPE;

char *CIL_KEY_ROLE;

char *CIL_KEY_USER;

char *CIL_KEY_USERATTRIBUTE;

char *CIL_KEY_USERATTRIBUTESET;

char *CIL_KEY_SENSITIVITY;

char *CIL_KEY_CATEGORY;

char *CIL_KEY_CATSET;

char *CIL_KEY_LEVEL;

char *CIL_KEY_LEVELRANGE;

char *CIL_KEY_CLASS;

char *CIL_KEY_IPADDR;

char *CIL_KEY_MAP_CLASS;

char *CIL_KEY_CLASSPERMISSION;

char *CIL_KEY_BOOL;

char *CIL_KEY_STRING;

char *CIL_KEY_NAME;

char *CIL_KEY_SOURCE;

char *CIL_KEY_TARGET;

char *CIL_KEY_LOW;

char *CIL_KEY_HIGH;

char *CIL_KEY_LOW_HIGH;

char *CIL_KEY_GLBLUB;

char *CIL_KEY_HANDLEUNKNOWN;

char *CIL_KEY_HANDLEUNKNOWN_ALLOW;

char *CIL_KEY_HANDLEUNKNOWN_DENY;

char *CIL_KEY_HANDLEUNKNOWN_REJECT;

char *CIL_KEY_MACRO;

char *CIL_KEY_IN;

char *CIL_KEY_IN_BEFORE;

char *CIL_KEY_IN_AFTER;

char *CIL_KEY_MLS;

char *CIL_KEY_DEFAULTRANGE;

char *CIL_KEY_BLOCKINHERIT;

char *CIL_KEY_BLOCKABSTRACT;

char *CIL_KEY_CLASSORDER;

char *CIL_KEY_CLASSMAPPING;

char *CIL_KEY_CLASSPERMISSIONSET;

char *CIL_KEY_COMMON;

char *CIL_KEY_CLASSCOMMON;

char *CIL_KEY_SID;

char *CIL_KEY_SIDCONTEXT;

char *CIL_KEY_SIDORDER;

char *CIL_KEY_USERLEVEL;

char *CIL_KEY_USERRANGE;

char *CIL_KEY_USERBOUNDS;

char *CIL_KEY_USERPREFIX;

char *CIL_KEY_SELINUXUSER;

char *CIL_KEY_SELINUXUSERDEFAULT;

char *CIL_KEY_TYPEATTRIBUTE;

char *CIL_KEY_TYPEATTRIBUTESET;

char *CIL_KEY_EXPANDTYPEATTRIBUTE;

char *CIL_KEY_TYPEALIAS;

char *CIL_KEY_TYPEALIASACTUAL;

char *CIL_KEY_TYPEBOUNDS;

char *CIL_KEY_TYPEPERMISSIVE;

char *CIL_KEY_RANGETRANSITION;

char *CIL_KEY_USERROLE;

char *CIL_KEY_ROLETYPE;

char *CIL_KEY_ROLETRANSITION;

char *CIL_KEY_ROLEALLOW;

char *CIL_KEY_ROLEATTRIBUTE;

char *CIL_KEY_ROLEATTRIBUTESET;

char *CIL_KEY_ROLEBOUNDS;

char *CIL_KEY_BOOLEANIF;

char *CIL_KEY_NEVERALLOW;

char *CIL_KEY_TYPEMEMBER;

char *CIL_KEY_SENSALIAS;

char *CIL_KEY_SENSALIASACTUAL;

char *CIL_KEY_CATALIAS;

char *CIL_KEY_CATALIASACTUAL;

char *CIL_KEY_CATORDER;

char *CIL_KEY_SENSITIVITYORDER;

char *CIL_KEY_SENSCAT;

char *CIL_KEY_CONSTRAIN;

char *CIL_KEY_MLSCONSTRAIN;

char *CIL_KEY_VALIDATETRANS;

char *CIL_KEY_MLSVALIDATETRANS;

char *CIL_KEY_CONTEXT;

char *CIL_KEY_FILECON;

char *CIL_KEY_IBPKEYCON;

char *CIL_KEY_IBENDPORTCON;

char *CIL_KEY_PORTCON;

char *CIL_KEY_NODECON;

char *CIL_KEY_GENFSCON;

char *CIL_KEY_NETIFCON;

char *CIL_KEY_PIRQCON;

char *CIL_KEY_IOMEMCON;

char *CIL_KEY_IOPORTCON;

char *CIL_KEY_PCIDEVICECON;

char *CIL_KEY_DEVICETREECON;

char *CIL_KEY_FSUSE;

char *CIL_KEY_POLICYCAP;

char *CIL_KEY_OPTIONAL;

char *CIL_KEY_DEFAULTUSER;

char *CIL_KEY_DEFAULTROLE;

char *CIL_KEY_DEFAULTTYPE;

char *CIL_KEY_ROOT;

char *CIL_KEY_NODE;

char *CIL_KEY_PERM;

char *CIL_KEY_ALLOWX;

char *CIL_KEY_AUDITALLOWX;

char *CIL_KEY_DONTAUDITX;

char *CIL_KEY_NEVERALLOWX;

char *CIL_KEY_PERMISSIONX;

char *CIL_KEY_IOCTL;

char *CIL_KEY_UNORDERED;

char *CIL_KEY_SRC_INFO;

char *CIL_KEY_SRC_CIL;

char *CIL_KEY_SRC_HLL_LMS;

char *CIL_KEY_SRC_HLL_LMX;

char *CIL_KEY_SRC_HLL_LME;

char *CIL_KEY_DENY_RULE;

static void cil_init_keys(void)

{

  /* Initialize CIL Keys into strpool */

  CIL_KEY_CONS_T1 = cil_strpool_add("t1");

  CIL_KEY_CONS_T2 = cil_strpool_add("t2");

  CIL_KEY_CONS_T3 = cil_strpool_add("t3");

  CIL_KEY_CONS_R1 = cil_strpool_add("r1");

  CIL_KEY_CONS_R2 = cil_strpool_add("r2");

  CIL_KEY_CONS_R3 = cil_strpool_add("r3");

  CIL_KEY_CONS_U1 = cil_strpool_add("u1");

  CIL_KEY_CONS_U2 = cil_strpool_add("u2");

  CIL_KEY_CONS_U3 = cil_strpool_add("u3");

  CIL_KEY_CONS_L1 = cil_strpool_add("l1");

  CIL_KEY_CONS_L2 = cil_strpool_add("l2");

  CIL_KEY_CONS_H1 = cil_strpool_add("h1");

  CIL_KEY_CONS_H2 = cil_strpool_add("h2");

  CIL_KEY_AND = cil_strpool_add("and");

  CIL_KEY_OR = cil_strpool_add("or");

  CIL_KEY_NOT = cil_strpool_add("not");

  CIL_KEY_EQ = cil_strpool_add("eq");

  CIL_KEY_NEQ = cil_strpool_add("neq");

  CIL_KEY_CONS_DOM = cil_strpool_add("dom");

  CIL_KEY_CONS_DOMBY = cil_strpool_add("domby");

  CIL_KEY_CONS_INCOMP = cil_strpool_add("incomp");

  CIL_KEY_CONDTRUE = cil_strpool_add("true");

  CIL_KEY_CONDFALSE = cil_strpool_add("false");

  CIL_KEY_SELF = cil_strpool_add("self");

  CIL_KEY_NOTSELF = cil_strpool_add("notself");

  CIL_KEY_OTHER = cil_strpool_add("other");

  CIL_KEY_OBJECT_R = cil_strpool_add("object_r");

  CIL_KEY_STAR = cil_strpool_add("*");

  CIL_KEY_UDP = cil_strpool_add("udp");

  CIL_KEY_TCP = cil_strpool_add("tcp");

  CIL_KEY_DCCP = cil_strpool_add("dccp");

  CIL_KEY_SCTP = cil_strpool_add("sctp");

  CIL_KEY_AUDITALLOW = cil_strpool_add("auditallow");

  CIL_KEY_TUNABLEIF = cil_strpool_add("tunableif");

  CIL_KEY_ALLOW = cil_strpool_add("allow");

  CIL_KEY_DONTAUDIT = cil_strpool_add("dontaudit");

  CIL_KEY_TYPETRANSITION = cil_strpool_add("typetransition");

  CIL_KEY_TYPECHANGE = cil_strpool_add("typechange");

  CIL_KEY_CALL = cil_strpool_add("call");

  CIL_KEY_TUNABLE = cil_strpool_add("tunable");

  CIL_KEY_XOR = cil_strpool_add("xor");

  CIL_KEY_ALL = cil_strpool_add("all");

  CIL_KEY_RANGE = cil_strpool_add("range");

  CIL_KEY_TYPE = cil_strpool_add("type");

  CIL_KEY_ROLE = cil_strpool_add("role");

  CIL_KEY_USER = cil_strpool_add("user");

  CIL_KEY_USERATTRIBUTE = cil_strpool_add("userattribute");

  CIL_KEY_USERATTRIBUTESET = cil_strpool_add("userattributeset");

  CIL_KEY_SENSITIVITY = cil_strpool_add("sensitivity");

  CIL_KEY_CATEGORY = cil_strpool_add("category");

  CIL_KEY_CATSET = cil_strpool_add("categoryset");

  CIL_KEY_LEVEL = cil_strpool_add("level");

  CIL_KEY_LEVELRANGE = cil_strpool_add("levelrange");

  CIL_KEY_CLASS = cil_strpool_add("class");

  CIL_KEY_IPADDR = cil_strpool_add("ipaddr");

  CIL_KEY_MAP_CLASS = cil_strpool_add("classmap");

  CIL_KEY_CLASSPERMISSION = cil_strpool_add("classpermission");

  CIL_KEY_BOOL = cil_strpool_add("boolean");

  CIL_KEY_STRING = cil_strpool_add("string");

  CIL_KEY_NAME = cil_strpool_add("name");

  CIL_KEY_HANDLEUNKNOWN = cil_strpool_add("handleunknown");

  CIL_KEY_HANDLEUNKNOWN_ALLOW = cil_strpool_add("allow");

  CIL_KEY_HANDLEUNKNOWN_DENY = cil_strpool_add("deny");

  CIL_KEY_HANDLEUNKNOWN_REJECT = cil_strpool_add("reject");

  CIL_KEY_BLOCKINHERIT = cil_strpool_add("blockinherit");

  CIL_KEY_BLOCKABSTRACT = cil_strpool_add("blockabstract");

  CIL_KEY_CLASSORDER = cil_strpool_add("classorder");

  CIL_KEY_CLASSMAPPING = cil_strpool_add("classmapping");

  CIL_KEY_CLASSPERMISSIONSET = cil_strpool_add("classpermissionset");

  CIL_KEY_COMMON = cil_strpool_add("common");

  CIL_KEY_CLASSCOMMON = cil_strpool_add("classcommon");

  CIL_KEY_SID = cil_strpool_add("sid");

  CIL_KEY_SIDCONTEXT = cil_strpool_add("sidcontext");

  CIL_KEY_SIDORDER = cil_strpool_add("sidorder");

  CIL_KEY_USERLEVEL = cil_strpool_add("userlevel");

  CIL_KEY_USERRANGE = cil_strpool_add("userrange");

  CIL_KEY_USERBOUNDS = cil_strpool_add("userbounds");

  CIL_KEY_USERPREFIX = cil_strpool_add("userprefix");

  CIL_KEY_SELINUXUSER = cil_strpool_add("selinuxuser");

  CIL_KEY_SELINUXUSERDEFAULT = cil_strpool_add("selinuxuserdefault");

  CIL_KEY_TYPEATTRIBUTE = cil_strpool_add("typeattribute");

  CIL_KEY_TYPEATTRIBUTESET = cil_strpool_add("typeattributeset");

  CIL_KEY_EXPANDTYPEATTRIBUTE = cil_strpool_add("expandtypeattribute");

  CIL_KEY_TYPEALIAS = cil_strpool_add("typealias");

  CIL_KEY_TYPEALIASACTUAL = cil_strpool_add("typealiasactual");

  CIL_KEY_TYPEBOUNDS = cil_strpool_add("typebounds");

  CIL_KEY_TYPEPERMISSIVE = cil_strpool_add("typepermissive");

  CIL_KEY_RANGETRANSITION = cil_strpool_add("rangetransition");

  CIL_KEY_USERROLE = cil_strpool_add("userrole");

  CIL_KEY_ROLETYPE = cil_strpool_add("roletype");

  CIL_KEY_ROLETRANSITION = cil_strpool_add("roletransition");

  CIL_KEY_ROLEALLOW = cil_strpool_add("roleallow");

  CIL_KEY_ROLEATTRIBUTE = cil_strpool_add("roleattribute");

  CIL_KEY_ROLEATTRIBUTESET = cil_strpool_add("roleattributeset");

  CIL_KEY_ROLEBOUNDS = cil_strpool_add("rolebounds");

  CIL_KEY_BOOLEANIF = cil_strpool_add("booleanif");

  CIL_KEY_NEVERALLOW = cil_strpool_add("neverallow");

  CIL_KEY_TYPEMEMBER = cil_strpool_add("typemember");

  CIL_KEY_SENSALIAS = cil_strpool_add("sensitivityalias");

  CIL_KEY_SENSALIASACTUAL = cil_strpool_add("sensitivityaliasactual");

  CIL_KEY_CATALIAS = cil_strpool_add("categoryalias");

  CIL_KEY_CATALIASACTUAL = cil_strpool_add("categoryaliasactual");

  CIL_KEY_CATORDER = cil_strpool_add("categoryorder");

  CIL_KEY_SENSITIVITYORDER = cil_strpool_add("sensitivityorder");

  CIL_KEY_SENSCAT = cil_strpool_add("sensitivitycategory");

  CIL_KEY_CONSTRAIN = cil_strpool_add("constrain");

  CIL_KEY_MLSCONSTRAIN = cil_strpool_add("mlsconstrain");

  CIL_KEY_VALIDATETRANS = cil_strpool_add("validatetrans");

  CIL_KEY_MLSVALIDATETRANS = cil_strpool_add("mlsvalidatetrans");

  CIL_KEY_CONTEXT = cil_strpool_add("context");

  CIL_KEY_FILECON = cil_strpool_add("filecon");

  CIL_KEY_IBPKEYCON = cil_strpool_add("ibpkeycon");

  CIL_KEY_IBENDPORTCON = cil_strpool_add("ibendportcon");

  CIL_KEY_PORTCON = cil_strpool_add("portcon");

  CIL_KEY_NODECON = cil_strpool_add("nodecon");

  CIL_KEY_GENFSCON = cil_strpool_add("genfscon");

  CIL_KEY_NETIFCON = cil_strpool_add("netifcon");

  CIL_KEY_PIRQCON = cil_strpool_add("pirqcon");

  CIL_KEY_IOMEMCON = cil_strpool_add("iomemcon");

  CIL_KEY_IOPORTCON = cil_strpool_add("ioportcon");

  CIL_KEY_PCIDEVICECON = cil_strpool_add("pcidevicecon");

  CIL_KEY_DEVICETREECON = cil_strpool_add("devicetreecon");

  CIL_KEY_FSUSE = cil_strpool_add("fsuse");

  CIL_KEY_POLICYCAP = cil_strpool_add("policycap");

  CIL_KEY_OPTIONAL = cil_strpool_add("optional");

  CIL_KEY_DEFAULTUSER = cil_strpool_add("defaultuser");

  CIL_KEY_DEFAULTROLE = cil_strpool_add("defaultrole");

  CIL_KEY_DEFAULTTYPE = cil_strpool_add("defaulttype");

  CIL_KEY_MACRO = cil_strpool_add("macro");

  CIL_KEY_IN = cil_strpool_add("in");

  CIL_KEY_IN_BEFORE = cil_strpool_add("before");

  CIL_KEY_IN_AFTER = cil_strpool_add("after");

  CIL_KEY_MLS = cil_strpool_add("mls");

  CIL_KEY_DEFAULTRANGE = cil_strpool_add("defaultrange");

  CIL_KEY_GLOB = cil_strpool_add("*");

  CIL_KEY_FILE = cil_strpool_add("file");

  CIL_KEY_DIR = cil_strpool_add("dir");

  CIL_KEY_CHAR = cil_strpool_add("char");

  CIL_KEY_BLOCK = cil_strpool_add("block");

  CIL_KEY_SOCKET = cil_strpool_add("socket");

  CIL_KEY_PIPE = cil_strpool_add("pipe");

  CIL_KEY_SYMLINK = cil_strpool_add("symlink");

  CIL_KEY_ANY = cil_strpool_add("any");

  CIL_KEY_XATTR = cil_strpool_add("xattr");

  CIL_KEY_TASK = cil_strpool_add("task");

  CIL_KEY_TRANS = cil_strpool_add("trans");

  CIL_KEY_SOURCE = cil_strpool_add("source");

  CIL_KEY_TARGET = cil_strpool_add("target");

  CIL_KEY_LOW = cil_strpool_add("low");

  CIL_KEY_HIGH = cil_strpool_add("high");

  CIL_KEY_LOW_HIGH = cil_strpool_add("low-high");

  CIL_KEY_GLBLUB = cil_strpool_add("glblub");

  CIL_KEY_ROOT = cil_strpool_add("<root>");

  CIL_KEY_NODE = cil_strpool_add("<node>");

  CIL_KEY_PERM = cil_strpool_add("perm");

  CIL_KEY_ALLOWX = cil_strpool_add("allowx");

  CIL_KEY_AUDITALLOWX = cil_strpool_add("auditallowx");

  CIL_KEY_DONTAUDITX = cil_strpool_add("dontauditx");

  CIL_KEY_NEVERALLOWX = cil_strpool_add("neverallowx");

  CIL_KEY_PERMISSIONX = cil_strpool_add("permissionx");

  CIL_KEY_IOCTL = cil_strpool_add("ioctl");

  CIL_KEY_UNORDERED = cil_strpool_add("unordered");

  CIL_KEY_SRC_INFO = cil_strpool_add("<src_info>");

  CIL_KEY_SRC_CIL = cil_strpool_add("cil");

  CIL_KEY_SRC_HLL_LMS = cil_strpool_add("lms");

  CIL_KEY_SRC_HLL_LMX = cil_strpool_add("lmx");

  CIL_KEY_SRC_HLL_LME = cil_strpool_add("lme");

  CIL_KEY_DENY_RULE = cil_strpool_add("deny");

}

void cil_db_init(struct cil_db **db)

{

  *db = cil_malloc(sizeof(**db));

  cil_strpool_init();

  cil_init_keys();

  cil_tree_init(&(*db)->parse);

  cil_tree_init(&(*db)->ast);

  cil_root_init((struct cil_root **)&(*db)->ast->root->data);

  (*db)->sidorder = NULL;

  (*db)->classorder = NULL;

  (*db)->catorder = NULL;

  (*db)->sensitivityorder = NULL;

  cil_sort_init(&(*db)->netifcon);

  cil_sort_init(&(*db)->genfscon);

  cil_sort_init(&(*db)->filecon);

  cil_sort_init(&(*db)->nodecon);

  cil_sort_init(&(*db)->ibpkeycon);

  cil_sort_init(&(*db)->ibendportcon);

  cil_sort_init(&(*db)->portcon);

  cil_sort_init(&(*db)->pirqcon);

  cil_sort_init(&(*db)->iomemcon);

  cil_sort_init(&(*db)->ioportcon);

  cil_sort_init(&(*db)->pcidevicecon);

  cil_sort_init(&(*db)->devicetreecon);

  cil_sort_init(&(*db)->fsuse);

  cil_list_init(&(*db)->userprefixes, CIL_LIST_ITEM);

  cil_list_init(&(*db)->selinuxusers, CIL_LIST_ITEM);

  cil_list_init(&(*db)->declared_strings, CIL_LIST_ITEM);

  cil_type_init(&(*db)->selftype);

  (*db)->selftype->datum.name = CIL_KEY_SELF;

  (*db)->selftype->datum.fqn = CIL_KEY_SELF;

  cil_type_init(&(*db)->notselftype);

  (*db)->notselftype->datum.name = CIL_KEY_NOTSELF;

  (*db)->notselftype->datum.fqn = CIL_KEY_NOTSELF;

  cil_type_init(&(*db)->othertype);

  (*db)->othertype->datum.name = CIL_KEY_OTHER;

  (*db)->othertype->datum.fqn = CIL_KEY_OTHER;

  (*db)->num_types_and_attrs = 0;

  (*db)->num_classes = 0;

  (*db)->num_types = 0;

  (*db)->num_roles = 0;

  (*db)->num_users = 0;

  (*db)->num_cats = 0;

  (*db)->val_to_type = NULL;

  (*db)->val_to_role = NULL;

  (*db)->val_to_user = NULL;

  (*db)->disable_dontaudit = CIL_FALSE;

  (*db)->disable_neverallow = CIL_FALSE;

  (*db)->attrs_expand_generated = CIL_FALSE;

  (*db)->attrs_expand_size = 1;

  (*db)->preserve_tunables = CIL_FALSE;

  (*db)->handle_unknown = -1;

  (*db)->mls = -1;

  (*db)->multiple_decls = CIL_FALSE;

  (*db)->qualified_names = CIL_FALSE;

  (*db)->target_platform = SEPOL_TARGET_SELINUX;

  (*db)->policy_version = POLICYDB_VERSION_MAX;

}

static void cil_declared_strings_list_destroy(struct cil_list **strings)

{

  struct cil_list_item *i;

  cil_list_for_each(i, *strings) {

    struct cil_symtab_datum *d = i->data;

    cil_symtab_datum_destroy(d);

    free(d);

  }

  cil_list_destroy(strings, CIL_FALSE);

}

void cil_db_destroy(struct cil_db **db)

{

  if (db == NULL || *db == NULL) {

    return;

  }

  cil_tree_destroy(&(*db)->parse);

  cil_tree_destroy(&(*db)->ast);

  cil_list_destroy(&(*db)->sidorder, CIL_FALSE);

  cil_list_destroy(&(*db)->classorder, CIL_FALSE);

  cil_list_destroy(&(*db)->catorder, CIL_FALSE);

  cil_list_destroy(&(*db)->sensitivityorder, CIL_FALSE);

  cil_sort_destroy(&(*db)->netifcon);

  cil_sort_destroy(&(*db)->genfscon);

  cil_sort_destroy(&(*db)->filecon);

  cil_sort_destroy(&(*db)->nodecon);

  cil_sort_destroy(&(*db)->ibpkeycon);

  cil_sort_destroy(&(*db)->ibendportcon);

  cil_sort_destroy(&(*db)->portcon);

  cil_sort_destroy(&(*db)->pirqcon);

  cil_sort_destroy(&(*db)->iomemcon);

  cil_sort_destroy(&(*db)->ioportcon);

  cil_sort_destroy(&(*db)->pcidevicecon);

  cil_sort_destroy(&(*db)->devicetreecon);

  cil_sort_destroy(&(*db)->fsuse);

  cil_list_destroy(&(*db)->userprefixes, CIL_FALSE);

  cil_list_destroy(&(*db)->selinuxusers, CIL_FALSE);

  cil_declared_strings_list_destroy(&(*db)->declared_strings);

  cil_destroy_type((*db)->selftype);

  cil_destroy_type((*db)->notselftype);

  cil_destroy_type((*db)->othertype);

  cil_strpool_destroy();

  free((*db)->val_to_type);

  free((*db)->val_to_role);

  free((*db)->val_to_user);

  free(*db);

  *db = NULL; 

}

void cil_root_init(struct cil_root **root)

{

  struct cil_root *r = cil_malloc(sizeof(*r));

  cil_symtab_array_init(r->symtab, cil_sym_sizes[CIL_SYM_ARRAY_ROOT]);

  *root = r;

}

void cil_root_destroy(struct cil_root *root)

{

  if (root == NULL) {

    return;

  }

  cil_symtab_array_destroy(root->symtab);

  free(root);

}

int cil_add_file(cil_db_t *db, const char *name, const char *data, size_t size)

{

  char *buffer = NULL;

  int rc;

  cil_log(CIL_INFO, "Parsing %s\n", name);

  buffer = cil_malloc(size + 2);

  memcpy(buffer, data, size);

  memset(buffer + size, 0, 2);

  rc = cil_parser(name, buffer, size + 2, &db->parse);

  if (rc != SEPOL_OK) {

    cil_log(CIL_INFO, "Failed to parse %s\n", name);

    goto exit;

  }

  free(buffer);

  buffer = NULL;

  rc = SEPOL_OK;

exit:

  free(buffer);

  return rc;

}

int cil_compile(struct cil_db *db)

{

  int rc = SEPOL_ERR;

  if (db == NULL) {

    goto exit;

  }

  cil_log(CIL_INFO, "Building AST from Parse Tree\n");

  rc = cil_build_ast(db, db->parse->root, db->ast->root);

  if (rc != SEPOL_OK) {

    cil_log(CIL_ERR, "Failed to build AST\n");

    goto exit;

  }

  cil_log(CIL_INFO, "Destroying Parse Tree\n");

  cil_tree_destroy(&db->parse);

  cil_log(CIL_INFO, "Resolving AST\n");

  rc = cil_resolve_ast(db, db->ast->root);

  if (rc != SEPOL_OK) {

    cil_log(CIL_ERR, "Failed to resolve AST\n");

    goto exit;

  }

  cil_log(CIL_INFO, "Qualifying Names\n");

  rc = cil_fqn_qualify(db->ast->root);

  if (rc != SEPOL_OK) {

    cil_log(CIL_ERR, "Failed to qualify names\n");

    goto exit;

  }

  cil_log(CIL_INFO, "Compile post process\n");

  rc = cil_post_process(db);

  if (rc != SEPOL_OK ) {

    cil_log(CIL_ERR, "Post process failed\n");

    goto exit;

  }

exit:

  return rc;

}

int cil_write_parse_ast(FILE *out, cil_db_t *db)

{

  int rc = SEPOL_ERR;

  if (db == NULL) {

    goto exit;

  }

  cil_log(CIL_INFO, "Writing Parse AST\n");

  rc = cil_write_ast(out, CIL_WRITE_AST_PHASE_PARSE, db->parse->root);

  if (rc != SEPOL_OK) {

    cil_log(CIL_ERR, "Failed to write parse ast\n");

    goto exit;

  }

exit:

  return rc;

}

int cil_write_build_ast(FILE *out, cil_db_t *db)

{

  int rc = SEPOL_ERR;

  if (db == NULL) {

    goto exit;

  }

  cil_log(CIL_INFO, "Building AST from Parse Tree\n");

  rc = cil_build_ast(db, db->parse->root, db->ast->root);

  if (rc != SEPOL_OK) {

    cil_log(CIL_ERR, "Failed to build ast\n");

    goto exit;

  }

  cil_log(CIL_INFO, "Destroying Parse Tree\n");

  cil_tree_destroy(&db->parse);

  cil_log(CIL_INFO, "Writing Build AST\n");

  rc = cil_write_ast(out, CIL_WRITE_AST_PHASE_BUILD, db->ast->root);

  if (rc != SEPOL_OK) {

    cil_log(CIL_ERR, "Failed to write build ast\n");

    goto exit;

  }

exit:

  return rc;

}

int cil_write_resolve_ast(FILE *out, cil_db_t *db)

{

  int rc = SEPOL_ERR;

  if (db == NULL) {

    goto exit;

  }

  cil_log(CIL_INFO, "Building AST from Parse Tree\n");

  rc = cil_build_ast(db, db->parse->root, db->ast->root);

  if (rc != SEPOL_OK) {

    cil_log(CIL_ERR, "Failed to build ast\n");

    goto exit;

  }

  cil_log(CIL_INFO, "Destroying Parse Tree\n");

  cil_tree_destroy(&db->parse);

  cil_log(CIL_INFO, "Resolving AST\n");

  rc = cil_resolve_ast(db, db->ast->root);

  if (rc != SEPOL_OK) {

    cil_log(CIL_ERR, "Failed to resolve ast\n");

    goto exit;

  }

  cil_log(CIL_INFO, "Qualifying Names\n");

  rc = cil_fqn_qualify(db->ast->root);

  if (rc != SEPOL_OK) {

    cil_log(CIL_ERR, "Failed to qualify names\n");

    goto exit;

  }

  cil_log(CIL_INFO, "Writing Resolve AST\n");

  rc = cil_write_ast(out, CIL_WRITE_AST_PHASE_RESOLVE, db->ast->root);

  if (rc != SEPOL_OK) {

    cil_log(CIL_ERR, "Failed to write resolve ast\n");

    goto exit;

  }

exit:

  return rc;

}

int cil_write_post_ast(FILE *out, cil_db_t *db)

{

  int rc = SEPOL_ERR;

  if (db == NULL) {

    goto exit;

  }

  cil_log(CIL_INFO, "Building AST from Parse Tree\n");

  rc = cil_build_ast(db, db->parse->root, db->ast->root);

  if (rc != SEPOL_OK) {

    cil_log(CIL_ERR, "Failed to build ast\n");

    goto exit;

  }

  cil_log(CIL_INFO, "Destroying Parse Tree\n");

  cil_tree_destroy(&db->parse);

  cil_log(CIL_INFO, "Resolving AST\n");

  rc = cil_resolve_ast(db, db->ast->root);

  if (rc != SEPOL_OK) {

    cil_log(CIL_ERR, "Failed to resolve ast\n");

    goto exit;

  }

  cil_log(CIL_INFO, "Qualifying Names\n");

  rc = cil_fqn_qualify(db->ast->root);

  if (rc != SEPOL_OK) {

    cil_log(CIL_ERR, "Failed to qualify names\n");

    goto exit;

  }

  cil_log(CIL_INFO, "Compile post process\n");

  rc = cil_post_process(db);

  if (rc != SEPOL_OK ) {

    cil_log(CIL_ERR, "Post process failed\n");

    goto exit;

  }

  cil_log(CIL_INFO, "Writing Post AST\n");

  rc = cil_write_ast(out, CIL_WRITE_AST_PHASE_POST, db->ast->root);

  if (rc != SEPOL_OK) {

    cil_log(CIL_ERR, "Failed to write post ast\n");

    goto exit;

  }

exit:

  return rc;

}

int cil_build_policydb(cil_db_t *db, sepol_policydb_t **sepol_db)

{

  int rc;

  cil_log(CIL_INFO, "Building policy binary\n");

  rc = cil_binary_create(db, sepol_db);

  if (rc != SEPOL_OK) {

    cil_log(CIL_ERR, "Failed to generate binary\n");

    goto exit;

  }

exit:

  return rc;

}

void cil_write_policy_conf(FILE *out, struct cil_db *db)

{

  cil_log(CIL_INFO, "Writing policy.conf file\n");

  cil_gen_policy(out, db);

}

void cil_destroy_data(void **data, enum cil_flavor flavor)

{

  if (*data == NULL) {

    return;

  }

  switch(flavor) {

  case CIL_NONE:

    break;

  case CIL_ROOT:

    cil_root_destroy(*data);

    break;

  case CIL_NODE:

    break;

  case CIL_STRING:

    break;

  case CIL_DATUM:

    break;

  case CIL_LIST:

    cil_list_destroy(*data, CIL_FALSE);

    break;

  case CIL_LIST_ITEM:

    break;

  case CIL_PARAM:

    cil_destroy_param(*data);

    break;

  case CIL_ARGS:

    cil_destroy_args(*data);

    break;

  case CIL_BLOCK:

    cil_destroy_block(*data);

    break;

  case CIL_BLOCKINHERIT:

    cil_destroy_blockinherit(*data);

    break;

  case CIL_BLOCKABSTRACT:

    cil_destroy_blockabstract(*data);

    break;

  case CIL_IN:

    cil_destroy_in(*data);

    break;

  case CIL_MACRO:

    cil_destroy_macro(*data);

    break;

  case CIL_CALL:

    cil_destroy_call(*data);

    break;

  case CIL_OPTIONAL:

    cil_destroy_optional(*data);

    break;

  case CIL_BOOL:

    cil_destroy_bool(*data);

    break;

  case CIL_BOOLEANIF:

    cil_destroy_boolif(*data);

    break;

  case CIL_TUNABLE:

    cil_destroy_tunable(*data);

    break;

  case CIL_TUNABLEIF:

    cil_destroy_tunif(*data);

    break;

  case CIL_CONDBLOCK:

    cil_destroy_condblock(*data);

    break;

  case CIL_CONDTRUE:

    break;

  case CIL_CONDFALSE:

    break;

  case CIL_PERM:

  case CIL_MAP_PERM:

    cil_destroy_perm(*data);

    break;

  case CIL_COMMON:

  case CIL_CLASS:

  case CIL_MAP_CLASS:

    cil_destroy_class(*data);

    break;

  case CIL_CLASSORDER:

    cil_destroy_ordered(*data);

    break;

  case CIL_CLASSPERMISSION:

    cil_destroy_classpermission(*data);

    break;

  case CIL_CLASSCOMMON:

    cil_destroy_classcommon(*data);

    break;

  case CIL_CLASSMAPPING:

    cil_destroy_classmapping(*data);

    break;

  case CIL_CLASSPERMS:

    cil_destroy_classperms(*data);

    break;

  case CIL_CLASSPERMS_SET:

    cil_destroy_classperms_set(*data);

    break;

  case CIL_CLASSPERMISSIONSET:

    cil_destroy_classpermissionset(*data);

    break;

  case CIL_USER:

    cil_destroy_user(*data);

    break;

  case CIL_USERATTRIBUTE:

    cil_destroy_userattribute(*data);

    break;

  case CIL_USERATTRIBUTESET:

    cil_destroy_userattributeset(*data);

    break;

  case CIL_USERPREFIX:

    cil_destroy_userprefix(*data);

    break;

  case CIL_USERROLE:

    cil_destroy_userrole(*data);

    break;

  case CIL_USERLEVEL:

    cil_destroy_userlevel(*data);

    break;

  case CIL_USERRANGE:

    cil_destroy_userrange(*data);

    break;

  case CIL_USERBOUNDS:

    cil_destroy_bounds(*data);

    break;

  case CIL_SELINUXUSER:

  case CIL_SELINUXUSERDEFAULT:

    cil_destroy_selinuxuser(*data);

    break;

  case CIL_ROLE:

    cil_destroy_role(*data);

    break;

  case CIL_ROLEATTRIBUTE:

    cil_destroy_roleattribute(*data);

    break;

  case CIL_ROLEATTRIBUTESET:

    cil_destroy_roleattributeset(*data);

    break;

  case CIL_ROLETYPE:

    cil_destroy_roletype(*data);

    break;

  case CIL_ROLEBOUNDS:

    cil_destroy_bounds(*data);

    break;

  case CIL_TYPE:

    cil_destroy_type(*data);

    break;

  case CIL_TYPEATTRIBUTE:

    cil_destroy_typeattribute(*data);

    break;

  case CIL_TYPEALIAS:

    cil_destroy_alias(*data);

    break;

  case CIL_TYPEATTRIBUTESET:

    cil_destroy_typeattributeset(*data);

    break;

  case CIL_EXPANDTYPEATTRIBUTE:

    cil_destroy_expandtypeattribute(*data);

    break;

  case CIL_TYPEALIASACTUAL:

    cil_destroy_aliasactual(*data);

    break;

  case CIL_TYPEBOUNDS:

    cil_destroy_bounds(*data);

    break;

  case CIL_TYPEPERMISSIVE:

    cil_destroy_typepermissive(*data);

    break;

  case CIL_SENS:

    cil_destroy_sensitivity(*data);

    break;

  case CIL_SENSALIAS:

    cil_destroy_alias(*data);

    break;

  case CIL_SENSALIASACTUAL:

    cil_destroy_aliasactual(*data);

    break;

  case CIL_SENSITIVITYORDER:

    cil_destroy_ordered(*data);

    break;

  case CIL_SENSCAT:

    cil_destroy_senscat(*data);

    break;

  case CIL_CAT:

    cil_destroy_category(*data);

    break;

  case CIL_CATSET:

    cil_destroy_catset(*data);

    break;

  case CIL_CATALIAS:

    cil_destroy_alias(*data);

    break;

  case CIL_CATALIASACTUAL:

    cil_destroy_aliasactual(*data);

    break;

  case CIL_CATORDER:

    cil_destroy_ordered(*data);

    break;

  case CIL_LEVEL:

    cil_destroy_level(*data);

    break;

  case CIL_LEVELRANGE:

    cil_destroy_levelrange(*data);

    break;

  case CIL_SID:

    cil_destroy_sid(*data);

    break;

  case CIL_SIDORDER:

    cil_destroy_ordered(*data);

    break;

  case CIL_ROLEALLOW:

    cil_destroy_roleallow(*data);

    break;

  case CIL_AVRULE:

  case CIL_AVRULEX:

    cil_destroy_avrule(*data);

    break;

  case CIL_PERMISSIONX:

    cil_destroy_permissionx(*data);

    break;

  case CIL_DENY_RULE:

    cil_destroy_deny_rule(*data);

    break;

  case CIL_ROLETRANSITION:

    cil_destroy_roletransition(*data);

    break;

  case CIL_TYPE_RULE:

    cil_destroy_type_rule(*data);

    break;

  case CIL_NAMETYPETRANSITION:

    cil_destroy_typetransition(*data);

    break;

  case CIL_RANGETRANSITION:

    cil_destroy_rangetransition(*data);

    break;