security/selinux/ss/policydb.c

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