Loadable policy module infrastructure

diff -burNd a1/libsepol/include/sepol/avtab.h b/libsepol/include/sepol/avtab.h
@@ -101,9 +101,6 @@
 
 avtab_ptr_t avtab_insert_nonunique(avtab_t * h, avtab_key_t * key, avtab_datum_t * datum);
 
-avtab_ptr_t avtab_insert_with_parse_context(avtab_t *h, avtab_key_t *key,
-					    avtab_datum_t *datum, void *parse_context);
-
 avtab_ptr_t avtab_search_node(avtab_t * h, avtab_key_t * key, int specified);
 
 avtab_ptr_t avtab_search_node_next(avtab_ptr_t node, int specified);

diff -burNd a1/libsepol/include/sepol/conditional.h b/libsepol/include/sepol/conditional.h
@@ -74,27 +74,34 @@
 typedef struct cond_node {
 	int cur_state;
 	cond_expr_t *expr;
+	/* these true/false lists point into te_avtab when that is used */
+	cond_av_list_t *true_list;
+	cond_av_list_t *false_list;
+	/* and these are using during parsing and for modules */
+	avrule_t *avtrue_list;
+	avrule_t *avfalse_list;
 	/* these fields are not written to binary policy */
 	int nbools;
 	uint32_t bool_ids[COND_MAX_BOOLS];
 	uint32_t expr_pre_comp;
 	/*                                               */
-	cond_av_list_t *true_list;
-	cond_av_list_t *false_list;
 	struct cond_node *next;
 } cond_node_t;
 
 int cond_evaluate_expr(policydb_t *p, cond_expr_t *expr);
+cond_expr_t *cond_copy_expr(cond_expr_t *expr);
 
 int cond_normalize_expr(policydb_t *p, cond_node_t *cn);
-cond_node_t *cond_node_search(policydb_t *p,cond_node_t *cn);
+void cond_node_destroy(cond_node_t *node);
+cond_node_t *cond_node_search(policydb_t *p, cond_node_t *list ,cond_node_t *cn);
 int evaluate_conds(policydb_t *p);
-avtab_datum_t *cond_av_list_search(avtab_key_t *key, cond_av_list_t *cond_list);
 
 void cond_optimize_lists(cond_list_t *cl);
+avtab_datum_t *cond_av_list_search(avtab_key_t *key, cond_av_list_t *cond_list);
 
 int cond_policydb_init(policydb_t* p);
 void cond_policydb_destroy(policydb_t* p);
+void cond_list_destroy(cond_list_t *list);
 
 int cond_init_bool_indexes(policydb_t* p);
 int cond_destroy_bool(hashtab_key_t key, hashtab_datum_t datum, void *p);

@@ -102,7 +109,7 @@
 int cond_index_bool(hashtab_key_t key, hashtab_datum_t datum, void *datap);
 
 int cond_read_bool(policydb_t *p, hashtab_t h, struct policy_file *fp);
-int cond_read_list(policydb_t *p, void *fp);
+int cond_read_list(policydb_t *p, cond_list_t **list, void *fp);
 
 void cond_compute_av(avtab_t *ctab, avtab_key_t *key, struct sepol_av_decision *avd);
 

diff -burNd a1/libsepol/include/sepol/ebitmap.h b/libsepol/include/sepol/ebitmap.h
@@ -47,6 +47,7 @@
 
 int ebitmap_cmp(ebitmap_t * e1, ebitmap_t * e2);
 int ebitmap_or(ebitmap_t * dst, ebitmap_t * e1, ebitmap_t * e2);
+int ebitmap_or_eq(ebitmap_t *dst, ebitmap_t *e1);
 int ebitmap_cpy(ebitmap_t * dst, ebitmap_t * src);
 int ebitmap_contains(ebitmap_t * e1, ebitmap_t * e2);
 int ebitmap_get_bit(ebitmap_t * e, unsigned int bit);

