1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Implementation of the policy database.
4  *
5  * Author : Stephen Smalley, <sds@tycho.nsa.gov>
6  */
7 
8 /*
9  * Updated: Trusted Computer Solutions, Inc. <dgoeddel@trustedcs.com>
10  *
11  *	Support for enhanced MLS infrastructure.
12  *
13  * Updated: Frank Mayer <mayerf@tresys.com> and Karl MacMillan <kmacmillan@tresys.com>
14  *
15  *	Added conditional policy language extensions
16  *
17  * Updated: Hewlett-Packard <paul@paul-moore.com>
18  *
19  *      Added support for the policy capability bitmap
20  *
21  * Update: Mellanox Techonologies
22  *
23  *	Added Infiniband support
24  *
25  * Copyright (C) 2016 Mellanox Techonologies
26  * Copyright (C) 2007 Hewlett-Packard Development Company, L.P.
27  * Copyright (C) 2004-2005 Trusted Computer Solutions, Inc.
28  * Copyright (C) 2003 - 2004 Tresys Technology, LLC
29  */
30 
31 #include <linux/kernel.h>
32 #include <linux/sched.h>
33 #include <linux/slab.h>
34 #include <linux/string.h>
35 #include <linux/errno.h>
36 #include <linux/audit.h>
37 #include "security.h"
38 
39 #include "policydb.h"
40 #include "conditional.h"
41 #include "mls.h"
42 #include "services.h"
43 
44 #ifdef DEBUG_HASHES
45 static const char *symtab_name[SYM_NUM] = {
46 	"common prefixes",
47 	"classes",
48 	"roles",
49 	"types",
50 	"users",
51 	"bools",
52 	"levels",
53 	"categories",
54 };
55 #endif
56 
57 struct policydb_compat_info {
58 	int version;
59 	int sym_num;
60 	int ocon_num;
61 };
62 
63 /* These need to be updated if SYM_NUM or OCON_NUM changes */
64 static const struct policydb_compat_info policydb_compat[] = {
65 	{
66 		.version	= POLICYDB_VERSION_BASE,
67 		.sym_num	= SYM_NUM - 3,
68 		.ocon_num	= OCON_NUM - 3,
69 	},
70 	{
71 		.version	= POLICYDB_VERSION_BOOL,
72 		.sym_num	= SYM_NUM - 2,
73 		.ocon_num	= OCON_NUM - 3,
74 	},
75 	{
76 		.version	= POLICYDB_VERSION_IPV6,
77 		.sym_num	= SYM_NUM - 2,
78 		.ocon_num	= OCON_NUM - 2,
79 	},
80 	{
81 		.version	= POLICYDB_VERSION_NLCLASS,
82 		.sym_num	= SYM_NUM - 2,
83 		.ocon_num	= OCON_NUM - 2,
84 	},
85 	{
86 		.version	= POLICYDB_VERSION_MLS,
87 		.sym_num	= SYM_NUM,
88 		.ocon_num	= OCON_NUM - 2,
89 	},
90 	{
91 		.version	= POLICYDB_VERSION_AVTAB,
92 		.sym_num	= SYM_NUM,
93 		.ocon_num	= OCON_NUM - 2,
94 	},
95 	{
96 		.version	= POLICYDB_VERSION_RANGETRANS,
97 		.sym_num	= SYM_NUM,
98 		.ocon_num	= OCON_NUM - 2,
99 	},
100 	{
101 		.version	= POLICYDB_VERSION_POLCAP,
102 		.sym_num	= SYM_NUM,
103 		.ocon_num	= OCON_NUM - 2,
104 	},
105 	{
106 		.version	= POLICYDB_VERSION_PERMISSIVE,
107 		.sym_num	= SYM_NUM,
108 		.ocon_num	= OCON_NUM - 2,
109 	},
110 	{
111 		.version	= POLICYDB_VERSION_BOUNDARY,
112 		.sym_num	= SYM_NUM,
113 		.ocon_num	= OCON_NUM - 2,
114 	},
115 	{
116 		.version	= POLICYDB_VERSION_FILENAME_TRANS,
117 		.sym_num	= SYM_NUM,
118 		.ocon_num	= OCON_NUM - 2,
119 	},
120 	{
121 		.version	= POLICYDB_VERSION_ROLETRANS,
122 		.sym_num	= SYM_NUM,
123 		.ocon_num	= OCON_NUM - 2,
124 	},
125 	{
126 		.version	= POLICYDB_VERSION_NEW_OBJECT_DEFAULTS,
127 		.sym_num	= SYM_NUM,
128 		.ocon_num	= OCON_NUM - 2,
129 	},
130 	{
131 		.version	= POLICYDB_VERSION_DEFAULT_TYPE,
132 		.sym_num	= SYM_NUM,
133 		.ocon_num	= OCON_NUM - 2,
134 	},
135 	{
136 		.version	= POLICYDB_VERSION_CONSTRAINT_NAMES,
137 		.sym_num	= SYM_NUM,
138 		.ocon_num	= OCON_NUM - 2,
139 	},
140 	{
141 		.version	= POLICYDB_VERSION_XPERMS_IOCTL,
142 		.sym_num	= SYM_NUM,
143 		.ocon_num	= OCON_NUM - 2,
144 	},
145 	{
146 		.version	= POLICYDB_VERSION_INFINIBAND,
147 		.sym_num	= SYM_NUM,
148 		.ocon_num	= OCON_NUM,
149 	},
150 	{
151 		.version	= POLICYDB_VERSION_GLBLUB,
152 		.sym_num	= SYM_NUM,
153 		.ocon_num	= OCON_NUM,
154 	},
155 	{
156 		.version	= POLICYDB_VERSION_COMP_FTRANS,
157 		.sym_num	= SYM_NUM,
158 		.ocon_num	= OCON_NUM,
159 	},
160 };
161 
policydb_lookup_compat(int version)162 static const struct policydb_compat_info *policydb_lookup_compat(int version)
163 {
164 	int i;
165 
166 	for (i = 0; i < ARRAY_SIZE(policydb_compat); i++) {
167 		if (policydb_compat[i].version == version)
168 			return &policydb_compat[i];
169 	}
170 
171 	return NULL;
172 }
173 
174 /*
175  * The following *_destroy functions are used to
176  * free any memory allocated for each kind of
177  * symbol data in the policy database.
178  */
179 
perm_destroy(void * key,void * datum,void * p)180 static int perm_destroy(void *key, void *datum, void *p)
181 {
182 	kfree(key);
183 	kfree(datum);
184 	return 0;
185 }
186 
common_destroy(void * key,void * datum,void * p)187 static int common_destroy(void *key, void *datum, void *p)
188 {
189 	struct common_datum *comdatum;
190 
191 	kfree(key);
192 	if (datum) {
193 		comdatum = datum;
194 		hashtab_map(&comdatum->permissions.table, perm_destroy, NULL);
195 		hashtab_destroy(&comdatum->permissions.table);
196 	}
197 	kfree(datum);
198 	return 0;
199 }
200 
constraint_expr_destroy(struct constraint_expr * expr)201 static void constraint_expr_destroy(struct constraint_expr *expr)
202 {
203 	if (expr) {
204 		ebitmap_destroy(&expr->names);
205 		if (expr->type_names) {
206 			ebitmap_destroy(&expr->type_names->types);
207 			ebitmap_destroy(&expr->type_names->negset);
208 			kfree(expr->type_names);
209 		}
210 		kfree(expr);
211 	}
212 }
213 
cls_destroy(void * key,void * datum,void * p)214 static int cls_destroy(void *key, void *datum, void *p)
215 {
216 	struct class_datum *cladatum;
217 	struct constraint_node *constraint, *ctemp;
218 	struct constraint_expr *e, *etmp;
219 
220 	kfree(key);
221 	if (datum) {
222 		cladatum = datum;
223 		hashtab_map(&cladatum->permissions.table, perm_destroy, NULL);
224 		hashtab_destroy(&cladatum->permissions.table);
225 		constraint = cladatum->constraints;
226 		while (constraint) {
227 			e = constraint->expr;
228 			while (e) {
229 				etmp = e;
230 				e = e->next;
231 				constraint_expr_destroy(etmp);
232 			}
233 			ctemp = constraint;
234 			constraint = constraint->next;
235 			kfree(ctemp);
236 		}
237 
238 		constraint = cladatum->validatetrans;
239 		while (constraint) {
240 			e = constraint->expr;
241 			while (e) {
242 				etmp = e;
243 				e = e->next;
244 				constraint_expr_destroy(etmp);
245 			}
246 			ctemp = constraint;
247 			constraint = constraint->next;
248 			kfree(ctemp);
249 		}
250 		kfree(cladatum->comkey);
251 	}
252 	kfree(datum);
253 	return 0;
254 }
255 
role_destroy(void * key,void * datum,void * p)256 static int role_destroy(void *key, void *datum, void *p)
257 {
258 	struct role_datum *role;
259 
260 	kfree(key);
261 	if (datum) {
262 		role = datum;
263 		ebitmap_destroy(&role->dominates);
264 		ebitmap_destroy(&role->types);
265 	}
266 	kfree(datum);
267 	return 0;
268 }
269 
type_destroy(void * key,void * datum,void * p)270 static int type_destroy(void *key, void *datum, void *p)
271 {
272 	kfree(key);
273 	kfree(datum);
274 	return 0;
275 }
276 
user_destroy(void * key,void * datum,void * p)277 static int user_destroy(void *key, void *datum, void *p)
278 {
279 	struct user_datum *usrdatum;
280 
281 	kfree(key);
282 	if (datum) {
283 		usrdatum = datum;
284 		ebitmap_destroy(&usrdatum->roles);
285 		ebitmap_destroy(&usrdatum->range.level[0].cat);
286 		ebitmap_destroy(&usrdatum->range.level[1].cat);
287 		ebitmap_destroy(&usrdatum->dfltlevel.cat);
288 	}
289 	kfree(datum);
290 	return 0;
291 }
292 
sens_destroy(void * key,void * datum,void * p)293 static int sens_destroy(void *key, void *datum, void *p)
294 {
295 	struct level_datum *levdatum;
296 
297 	kfree(key);
298 	if (datum) {
299 		levdatum = datum;
300 		if (levdatum->level)
301 			ebitmap_destroy(&levdatum->level->cat);
302 		kfree(levdatum->level);
303 	}
304 	kfree(datum);
305 	return 0;
306 }
307 
cat_destroy(void * key,void * datum,void * p)308 static int cat_destroy(void *key, void *datum, void *p)
309 {
310 	kfree(key);
311 	kfree(datum);
312 	return 0;
313 }
314 
315 static int (*const destroy_f[SYM_NUM]) (void *key, void *datum, void *datap) = {
316 	common_destroy,
317 	cls_destroy,
318 	role_destroy,
319 	type_destroy,
320 	user_destroy,
321 	cond_destroy_bool,
322 	sens_destroy,
323 	cat_destroy,
324 };
325 
filenametr_destroy(void * key,void * datum,void * p)326 static int filenametr_destroy(void *key, void *datum, void *p)
327 {
328 	struct filename_trans_key *ft = key;
329 	struct filename_trans_datum *next, *d = datum;
330 
331 	kfree(ft->name);
332 	kfree(key);
333 	do {
334 		ebitmap_destroy(&d->stypes);
335 		next = d->next;
336 		kfree(d);
337 		d = next;
338 	} while (unlikely(d));
339 	cond_resched();
340 	return 0;
341 }
342 
range_tr_destroy(void * key,void * datum,void * p)343 static int range_tr_destroy(void *key, void *datum, void *p)
344 {
345 	struct mls_range *rt = datum;
346 
347 	kfree(key);
348 	ebitmap_destroy(&rt->level[0].cat);
349 	ebitmap_destroy(&rt->level[1].cat);
350 	kfree(datum);
351 	cond_resched();
352 	return 0;
353 }
354 
role_tr_destroy(void * key,void * datum,void * p)355 static int role_tr_destroy(void *key, void *datum, void *p)
356 {
357 	kfree(key);
358 	kfree(datum);
359 	return 0;
360 }
361 
ocontext_destroy(struct ocontext * c,int i)362 static void ocontext_destroy(struct ocontext *c, int i)
363 {
364 	if (!c)
365 		return;
366 
367 	context_destroy(&c->context[0]);
368 	context_destroy(&c->context[1]);
369 	if (i == OCON_ISID || i == OCON_FS ||
370 	    i == OCON_NETIF || i == OCON_FSUSE)
371 		kfree(c->u.name);
372 	kfree(c);
373 }
374 
375 /*
376  * Initialize the role table.
377  */
roles_init(struct policydb * p)378 static int roles_init(struct policydb *p)
379 {
380 	char *key = NULL;
381 	int rc;
382 	struct role_datum *role;
383 
384 	role = kzalloc(sizeof(*role), GFP_KERNEL);
385 	if (!role)
386 		return -ENOMEM;
387 
388 	rc = -EINVAL;
389 	role->value = ++p->p_roles.nprim;
390 	if (role->value != OBJECT_R_VAL)
391 		goto out;
392 
393 	rc = -ENOMEM;
394 	key = kstrdup(OBJECT_R, GFP_KERNEL);
395 	if (!key)
396 		goto out;
397 
398 	rc = symtab_insert(&p->p_roles, key, role);
399 	if (rc)
400 		goto out;
401 
402 	return 0;
403 out:
404 	kfree(key);
405 	kfree(role);
406 	return rc;
407 }
408 
filenametr_hash(const void * k)409 static u32 filenametr_hash(const void *k)
410 {
411 	const struct filename_trans_key *ft = k;
412 	unsigned long hash;
413 	unsigned int byte_num;
414 	unsigned char focus;
415 
416 	hash = ft->ttype ^ ft->tclass;
417 
418 	byte_num = 0;
419 	while ((focus = ft->name[byte_num++]))
420 		hash = partial_name_hash(focus, hash);
421 	return hash;
422 }
423 
filenametr_cmp(const void * k1,const void * k2)424 static int filenametr_cmp(const void *k1, const void *k2)
425 {
426 	const struct filename_trans_key *ft1 = k1;
427 	const struct filename_trans_key *ft2 = k2;
428 	int v;
429 
430 	v = ft1->ttype - ft2->ttype;
431 	if (v)
432 		return v;
433 
434 	v = ft1->tclass - ft2->tclass;
435 	if (v)
436 		return v;
437 
438 	return strcmp(ft1->name, ft2->name);
439 
440 }
441 
442 static const struct hashtab_key_params filenametr_key_params = {
443 	.hash = filenametr_hash,
444 	.cmp = filenametr_cmp,
445 };
446 
policydb_filenametr_search(struct policydb * p,struct filename_trans_key * key)447 struct filename_trans_datum *policydb_filenametr_search(
448 	struct policydb *p, struct filename_trans_key *key)
449 {
450 	return hashtab_search(&p->filename_trans, key, filenametr_key_params);
451 }
452 
rangetr_hash(const void * k)453 static u32 rangetr_hash(const void *k)
454 {
455 	const struct range_trans *key = k;
456 
457 	return key->source_type + (key->target_type << 3) +
458 		(key->target_class << 5);
459 }
460 
rangetr_cmp(const void * k1,const void * k2)461 static int rangetr_cmp(const void *k1, const void *k2)
462 {
463 	const struct range_trans *key1 = k1, *key2 = k2;
464 	int v;
465 
466 	v = key1->source_type - key2->source_type;
467 	if (v)
468 		return v;
469 
470 	v = key1->target_type - key2->target_type;
471 	if (v)
472 		return v;
473 
474 	v = key1->target_class - key2->target_class;
475 
476 	return v;
477 }
478 
479 static const struct hashtab_key_params rangetr_key_params = {
480 	.hash = rangetr_hash,
481 	.cmp = rangetr_cmp,
482 };
483 
policydb_rangetr_search(struct policydb * p,struct range_trans * key)484 struct mls_range *policydb_rangetr_search(struct policydb *p,
485 					  struct range_trans *key)
486 {
487 	return hashtab_search(&p->range_tr, key, rangetr_key_params);
488 }
489 
role_trans_hash(const void * k)490 static u32 role_trans_hash(const void *k)
491 {
492 	const struct role_trans_key *key = k;
493 
494 	return key->role + (key->type << 3) + (key->tclass << 5);
495 }
496 
role_trans_cmp(const void * k1,const void * k2)497 static int role_trans_cmp(const void *k1, const void *k2)
498 {
499 	const struct role_trans_key *key1 = k1, *key2 = k2;
500 	int v;
501 
502 	v = key1->role - key2->role;
503 	if (v)
504 		return v;
505 
506 	v = key1->type - key2->type;
507 	if (v)
508 		return v;
509 
510 	return key1->tclass - key2->tclass;
511 }
512 
513 static const struct hashtab_key_params roletr_key_params = {
514 	.hash = role_trans_hash,
515 	.cmp = role_trans_cmp,
516 };
517 
policydb_roletr_search(struct policydb * p,struct role_trans_key * key)518 struct role_trans_datum *policydb_roletr_search(struct policydb *p,
519 						struct role_trans_key *key)
520 {
521 	return hashtab_search(&p->role_tr, key, roletr_key_params);
522 }
523 
524 /*
525  * Initialize a policy database structure.
526  */
policydb_init(struct policydb * p)527 static void policydb_init(struct policydb *p)
528 {
529 	memset(p, 0, sizeof(*p));
530 
531 	avtab_init(&p->te_avtab);
532 	cond_policydb_init(p);
533 
534 	ebitmap_init(&p->filename_trans_ttypes);
535 	ebitmap_init(&p->policycaps);
536 	ebitmap_init(&p->permissive_map);
537 }
538 
539 /*
540  * The following *_index functions are used to
541  * define the val_to_name and val_to_struct arrays
542  * in a policy database structure.  The val_to_name
543  * arrays are used when converting security context
544  * structures into string representations.  The
545  * val_to_struct arrays are used when the attributes
546  * of a class, role, or user are needed.
547  */
548 
common_index(void * key,void * datum,void * datap)549 static int common_index(void *key, void *datum, void *datap)
550 {
551 	struct policydb *p;
552 	struct common_datum *comdatum;
553 
554 	comdatum = datum;
555 	p = datap;
556 	if (!comdatum->value || comdatum->value > p->p_commons.nprim)
557 		return -EINVAL;
558 
559 	p->sym_val_to_name[SYM_COMMONS][comdatum->value - 1] = key;
560 
561 	return 0;
562 }
563 
class_index(void * key,void * datum,void * datap)564 static int class_index(void *key, void *datum, void *datap)
565 {
566 	struct policydb *p;
567 	struct class_datum *cladatum;
568 
569 	cladatum = datum;
570 	p = datap;
571 	if (!cladatum->value || cladatum->value > p->p_classes.nprim)
572 		return -EINVAL;
573 
574 	p->sym_val_to_name[SYM_CLASSES][cladatum->value - 1] = key;
575 	p->class_val_to_struct[cladatum->value - 1] = cladatum;
576 	return 0;
577 }
578 
role_index(void * key,void * datum,void * datap)579 static int role_index(void *key, void *datum, void *datap)
580 {
581 	struct policydb *p;
582 	struct role_datum *role;
583 
584 	role = datum;
585 	p = datap;
586 	if (!role->value
587 	    || role->value > p->p_roles.nprim
588 	    || role->bounds > p->p_roles.nprim)
589 		return -EINVAL;
590 
591 	p->sym_val_to_name[SYM_ROLES][role->value - 1] = key;
592 	p->role_val_to_struct[role->value - 1] = role;
593 	return 0;
594 }
595 
type_index(void * key,void * datum,void * datap)596 static int type_index(void *key, void *datum, void *datap)
597 {
598 	struct policydb *p;
599 	struct type_datum *typdatum;
600 
601 	typdatum = datum;
602 	p = datap;
603 
604 	if (typdatum->primary) {
605 		if (!typdatum->value
606 		    || typdatum->value > p->p_types.nprim
607 		    || typdatum->bounds > p->p_types.nprim)
608 			return -EINVAL;
609 		p->sym_val_to_name[SYM_TYPES][typdatum->value - 1] = key;
610 		p->type_val_to_struct[typdatum->value - 1] = typdatum;
611 	}
612 
613 	return 0;
614 }
615 
user_index(void * key,void * datum,void * datap)616 static int user_index(void *key, void *datum, void *datap)
617 {
618 	struct policydb *p;
619 	struct user_datum *usrdatum;
620 
621 	usrdatum = datum;
622 	p = datap;
623 	if (!usrdatum->value
624 	    || usrdatum->value > p->p_users.nprim
625 	    || usrdatum->bounds > p->p_users.nprim)
626 		return -EINVAL;
627 
628 	p->sym_val_to_name[SYM_USERS][usrdatum->value - 1] = key;
629 	p->user_val_to_struct[usrdatum->value - 1] = usrdatum;
630 	return 0;
631 }
632 
sens_index(void * key,void * datum,void * datap)633 static int sens_index(void *key, void *datum, void *datap)
634 {
635 	struct policydb *p;
636 	struct level_datum *levdatum;
637 
638 	levdatum = datum;
639 	p = datap;
640 
641 	if (!levdatum->isalias) {
642 		if (!levdatum->level->sens ||
643 		    levdatum->level->sens > p->p_levels.nprim)
644 			return -EINVAL;
645 
646 		p->sym_val_to_name[SYM_LEVELS][levdatum->level->sens - 1] = key;
647 	}
648 
649 	return 0;
650 }
651 
cat_index(void * key,void * datum,void * datap)652 static int cat_index(void *key, void *datum, void *datap)
653 {
654 	struct policydb *p;
655 	struct cat_datum *catdatum;
656 
657 	catdatum = datum;
658 	p = datap;
659 
660 	if (!catdatum->isalias) {
661 		if (!catdatum->value || catdatum->value > p->p_cats.nprim)
662 			return -EINVAL;
663 
664 		p->sym_val_to_name[SYM_CATS][catdatum->value - 1] = key;
665 	}
666 
667 	return 0;
668 }
669 
670 static int (*const index_f[SYM_NUM]) (void *key, void *datum, void *datap) = {
671 	common_index,
672 	class_index,
673 	role_index,
674 	type_index,
675 	user_index,
676 	cond_index_bool,
677 	sens_index,
678 	cat_index,
679 };
680 
681 #ifdef DEBUG_HASHES
hash_eval(struct hashtab * h,const char * hash_name)682 static void hash_eval(struct hashtab *h, const char *hash_name)
683 {
684 	struct hashtab_info info;
685 
686 	hashtab_stat(h, &info);
687 	pr_debug("SELinux: %s:  %d entries and %d/%d buckets used, longest chain length %d\n",
688 		 hash_name, h->nel, info.slots_used, h->size,
689 		 info.max_chain_len);
690 }
691 
symtab_hash_eval(struct symtab * s)692 static void symtab_hash_eval(struct symtab *s)
693 {
694 	int i;
695 
696 	for (i = 0; i < SYM_NUM; i++)
697 		hash_eval(&s[i].table, symtab_name[i]);
698 }
699 
700 #else
hash_eval(struct hashtab * h,const char * hash_name)701 static inline void hash_eval(struct hashtab *h, const char *hash_name)
702 {
703 }
704 #endif
705 
706 /*
707  * Define the other val_to_name and val_to_struct arrays
708  * in a policy database structure.
709  *
710  * Caller must clean up on failure.
711  */
policydb_index(struct policydb * p)712 static int policydb_index(struct policydb *p)
713 {
714 	int i, rc;
715 
716 	if (p->mls_enabled)
717 		pr_debug("SELinux:  %d users, %d roles, %d types, %d bools, %d sens, %d cats\n",
718 			 p->p_users.nprim, p->p_roles.nprim, p->p_types.nprim,
719 			 p->p_bools.nprim, p->p_levels.nprim, p->p_cats.nprim);
720 	else
721 		pr_debug("SELinux:  %d users, %d roles, %d types, %d bools\n",
722 			 p->p_users.nprim, p->p_roles.nprim, p->p_types.nprim,
723 			 p->p_bools.nprim);
724 
725 	pr_debug("SELinux:  %d classes, %d rules\n",
726 		 p->p_classes.nprim, p->te_avtab.nel);
727 
728 #ifdef DEBUG_HASHES
729 	avtab_hash_eval(&p->te_avtab, "rules");
730 	symtab_hash_eval(p->symtab);
731 #endif
732 
733 	p->class_val_to_struct = kcalloc(p->p_classes.nprim,
734 					 sizeof(*p->class_val_to_struct),
735 					 GFP_KERNEL);
736 	if (!p->class_val_to_struct)
737 		return -ENOMEM;
738 
739 	p->role_val_to_struct = kcalloc(p->p_roles.nprim,
740 					sizeof(*p->role_val_to_struct),
741 					GFP_KERNEL);
742 	if (!p->role_val_to_struct)
743 		return -ENOMEM;
744 
745 	p->user_val_to_struct = kcalloc(p->p_users.nprim,
746 					sizeof(*p->user_val_to_struct),
747 					GFP_KERNEL);
748 	if (!p->user_val_to_struct)
749 		return -ENOMEM;
750 
751 	p->type_val_to_struct = kvcalloc(p->p_types.nprim,
752 					 sizeof(*p->type_val_to_struct),
753 					 GFP_KERNEL);
754 	if (!p->type_val_to_struct)
755 		return -ENOMEM;
756 
757 	rc = cond_init_bool_indexes(p);
758 	if (rc)
759 		goto out;
760 
761 	for (i = 0; i < SYM_NUM; i++) {
762 		p->sym_val_to_name[i] = kvcalloc(p->symtab[i].nprim,
763 						 sizeof(char *),
764 						 GFP_KERNEL);
765 		if (!p->sym_val_to_name[i])
766 			return -ENOMEM;
767 
768 		rc = hashtab_map(&p->symtab[i].table, index_f[i], p);
769 		if (rc)
770 			goto out;
771 	}
772 	rc = 0;
773 out:
774 	return rc;
775 }
776 
777 /*
778  * Free any memory allocated by a policy database structure.
779  */
policydb_destroy(struct policydb * p)780 void policydb_destroy(struct policydb *p)
781 {
782 	struct ocontext *c, *ctmp;
783 	struct genfs *g, *gtmp;
784 	int i;
785 	struct role_allow *ra, *lra = NULL;
786 
787 	for (i = 0; i < SYM_NUM; i++) {
788 		cond_resched();
789 		hashtab_map(&p->symtab[i].table, destroy_f[i], NULL);
790 		hashtab_destroy(&p->symtab[i].table);
791 	}
792 
793 	for (i = 0; i < SYM_NUM; i++)
794 		kvfree(p->sym_val_to_name[i]);
795 
796 	kfree(p->class_val_to_struct);
797 	kfree(p->role_val_to_struct);
798 	kfree(p->user_val_to_struct);
799 	kvfree(p->type_val_to_struct);
800 
801 	avtab_destroy(&p->te_avtab);
802 
803 	for (i = 0; i < OCON_NUM; i++) {
804 		cond_resched();
805 		c = p->ocontexts[i];
806 		while (c) {
807 			ctmp = c;
808 			c = c->next;
809 			ocontext_destroy(ctmp, i);
810 		}
811 		p->ocontexts[i] = NULL;
812 	}
813 
814 	g = p->genfs;
815 	while (g) {
816 		cond_resched();
817 		kfree(g->fstype);
818 		c = g->head;
819 		while (c) {
820 			ctmp = c;
821 			c = c->next;
822 			ocontext_destroy(ctmp, OCON_FSUSE);
823 		}
824 		gtmp = g;
825 		g = g->next;
826 		kfree(gtmp);
827 	}
828 	p->genfs = NULL;
829 
830 	cond_policydb_destroy(p);
831 
832 	hashtab_map(&p->role_tr, role_tr_destroy, NULL);
833 	hashtab_destroy(&p->role_tr);
834 
835 	for (ra = p->role_allow; ra; ra = ra->next) {
836 		cond_resched();
837 		kfree(lra);
838 		lra = ra;
839 	}
840 	kfree(lra);
841 
842 	hashtab_map(&p->filename_trans, filenametr_destroy, NULL);
843 	hashtab_destroy(&p->filename_trans);
844 
845 	hashtab_map(&p->range_tr, range_tr_destroy, NULL);
846 	hashtab_destroy(&p->range_tr);
847 
848 	if (p->type_attr_map_array) {
849 		for (i = 0; i < p->p_types.nprim; i++)
850 			ebitmap_destroy(&p->type_attr_map_array[i]);
851 		kvfree(p->type_attr_map_array);
852 	}
853 
854 	ebitmap_destroy(&p->filename_trans_ttypes);
855 	ebitmap_destroy(&p->policycaps);
856 	ebitmap_destroy(&p->permissive_map);
857 }
858 
859 /*
860  * Load the initial SIDs specified in a policy database
861  * structure into a SID table.
862  */
policydb_load_isids(struct policydb * p,struct sidtab * s)863 int policydb_load_isids(struct policydb *p, struct sidtab *s)
864 {
865 	struct ocontext *head, *c;
866 	int rc;
867 
868 	rc = sidtab_init(s);
869 	if (rc) {
870 		pr_err("SELinux:  out of memory on SID table init\n");
871 		return rc;
872 	}
873 
874 	head = p->ocontexts[OCON_ISID];
875 	for (c = head; c; c = c->next) {
876 		u32 sid = c->sid[0];
877 		const char *name = security_get_initial_sid_context(sid);
878 
879 		if (sid == SECSID_NULL) {
880 			pr_err("SELinux:  SID 0 was assigned a context.\n");
881 			sidtab_destroy(s);
882 			return -EINVAL;
883 		}
884 
885 		/* Ignore initial SIDs unused by this kernel. */
886 		if (!name)
887 			continue;
888 
889 		rc = sidtab_set_initial(s, sid, &c->context[0]);
890 		if (rc) {
891 			pr_err("SELinux:  unable to load initial SID %s.\n",
892 			       name);
893 			sidtab_destroy(s);
894 			return rc;
895 		}
896 	}
897 	return 0;
898 }
899 
policydb_class_isvalid(struct policydb * p,unsigned int class)900 int policydb_class_isvalid(struct policydb *p, unsigned int class)
901 {
902 	if (!class || class > p->p_classes.nprim)
903 		return 0;
904 	return 1;
905 }
906 
policydb_role_isvalid(struct policydb * p,unsigned int role)907 int policydb_role_isvalid(struct policydb *p, unsigned int role)
908 {
909 	if (!role || role > p->p_roles.nprim)
910 		return 0;
911 	return 1;
912 }
913 
policydb_type_isvalid(struct policydb * p,unsigned int type)914 int policydb_type_isvalid(struct policydb *p, unsigned int type)
915 {
916 	if (!type || type > p->p_types.nprim)
917 		return 0;
918 	return 1;
919 }
920 
921 /*
922  * Return 1 if the fields in the security context
923  * structure `c' are valid.  Return 0 otherwise.
924  */
policydb_context_isvalid(struct policydb * p,struct context * c)925 int policydb_context_isvalid(struct policydb *p, struct context *c)
926 {
927 	struct role_datum *role;
928 	struct user_datum *usrdatum;
929 
930 	if (!c->role || c->role > p->p_roles.nprim)
931 		return 0;
932 
933 	if (!c->user || c->user > p->p_users.nprim)
934 		return 0;
935 
936 	if (!c->type || c->type > p->p_types.nprim)
937 		return 0;
938 
939 	if (c->role != OBJECT_R_VAL) {
940 		/*
941 		 * Role must be authorized for the type.
942 		 */
943 		role = p->role_val_to_struct[c->role - 1];
944 		if (!role || !ebitmap_get_bit(&role->types, c->type - 1))
945 			/* role may not be associated with type */
946 			return 0;
947 
948 		/*
949 		 * User must be authorized for the role.
950 		 */
951 		usrdatum = p->user_val_to_struct[c->user - 1];
952 		if (!usrdatum)
953 			return 0;
954 
955 		if (!ebitmap_get_bit(&usrdatum->roles, c->role - 1))
956 			/* user may not be associated with role */
957 			return 0;
958 	}
959 
960 	if (!mls_context_isvalid(p, c))
961 		return 0;
962 
963 	return 1;
964 }
965 
966 /*
967  * Read a MLS range structure from a policydb binary
968  * representation file.
969  */
mls_read_range_helper(struct mls_range * r,void * fp)970 static int mls_read_range_helper(struct mls_range *r, void *fp)
971 {
972 	__le32 buf[2];
973 	u32 items;
974 	int rc;
975 
976 	rc = next_entry(buf, fp, sizeof(u32));
977 	if (rc)
978 		goto out;
979 
980 	rc = -EINVAL;
981 	items = le32_to_cpu(buf[0]);
982 	if (items > ARRAY_SIZE(buf)) {
983 		pr_err("SELinux: mls:  range overflow\n");
984 		goto out;
985 	}
986 
987 	rc = next_entry(buf, fp, sizeof(u32) * items);
988 	if (rc) {
989 		pr_err("SELinux: mls:  truncated range\n");
990 		goto out;
991 	}
992 
993 	r->level[0].sens = le32_to_cpu(buf[0]);
994 	if (items > 1)
995 		r->level[1].sens = le32_to_cpu(buf[1]);
996 	else
997 		r->level[1].sens = r->level[0].sens;
998 
999 	rc = ebitmap_read(&r->level[0].cat, fp);
1000 	if (rc) {
1001 		pr_err("SELinux: mls:  error reading low categories\n");
1002 		goto out;
1003 	}
1004 	if (items > 1) {
1005 		rc = ebitmap_read(&r->level[1].cat, fp);
1006 		if (rc) {
1007 			pr_err("SELinux: mls:  error reading high categories\n");
1008 			goto bad_high;
1009 		}
1010 	} else {
1011 		rc = ebitmap_cpy(&r->level[1].cat, &r->level[0].cat);
1012 		if (rc) {
1013 			pr_err("SELinux: mls:  out of memory\n");
1014 			goto bad_high;
1015 		}
1016 	}
1017 
1018 	return 0;
1019 bad_high:
1020 	ebitmap_destroy(&r->level[0].cat);
1021 out:
1022 	return rc;
1023 }
1024 
1025 /*
1026  * Read and validate a security context structure
1027  * from a policydb binary representation file.
1028  */
context_read_and_validate(struct context * c,struct policydb * p,void * fp)1029 static int context_read_and_validate(struct context *c,
1030 				     struct policydb *p,
1031 				     void *fp)
1032 {
1033 	__le32 buf[3];
1034 	int rc;
1035 
1036 	rc = next_entry(buf, fp, sizeof buf);
1037 	if (rc) {
1038 		pr_err("SELinux: context truncated\n");
1039 		goto out;
1040 	}
1041 	c->user = le32_to_cpu(buf[0]);
1042 	c->role = le32_to_cpu(buf[1]);
1043 	c->type = le32_to_cpu(buf[2]);
1044 	if (p->policyvers >= POLICYDB_VERSION_MLS) {
1045 		rc = mls_read_range_helper(&c->range, fp);
1046 		if (rc) {
1047 			pr_err("SELinux: error reading MLS range of context\n");
1048 			goto out;
1049 		}
1050 	}
1051 
1052 	rc = -EINVAL;
1053 	if (!policydb_context_isvalid(p, c)) {
1054 		pr_err("SELinux:  invalid security context\n");
1055 		context_destroy(c);
1056 		goto out;
1057 	}
1058 	rc = 0;
1059 out:
1060 	return rc;
1061 }
1062 
1063 /*
1064  * The following *_read functions are used to
1065  * read the symbol data from a policy database
1066  * binary representation file.
1067  */
1068 
str_read(char ** strp,gfp_t flags,void * fp,u32 len)1069 static int str_read(char **strp, gfp_t flags, void *fp, u32 len)
1070 {
1071 	int rc;
1072 	char *str;
1073 
1074 	if ((len == 0) || (len == (u32)-1))
1075 		return -EINVAL;
1076 
1077 	str = kmalloc(len + 1, flags | __GFP_NOWARN);
1078 	if (!str)
1079 		return -ENOMEM;
1080 
1081 	rc = next_entry(str, fp, len);
1082 	if (rc) {
1083 		kfree(str);
1084 		return rc;
1085 	}
1086 
1087 	str[len] = '\0';
1088 	*strp = str;
1089 	return 0;
1090 }
1091 
perm_read(struct policydb * p,struct symtab * s,void * fp)1092 static int perm_read(struct policydb *p, struct symtab *s, void *fp)
1093 {
1094 	char *key = NULL;
1095 	struct perm_datum *perdatum;
1096 	int rc;
1097 	__le32 buf[2];
1098 	u32 len;
1099 
1100 	perdatum = kzalloc(sizeof(*perdatum), GFP_KERNEL);
1101 	if (!perdatum)
1102 		return -ENOMEM;
1103 
1104 	rc = next_entry(buf, fp, sizeof buf);
1105 	if (rc)
1106 		goto bad;
1107 
1108 	len = le32_to_cpu(buf[0]);
1109 	perdatum->value = le32_to_cpu(buf[1]);
1110 
1111 	rc = str_read(&key, GFP_KERNEL, fp, len);
1112 	if (rc)
1113 		goto bad;
1114 
1115 	rc = symtab_insert(s, key, perdatum);
1116 	if (rc)
1117 		goto bad;
1118 
1119 	return 0;
1120 bad:
1121 	perm_destroy(key, perdatum, NULL);
1122 	return rc;
1123 }
1124 
common_read(struct policydb * p,struct symtab * s,void * fp)1125 static int common_read(struct policydb *p, struct symtab *s, void *fp)
1126 {
1127 	char *key = NULL;
1128 	struct common_datum *comdatum;
1129 	__le32 buf[4];
1130 	u32 len, nel;
1131 	int i, rc;
1132 
1133 	comdatum = kzalloc(sizeof(*comdatum), GFP_KERNEL);
1134 	if (!comdatum)
1135 		return -ENOMEM;
1136 
1137 	rc = next_entry(buf, fp, sizeof buf);
1138 	if (rc)
1139 		goto bad;
1140 
1141 	len = le32_to_cpu(buf[0]);
1142 	comdatum->value = le32_to_cpu(buf[1]);
1143 	nel = le32_to_cpu(buf[3]);
1144 
1145 	rc = symtab_init(&comdatum->permissions, nel);
1146 	if (rc)
1147 		goto bad;
1148 	comdatum->permissions.nprim = le32_to_cpu(buf[2]);
1149 
1150 	rc = str_read(&key, GFP_KERNEL, fp, len);
1151 	if (rc)
1152 		goto bad;
1153 
1154 	for (i = 0; i < nel; i++) {
1155 		rc = perm_read(p, &comdatum->permissions, fp);
1156 		if (rc)
1157 			goto bad;
1158 	}
1159 
1160 	rc = symtab_insert(s, key, comdatum);
1161 	if (rc)
1162 		goto bad;
1163 	return 0;
1164 bad:
1165 	common_destroy(key, comdatum, NULL);
1166 	return rc;
1167 }
1168 
type_set_init(struct type_set * t)1169 static void type_set_init(struct type_set *t)
1170 {
1171 	ebitmap_init(&t->types);
1172 	ebitmap_init(&t->negset);
1173 }
1174 
type_set_read(struct type_set * t,void * fp)1175 static int type_set_read(struct type_set *t, void *fp)
1176 {
1177 	__le32 buf[1];
1178 	int rc;
1179 
1180 	if (ebitmap_read(&t->types, fp))
1181 		return -EINVAL;
1182 	if (ebitmap_read(&t->negset, fp))
1183 		return -EINVAL;
1184 
1185 	rc = next_entry(buf, fp, sizeof(u32));
1186 	if (rc < 0)
1187 		return -EINVAL;
1188 	t->flags = le32_to_cpu(buf[0]);
1189 
1190 	return 0;
1191 }
1192 
1193 
read_cons_helper(struct policydb * p,struct constraint_node ** nodep,int ncons,int allowxtarget,void * fp)1194 static int read_cons_helper(struct policydb *p,
1195 				struct constraint_node **nodep,
1196 				int ncons, int allowxtarget, void *fp)
1197 {
1198 	struct constraint_node *c, *lc;
1199 	struct constraint_expr *e, *le;
1200 	__le32 buf[3];
1201 	u32 nexpr;
1202 	int rc, i, j, depth;
1203 
1204 	lc = NULL;
1205 	for (i = 0; i < ncons; i++) {
1206 		c = kzalloc(sizeof(*c), GFP_KERNEL);
1207 		if (!c)
1208 			return -ENOMEM;
1209 
1210 		if (lc)
1211 			lc->next = c;
1212 		else
1213 			*nodep = c;
1214 
1215 		rc = next_entry(buf, fp, (sizeof(u32) * 2));
1216 		if (rc)
1217 			return rc;
1218 		c->permissions = le32_to_cpu(buf[0]);
1219 		nexpr = le32_to_cpu(buf[1]);
1220 		le = NULL;
1221 		depth = -1;
1222 		for (j = 0; j < nexpr; j++) {
1223 			e = kzalloc(sizeof(*e), GFP_KERNEL);
1224 			if (!e)
1225 				return -ENOMEM;
1226 
1227 			if (le)
1228 				le->next = e;
1229 			else
1230 				c->expr = e;
1231 
1232 			rc = next_entry(buf, fp, (sizeof(u32) * 3));
1233 			if (rc)
1234 				return rc;
1235 			e->expr_type = le32_to_cpu(buf[0]);
1236 			e->attr = le32_to_cpu(buf[1]);
1237 			e->op = le32_to_cpu(buf[2]);
1238 
1239 			switch (e->expr_type) {
1240 			case CEXPR_NOT:
1241 				if (depth < 0)
1242 					return -EINVAL;
1243 				break;
1244 			case CEXPR_AND:
1245 			case CEXPR_OR:
1246 				if (depth < 1)
1247 					return -EINVAL;
1248 				depth--;
1249 				break;
1250 			case CEXPR_ATTR:
1251 				if (depth == (CEXPR_MAXDEPTH - 1))
1252 					return -EINVAL;
1253 				depth++;
1254 				break;
1255 			case CEXPR_NAMES:
1256 				if (!allowxtarget && (e->attr & CEXPR_XTARGET))
1257 					return -EINVAL;
1258 				if (depth == (CEXPR_MAXDEPTH - 1))
1259 					return -EINVAL;
1260 				depth++;
1261 				rc = ebitmap_read(&e->names, fp);
1262 				if (rc)
1263 					return rc;
1264 				if (p->policyvers >=
1265 				    POLICYDB_VERSION_CONSTRAINT_NAMES) {
1266 					e->type_names = kzalloc(sizeof
1267 						(*e->type_names), GFP_KERNEL);
1268 					if (!e->type_names)
1269 						return -ENOMEM;
1270 					type_set_init(e->type_names);
1271 					rc = type_set_read(e->type_names, fp);
1272 					if (rc)
1273 						return rc;
1274 				}
1275 				break;
1276 			default:
1277 				return -EINVAL;
1278 			}
1279 			le = e;
1280 		}
1281 		if (depth != 0)
1282 			return -EINVAL;
1283 		lc = c;
1284 	}
1285 
1286 	return 0;
1287 }
1288 
class_read(struct policydb * p,struct symtab * s,void * fp)1289 static int class_read(struct policydb *p, struct symtab *s, void *fp)
1290 {
1291 	char *key = NULL;
1292 	struct class_datum *cladatum;
1293 	__le32 buf[6];
1294 	u32 len, len2, ncons, nel;
1295 	int i, rc;
1296 
1297 	cladatum = kzalloc(sizeof(*cladatum), GFP_KERNEL);
1298 	if (!cladatum)
1299 		return -ENOMEM;
1300 
1301 	rc = next_entry(buf, fp, sizeof(u32)*6);
1302 	if (rc)
1303 		goto bad;
1304 
1305 	len = le32_to_cpu(buf[0]);
1306 	len2 = le32_to_cpu(buf[1]);
1307 	cladatum->value = le32_to_cpu(buf[2]);
1308 	nel = le32_to_cpu(buf[4]);
1309 
1310 	rc = symtab_init(&cladatum->permissions, nel);
1311 	if (rc)
1312 		goto bad;
1313 	cladatum->permissions.nprim = le32_to_cpu(buf[3]);
1314 
1315 	ncons = le32_to_cpu(buf[5]);
1316 
1317 	rc = str_read(&key, GFP_KERNEL, fp, len);
1318 	if (rc)
1319 		goto bad;
1320 
1321 	if (len2) {
1322 		rc = str_read(&cladatum->comkey, GFP_KERNEL, fp, len2);
1323 		if (rc)
1324 			goto bad;
1325 
1326 		rc = -EINVAL;
1327 		cladatum->comdatum = symtab_search(&p->p_commons,
1328 						   cladatum->comkey);
1329 		if (!cladatum->comdatum) {
1330 			pr_err("SELinux:  unknown common %s\n",
1331 			       cladatum->comkey);
1332 			goto bad;
1333 		}
1334 	}
1335 	for (i = 0; i < nel; i++) {
1336 		rc = perm_read(p, &cladatum->permissions, fp);
1337 		if (rc)
1338 			goto bad;
1339 	}
1340 
1341 	rc = read_cons_helper(p, &cladatum->constraints, ncons, 0, fp);
1342 	if (rc)
1343 		goto bad;
1344 
1345 	if (p->policyvers >= POLICYDB_VERSION_VALIDATETRANS) {
1346 		/* grab the validatetrans rules */
1347 		rc = next_entry(buf, fp, sizeof(u32));
1348 		if (rc)
1349 			goto bad;
1350 		ncons = le32_to_cpu(buf[0]);
1351 		rc = read_cons_helper(p, &cladatum->validatetrans,
1352 				ncons, 1, fp);
1353 		if (rc)
1354 			goto bad;
1355 	}
1356 
1357 	if (p->policyvers >= POLICYDB_VERSION_NEW_OBJECT_DEFAULTS) {
1358 		rc = next_entry(buf, fp, sizeof(u32) * 3);
1359 		if (rc)
1360 			goto bad;
1361 
1362 		cladatum->default_user = le32_to_cpu(buf[0]);
1363 		cladatum->default_role = le32_to_cpu(buf[1]);
1364 		cladatum->default_range = le32_to_cpu(buf[2]);
1365 	}
1366 
1367 	if (p->policyvers >= POLICYDB_VERSION_DEFAULT_TYPE) {
1368 		rc = next_entry(buf, fp, sizeof(u32) * 1);
1369 		if (rc)
1370 			goto bad;
1371 		cladatum->default_type = le32_to_cpu(buf[0]);
1372 	}
1373 
1374 	rc = symtab_insert(s, key, cladatum);
1375 	if (rc)
1376 		goto bad;
1377 
1378 	return 0;
1379 bad:
1380 	cls_destroy(key, cladatum, NULL);
1381 	return rc;
1382 }
1383 
role_read(struct policydb * p,struct symtab * s,void * fp)1384 static int role_read(struct policydb *p, struct symtab *s, void *fp)
1385 {
1386 	char *key = NULL;
1387 	struct role_datum *role;
1388 	int rc, to_read = 2;
1389 	__le32 buf[3];
1390 	u32 len;
1391 
1392 	role = kzalloc(sizeof(*role), GFP_KERNEL);
1393 	if (!role)
1394 		return -ENOMEM;
1395 
1396 	if (p->policyvers >= POLICYDB_VERSION_BOUNDARY)
1397 		to_read = 3;
1398 
1399 	rc = next_entry(buf, fp, sizeof(buf[0]) * to_read);
1400 	if (rc)
1401 		goto bad;
1402 
1403 	len = le32_to_cpu(buf[0]);
1404 	role->value = le32_to_cpu(buf[1]);
1405 	if (p->policyvers >= POLICYDB_VERSION_BOUNDARY)
1406 		role->bounds = le32_to_cpu(buf[2]);
1407 
1408 	rc = str_read(&key, GFP_KERNEL, fp, len);
1409 	if (rc)
1410 		goto bad;
1411 
1412 	rc = ebitmap_read(&role->dominates, fp);
1413 	if (rc)
1414 		goto bad;
1415 
1416 	rc = ebitmap_read(&role->types, fp);
1417 	if (rc)
1418 		goto bad;
1419 
1420 	if (strcmp(key, OBJECT_R) == 0) {
1421 		rc = -EINVAL;
1422 		if (role->value != OBJECT_R_VAL) {
1423 			pr_err("SELinux: Role %s has wrong value %d\n",
1424 			       OBJECT_R, role->value);
1425 			goto bad;
1426 		}
1427 		rc = 0;
1428 		goto bad;
1429 	}
1430 
1431 	rc = symtab_insert(s, key, role);
1432 	if (rc)
1433 		goto bad;
1434 	return 0;
1435 bad:
1436 	role_destroy(key, role, NULL);
1437 	return rc;
1438 }
1439 
type_read(struct policydb * p,struct symtab * s,void * fp)1440 static int type_read(struct policydb *p, struct symtab *s, void *fp)
1441 {
1442 	char *key = NULL;
1443 	struct type_datum *typdatum;
1444 	int rc, to_read = 3;
1445 	__le32 buf[4];
1446 	u32 len;
1447 
1448 	typdatum = kzalloc(sizeof(*typdatum), GFP_KERNEL);
1449 	if (!typdatum)
1450 		return -ENOMEM;
1451 
1452 	if (p->policyvers >= POLICYDB_VERSION_BOUNDARY)
1453 		to_read = 4;
1454 
1455 	rc = next_entry(buf, fp, sizeof(buf[0]) * to_read);
1456 	if (rc)
1457 		goto bad;
1458 
1459 	len = le32_to_cpu(buf[0]);
1460 	typdatum->value = le32_to_cpu(buf[1]);
1461 	if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) {
1462 		u32 prop = le32_to_cpu(buf[2]);
1463 
1464 		if (prop & TYPEDATUM_PROPERTY_PRIMARY)
1465 			typdatum->primary = 1;
1466 		if (prop & TYPEDATUM_PROPERTY_ATTRIBUTE)
1467 			typdatum->attribute = 1;
1468 
1469 		typdatum->bounds = le32_to_cpu(buf[3]);
1470 	} else {
1471 		typdatum->primary = le32_to_cpu(buf[2]);
1472 	}
1473 
1474 	rc = str_read(&key, GFP_KERNEL, fp, len);
1475 	if (rc)
1476 		goto bad;
1477 
1478 	rc = symtab_insert(s, key, typdatum);
1479 	if (rc)
1480 		goto bad;
1481 	return 0;
1482 bad:
1483 	type_destroy(key, typdatum, NULL);
1484 	return rc;
1485 }
1486 
1487 
1488 /*
1489  * Read a MLS level structure from a policydb binary
1490  * representation file.
1491  */
mls_read_level(struct mls_level * lp,void * fp)1492 static int mls_read_level(struct mls_level *lp, void *fp)
1493 {
1494 	__le32 buf[1];
1495 	int rc;
1496 
1497 	memset(lp, 0, sizeof(*lp));
1498 
1499 	rc = next_entry(buf, fp, sizeof buf);
1500 	if (rc) {
1501 		pr_err("SELinux: mls: truncated level\n");
1502 		return rc;
1503 	}
1504 	lp->sens = le32_to_cpu(buf[0]);
1505 
1506 	rc = ebitmap_read(&lp->cat, fp);
1507 	if (rc) {
1508 		pr_err("SELinux: mls:  error reading level categories\n");
1509 		return rc;
1510 	}
1511 	return 0;
1512 }
1513 
user_read(struct policydb * p,struct symtab * s,void * fp)1514 static int user_read(struct policydb *p, struct symtab *s, void *fp)
1515 {
1516 	char *key = NULL;
1517 	struct user_datum *usrdatum;
1518 	int rc, to_read = 2;
1519 	__le32 buf[3];
1520 	u32 len;
1521 
1522 	usrdatum = kzalloc(sizeof(*usrdatum), GFP_KERNEL);
1523 	if (!usrdatum)
1524 		return -ENOMEM;
1525 
1526 	if (p->policyvers >= POLICYDB_VERSION_BOUNDARY)
1527 		to_read = 3;
1528 
1529 	rc = next_entry(buf, fp, sizeof(buf[0]) * to_read);
1530 	if (rc)
1531 		goto bad;
1532 
1533 	len = le32_to_cpu(buf[0]);
1534 	usrdatum->value = le32_to_cpu(buf[1]);
1535 	if (p->policyvers >= POLICYDB_VERSION_BOUNDARY)
1536 		usrdatum->bounds = le32_to_cpu(buf[2]);
1537 
1538 	rc = str_read(&key, GFP_KERNEL, fp, len);
1539 	if (rc)
1540 		goto bad;
1541 
1542 	rc = ebitmap_read(&usrdatum->roles, fp);
1543 	if (rc)
1544 		goto bad;
1545 
1546 	if (p->policyvers >= POLICYDB_VERSION_MLS) {
1547 		rc = mls_read_range_helper(&usrdatum->range, fp);
1548 		if (rc)
1549 			goto bad;
1550 		rc = mls_read_level(&usrdatum->dfltlevel, fp);
1551 		if (rc)
1552 			goto bad;
1553 	}
1554 
1555 	rc = symtab_insert(s, key, usrdatum);
1556 	if (rc)
1557 		goto bad;
1558 	return 0;
1559 bad:
1560 	user_destroy(key, usrdatum, NULL);
1561 	return rc;
1562 }
1563 
sens_read(struct policydb * p,struct symtab * s,void * fp)1564 static int sens_read(struct policydb *p, struct symtab *s, void *fp)
1565 {
1566 	char *key = NULL;
1567 	struct level_datum *levdatum;
1568 	int rc;
1569 	__le32 buf[2];
1570 	u32 len;
1571 
1572 	levdatum = kzalloc(sizeof(*levdatum), GFP_ATOMIC);
1573 	if (!levdatum)
1574 		return -ENOMEM;
1575 
1576 	rc = next_entry(buf, fp, sizeof buf);
1577 	if (rc)
1578 		goto bad;
1579 
1580 	len = le32_to_cpu(buf[0]);
1581 	levdatum->isalias = le32_to_cpu(buf[1]);
1582 
1583 	rc = str_read(&key, GFP_ATOMIC, fp, len);
1584 	if (rc)
1585 		goto bad;
1586 
1587 	rc = -ENOMEM;
1588 	levdatum->level = kmalloc(sizeof(*levdatum->level), GFP_ATOMIC);
1589 	if (!levdatum->level)
1590 		goto bad;
1591 
1592 	rc = mls_read_level(levdatum->level, fp);
1593 	if (rc)
1594 		goto bad;
1595 
1596 	rc = symtab_insert(s, key, levdatum);
1597 	if (rc)
1598 		goto bad;
1599 	return 0;
1600 bad:
1601 	sens_destroy(key, levdatum, NULL);
1602 	return rc;
1603 }
1604 
cat_read(struct policydb * p,struct symtab * s,void * fp)1605 static int cat_read(struct policydb *p, struct symtab *s, void *fp)
1606 {
1607 	char *key = NULL;
1608 	struct cat_datum *catdatum;
1609 	int rc;
1610 	__le32 buf[3];
1611 	u32 len;
1612 
1613 	catdatum = kzalloc(sizeof(*catdatum), GFP_ATOMIC);
1614 	if (!catdatum)
1615 		return -ENOMEM;
1616 
1617 	rc = next_entry(buf, fp, sizeof buf);
1618 	if (rc)
1619 		goto bad;
1620 
1621 	len = le32_to_cpu(buf[0]);
1622 	catdatum->value = le32_to_cpu(buf[1]);
1623 	catdatum->isalias = le32_to_cpu(buf[2]);
1624 
1625 	rc = str_read(&key, GFP_ATOMIC, fp, len);
1626 	if (rc)
1627 		goto bad;
1628 
1629 	rc = symtab_insert(s, key, catdatum);
1630 	if (rc)
1631 		goto bad;
1632 	return 0;
1633 bad:
1634 	cat_destroy(key, catdatum, NULL);
1635 	return rc;
1636 }
1637 
1638 static int (*const read_f[SYM_NUM]) (struct policydb *p,
1639 				     struct symtab *s, void *fp) = {
1640 	common_read,
1641 	class_read,
1642 	role_read,
1643 	type_read,
1644 	user_read,
1645 	cond_read_bool,
1646 	sens_read,
1647 	cat_read,
1648 };
1649 
user_bounds_sanity_check(void * key,void * datum,void * datap)1650 static int user_bounds_sanity_check(void *key, void *datum, void *datap)
1651 {
1652 	struct user_datum *upper, *user;
1653 	struct policydb *p = datap;
1654 	int depth = 0;
1655 
1656 	upper = user = datum;
1657 	while (upper->bounds) {
1658 		struct ebitmap_node *node;
1659 		unsigned long bit;
1660 
1661 		if (++depth == POLICYDB_BOUNDS_MAXDEPTH) {
1662 			pr_err("SELinux: user %s: "
1663 			       "too deep or looped boundary",
1664 			       (char *) key);
1665 			return -EINVAL;
1666 		}
1667 
1668 		upper = p->user_val_to_struct[upper->bounds - 1];
1669 		ebitmap_for_each_positive_bit(&user->roles, node, bit) {
1670 			if (ebitmap_get_bit(&upper->roles, bit))
1671 				continue;
1672 
1673 			pr_err("SELinux: boundary violated policy: "
1674 			       "user=%s role=%s bounds=%s\n",
1675 			       sym_name(p, SYM_USERS, user->value - 1),
1676 			       sym_name(p, SYM_ROLES, bit),
1677 			       sym_name(p, SYM_USERS, upper->value - 1));
1678 
1679 			return -EINVAL;
1680 		}
1681 	}
1682 
1683 	return 0;
1684 }
1685 
role_bounds_sanity_check(void * key,void * datum,void * datap)1686 static int role_bounds_sanity_check(void *key, void *datum, void *datap)
1687 {
1688 	struct role_datum *upper, *role;
1689 	struct policydb *p = datap;
1690 	int depth = 0;
1691 
1692 	upper = role = datum;
1693 	while (upper->bounds) {
1694 		struct ebitmap_node *node;
1695 		unsigned long bit;
1696 
1697 		if (++depth == POLICYDB_BOUNDS_MAXDEPTH) {
1698 			pr_err("SELinux: role %s: "
1699 			       "too deep or looped bounds\n",
1700 			       (char *) key);
1701 			return -EINVAL;
1702 		}
1703 
1704 		upper = p->role_val_to_struct[upper->bounds - 1];
1705 		ebitmap_for_each_positive_bit(&role->types, node, bit) {
1706 			if (ebitmap_get_bit(&upper->types, bit))
1707 				continue;
1708 
1709 			pr_err("SELinux: boundary violated policy: "
1710 			       "role=%s type=%s bounds=%s\n",
1711 			       sym_name(p, SYM_ROLES, role->value - 1),
1712 			       sym_name(p, SYM_TYPES, bit),
1713 			       sym_name(p, SYM_ROLES, upper->value - 1));
1714 
1715 			return -EINVAL;
1716 		}
1717 	}
1718 
1719 	return 0;
1720 }
1721 
type_bounds_sanity_check(void * key,void * datum,void * datap)1722 static int type_bounds_sanity_check(void *key, void *datum, void *datap)
1723 {
1724 	struct type_datum *upper;
1725 	struct policydb *p = datap;
1726 	int depth = 0;
1727 
1728 	upper = datum;
1729 	while (upper->bounds) {
1730 		if (++depth == POLICYDB_BOUNDS_MAXDEPTH) {
1731 			pr_err("SELinux: type %s: "
1732 			       "too deep or looped boundary\n",
1733 			       (char *) key);
1734 			return -EINVAL;
1735 		}
1736 
1737 		upper = p->type_val_to_struct[upper->bounds - 1];
1738 		BUG_ON(!upper);
1739 
1740 		if (upper->attribute) {
1741 			pr_err("SELinux: type %s: "
1742 			       "bounded by attribute %s",
1743 			       (char *) key,
1744 			       sym_name(p, SYM_TYPES, upper->value - 1));
1745 			return -EINVAL;
1746 		}
1747 	}
1748 
1749 	return 0;
1750 }
1751 
policydb_bounds_sanity_check(struct policydb * p)1752 static int policydb_bounds_sanity_check(struct policydb *p)
1753 {
1754 	int rc;
1755 
1756 	if (p->policyvers < POLICYDB_VERSION_BOUNDARY)
1757 		return 0;
1758 
1759 	rc = hashtab_map(&p->p_users.table, user_bounds_sanity_check, p);
1760 	if (rc)
1761 		return rc;
1762 
1763 	rc = hashtab_map(&p->p_roles.table, role_bounds_sanity_check, p);
1764 	if (rc)
1765 		return rc;
1766 
1767 	rc = hashtab_map(&p->p_types.table, type_bounds_sanity_check, p);
1768 	if (rc)
1769 		return rc;
1770 
1771 	return 0;
1772 }
1773 
string_to_security_class(struct policydb * p,const char * name)1774 u16 string_to_security_class(struct policydb *p, const char *name)
1775 {
1776 	struct class_datum *cladatum;
1777 
1778 	cladatum = symtab_search(&p->p_classes, name);
1779 	if (!cladatum)
1780 		return 0;
1781 
1782 	return cladatum->value;
1783 }
1784 
string_to_av_perm(struct policydb * p,u16 tclass,const char * name)1785 u32 string_to_av_perm(struct policydb *p, u16 tclass, const char *name)
1786 {
1787 	struct class_datum *cladatum;
1788 	struct perm_datum *perdatum = NULL;
1789 	struct common_datum *comdatum;
1790 
1791 	if (!tclass || tclass > p->p_classes.nprim)
1792 		return 0;
1793 
1794 	cladatum = p->class_val_to_struct[tclass-1];
1795 	comdatum = cladatum->comdatum;
1796 	if (comdatum)
1797 		perdatum = symtab_search(&comdatum->permissions, name);
1798 	if (!perdatum)
1799 		perdatum = symtab_search(&cladatum->permissions, name);
1800 	if (!perdatum)
1801 		return 0;
1802 
1803 	return 1U << (perdatum->value-1);
1804 }
1805 
range_read(struct policydb * p,void * fp)1806 static int range_read(struct policydb *p, void *fp)
1807 {
1808 	struct range_trans *rt = NULL;
1809 	struct mls_range *r = NULL;
1810 	int i, rc;
1811 	__le32 buf[2];
1812 	u32 nel;
1813 
1814 	if (p->policyvers < POLICYDB_VERSION_MLS)
1815 		return 0;
1816 
1817 	rc = next_entry(buf, fp, sizeof(u32));
1818 	if (rc)
1819 		return rc;
1820 
1821 	nel = le32_to_cpu(buf[0]);
1822 
1823 	rc = hashtab_init(&p->range_tr, nel);
1824 	if (rc)
1825 		return rc;
1826 
1827 	for (i = 0; i < nel; i++) {
1828 		rc = -ENOMEM;
1829 		rt = kzalloc(sizeof(*rt), GFP_KERNEL);
1830 		if (!rt)
1831 			goto out;
1832 
1833 		rc = next_entry(buf, fp, (sizeof(u32) * 2));
1834 		if (rc)
1835 			goto out;
1836 
1837 		rt->source_type = le32_to_cpu(buf[0]);
1838 		rt->target_type = le32_to_cpu(buf[1]);
1839 		if (p->policyvers >= POLICYDB_VERSION_RANGETRANS) {
1840 			rc = next_entry(buf, fp, sizeof(u32));
1841 			if (rc)
1842 				goto out;
1843 			rt->target_class = le32_to_cpu(buf[0]);
1844 		} else
1845 			rt->target_class = p->process_class;
1846 
1847 		rc = -EINVAL;
1848 		if (!policydb_type_isvalid(p, rt->source_type) ||
1849 		    !policydb_type_isvalid(p, rt->target_type) ||
1850 		    !policydb_class_isvalid(p, rt->target_class))
1851 			goto out;
1852 
1853 		rc = -ENOMEM;
1854 		r = kzalloc(sizeof(*r), GFP_KERNEL);
1855 		if (!r)
1856 			goto out;
1857 
1858 		rc = mls_read_range_helper(r, fp);
1859 		if (rc)
1860 			goto out;
1861 
1862 		rc = -EINVAL;
1863 		if (!mls_range_isvalid(p, r)) {
1864 			pr_warn("SELinux:  rangetrans:  invalid range\n");
1865 			goto out;
1866 		}
1867 
1868 		rc = hashtab_insert(&p->range_tr, rt, r, rangetr_key_params);
1869 		if (rc)
1870 			goto out;
1871 
1872 		rt = NULL;
1873 		r = NULL;
1874 	}
1875 	hash_eval(&p->range_tr, "rangetr");
1876 	rc = 0;
1877 out:
1878 	kfree(rt);
1879 	kfree(r);
1880 	return rc;
1881 }
1882 
filename_trans_read_helper_compat(struct policydb * p,void * fp)1883 static int filename_trans_read_helper_compat(struct policydb *p, void *fp)
1884 {
1885 	struct filename_trans_key key, *ft = NULL;
1886 	struct filename_trans_datum *last, *datum = NULL;
1887 	char *name = NULL;
1888 	u32 len, stype, otype;
1889 	__le32 buf[4];
1890 	int rc;
1891 
1892 	/* length of the path component string */
1893 	rc = next_entry(buf, fp, sizeof(u32));
1894 	if (rc)
1895 		return rc;
1896 	len = le32_to_cpu(buf[0]);
1897 
1898 	/* path component string */
1899 	rc = str_read(&name, GFP_KERNEL, fp, len);
1900 	if (rc)
1901 		return rc;
1902 
1903 	rc = next_entry(buf, fp, sizeof(u32) * 4);
1904 	if (rc)
1905 		goto out;
1906 
1907 	stype = le32_to_cpu(buf[0]);
1908 	key.ttype = le32_to_cpu(buf[1]);
1909 	key.tclass = le32_to_cpu(buf[2]);
1910 	key.name = name;
1911 
1912 	otype = le32_to_cpu(buf[3]);
1913 
1914 	last = NULL;
1915 	datum = policydb_filenametr_search(p, &key);
1916 	while (datum) {
1917 		if (unlikely(ebitmap_get_bit(&datum->stypes, stype - 1))) {
1918 			/* conflicting/duplicate rules are ignored */
1919 			datum = NULL;
1920 			goto out;
1921 		}
1922 		if (likely(datum->otype == otype))
1923 			break;
1924 		last = datum;
1925 		datum = datum->next;
1926 	}
1927 	if (!datum) {
1928 		rc = -ENOMEM;
1929 		datum = kmalloc(sizeof(*datum), GFP_KERNEL);
1930 		if (!datum)
1931 			goto out;
1932 
1933 		ebitmap_init(&datum->stypes);
1934 		datum->otype = otype;
1935 		datum->next = NULL;
1936 
1937 		if (unlikely(last)) {
1938 			last->next = datum;
1939 		} else {
1940 			rc = -ENOMEM;
1941 			ft = kmemdup(&key, sizeof(key), GFP_KERNEL);
1942 			if (!ft)
1943 				goto out;
1944 
1945 			rc = hashtab_insert(&p->filename_trans, ft, datum,
1946 					    filenametr_key_params);
1947 			if (rc)
1948 				goto out;
1949 			name = NULL;
1950 
1951 			rc = ebitmap_set_bit(&p->filename_trans_ttypes,
1952 					     key.ttype, 1);
1953 			if (rc)
1954 				return rc;
1955 		}
1956 	}
1957 	kfree(name);
1958 	return ebitmap_set_bit(&datum->stypes, stype - 1, 1);
1959 
1960 out:
1961 	kfree(ft);
1962 	kfree(name);
1963 	kfree(datum);
1964 	return rc;
1965 }
1966 
filename_trans_read_helper(struct policydb * p,void * fp)1967 static int filename_trans_read_helper(struct policydb *p, void *fp)
1968 {
1969 	struct filename_trans_key *ft = NULL;
1970 	struct filename_trans_datum **dst, *datum, *first = NULL;
1971 	char *name = NULL;
1972 	u32 len, ttype, tclass, ndatum, i;
1973 	__le32 buf[3];
1974 	int rc;
1975 
1976 	/* length of the path component string */
1977 	rc = next_entry(buf, fp, sizeof(u32));
1978 	if (rc)
1979 		return rc;
1980 	len = le32_to_cpu(buf[0]);
1981 
1982 	/* path component string */
1983 	rc = str_read(&name, GFP_KERNEL, fp, len);
1984 	if (rc)
1985 		return rc;
1986 
1987 	rc = next_entry(buf, fp, sizeof(u32) * 3);
1988 	if (rc)
1989 		goto out;
1990 
1991 	ttype = le32_to_cpu(buf[0]);
1992 	tclass = le32_to_cpu(buf[1]);
1993 
1994 	ndatum = le32_to_cpu(buf[2]);
1995 	if (ndatum == 0) {
1996 		pr_err("SELinux:  Filename transition key with no datum\n");
1997 		rc = -ENOENT;
1998 		goto out;
1999 	}
2000 
2001 	dst = &first;
2002 	for (i = 0; i < ndatum; i++) {
2003 		rc = -ENOMEM;
2004 		datum = kmalloc(sizeof(*datum), GFP_KERNEL);
2005 		if (!datum)
2006 			goto out;
2007 
2008 		*dst = datum;
2009 
2010 		/* ebitmap_read() will at least init the bitmap */
2011 		rc = ebitmap_read(&datum->stypes, fp);
2012 		if (rc)
2013 			goto out;
2014 
2015 		rc = next_entry(buf, fp, sizeof(u32));
2016 		if (rc)
2017 			goto out;
2018 
2019 		datum->otype = le32_to_cpu(buf[0]);
2020 		datum->next = NULL;
2021 
2022 		dst = &datum->next;
2023 	}
2024 
2025 	rc = -ENOMEM;
2026 	ft = kmalloc(sizeof(*ft), GFP_KERNEL);
2027 	if (!ft)
2028 		goto out;
2029 
2030 	ft->ttype = ttype;
2031 	ft->tclass = tclass;
2032 	ft->name = name;
2033 
2034 	rc = hashtab_insert(&p->filename_trans, ft, first,
2035 			    filenametr_key_params);
2036 	if (rc == -EEXIST)
2037 		pr_err("SELinux:  Duplicate filename transition key\n");
2038 	if (rc)
2039 		goto out;
2040 
2041 	return ebitmap_set_bit(&p->filename_trans_ttypes, ttype, 1);
2042 
2043 out:
2044 	kfree(ft);
2045 	kfree(name);
2046 	while (first) {
2047 		datum = first;
2048 		first = first->next;
2049 
2050 		ebitmap_destroy(&datum->stypes);
2051 		kfree(datum);
2052 	}
2053 	return rc;
2054 }
2055 
filename_trans_read(struct policydb * p,void * fp)2056 static int filename_trans_read(struct policydb *p, void *fp)
2057 {
2058 	u32 nel;
2059 	__le32 buf[1];
2060 	int rc, i;
2061 
2062 	if (p->policyvers < POLICYDB_VERSION_FILENAME_TRANS)
2063 		return 0;
2064 
2065 	rc = next_entry(buf, fp, sizeof(u32));
2066 	if (rc)
2067 		return rc;
2068 	nel = le32_to_cpu(buf[0]);
2069 
2070 	if (p->policyvers < POLICYDB_VERSION_COMP_FTRANS) {
2071 		p->compat_filename_trans_count = nel;
2072 
2073 		rc = hashtab_init(&p->filename_trans, (1 << 11));
2074 		if (rc)
2075 			return rc;
2076 
2077 		for (i = 0; i < nel; i++) {
2078 			rc = filename_trans_read_helper_compat(p, fp);
2079 			if (rc)
2080 				return rc;
2081 		}
2082 	} else {
2083 		rc = hashtab_init(&p->filename_trans, nel);
2084 		if (rc)
2085 			return rc;
2086 
2087 		for (i = 0; i < nel; i++) {
2088 			rc = filename_trans_read_helper(p, fp);
2089 			if (rc)
2090 				return rc;
2091 		}
2092 	}
2093 	hash_eval(&p->filename_trans, "filenametr");
2094 	return 0;
2095 }
2096 
genfs_read(struct policydb * p,void * fp)2097 static int genfs_read(struct policydb *p, void *fp)
2098 {
2099 	int i, j, rc;
2100 	u32 nel, nel2, len, len2;
2101 	__le32 buf[1];
2102 	struct ocontext *l, *c;
2103 	struct ocontext *newc = NULL;
2104 	struct genfs *genfs_p, *genfs;
2105 	struct genfs *newgenfs = NULL;
2106 
2107 	rc = next_entry(buf, fp, sizeof(u32));
2108 	if (rc)
2109 		return rc;
2110 	nel = le32_to_cpu(buf[0]);
2111 
2112 	for (i = 0; i < nel; i++) {
2113 		rc = next_entry(buf, fp, sizeof(u32));
2114 		if (rc)
2115 			goto out;
2116 		len = le32_to_cpu(buf[0]);
2117 
2118 		rc = -ENOMEM;
2119 		newgenfs = kzalloc(sizeof(*newgenfs), GFP_KERNEL);
2120 		if (!newgenfs)
2121 			goto out;
2122 
2123 		rc = str_read(&newgenfs->fstype, GFP_KERNEL, fp, len);
2124 		if (rc)
2125 			goto out;
2126 
2127 		for (genfs_p = NULL, genfs = p->genfs; genfs;
2128 		     genfs_p = genfs, genfs = genfs->next) {
2129 			rc = -EINVAL;
2130 			if (strcmp(newgenfs->fstype, genfs->fstype) == 0) {
2131 				pr_err("SELinux:  dup genfs fstype %s\n",
2132 				       newgenfs->fstype);
2133 				goto out;
2134 			}
2135 			if (strcmp(newgenfs->fstype, genfs->fstype) < 0)
2136 				break;
2137 		}
2138 		newgenfs->next = genfs;
2139 		if (genfs_p)
2140 			genfs_p->next = newgenfs;
2141 		else
2142 			p->genfs = newgenfs;
2143 		genfs = newgenfs;
2144 		newgenfs = NULL;
2145 
2146 		rc = next_entry(buf, fp, sizeof(u32));
2147 		if (rc)
2148 			goto out;
2149 
2150 		nel2 = le32_to_cpu(buf[0]);
2151 		for (j = 0; j < nel2; j++) {
2152 			rc = next_entry(buf, fp, sizeof(u32));
2153 			if (rc)
2154 				goto out;
2155 			len = le32_to_cpu(buf[0]);
2156 
2157 			rc = -ENOMEM;
2158 			newc = kzalloc(sizeof(*newc), GFP_KERNEL);
2159 			if (!newc)
2160 				goto out;
2161 
2162 			rc = str_read(&newc->u.name, GFP_KERNEL, fp, len);
2163 			if (rc)
2164 				goto out;
2165 
2166 			rc = next_entry(buf, fp, sizeof(u32));
2167 			if (rc)
2168 				goto out;
2169 
2170 			newc->v.sclass = le32_to_cpu(buf[0]);
2171 			rc = context_read_and_validate(&newc->context[0], p, fp);
2172 			if (rc)
2173 				goto out;
2174 
2175 			for (l = NULL, c = genfs->head; c;
2176 			     l = c, c = c->next) {
2177 				rc = -EINVAL;
2178 				if (!strcmp(newc->u.name, c->u.name) &&
2179 				    (!c->v.sclass || !newc->v.sclass ||
2180 				     newc->v.sclass == c->v.sclass)) {
2181 					pr_err("SELinux:  dup genfs entry (%s,%s)\n",
2182 					       genfs->fstype, c->u.name);
2183 					goto out;
2184 				}
2185 				len = strlen(newc->u.name);
2186 				len2 = strlen(c->u.name);
2187 				if (len > len2)
2188 					break;
2189 			}
2190 
2191 			newc->next = c;
2192 			if (l)
2193 				l->next = newc;
2194 			else
2195 				genfs->head = newc;
2196 			newc = NULL;
2197 		}
2198 	}
2199 	rc = 0;
2200 out:
2201 	if (newgenfs) {
2202 		kfree(newgenfs->fstype);
2203 		kfree(newgenfs);
2204 	}
2205 	ocontext_destroy(newc, OCON_FSUSE);
2206 
2207 	return rc;
2208 }
2209 
ocontext_read(struct policydb * p,const struct policydb_compat_info * info,void * fp)2210 static int ocontext_read(struct policydb *p, const struct policydb_compat_info *info,
2211 			 void *fp)
2212 {
2213 	int i, j, rc;
2214 	u32 nel, len;
2215 	__be64 prefixbuf[1];
2216 	__le32 buf[3];
2217 	struct ocontext *l, *c;
2218 	u32 nodebuf[8];
2219 
2220 	for (i = 0; i < info->ocon_num; i++) {
2221 		rc = next_entry(buf, fp, sizeof(u32));
2222 		if (rc)
2223 			goto out;
2224 		nel = le32_to_cpu(buf[0]);
2225 
2226 		l = NULL;
2227 		for (j = 0; j < nel; j++) {
2228 			rc = -ENOMEM;
2229 			c = kzalloc(sizeof(*c), GFP_KERNEL);
2230 			if (!c)
2231 				goto out;
2232 			if (l)
2233 				l->next = c;
2234 			else
2235 				p->ocontexts[i] = c;
2236 			l = c;
2237 
2238 			switch (i) {
2239 			case OCON_ISID:
2240 				rc = next_entry(buf, fp, sizeof(u32));
2241 				if (rc)
2242 					goto out;
2243 
2244 				c->sid[0] = le32_to_cpu(buf[0]);
2245 				rc = context_read_and_validate(&c->context[0], p, fp);
2246 				if (rc)
2247 					goto out;
2248 				break;
2249 			case OCON_FS:
2250 			case OCON_NETIF:
2251 				rc = next_entry(buf, fp, sizeof(u32));
2252 				if (rc)
2253 					goto out;
2254 				len = le32_to_cpu(buf[0]);
2255 
2256 				rc = str_read(&c->u.name, GFP_KERNEL, fp, len);
2257 				if (rc)
2258 					goto out;
2259 
2260 				rc = context_read_and_validate(&c->context[0], p, fp);
2261 				if (rc)
2262 					goto out;
2263 				rc = context_read_and_validate(&c->context[1], p, fp);
2264 				if (rc)
2265 					goto out;
2266 				break;
2267 			case OCON_PORT:
2268 				rc = next_entry(buf, fp, sizeof(u32)*3);
2269 				if (rc)
2270 					goto out;
2271 				c->u.port.protocol = le32_to_cpu(buf[0]);
2272 				c->u.port.low_port = le32_to_cpu(buf[1]);
2273 				c->u.port.high_port = le32_to_cpu(buf[2]);
2274 				rc = context_read_and_validate(&c->context[0], p, fp);
2275 				if (rc)
2276 					goto out;
2277 				break;
2278 			case OCON_NODE:
2279 				rc = next_entry(nodebuf, fp, sizeof(u32) * 2);
2280 				if (rc)
2281 					goto out;
2282 				c->u.node.addr = nodebuf[0]; /* network order */
2283 				c->u.node.mask = nodebuf[1]; /* network order */
2284 				rc = context_read_and_validate(&c->context[0], p, fp);
2285 				if (rc)
2286 					goto out;
2287 				break;
2288 			case OCON_FSUSE:
2289 				rc = next_entry(buf, fp, sizeof(u32)*2);
2290 				if (rc)
2291 					goto out;
2292 
2293 				rc = -EINVAL;
2294 				c->v.behavior = le32_to_cpu(buf[0]);
2295 				/* Determined at runtime, not in policy DB. */
2296 				if (c->v.behavior == SECURITY_FS_USE_MNTPOINT)
2297 					goto out;
2298 				if (c->v.behavior > SECURITY_FS_USE_MAX)
2299 					goto out;
2300 
2301 				len = le32_to_cpu(buf[1]);
2302 				rc = str_read(&c->u.name, GFP_KERNEL, fp, len);
2303 				if (rc)
2304 					goto out;
2305 
2306 				rc = context_read_and_validate(&c->context[0], p, fp);
2307 				if (rc)
2308 					goto out;
2309 				break;
2310 			case OCON_NODE6: {
2311 				int k;
2312 
2313 				rc = next_entry(nodebuf, fp, sizeof(u32) * 8);
2314 				if (rc)
2315 					goto out;
2316 				for (k = 0; k < 4; k++)
2317 					c->u.node6.addr[k] = nodebuf[k];
2318 				for (k = 0; k < 4; k++)
2319 					c->u.node6.mask[k] = nodebuf[k+4];
2320 				rc = context_read_and_validate(&c->context[0], p, fp);
2321 				if (rc)
2322 					goto out;
2323 				break;
2324 			}
2325 			case OCON_IBPKEY: {
2326 				u32 pkey_lo, pkey_hi;
2327 
2328 				rc = next_entry(prefixbuf, fp, sizeof(u64));
2329 				if (rc)
2330 					goto out;
2331 
2332 				/* we need to have subnet_prefix in CPU order */
2333 				c->u.ibpkey.subnet_prefix = be64_to_cpu(prefixbuf[0]);
2334 
2335 				rc = next_entry(buf, fp, sizeof(u32) * 2);
2336 				if (rc)
2337 					goto out;
2338 
2339 				pkey_lo = le32_to_cpu(buf[0]);
2340 				pkey_hi = le32_to_cpu(buf[1]);
2341 
2342 				if (pkey_lo > U16_MAX || pkey_hi > U16_MAX) {
2343 					rc = -EINVAL;
2344 					goto out;
2345 				}
2346 
2347 				c->u.ibpkey.low_pkey  = pkey_lo;
2348 				c->u.ibpkey.high_pkey = pkey_hi;
2349 
2350 				rc = context_read_and_validate(&c->context[0],
2351 							       p,
2352 							       fp);
2353 				if (rc)
2354 					goto out;
2355 				break;
2356 			}
2357 			case OCON_IBENDPORT: {
2358 				u32 port;
2359 
2360 				rc = next_entry(buf, fp, sizeof(u32) * 2);
2361 				if (rc)
2362 					goto out;
2363 				len = le32_to_cpu(buf[0]);
2364 
2365 				rc = str_read(&c->u.ibendport.dev_name, GFP_KERNEL, fp, len);
2366 				if (rc)
2367 					goto out;
2368 
2369 				port = le32_to_cpu(buf[1]);
2370 				if (port > U8_MAX || port == 0) {
2371 					rc = -EINVAL;
2372 					goto out;
2373 				}
2374 
2375 				c->u.ibendport.port = port;
2376 
2377 				rc = context_read_and_validate(&c->context[0],
2378 							       p,
2379 							       fp);
2380 				if (rc)
2381 					goto out;
2382 				break;
2383 			} /* end case */
2384 			} /* end switch */
2385 		}
2386 	}
2387 	rc = 0;
2388 out:
2389 	return rc;
2390 }
2391 
2392 /*
2393  * Read the configuration data from a policy database binary
2394  * representation file into a policy database structure.
2395  */
policydb_read(struct policydb * p,void * fp)2396 int policydb_read(struct policydb *p, void *fp)
2397 {
2398 	struct role_allow *ra, *lra;
2399 	struct role_trans_key *rtk = NULL;
2400 	struct role_trans_datum *rtd = NULL;
2401 	int i, j, rc;
2402 	__le32 buf[4];
2403 	u32 len, nprim, nel, perm;
2404 
2405 	char *policydb_str;
2406 	const struct policydb_compat_info *info;
2407 
2408 	policydb_init(p);
2409 
2410 	/* Read the magic number and string length. */
2411 	rc = next_entry(buf, fp, sizeof(u32) * 2);
2412 	if (rc)
2413 		goto bad;
2414 
2415 	rc = -EINVAL;
2416 	if (le32_to_cpu(buf[0]) != POLICYDB_MAGIC) {
2417 		pr_err("SELinux:  policydb magic number 0x%x does "
2418 		       "not match expected magic number 0x%x\n",
2419 		       le32_to_cpu(buf[0]), POLICYDB_MAGIC);
2420 		goto bad;
2421 	}
2422 
2423 	rc = -EINVAL;
2424 	len = le32_to_cpu(buf[1]);
2425 	if (len != strlen(POLICYDB_STRING)) {
2426 		pr_err("SELinux:  policydb string length %d does not "
2427 		       "match expected length %zu\n",
2428 		       len, strlen(POLICYDB_STRING));
2429 		goto bad;
2430 	}
2431 
2432 	rc = -ENOMEM;
2433 	policydb_str = kmalloc(len + 1, GFP_KERNEL);
2434 	if (!policydb_str) {
2435 		pr_err("SELinux:  unable to allocate memory for policydb "
2436 		       "string of length %d\n", len);
2437 		goto bad;
2438 	}
2439 
2440 	rc = next_entry(policydb_str, fp, len);
2441 	if (rc) {
2442 		pr_err("SELinux:  truncated policydb string identifier\n");
2443 		kfree(policydb_str);
2444 		goto bad;
2445 	}
2446 
2447 	rc = -EINVAL;
2448 	policydb_str[len] = '\0';
2449 	if (strcmp(policydb_str, POLICYDB_STRING)) {
2450 		pr_err("SELinux:  policydb string %s does not match "
2451 		       "my string %s\n", policydb_str, POLICYDB_STRING);
2452 		kfree(policydb_str);
2453 		goto bad;
2454 	}
2455 	/* Done with policydb_str. */
2456 	kfree(policydb_str);
2457 	policydb_str = NULL;
2458 
2459 	/* Read the version and table sizes. */
2460 	rc = next_entry(buf, fp, sizeof(u32)*4);
2461 	if (rc)
2462 		goto bad;
2463 
2464 	rc = -EINVAL;
2465 	p->policyvers = le32_to_cpu(buf[0]);
2466 	if (p->policyvers < POLICYDB_VERSION_MIN ||
2467 	    p->policyvers > POLICYDB_VERSION_MAX) {
2468 		pr_err("SELinux:  policydb version %d does not match "
2469 		       "my version range %d-%d\n",
2470 		       le32_to_cpu(buf[0]), POLICYDB_VERSION_MIN, POLICYDB_VERSION_MAX);
2471 		goto bad;
2472 	}
2473 
2474 	if ((le32_to_cpu(buf[1]) & POLICYDB_CONFIG_MLS)) {
2475 		p->mls_enabled = 1;
2476 
2477 		rc = -EINVAL;
2478 		if (p->policyvers < POLICYDB_VERSION_MLS) {
2479 			pr_err("SELinux: security policydb version %d "
2480 				"(MLS) not backwards compatible\n",
2481 				p->policyvers);
2482 			goto bad;
2483 		}
2484 	}
2485 	p->reject_unknown = !!(le32_to_cpu(buf[1]) & REJECT_UNKNOWN);
2486 	p->allow_unknown = !!(le32_to_cpu(buf[1]) & ALLOW_UNKNOWN);
2487 
2488 	if (p->policyvers >= POLICYDB_VERSION_POLCAP) {
2489 		rc = ebitmap_read(&p->policycaps, fp);
2490 		if (rc)
2491 			goto bad;
2492 	}
2493 
2494 	if (p->policyvers >= POLICYDB_VERSION_PERMISSIVE) {
2495 		rc = ebitmap_read(&p->permissive_map, fp);
2496 		if (rc)
2497 			goto bad;
2498 	}
2499 
2500 	rc = -EINVAL;
2501 	info = policydb_lookup_compat(p->policyvers);
2502 	if (!info) {
2503 		pr_err("SELinux:  unable to find policy compat info "
2504 		       "for version %d\n", p->policyvers);
2505 		goto bad;
2506 	}
2507 
2508 	rc = -EINVAL;
2509 	if (le32_to_cpu(buf[2]) != info->sym_num ||
2510 		le32_to_cpu(buf[3]) != info->ocon_num) {
2511 		pr_err("SELinux:  policydb table sizes (%d,%d) do "
2512 		       "not match mine (%d,%d)\n", le32_to_cpu(buf[2]),
2513 			le32_to_cpu(buf[3]),
2514 		       info->sym_num, info->ocon_num);
2515 		goto bad;
2516 	}
2517 
2518 	for (i = 0; i < info->sym_num; i++) {
2519 		rc = next_entry(buf, fp, sizeof(u32)*2);
2520 		if (rc)
2521 			goto bad;
2522 		nprim = le32_to_cpu(buf[0]);
2523 		nel = le32_to_cpu(buf[1]);
2524 
2525 		rc = symtab_init(&p->symtab[i], nel);
2526 		if (rc)
2527 			goto out;
2528 
2529 		if (i == SYM_ROLES) {
2530 			rc = roles_init(p);
2531 			if (rc)
2532 				goto out;
2533 		}
2534 
2535 		for (j = 0; j < nel; j++) {
2536 			rc = read_f[i](p, &p->symtab[i], fp);
2537 			if (rc)
2538 				goto bad;
2539 		}
2540 
2541 		p->symtab[i].nprim = nprim;
2542 	}
2543 
2544 	rc = -EINVAL;
2545 	p->process_class = string_to_security_class(p, "process");
2546 	if (!p->process_class) {
2547 		pr_err("SELinux: process class is required, not defined in policy\n");
2548 		goto bad;
2549 	}
2550 
2551 	rc = avtab_read(&p->te_avtab, fp, p);
2552 	if (rc)
2553 		goto bad;
2554 
2555 	if (p->policyvers >= POLICYDB_VERSION_BOOL) {
2556 		rc = cond_read_list(p, fp);
2557 		if (rc)
2558 			goto bad;
2559 	}
2560 
2561 	rc = next_entry(buf, fp, sizeof(u32));
2562 	if (rc)
2563 		goto bad;
2564 	nel = le32_to_cpu(buf[0]);
2565 
2566 	rc = hashtab_init(&p->role_tr, nel);
2567 	if (rc)
2568 		goto bad;
2569 	for (i = 0; i < nel; i++) {
2570 		rc = -ENOMEM;
2571 		rtk = kmalloc(sizeof(*rtk), GFP_KERNEL);
2572 		if (!rtk)
2573 			goto bad;
2574 
2575 		rc = -ENOMEM;
2576 		rtd = kmalloc(sizeof(*rtd), GFP_KERNEL);
2577 		if (!rtd)
2578 			goto bad;
2579 
2580 		rc = next_entry(buf, fp, sizeof(u32)*3);
2581 		if (rc)
2582 			goto bad;
2583 
2584 		rtk->role = le32_to_cpu(buf[0]);
2585 		rtk->type = le32_to_cpu(buf[1]);
2586 		rtd->new_role = le32_to_cpu(buf[2]);
2587 		if (p->policyvers >= POLICYDB_VERSION_ROLETRANS) {
2588 			rc = next_entry(buf, fp, sizeof(u32));
2589 			if (rc)
2590 				goto bad;
2591 			rtk->tclass = le32_to_cpu(buf[0]);
2592 		} else
2593 			rtk->tclass = p->process_class;
2594 
2595 		rc = -EINVAL;
2596 		if (!policydb_role_isvalid(p, rtk->role) ||
2597 		    !policydb_type_isvalid(p, rtk->type) ||
2598 		    !policydb_class_isvalid(p, rtk->tclass) ||
2599 		    !policydb_role_isvalid(p, rtd->new_role))
2600 			goto bad;
2601 
2602 		rc = hashtab_insert(&p->role_tr, rtk, rtd, roletr_key_params);
2603 		if (rc)
2604 			goto bad;
2605 
2606 		rtk = NULL;
2607 		rtd = NULL;
2608 	}
2609 
2610 	rc = next_entry(buf, fp, sizeof(u32));
2611 	if (rc)
2612 		goto bad;
2613 	nel = le32_to_cpu(buf[0]);
2614 	lra = NULL;
2615 	for (i = 0; i < nel; i++) {
2616 		rc = -ENOMEM;
2617 		ra = kzalloc(sizeof(*ra), GFP_KERNEL);
2618 		if (!ra)
2619 			goto bad;
2620 		if (lra)
2621 			lra->next = ra;
2622 		else
2623 			p->role_allow = ra;
2624 		rc = next_entry(buf, fp, sizeof(u32)*2);
2625 		if (rc)
2626 			goto bad;
2627 
2628 		rc = -EINVAL;
2629 		ra->role = le32_to_cpu(buf[0]);
2630 		ra->new_role = le32_to_cpu(buf[1]);
2631 		if (!policydb_role_isvalid(p, ra->role) ||
2632 		    !policydb_role_isvalid(p, ra->new_role))
2633 			goto bad;
2634 		lra = ra;
2635 	}
2636 
2637 	rc = filename_trans_read(p, fp);
2638 	if (rc)
2639 		goto bad;
2640 
2641 	rc = policydb_index(p);
2642 	if (rc)
2643 		goto bad;
2644 
2645 	rc = -EINVAL;
2646 	perm = string_to_av_perm(p, p->process_class, "transition");
2647 	if (!perm) {
2648 		pr_err("SELinux: process transition permission is required, not defined in policy\n");
2649 		goto bad;
2650 	}
2651 	p->process_trans_perms = perm;
2652 	perm = string_to_av_perm(p, p->process_class, "dyntransition");
2653 	if (!perm) {
2654 		pr_err("SELinux: process dyntransition permission is required, not defined in policy\n");
2655 		goto bad;
2656 	}
2657 	p->process_trans_perms |= perm;
2658 
2659 	rc = ocontext_read(p, info, fp);
2660 	if (rc)
2661 		goto bad;
2662 
2663 	rc = genfs_read(p, fp);
2664 	if (rc)
2665 		goto bad;
2666 
2667 	rc = range_read(p, fp);
2668 	if (rc)
2669 		goto bad;
2670 
2671 	rc = -ENOMEM;
2672 	p->type_attr_map_array = kvcalloc(p->p_types.nprim,
2673 					  sizeof(*p->type_attr_map_array),
2674 					  GFP_KERNEL);
2675 	if (!p->type_attr_map_array)
2676 		goto bad;
2677 
2678 	/* just in case ebitmap_init() becomes more than just a memset(0): */
2679 	for (i = 0; i < p->p_types.nprim; i++)
2680 		ebitmap_init(&p->type_attr_map_array[i]);
2681 
2682 	for (i = 0; i < p->p_types.nprim; i++) {
2683 		struct ebitmap *e = &p->type_attr_map_array[i];
2684 
2685 		if (p->policyvers >= POLICYDB_VERSION_AVTAB) {
2686 			rc = ebitmap_read(e, fp);
2687 			if (rc)
2688 				goto bad;
2689 		}
2690 		/* add the type itself as the degenerate case */
2691 		rc = ebitmap_set_bit(e, i, 1);
2692 		if (rc)
2693 			goto bad;
2694 	}
2695 
2696 	rc = policydb_bounds_sanity_check(p);
2697 	if (rc)
2698 		goto bad;
2699 
2700 	rc = 0;
2701 out:
2702 	return rc;
2703 bad:
2704 	kfree(rtk);
2705 	kfree(rtd);
2706 	policydb_destroy(p);
2707 	goto out;
2708 }
2709 
2710 /*
2711  * Write a MLS level structure to a policydb binary
2712  * representation file.
2713  */
mls_write_level(struct mls_level * l,void * fp)2714 static int mls_write_level(struct mls_level *l, void *fp)
2715 {
2716 	__le32 buf[1];
2717 	int rc;
2718 
2719 	buf[0] = cpu_to_le32(l->sens);
2720 	rc = put_entry(buf, sizeof(u32), 1, fp);
2721 	if (rc)
2722 		return rc;
2723 
2724 	rc = ebitmap_write(&l->cat, fp);
2725 	if (rc)
2726 		return rc;
2727 
2728 	return 0;
2729 }
2730 
2731 /*
2732  * Write a MLS range structure to a policydb binary
2733  * representation file.
2734  */
mls_write_range_helper(struct mls_range * r,void * fp)2735 static int mls_write_range_helper(struct mls_range *r, void *fp)
2736 {
2737 	__le32 buf[3];
2738 	size_t items;
2739 	int rc, eq;
2740 
2741 	eq = mls_level_eq(&r->level[1], &r->level[0]);
2742 
2743 	if (eq)
2744 		items = 2;
2745 	else
2746 		items = 3;
2747 	buf[0] = cpu_to_le32(items-1);
2748 	buf[1] = cpu_to_le32(r->level[0].sens);
2749 	if (!eq)
2750 		buf[2] = cpu_to_le32(r->level[1].sens);
2751 
2752 	BUG_ON(items > ARRAY_SIZE(buf));
2753 
2754 	rc = put_entry(buf, sizeof(u32), items, fp);
2755 	if (rc)
2756 		return rc;
2757 
2758 	rc = ebitmap_write(&r->level[0].cat, fp);
2759 	if (rc)
2760 		return rc;
2761 	if (!eq) {
2762 		rc = ebitmap_write(&r->level[1].cat, fp);
2763 		if (rc)
2764 			return rc;
2765 	}
2766 
2767 	return 0;
2768 }
2769 
sens_write(void * vkey,void * datum,void * ptr)2770 static int sens_write(void *vkey, void *datum, void *ptr)
2771 {
2772 	char *key = vkey;
2773 	struct level_datum *levdatum = datum;
2774 	struct policy_data *pd = ptr;
2775 	void *fp = pd->fp;
2776 	__le32 buf[2];
2777 	size_t len;
2778 	int rc;
2779 
2780 	len = strlen(key);
2781 	buf[0] = cpu_to_le32(len);
2782 	buf[1] = cpu_to_le32(levdatum->isalias);
2783 	rc = put_entry(buf, sizeof(u32), 2, fp);
2784 	if (rc)
2785 		return rc;
2786 
2787 	rc = put_entry(key, 1, len, fp);
2788 	if (rc)
2789 		return rc;
2790 
2791 	rc = mls_write_level(levdatum->level, fp);
2792 	if (rc)
2793 		return rc;
2794 
2795 	return 0;
2796 }
2797 
cat_write(void * vkey,void * datum,void * ptr)2798 static int cat_write(void *vkey, void *datum, void *ptr)
2799 {
2800 	char *key = vkey;
2801 	struct cat_datum *catdatum = datum;
2802 	struct policy_data *pd = ptr;
2803 	void *fp = pd->fp;
2804 	__le32 buf[3];
2805 	size_t len;
2806 	int rc;
2807 
2808 	len = strlen(key);
2809 	buf[0] = cpu_to_le32(len);
2810 	buf[1] = cpu_to_le32(catdatum->value);
2811 	buf[2] = cpu_to_le32(catdatum->isalias);
2812 	rc = put_entry(buf, sizeof(u32), 3, fp);
2813 	if (rc)
2814 		return rc;
2815 
2816 	rc = put_entry(key, 1, len, fp);
2817 	if (rc)
2818 		return rc;
2819 
2820 	return 0;
2821 }
2822 
role_trans_write_one(void * key,void * datum,void * ptr)2823 static int role_trans_write_one(void *key, void *datum, void *ptr)
2824 {
2825 	struct role_trans_key *rtk = key;
2826 	struct role_trans_datum *rtd = datum;
2827 	struct policy_data *pd = ptr;
2828 	void *fp = pd->fp;
2829 	struct policydb *p = pd->p;
2830 	__le32 buf[3];
2831 	int rc;
2832 
2833 	buf[0] = cpu_to_le32(rtk->role);
2834 	buf[1] = cpu_to_le32(rtk->type);
2835 	buf[2] = cpu_to_le32(rtd->new_role);
2836 	rc = put_entry(buf, sizeof(u32), 3, fp);
2837 	if (rc)
2838 		return rc;
2839 	if (p->policyvers >= POLICYDB_VERSION_ROLETRANS) {
2840 		buf[0] = cpu_to_le32(rtk->tclass);
2841 		rc = put_entry(buf, sizeof(u32), 1, fp);
2842 		if (rc)
2843 			return rc;
2844 	}
2845 	return 0;
2846 }
2847 
role_trans_write(struct policydb * p,void * fp)2848 static int role_trans_write(struct policydb *p, void *fp)
2849 {
2850 	struct policy_data pd = { .p = p, .fp = fp };
2851 	__le32 buf[1];
2852 	int rc;
2853 
2854 	buf[0] = cpu_to_le32(p->role_tr.nel);
2855 	rc = put_entry(buf, sizeof(u32), 1, fp);
2856 	if (rc)
2857 		return rc;
2858 
2859 	return hashtab_map(&p->role_tr, role_trans_write_one, &pd);
2860 }
2861 
role_allow_write(struct role_allow * r,void * fp)2862 static int role_allow_write(struct role_allow *r, void *fp)
2863 {
2864 	struct role_allow *ra;
2865 	__le32 buf[2];
2866 	size_t nel;
2867 	int rc;
2868 
2869 	nel = 0;
2870 	for (ra = r; ra; ra = ra->next)
2871 		nel++;
2872 	buf[0] = cpu_to_le32(nel);
2873 	rc = put_entry(buf, sizeof(u32), 1, fp);
2874 	if (rc)
2875 		return rc;
2876 	for (ra = r; ra; ra = ra->next) {
2877 		buf[0] = cpu_to_le32(ra->role);
2878 		buf[1] = cpu_to_le32(ra->new_role);
2879 		rc = put_entry(buf, sizeof(u32), 2, fp);
2880 		if (rc)
2881 			return rc;
2882 	}
2883 	return 0;
2884 }
2885 
2886 /*
2887  * Write a security context structure
2888  * to a policydb binary representation file.
2889  */
context_write(struct policydb * p,struct context * c,void * fp)2890 static int context_write(struct policydb *p, struct context *c,
2891 			 void *fp)
2892 {
2893 	int rc;
2894 	__le32 buf[3];
2895 
2896 	buf[0] = cpu_to_le32(c->user);
2897 	buf[1] = cpu_to_le32(c->role);
2898 	buf[2] = cpu_to_le32(c->type);
2899 
2900 	rc = put_entry(buf, sizeof(u32), 3, fp);
2901 	if (rc)
2902 		return rc;
2903 
2904 	rc = mls_write_range_helper(&c->range, fp);
2905 	if (rc)
2906 		return rc;
2907 
2908 	return 0;
2909 }
2910 
2911 /*
2912  * The following *_write functions are used to
2913  * write the symbol data to a policy database
2914  * binary representation file.
2915  */
2916 
perm_write(void * vkey,void * datum,void * fp)2917 static int perm_write(void *vkey, void *datum, void *fp)
2918 {
2919 	char *key = vkey;
2920 	struct perm_datum *perdatum = datum;
2921 	__le32 buf[2];
2922 	size_t len;
2923 	int rc;
2924 
2925 	len = strlen(key);
2926 	buf[0] = cpu_to_le32(len);
2927 	buf[1] = cpu_to_le32(perdatum->value);
2928 	rc = put_entry(buf, sizeof(u32), 2, fp);
2929 	if (rc)
2930 		return rc;
2931 
2932 	rc = put_entry(key, 1, len, fp);
2933 	if (rc)
2934 		return rc;
2935 
2936 	return 0;
2937 }
2938 
common_write(void * vkey,void * datum,void * ptr)2939 static int common_write(void *vkey, void *datum, void *ptr)
2940 {
2941 	char *key = vkey;
2942 	struct common_datum *comdatum = datum;
2943 	struct policy_data *pd = ptr;
2944 	void *fp = pd->fp;
2945 	__le32 buf[4];
2946 	size_t len;
2947 	int rc;
2948 
2949 	len = strlen(key);
2950 	buf[0] = cpu_to_le32(len);
2951 	buf[1] = cpu_to_le32(comdatum->value);
2952 	buf[2] = cpu_to_le32(comdatum->permissions.nprim);
2953 	buf[3] = cpu_to_le32(comdatum->permissions.table.nel);
2954 	rc = put_entry(buf, sizeof(u32), 4, fp);
2955 	if (rc)
2956 		return rc;
2957 
2958 	rc = put_entry(key, 1, len, fp);
2959 	if (rc)
2960 		return rc;
2961 
2962 	rc = hashtab_map(&comdatum->permissions.table, perm_write, fp);
2963 	if (rc)
2964 		return rc;
2965 
2966 	return 0;
2967 }
2968 
type_set_write(struct type_set * t,void * fp)2969 static int type_set_write(struct type_set *t, void *fp)
2970 {
2971 	int rc;
2972 	__le32 buf[1];
2973 
2974 	if (ebitmap_write(&t->types, fp))
2975 		return -EINVAL;
2976 	if (ebitmap_write(&t->negset, fp))
2977 		return -EINVAL;
2978 
2979 	buf[0] = cpu_to_le32(t->flags);
2980 	rc = put_entry(buf, sizeof(u32), 1, fp);
2981 	if (rc)
2982 		return -EINVAL;
2983 
2984 	return 0;
2985 }
2986 
write_cons_helper(struct policydb * p,struct constraint_node * node,void * fp)2987 static int write_cons_helper(struct policydb *p, struct constraint_node *node,
2988 			     void *fp)
2989 {
2990 	struct constraint_node *c;
2991 	struct constraint_expr *e;
2992 	__le32 buf[3];
2993 	u32 nel;
2994 	int rc;
2995 
2996 	for (c = node; c; c = c->next) {
2997 		nel = 0;
2998 		for (e = c->expr; e; e = e->next)
2999 			nel++;
3000 		buf[0] = cpu_to_le32(c->permissions);
3001 		buf[1] = cpu_to_le32(nel);
3002 		rc = put_entry(buf, sizeof(u32), 2, fp);
3003 		if (rc)
3004 			return rc;
3005 		for (e = c->expr; e; e = e->next) {
3006 			buf[0] = cpu_to_le32(e->expr_type);
3007 			buf[1] = cpu_to_le32(e->attr);
3008 			buf[2] = cpu_to_le32(e->op);
3009 			rc = put_entry(buf, sizeof(u32), 3, fp);
3010 			if (rc)
3011 				return rc;
3012 
3013 			switch (e->expr_type) {
3014 			case CEXPR_NAMES:
3015 				rc = ebitmap_write(&e->names, fp);
3016 				if (rc)
3017 					return rc;
3018 				if (p->policyvers >=
3019 					POLICYDB_VERSION_CONSTRAINT_NAMES) {
3020 					rc = type_set_write(e->type_names, fp);
3021 					if (rc)
3022 						return rc;
3023 				}
3024 				break;
3025 			default:
3026 				break;
3027 			}
3028 		}
3029 	}
3030 
3031 	return 0;
3032 }
3033 
class_write(void * vkey,void * datum,void * ptr)3034 static int class_write(void *vkey, void *datum, void *ptr)
3035 {
3036 	char *key = vkey;
3037 	struct class_datum *cladatum = datum;
3038 	struct policy_data *pd = ptr;
3039 	void *fp = pd->fp;
3040 	struct policydb *p = pd->p;
3041 	struct constraint_node *c;
3042 	__le32 buf[6];
3043 	u32 ncons;
3044 	size_t len, len2;
3045 	int rc;
3046 
3047 	len = strlen(key);
3048 	if (cladatum->comkey)
3049 		len2 = strlen(cladatum->comkey);
3050 	else
3051 		len2 = 0;
3052 
3053 	ncons = 0;
3054 	for (c = cladatum->constraints; c; c = c->next)
3055 		ncons++;
3056 
3057 	buf[0] = cpu_to_le32(len);
3058 	buf[1] = cpu_to_le32(len2);
3059 	buf[2] = cpu_to_le32(cladatum->value);
3060 	buf[3] = cpu_to_le32(cladatum->permissions.nprim);
3061 	buf[4] = cpu_to_le32(cladatum->permissions.table.nel);
3062 	buf[5] = cpu_to_le32(ncons);
3063 	rc = put_entry(buf, sizeof(u32), 6, fp);
3064 	if (rc)
3065 		return rc;
3066 
3067 	rc = put_entry(key, 1, len, fp);
3068 	if (rc)
3069 		return rc;
3070 
3071 	if (cladatum->comkey) {
3072 		rc = put_entry(cladatum->comkey, 1, len2, fp);
3073 		if (rc)
3074 			return rc;
3075 	}
3076 
3077 	rc = hashtab_map(&cladatum->permissions.table, perm_write, fp);
3078 	if (rc)
3079 		return rc;
3080 
3081 	rc = write_cons_helper(p, cladatum->constraints, fp);
3082 	if (rc)
3083 		return rc;
3084 
3085 	/* write out the validatetrans rule */
3086 	ncons = 0;
3087 	for (c = cladatum->validatetrans; c; c = c->next)
3088 		ncons++;
3089 
3090 	buf[0] = cpu_to_le32(ncons);
3091 	rc = put_entry(buf, sizeof(u32), 1, fp);
3092 	if (rc)
3093 		return rc;
3094 
3095 	rc = write_cons_helper(p, cladatum->validatetrans, fp);
3096 	if (rc)
3097 		return rc;
3098 
3099 	if (p->policyvers >= POLICYDB_VERSION_NEW_OBJECT_DEFAULTS) {
3100 		buf[0] = cpu_to_le32(cladatum->default_user);
3101 		buf[1] = cpu_to_le32(cladatum->default_role);
3102 		buf[2] = cpu_to_le32(cladatum->default_range);
3103 
3104 		rc = put_entry(buf, sizeof(uint32_t), 3, fp);
3105 		if (rc)
3106 			return rc;
3107 	}
3108 
3109 	if (p->policyvers >= POLICYDB_VERSION_DEFAULT_TYPE) {
3110 		buf[0] = cpu_to_le32(cladatum->default_type);
3111 		rc = put_entry(buf, sizeof(uint32_t), 1, fp);
3112 		if (rc)
3113 			return rc;
3114 	}
3115 
3116 	return 0;
3117 }
3118 
role_write(void * vkey,void * datum,void * ptr)3119 static int role_write(void *vkey, void *datum, void *ptr)
3120 {
3121 	char *key = vkey;
3122 	struct role_datum *role = datum;
3123 	struct policy_data *pd = ptr;
3124 	void *fp = pd->fp;
3125 	struct policydb *p = pd->p;
3126 	__le32 buf[3];
3127 	size_t items, len;
3128 	int rc;
3129 
3130 	len = strlen(key);
3131 	items = 0;
3132 	buf[items++] = cpu_to_le32(len);
3133 	buf[items++] = cpu_to_le32(role->value);
3134 	if (p->policyvers >= POLICYDB_VERSION_BOUNDARY)
3135 		buf[items++] = cpu_to_le32(role->bounds);
3136 
3137 	BUG_ON(items > ARRAY_SIZE(buf));
3138 
3139 	rc = put_entry(buf, sizeof(u32), items, fp);
3140 	if (rc)
3141 		return rc;
3142 
3143 	rc = put_entry(key, 1, len, fp);
3144 	if (rc)
3145 		return rc;
3146 
3147 	rc = ebitmap_write(&role->dominates, fp);
3148 	if (rc)
3149 		return rc;
3150 
3151 	rc = ebitmap_write(&role->types, fp);
3152 	if (rc)
3153 		return rc;
3154 
3155 	return 0;
3156 }
3157 
type_write(void * vkey,void * datum,void * ptr)3158 static int type_write(void *vkey, void *datum, void *ptr)
3159 {
3160 	char *key = vkey;
3161 	struct type_datum *typdatum = datum;
3162 	struct policy_data *pd = ptr;
3163 	struct policydb *p = pd->p;
3164 	void *fp = pd->fp;
3165 	__le32 buf[4];
3166 	int rc;
3167 	size_t items, len;
3168 
3169 	len = strlen(key);
3170 	items = 0;
3171 	buf[items++] = cpu_to_le32(len);
3172 	buf[items++] = cpu_to_le32(typdatum->value);
3173 	if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) {
3174 		u32 properties = 0;
3175 
3176 		if (typdatum->primary)
3177 			properties |= TYPEDATUM_PROPERTY_PRIMARY;
3178 
3179 		if (typdatum->attribute)
3180 			properties |= TYPEDATUM_PROPERTY_ATTRIBUTE;
3181 
3182 		buf[items++] = cpu_to_le32(properties);
3183 		buf[items++] = cpu_to_le32(typdatum->bounds);
3184 	} else {
3185 		buf[items++] = cpu_to_le32(typdatum->primary);
3186 	}
3187 	BUG_ON(items > ARRAY_SIZE(buf));
3188 	rc = put_entry(buf, sizeof(u32), items, fp);
3189 	if (rc)
3190 		return rc;
3191 
3192 	rc = put_entry(key, 1, len, fp);
3193 	if (rc)
3194 		return rc;
3195 
3196 	return 0;
3197 }
3198 
user_write(void * vkey,void * datum,void * ptr)3199 static int user_write(void *vkey, void *datum, void *ptr)
3200 {
3201 	char *key = vkey;
3202 	struct user_datum *usrdatum = datum;
3203 	struct policy_data *pd = ptr;
3204 	struct policydb *p = pd->p;
3205 	void *fp = pd->fp;
3206 	__le32 buf[3];
3207 	size_t items, len;
3208 	int rc;
3209 
3210 	len = strlen(key);
3211 	items = 0;
3212 	buf[items++] = cpu_to_le32(len);
3213 	buf[items++] = cpu_to_le32(usrdatum->value);
3214 	if (p->policyvers >= POLICYDB_VERSION_BOUNDARY)
3215 		buf[items++] = cpu_to_le32(usrdatum->bounds);
3216 	BUG_ON(items > ARRAY_SIZE(buf));
3217 	rc = put_entry(buf, sizeof(u32), items, fp);
3218 	if (rc)
3219 		return rc;
3220 
3221 	rc = put_entry(key, 1, len, fp);
3222 	if (rc)
3223 		return rc;
3224 
3225 	rc = ebitmap_write(&usrdatum->roles, fp);
3226 	if (rc)
3227 		return rc;
3228 
3229 	rc = mls_write_range_helper(&usrdatum->range, fp);
3230 	if (rc)
3231 		return rc;
3232 
3233 	rc = mls_write_level(&usrdatum->dfltlevel, fp);
3234 	if (rc)
3235 		return rc;
3236 
3237 	return 0;
3238 }
3239 
3240 static int (*const write_f[SYM_NUM]) (void *key, void *datum, void *datap) = {
3241 	common_write,
3242 	class_write,
3243 	role_write,
3244 	type_write,
3245 	user_write,
3246 	cond_write_bool,
3247 	sens_write,
3248 	cat_write,
3249 };
3250 
ocontext_write(struct policydb * p,const struct policydb_compat_info * info,void * fp)3251 static int ocontext_write(struct policydb *p, const struct policydb_compat_info *info,
3252 			  void *fp)
3253 {
3254 	unsigned int i, j, rc;
3255 	size_t nel, len;
3256 	__be64 prefixbuf[1];
3257 	__le32 buf[3];
3258 	u32 nodebuf[8];
3259 	struct ocontext *c;
3260 	for (i = 0; i < info->ocon_num; i++) {
3261 		nel = 0;
3262 		for (c = p->ocontexts[i]; c; c = c->next)
3263 			nel++;
3264 		buf[0] = cpu_to_le32(nel);
3265 		rc = put_entry(buf, sizeof(u32), 1, fp);
3266 		if (rc)
3267 			return rc;
3268 		for (c = p->ocontexts[i]; c; c = c->next) {
3269 			switch (i) {
3270 			case OCON_ISID:
3271 				buf[0] = cpu_to_le32(c->sid[0]);
3272 				rc = put_entry(buf, sizeof(u32), 1, fp);
3273 				if (rc)
3274 					return rc;
3275 				rc = context_write(p, &c->context[0], fp);
3276 				if (rc)
3277 					return rc;
3278 				break;
3279 			case OCON_FS:
3280 			case OCON_NETIF:
3281 				len = strlen(c->u.name);
3282 				buf[0] = cpu_to_le32(len);
3283 				rc = put_entry(buf, sizeof(u32), 1, fp);
3284 				if (rc)
3285 					return rc;
3286 				rc = put_entry(c->u.name, 1, len, fp);
3287 				if (rc)
3288 					return rc;
3289 				rc = context_write(p, &c->context[0], fp);
3290 				if (rc)
3291 					return rc;
3292 				rc = context_write(p, &c->context[1], fp);
3293 				if (rc)
3294 					return rc;
3295 				break;
3296 			case OCON_PORT:
3297 				buf[0] = cpu_to_le32(c->u.port.protocol);
3298 				buf[1] = cpu_to_le32(c->u.port.low_port);
3299 				buf[2] = cpu_to_le32(c->u.port.high_port);
3300 				rc = put_entry(buf, sizeof(u32), 3, fp);
3301 				if (rc)
3302 					return rc;
3303 				rc = context_write(p, &c->context[0], fp);
3304 				if (rc)
3305 					return rc;
3306 				break;
3307 			case OCON_NODE:
3308 				nodebuf[0] = c->u.node.addr; /* network order */
3309 				nodebuf[1] = c->u.node.mask; /* network order */
3310 				rc = put_entry(nodebuf, sizeof(u32), 2, fp);
3311 				if (rc)
3312 					return rc;
3313 				rc = context_write(p, &c->context[0], fp);
3314 				if (rc)
3315 					return rc;
3316 				break;
3317 			case OCON_FSUSE:
3318 				buf[0] = cpu_to_le32(c->v.behavior);
3319 				len = strlen(c->u.name);
3320 				buf[1] = cpu_to_le32(len);
3321 				rc = put_entry(buf, sizeof(u32), 2, fp);
3322 				if (rc)
3323 					return rc;
3324 				rc = put_entry(c->u.name, 1, len, fp);
3325 				if (rc)
3326 					return rc;
3327 				rc = context_write(p, &c->context[0], fp);
3328 				if (rc)
3329 					return rc;
3330 				break;
3331 			case OCON_NODE6:
3332 				for (j = 0; j < 4; j++)
3333 					nodebuf[j] = c->u.node6.addr[j]; /* network order */
3334 				for (j = 0; j < 4; j++)
3335 					nodebuf[j + 4] = c->u.node6.mask[j]; /* network order */
3336 				rc = put_entry(nodebuf, sizeof(u32), 8, fp);
3337 				if (rc)
3338 					return rc;
3339 				rc = context_write(p, &c->context[0], fp);
3340 				if (rc)
3341 					return rc;
3342 				break;
3343 			case OCON_IBPKEY:
3344 				/* subnet_prefix is in CPU order */
3345 				prefixbuf[0] = cpu_to_be64(c->u.ibpkey.subnet_prefix);
3346 
3347 				rc = put_entry(prefixbuf, sizeof(u64), 1, fp);
3348 				if (rc)
3349 					return rc;
3350 
3351 				buf[0] = cpu_to_le32(c->u.ibpkey.low_pkey);
3352 				buf[1] = cpu_to_le32(c->u.ibpkey.high_pkey);
3353 
3354 				rc = put_entry(buf, sizeof(u32), 2, fp);
3355 				if (rc)
3356 					return rc;
3357 				rc = context_write(p, &c->context[0], fp);
3358 				if (rc)
3359 					return rc;
3360 				break;
3361 			case OCON_IBENDPORT:
3362 				len = strlen(c->u.ibendport.dev_name);
3363 				buf[0] = cpu_to_le32(len);
3364 				buf[1] = cpu_to_le32(c->u.ibendport.port);
3365 				rc = put_entry(buf, sizeof(u32), 2, fp);
3366 				if (rc)
3367 					return rc;
3368 				rc = put_entry(c->u.ibendport.dev_name, 1, len, fp);
3369 				if (rc)
3370 					return rc;
3371 				rc = context_write(p, &c->context[0], fp);
3372 				if (rc)
3373 					return rc;
3374 				break;
3375 			}
3376 		}
3377 	}
3378 	return 0;
3379 }
3380 
genfs_write(struct policydb * p,void * fp)3381 static int genfs_write(struct policydb *p, void *fp)
3382 {
3383 	struct genfs *genfs;
3384 	struct ocontext *c;
3385 	size_t len;
3386 	__le32 buf[1];
3387 	int rc;
3388 
3389 	len = 0;
3390 	for (genfs = p->genfs; genfs; genfs = genfs->next)
3391 		len++;
3392 	buf[0] = cpu_to_le32(len);
3393 	rc = put_entry(buf, sizeof(u32), 1, fp);
3394 	if (rc)
3395 		return rc;
3396 	for (genfs = p->genfs; genfs; genfs = genfs->next) {
3397 		len = strlen(genfs->fstype);
3398 		buf[0] = cpu_to_le32(len);
3399 		rc = put_entry(buf, sizeof(u32), 1, fp);
3400 		if (rc)
3401 			return rc;
3402 		rc = put_entry(genfs->fstype, 1, len, fp);
3403 		if (rc)
3404 			return rc;
3405 		len = 0;
3406 		for (c = genfs->head; c; c = c->next)
3407 			len++;
3408 		buf[0] = cpu_to_le32(len);
3409 		rc = put_entry(buf, sizeof(u32), 1, fp);
3410 		if (rc)
3411 			return rc;
3412 		for (c = genfs->head; c; c = c->next) {
3413 			len = strlen(c->u.name);
3414 			buf[0] = cpu_to_le32(len);
3415 			rc = put_entry(buf, sizeof(u32), 1, fp);
3416 			if (rc)
3417 				return rc;
3418 			rc = put_entry(c->u.name, 1, len, fp);
3419 			if (rc)
3420 				return rc;
3421 			buf[0] = cpu_to_le32(c->v.sclass);
3422 			rc = put_entry(buf, sizeof(u32), 1, fp);
3423 			if (rc)
3424 				return rc;
3425 			rc = context_write(p, &c->context[0], fp);
3426 			if (rc)
3427 				return rc;
3428 		}
3429 	}
3430 	return 0;
3431 }
3432 
range_write_helper(void * key,void * data,void * ptr)3433 static int range_write_helper(void *key, void *data, void *ptr)
3434 {
3435 	__le32 buf[2];
3436 	struct range_trans *rt = key;
3437 	struct mls_range *r = data;
3438 	struct policy_data *pd = ptr;
3439 	void *fp = pd->fp;
3440 	struct policydb *p = pd->p;
3441 	int rc;
3442 
3443 	buf[0] = cpu_to_le32(rt->source_type);
3444 	buf[1] = cpu_to_le32(rt->target_type);
3445 	rc = put_entry(buf, sizeof(u32), 2, fp);
3446 	if (rc)
3447 		return rc;
3448 	if (p->policyvers >= POLICYDB_VERSION_RANGETRANS) {
3449 		buf[0] = cpu_to_le32(rt->target_class);
3450 		rc = put_entry(buf, sizeof(u32), 1, fp);
3451 		if (rc)
3452 			return rc;
3453 	}
3454 	rc = mls_write_range_helper(r, fp);
3455 	if (rc)
3456 		return rc;
3457 
3458 	return 0;
3459 }
3460 
range_write(struct policydb * p,void * fp)3461 static int range_write(struct policydb *p, void *fp)
3462 {
3463 	__le32 buf[1];
3464 	int rc;
3465 	struct policy_data pd;
3466 
3467 	pd.p = p;
3468 	pd.fp = fp;
3469 
3470 	buf[0] = cpu_to_le32(p->range_tr.nel);
3471 	rc = put_entry(buf, sizeof(u32), 1, fp);
3472 	if (rc)
3473 		return rc;
3474 
3475 	/* actually write all of the entries */
3476 	rc = hashtab_map(&p->range_tr, range_write_helper, &pd);
3477 	if (rc)
3478 		return rc;
3479 
3480 	return 0;
3481 }
3482 
filename_write_helper_compat(void * key,void * data,void * ptr)3483 static int filename_write_helper_compat(void *key, void *data, void *ptr)
3484 {
3485 	struct filename_trans_key *ft = key;
3486 	struct filename_trans_datum *datum = data;
3487 	struct ebitmap_node *node;
3488 	void *fp = ptr;
3489 	__le32 buf[4];
3490 	int rc;
3491 	u32 bit, len = strlen(ft->name);
3492 
3493 	do {
3494 		ebitmap_for_each_positive_bit(&datum->stypes, node, bit) {
3495 			buf[0] = cpu_to_le32(len);
3496 			rc = put_entry(buf, sizeof(u32), 1, fp);
3497 			if (rc)
3498 				return rc;
3499 
3500 			rc = put_entry(ft->name, sizeof(char), len, fp);
3501 			if (rc)
3502 				return rc;
3503 
3504 			buf[0] = cpu_to_le32(bit + 1);
3505 			buf[1] = cpu_to_le32(ft->ttype);
3506 			buf[2] = cpu_to_le32(ft->tclass);
3507 			buf[3] = cpu_to_le32(datum->otype);
3508 
3509 			rc = put_entry(buf, sizeof(u32), 4, fp);
3510 			if (rc)
3511 				return rc;
3512 		}
3513 
3514 		datum = datum->next;
3515 	} while (unlikely(datum));
3516 
3517 	return 0;
3518 }
3519 
filename_write_helper(void * key,void * data,void * ptr)3520 static int filename_write_helper(void *key, void *data, void *ptr)
3521 {
3522 	struct filename_trans_key *ft = key;
3523 	struct filename_trans_datum *datum;
3524 	void *fp = ptr;
3525 	__le32 buf[3];
3526 	int rc;
3527 	u32 ndatum, len = strlen(ft->name);
3528 
3529 	buf[0] = cpu_to_le32(len);
3530 	rc = put_entry(buf, sizeof(u32), 1, fp);
3531 	if (rc)
3532 		return rc;
3533 
3534 	rc = put_entry(ft->name, sizeof(char), len, fp);
3535 	if (rc)
3536 		return rc;
3537 
3538 	ndatum = 0;
3539 	datum = data;
3540 	do {
3541 		ndatum++;
3542 		datum = datum->next;
3543 	} while (unlikely(datum));
3544 
3545 	buf[0] = cpu_to_le32(ft->ttype);
3546 	buf[1] = cpu_to_le32(ft->tclass);
3547 	buf[2] = cpu_to_le32(ndatum);
3548 	rc = put_entry(buf, sizeof(u32), 3, fp);
3549 	if (rc)
3550 		return rc;
3551 
3552 	datum = data;
3553 	do {
3554 		rc = ebitmap_write(&datum->stypes, fp);
3555 		if (rc)
3556 			return rc;
3557 
3558 		buf[0] = cpu_to_le32(datum->otype);
3559 		rc = put_entry(buf, sizeof(u32), 1, fp);
3560 		if (rc)
3561 			return rc;
3562 
3563 		datum = datum->next;
3564 	} while (unlikely(datum));
3565 
3566 	return 0;
3567 }
3568 
filename_trans_write(struct policydb * p,void * fp)3569 static int filename_trans_write(struct policydb *p, void *fp)
3570 {
3571 	__le32 buf[1];
3572 	int rc;
3573 
3574 	if (p->policyvers < POLICYDB_VERSION_FILENAME_TRANS)
3575 		return 0;
3576 
3577 	if (p->policyvers < POLICYDB_VERSION_COMP_FTRANS) {
3578 		buf[0] = cpu_to_le32(p->compat_filename_trans_count);
3579 		rc = put_entry(buf, sizeof(u32), 1, fp);
3580 		if (rc)
3581 			return rc;
3582 
3583 		rc = hashtab_map(&p->filename_trans,
3584 				 filename_write_helper_compat, fp);
3585 	} else {
3586 		buf[0] = cpu_to_le32(p->filename_trans.nel);
3587 		rc = put_entry(buf, sizeof(u32), 1, fp);
3588 		if (rc)
3589 			return rc;
3590 
3591 		rc = hashtab_map(&p->filename_trans, filename_write_helper, fp);
3592 	}
3593 	return rc;
3594 }
3595 
3596 /*
3597  * Write the configuration data in a policy database
3598  * structure to a policy database binary representation
3599  * file.
3600  */
policydb_write(struct policydb * p,void * fp)3601 int policydb_write(struct policydb *p, void *fp)
3602 {
3603 	unsigned int i, num_syms;
3604 	int rc;
3605 	__le32 buf[4];
3606 	u32 config;
3607 	size_t len;
3608 	const struct policydb_compat_info *info;
3609 
3610 	/*
3611 	 * refuse to write policy older than compressed avtab
3612 	 * to simplify the writer.  There are other tests dropped
3613 	 * since we assume this throughout the writer code.  Be
3614 	 * careful if you ever try to remove this restriction
3615 	 */
3616 	if (p->policyvers < POLICYDB_VERSION_AVTAB) {
3617 		pr_err("SELinux: refusing to write policy version %d."
3618 		       "  Because it is less than version %d\n", p->policyvers,
3619 		       POLICYDB_VERSION_AVTAB);
3620 		return -EINVAL;
3621 	}
3622 
3623 	config = 0;
3624 	if (p->mls_enabled)
3625 		config |= POLICYDB_CONFIG_MLS;
3626 
3627 	if (p->reject_unknown)
3628 		config |= REJECT_UNKNOWN;
3629 	if (p->allow_unknown)
3630 		config |= ALLOW_UNKNOWN;
3631 
3632 	/* Write the magic number and string identifiers. */
3633 	buf[0] = cpu_to_le32(POLICYDB_MAGIC);
3634 	len = strlen(POLICYDB_STRING);
3635 	buf[1] = cpu_to_le32(len);
3636 	rc = put_entry(buf, sizeof(u32), 2, fp);
3637 	if (rc)
3638 		return rc;
3639 	rc = put_entry(POLICYDB_STRING, 1, len, fp);
3640 	if (rc)
3641 		return rc;
3642 
3643 	/* Write the version, config, and table sizes. */
3644 	info = policydb_lookup_compat(p->policyvers);
3645 	if (!info) {
3646 		pr_err("SELinux: compatibility lookup failed for policy "
3647 		    "version %d", p->policyvers);
3648 		return -EINVAL;
3649 	}
3650 
3651 	buf[0] = cpu_to_le32(p->policyvers);
3652 	buf[1] = cpu_to_le32(config);
3653 	buf[2] = cpu_to_le32(info->sym_num);
3654 	buf[3] = cpu_to_le32(info->ocon_num);
3655 
3656 	rc = put_entry(buf, sizeof(u32), 4, fp);
3657 	if (rc)
3658 		return rc;
3659 
3660 	if (p->policyvers >= POLICYDB_VERSION_POLCAP) {
3661 		rc = ebitmap_write(&p->policycaps, fp);
3662 		if (rc)
3663 			return rc;
3664 	}
3665 
3666 	if (p->policyvers >= POLICYDB_VERSION_PERMISSIVE) {
3667 		rc = ebitmap_write(&p->permissive_map, fp);
3668 		if (rc)
3669 			return rc;
3670 	}
3671 
3672 	num_syms = info->sym_num;
3673 	for (i = 0; i < num_syms; i++) {
3674 		struct policy_data pd;
3675 
3676 		pd.fp = fp;
3677 		pd.p = p;
3678 
3679 		buf[0] = cpu_to_le32(p->symtab[i].nprim);
3680 		buf[1] = cpu_to_le32(p->symtab[i].table.nel);
3681 
3682 		rc = put_entry(buf, sizeof(u32), 2, fp);
3683 		if (rc)
3684 			return rc;
3685 		rc = hashtab_map(&p->symtab[i].table, write_f[i], &pd);
3686 		if (rc)
3687 			return rc;
3688 	}
3689 
3690 	rc = avtab_write(p, &p->te_avtab, fp);
3691 	if (rc)
3692 		return rc;
3693 
3694 	rc = cond_write_list(p, fp);
3695 	if (rc)
3696 		return rc;
3697 
3698 	rc = role_trans_write(p, fp);
3699 	if (rc)
3700 		return rc;
3701 
3702 	rc = role_allow_write(p->role_allow, fp);
3703 	if (rc)
3704 		return rc;
3705 
3706 	rc = filename_trans_write(p, fp);
3707 	if (rc)
3708 		return rc;
3709 
3710 	rc = ocontext_write(p, info, fp);
3711 	if (rc)
3712 		return rc;
3713 
3714 	rc = genfs_write(p, fp);
3715 	if (rc)
3716 		return rc;
3717 
3718 	rc = range_write(p, fp);
3719 	if (rc)
3720 		return rc;
3721 
3722 	for (i = 0; i < p->p_types.nprim; i++) {
3723 		struct ebitmap *e = &p->type_attr_map_array[i];
3724 
3725 		rc = ebitmap_write(e, fp);
3726 		if (rc)
3727 			return rc;
3728 	}
3729 
3730 	return 0;
3731 }
3732