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