diff -burNd a1/libsepol/include/sepol/expand.h b/libsepol/include/sepol/expand.h
@@ -0,0 +1,40 @@
+/* Authors: Jason Tang <[email protected]>
+ *	    Joshua Brindle <[email protected]>
+ *          Karl MacMillan <[email protected]>
+ *
+ * A set of utility functions that aid policy decision when dealing
+ * with hierarchal items.
+ *
+ * Copyright (C) 2005 Tresys Technology, LLC
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <sepol/conditional.h>
+
+#ifndef _SEPOL_EXPAND_H
+#define _SEPOL_EXPAND_H
+
+int expand_module(policydb_t *base, policydb_t *out,
+                        int verbose, char *error_buf, size_t error_buf_size);
+int expand_convert_type_set(policydb_t *p, uint32_t *typemap, type_set_t *set, ebitmap_t *types);
+int type_set_expand(type_set_t *set, ebitmap_t *t, policydb_t *p);
+int role_set_expand(role_set_t *x, ebitmap_t *r, policydb_t *p);
+int expand_rule(policydb_t *source_pol,
+                avrule_t *source_rule, avtab_t *dest_avtab,
+                cond_av_list_t **cond, cond_av_list_t **other,
+                int enabled, char **error_msg);
+
+#endif

diff -burNd a1/libsepol/include/sepol/flask_types.h b/libsepol/include/sepol/flask_types.h
@@ -43,9 +43,11 @@
  * generated header file flask.h.
  */
 typedef uint16_t sepol_security_class_t;
+
 #define SEPOL_SECCLASS_NULL			0x0000 /* no class */
 
 #define SELINUX_MAGIC 0xf97cff8c 
+#define SELINUX_MOD_MAGIC 0xf97cff8d
 
 typedef uint32_t sepol_security_id_t;
 #define SEPOL_SECSID_NULL 0

diff -burNd a1/libsepol/include/sepol/hierarchy.h b/libsepol/include/sepol/hierarchy.h
@@ -1,6 +1,5 @@
 /* Authors: Jason Tang <[email protected]>
  *	    Joshua Brindle <[email protected]>
- *          Karl MacMillan <[email protected]>
  *
  * A set of utility functions that aid policy decision when dealing
  * with hierarchal items.

@@ -22,12 +21,10 @@
  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-#ifndef _HIERARCHY_H_
-#define _HIERARCHY_H_
-
-#include <sepol/avtab.h>
-#include <sepol/hashtab.h>
-
-int hierarchy_check_constraints(policydb_t *p, char *error_msg, uint32_t error_len);
+#ifndef _SEPOL_HIERARCHY_H
+#define _SEPOL_HIERARCHY_H_
 
+int hierarchy_is_valid_name (char *);
+int hierarchy_check_constraints(policydb_t *p, char *error_msg,
+                                uint32_t error_len);
 #endif

257 lines not on this page · raw message

95 lines not on this page · raw message

diff -burNd a1/libsepol/src/avtab.c b/libsepol/src/avtab.c
@@ -46,7 +46,7 @@
  AVTAB_HASH_MASK)
 
 static avtab_ptr_t 
-   avtab_insert_node(avtab_t *h, int hvalue, avtab_ptr_t prev, avtab_ptr_t cur, avtab_key_t *key, avtab_datum_t *datum)
+   avtab_insert_node(avtab_t *h, int hvalue, avtab_ptr_t prev, avtab_key_t *key, avtab_datum_t *datum)
 {
 	avtab_ptr_t newnode;
 	newnode = (avtab_ptr_t) malloc(sizeof(struct avtab_node));

@@ -68,7 +68,6 @@
 }
 
 
-
 int avtab_insert(avtab_t * h, avtab_key_t * key, avtab_datum_t * datum)
 {
 	int hvalue;

@@ -97,7 +96,7 @@
 			break;
 	}
 
-	newnode = avtab_insert_node(h, hvalue, prev, cur, key, datum);
+	newnode = avtab_insert_node(h, hvalue, prev, key, datum);
 	if(!newnode)
 		return -ENOMEM;
 

@@ -135,28 +134,7 @@
 		    key->target_class < cur->key.target_class)
 			break;
 	}
-	newnode = avtab_insert_node(h, hvalue, prev, cur, key, datum);
-	
-	return newnode;
-}
-
-/* Unlike avtab_insert(), this function stores a caller-provided parse_context pointer, AND
- * allow multiple insertions of the same key/specified mask into the table, AND returns
- * a pointer to the new node added, all as needed by the conditional avtab.  
- */
-avtab_ptr_t
- avtab_insert_with_parse_context(avtab_t *h, avtab_key_t *key, avtab_datum_t *datum, void *parse_context)
-{
-	avtab_ptr_t newnode;
-
-	if (!h)
-		return NULL;
-
-	newnode = avtab_insert_nonunique(h, key, datum);
-	if(!newnode)
-		return NULL;
-		
-	newnode->parse_context = parse_context;
+	newnode = avtab_insert_node(h, hvalue, prev, key, datum);
 		
 	return newnode;			
 }

