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