142 lines not on this page · raw message

diff -burNd a1/libsepol/src/ebitmap.c b/libsepol/src/ebitmap.c
@@ -1,5 +1,26 @@
 
-/* Author : Stephen Smalley, <[email protected]> */
+/* Author : Stephen Smalley, <[email protected]> 
+ *
+ * Updated: Karl MacMillan <[email protected]>
+ *
+ *      Added support for binary policy modules
+ *
+ * Copyright (C) 2005 Tresys Technology, LLC
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
 
 /* FLASK */
 

@@ -58,6 +79,19 @@
 	return 0;
 }
 
+int ebitmap_or_eq(ebitmap_t *dst, ebitmap_t *e1)
+{
+       int ret;
+       ebitmap_t tmp;
+
+       if (ebitmap_or(&tmp, dst, e1))
+               return -1;
+       ebitmap_destroy(dst);
+       ret = ebitmap_cpy(dst, &tmp);
+       ebitmap_destroy(&tmp);
+               
+       return ret;
+}
 
 int ebitmap_cmp(ebitmap_t * e1, ebitmap_t * e2)
 {

diff -burNd a1/libsepol/src/genbools.c b/libsepol/src/genbools.c
@@ -126,7 +125,7 @@
 
 	/* Preserve the policy version of the original policy
 	   for the new policy. */
-	sepol_set_policyvers(policydb.policyvers);
+	sepol_set_policyvers(POLICY_KERN, policydb.policyvers);
 
 	if (load_booleans(&policydb, booleans) < 0) {
 		__sepol_debug_printf("%s:  Warning!  Error while reading %s\n",

@@ -189,7 +176,7 @@
 
 	/* Preserve the policy version of the original policy
 	   for the new policy. */
-	sepol_set_policyvers(policydb.policyvers);
+	sepol_set_policyvers(POLICY_KERN, policydb.policyvers);
 
 	for (i = 0; i < nel; i++) {
 		datum = hashtab_search(policydb.p_bools.table, names[i]);

diff -burNd a1/libsepol/src/genusers.c b/libsepol/src/genusers.c
@@ -81,7 +81,7 @@
 		usrdatum = hashtab_search(policydb->p_users.table, q);
 		if (usrdatum) {
 			/* Replacing an existing user definition. */
-			ebitmap_init(&usrdatum->roles);
+			ebitmap_init(&usrdatum->roles.roles);
 			usrdatum->defined = 1;
 		} else {
 			char *id = strdup(q);

@@ -98,7 +98,7 @@
 			}
 			memset(usrdatum, 0, sizeof(user_datum_t));
 			usrdatum->value = ++policydb->p_users.nprim;
-			ebitmap_init(&usrdatum->roles);
+			ebitmap_init(&usrdatum->roles.roles);
 			usrdatum->defined = 1;
 			rc = hashtab_insert(policydb->p_users.table,
 					    id, (hashtab_datum_t) usrdatum);

@@ -158,7 +158,7 @@
 			/* Set the role and every role it dominates */
 			for (bit = ebitmap_startbit(&roldatum->dominates); bit < ebitmap_length(&roldatum->dominates); bit++) {
 				if (ebitmap_get_bit(&roldatum->dominates, bit))
-					if (ebitmap_set_bit(&usrdatum->roles, bit, 1)) {
+					if (ebitmap_set_bit(&usrdatum->roles.roles, bit, 1)) {
 						__sepol_debug_printf("%s:  out of memory for %s on line %u\n",
 							path, buffer, lineno);
 						errno = ENOMEM;

@@ -309,7 +309,7 @@
 	usrdatum = (user_datum_t *) datum;
 	ebitmap_set_bit(free_users, usrdatum->value - 1, 1);
 
-	ebitmap_destroy(&usrdatum->roles);
+	ebitmap_destroy(&usrdatum->roles.roles);
 	free(datum);
 	pol->p_users.nprim--;
 }

@@ -389,7 +389,7 @@
 	/* Set the policy version for the new binary policy image we are
 	   about to generate so that it stays the same as the original,
 	   even if we support a newer one. */
-	sepol_set_policyvers(policydb.policyvers);
+	sepol_set_policyvers(policydb.policyvers, POLICY_KERN);
 
 	/* Compute the length for the new binary policy image. */
 	pf.type = PF_LEN;

diff -burNd a1/libsepol/src/hierarchy.c b/libsepol/src/hierarchy.c
@@ -302,12 +302,12 @@
 		return 1;
 	}
 
-	if (ebitmap_or(&eb, &r->types, &rp->types)) {
+	if (ebitmap_or(&eb, &r->types.types, &rp->types.types)) {
 		/* Memory error */
 		return -1;
 	}
 	
-	if (!ebitmap_cmp(&eb, &rp->types)) {
+	if (!ebitmap_cmp(&eb, &rp->types.types)) {
 		ebitmap_destroy(&eb);
 		/* This is a violation of the hiearchal constraint, return error condition */
 		snprintf(a->errmsg, ERRMSG_LEN, "Role hierarchy violation, %s exceeds %s",

1,288 lines not on this page · raw message

diff -burNd a1/libsepol/src/private.h b/libsepol/src/private.h
@@ -19,40 +19,40 @@
 
 /* Policy compatibility information. */
 struct policydb_compat_info {
+	int type;
 	int version;
 	int sym_num;
 	int ocon_num;
 };
 
-extern struct policydb_compat_info *policydb_lookup_compat(int version);
+extern struct policydb_compat_info *policydb_lookup_compat(int version, int type);
 extern void __sepol_debug_printf(const char *fmt, ...);
 
 /* Reading from a policy "file". */
 static inline void *next_entry(struct policy_file * fp, size_t bytes)
 {
-	static unsigned char buffer[BUFSIZ];
 	size_t nread;
 
-	if (bytes > sizeof buffer)
+	if (bytes > sizeof(fp->buffer))
 		return NULL;
 
 	switch (fp->type) {
 	case PF_USE_STDIO:
-		nread = fread(buffer, bytes, 1, fp->fp);
+		nread = fread(fp->buffer, bytes, 1, fp->fp);
 		if (nread != 1)
 			return NULL;
 		break;
 	case PF_USE_MEMORY:
 		if (bytes > fp->len) 
 			return NULL;
-		memcpy(buffer, fp->data, bytes);
+		memcpy(fp->buffer, fp->data, bytes);
 		fp->data += bytes;
 		fp->len -= bytes;
 		break;
 	default:
 		return NULL;
 	}
-	return buffer;
+	return fp->buffer;
 }
 
 extern int mls_enabled;

diff -burNd a1/libsepol/src/services.c b/libsepol/src/services.c
@@ -1370,13 +1347,13 @@
 	}
 	memset(mysids, 0, maxnel*sizeof(sepol_security_id_t));
 
-	for (i = ebitmap_startbit(&user->roles); i < ebitmap_length(&user->roles); i++) {
-		if (!ebitmap_get_bit(&user->roles, i)) 
+	for (i = ebitmap_startbit(&user->roles.roles); i < ebitmap_length(&user->roles.roles); i++) {
+		if (!ebitmap_get_bit(&user->roles.roles, i)) 
 			continue;		
 		role = policydb->role_val_to_struct[i];
 		usercon.role = i+1;
-		for (j = ebitmap_startbit(&role->types); j < ebitmap_length(&role->types); j++) {
-			if (!ebitmap_get_bit(&role->types, j)) 
+		for (j = ebitmap_startbit(&role->types.types); j < ebitmap_length(&role->types.types); j++) {
+			if (!ebitmap_get_bit(&role->types.types, j)) 
 				continue;	
 			usercon.type = j+1;
 			if (usercon.type == fromcon->type)

135 lines not on this page · raw message

704 lines not on this page · raw message