Branch data     Line data    Source code

       1                 :            : /*
       2                 :            :  * Implementation of the access vector table type.
       3                 :            :  *
       4                 :            :  * Author : Stephen Smalley, <sds@tycho.nsa.gov>
       5                 :            :  */
       6                 :            : 
       7                 :            : /* Updated: Frank Mayer <mayerf@tresys.com> and Karl MacMillan <kmacmillan@tresys.com>
       8                 :            :  *
       9                 :            :  *      Added conditional policy language extensions
      10                 :            :  *
      11                 :            :  * Copyright (C) 2003 Tresys Technology, LLC
      12                 :            :  *      This program is free software; you can redistribute it and/or modify
      13                 :            :  *      it under the terms of the GNU General Public License as published by
      14                 :            :  *      the Free Software Foundation, version 2.
      15                 :            :  *
      16                 :            :  * Updated: Yuichi Nakamura <ynakam@hitachisoft.jp>
      17                 :            :  *      Tuned number of hash slots for avtab to reduce memory usage
      18                 :            :  */
      19                 :            : 
      20                 :            : #include <linux/kernel.h>
      21                 :            : #include <linux/slab.h>
      22                 :            : #include <linux/errno.h>
      23                 :            : #include "avtab.h"
      24                 :            : #include "policydb.h"
      25                 :            : 
      26                 :            : static struct kmem_cache *avtab_node_cachep;
      27                 :            : static struct kmem_cache *avtab_xperms_cachep;
      28                 :            : 
      29                 :            : /* Based on MurmurHash3, written by Austin Appleby and placed in the
      30                 :            :  * public domain.
      31                 :            :  */
      32                 :          0 : static inline int avtab_hash(struct avtab_key *keyp, u32 mask)
      33                 :            : {
      34                 :          0 :         static const u32 c1 = 0xcc9e2d51;
      35                 :          0 :         static const u32 c2 = 0x1b873593;
      36                 :          0 :         static const u32 r1 = 15;
      37                 :          0 :         static const u32 r2 = 13;
      38                 :          0 :         static const u32 m  = 5;
      39                 :          0 :         static const u32 n  = 0xe6546b64;
      40                 :            : 
      41                 :          0 :         u32 hash = 0;
      42                 :            : 
      43                 :            : #define mix(input) { \
      44                 :            :         u32 v = input; \
      45                 :            :         v *= c1; \
      46                 :            :         v = (v << r1) | (v >> (32 - r1)); \
      47                 :            :         v *= c2; \
      48                 :            :         hash ^= v; \
      49                 :            :         hash = (hash << r2) | (hash >> (32 - r2)); \
      50                 :            :         hash = hash * m + n; \
      51                 :            : }
      52                 :            : 
      53                 :          0 :         mix(keyp->target_class);
      54                 :          0 :         mix(keyp->target_type);
      55                 :          0 :         mix(keyp->source_type);
      56                 :            : 
      57                 :            : #undef mix
      58                 :            : 
      59                 :          0 :         hash ^= hash >> 16;
      60                 :          0 :         hash *= 0x85ebca6b;
      61                 :          0 :         hash ^= hash >> 13;
      62                 :          0 :         hash *= 0xc2b2ae35;
      63                 :          0 :         hash ^= hash >> 16;
      64                 :            : 
      65                 :          0 :         return hash & mask;
      66                 :            : }
      67                 :            : 
      68                 :            : static struct avtab_node*
      69                 :            : avtab_insert_node(struct avtab *h, int hvalue,
      70                 :            :                   struct avtab_node *prev, struct avtab_node *cur,
      71                 :            :                   struct avtab_key *key, struct avtab_datum *datum)
      72                 :            : {
      73                 :            :         struct avtab_node *newnode;
      74                 :            :         struct avtab_extended_perms *xperms;
      75                 :            :         newnode = kmem_cache_zalloc(avtab_node_cachep, GFP_KERNEL);
      76                 :            :         if (newnode == NULL)
      77                 :            :                 return NULL;
      78                 :            :         newnode->key = *key;
      79                 :            : 
      80                 :            :         if (key->specified & AVTAB_XPERMS) {
      81                 :            :                 xperms = kmem_cache_zalloc(avtab_xperms_cachep, GFP_KERNEL);
      82                 :            :                 if (xperms == NULL) {
      83                 :            :                         kmem_cache_free(avtab_node_cachep, newnode);
      84                 :            :                         return NULL;
      85                 :            :                 }
      86                 :            :                 *xperms = *(datum->u.xperms);
      87                 :            :                 newnode->datum.u.xperms = xperms;
      88                 :            :         } else {
      89                 :            :                 newnode->datum.u.data = datum->u.data;
      90                 :            :         }
      91                 :            : 
      92                 :            :         if (prev) {
      93                 :            :                 newnode->next = prev->next;
      94                 :            :                 prev->next = newnode;
      95                 :            :         } else {
      96                 :            :                 struct avtab_node **n = &h->htable[hvalue];
      97                 :            : 
      98                 :            :                 newnode->next = *n;
      99                 :            :                 *n = newnode;
     100                 :            :         }
     101                 :            : 
     102                 :            :         h->nel++;
     103                 :            :         return newnode;
     104                 :            : }
     105                 :            : 
     106                 :          0 : static int avtab_insert(struct avtab *h, struct avtab_key *key, struct avtab_datum *datum)
     107                 :            : {
     108                 :          0 :         int hvalue;
     109                 :          0 :         struct avtab_node *prev, *cur, *newnode;
     110                 :          0 :         u16 specified = key->specified & ~(AVTAB_ENABLED|AVTAB_ENABLED_OLD);
     111                 :            : 
     112         [ #  # ]:          0 :         if (!h)
     113                 :            :                 return -EINVAL;
     114                 :            : 
     115                 :          0 :         hvalue = avtab_hash(key, h->mask);
     116                 :          0 :         for (prev = NULL, cur = h->htable[hvalue];
     117         [ #  # ]:          0 :              cur;
     118                 :          0 :              prev = cur, cur = cur->next) {
     119         [ #  # ]:          0 :                 if (key->source_type == cur->key.source_type &&
     120         [ #  # ]:          0 :                     key->target_type == cur->key.target_type &&
     121         [ #  # ]:          0 :                     key->target_class == cur->key.target_class &&
     122         [ #  # ]:          0 :                     (specified & cur->key.specified)) {
     123                 :            :                         /* extended perms may not be unique */
     124         [ #  # ]:          0 :                         if (specified & AVTAB_XPERMS)
     125                 :            :                                 break;
     126                 :            :                         return -EEXIST;
     127                 :            :                 }
     128         [ #  # ]:          0 :                 if (key->source_type < cur->key.source_type)
     129                 :            :                         break;
     130         [ #  # ]:          0 :                 if (key->source_type == cur->key.source_type &&
     131         [ #  # ]:          0 :                     key->target_type < cur->key.target_type)
     132                 :            :                         break;
     133         [ #  # ]:          0 :                 if (key->source_type == cur->key.source_type &&
     134         [ #  # ]:          0 :                     key->target_type == cur->key.target_type &&
     135         [ #  # ]:          0 :                     key->target_class < cur->key.target_class)
     136                 :            :                         break;
     137                 :            :         }
     138                 :            : 
     139                 :          0 :         newnode = avtab_insert_node(h, hvalue, prev, cur, key, datum);
     140         [ #  # ]:          0 :         if (!newnode)
     141                 :          0 :                 return -ENOMEM;
     142                 :            : 
     143                 :            :         return 0;
     144                 :            : }
     145                 :            : 
     146                 :            : /* Unlike avtab_insert(), this function allow multiple insertions of the same
     147                 :            :  * key/specified mask into the table, as needed by the conditional avtab.
     148                 :            :  * It also returns a pointer to the node inserted.
     149                 :            :  */
     150                 :            : struct avtab_node *
     151                 :          0 : avtab_insert_nonunique(struct avtab *h, struct avtab_key *key, struct avtab_datum *datum)
     152                 :            : {
     153                 :          0 :         int hvalue;
     154                 :          0 :         struct avtab_node *prev, *cur;
     155                 :          0 :         u16 specified = key->specified & ~(AVTAB_ENABLED|AVTAB_ENABLED_OLD);
     156                 :            : 
     157         [ #  # ]:          0 :         if (!h)
     158                 :            :                 return NULL;
     159                 :          0 :         hvalue = avtab_hash(key, h->mask);
     160                 :          0 :         for (prev = NULL, cur = h->htable[hvalue];
     161         [ #  # ]:          0 :              cur;
     162                 :          0 :              prev = cur, cur = cur->next) {
     163         [ #  # ]:          0 :                 if (key->source_type == cur->key.source_type &&
     164         [ #  # ]:          0 :                     key->target_type == cur->key.target_type &&
     165         [ #  # ]:          0 :                     key->target_class == cur->key.target_class &&
     166         [ #  # ]:          0 :                     (specified & cur->key.specified))
     167                 :            :                         break;
     168         [ #  # ]:          0 :                 if (key->source_type < cur->key.source_type)
     169                 :            :                         break;
     170         [ #  # ]:          0 :                 if (key->source_type == cur->key.source_type &&
     171         [ #  # ]:          0 :                     key->target_type < cur->key.target_type)
     172                 :            :                         break;
     173         [ #  # ]:          0 :                 if (key->source_type == cur->key.source_type &&
     174         [ #  # ]:          0 :                     key->target_type == cur->key.target_type &&
     175         [ #  # ]:          0 :                     key->target_class < cur->key.target_class)
     176                 :            :                         break;
     177                 :            :         }
     178                 :          0 :         return avtab_insert_node(h, hvalue, prev, cur, key, datum);
     179                 :            : }
     180                 :            : 
     181                 :          0 : struct avtab_datum *avtab_search(struct avtab *h, struct avtab_key *key)
     182                 :            : {
     183                 :          0 :         int hvalue;
     184                 :          0 :         struct avtab_node *cur;
     185                 :          0 :         u16 specified = key->specified & ~(AVTAB_ENABLED|AVTAB_ENABLED_OLD);
     186                 :            : 
     187         [ #  # ]:          0 :         if (!h)
     188                 :            :                 return NULL;
     189                 :            : 
     190                 :          0 :         hvalue = avtab_hash(key, h->mask);
     191         [ #  # ]:          0 :         for (cur = h->htable[hvalue]; cur;
     192                 :          0 :              cur = cur->next) {
     193         [ #  # ]:          0 :                 if (key->source_type == cur->key.source_type &&
     194         [ #  # ]:          0 :                     key->target_type == cur->key.target_type &&
     195         [ #  # ]:          0 :                     key->target_class == cur->key.target_class &&
     196         [ #  # ]:          0 :                     (specified & cur->key.specified))
     197                 :          0 :                         return &cur->datum;
     198                 :            : 
     199         [ #  # ]:          0 :                 if (key->source_type < cur->key.source_type)
     200                 :            :                         break;
     201         [ #  # ]:          0 :                 if (key->source_type == cur->key.source_type &&
     202         [ #  # ]:          0 :                     key->target_type < cur->key.target_type)
     203                 :            :                         break;
     204         [ #  # ]:          0 :                 if (key->source_type == cur->key.source_type &&
     205         [ #  # ]:          0 :                     key->target_type == cur->key.target_type &&
     206         [ #  # ]:          0 :                     key->target_class < cur->key.target_class)
     207                 :            :                         break;
     208                 :            :         }
     209                 :            : 
     210                 :            :         return NULL;
     211                 :            : }
     212                 :            : 
     213                 :            : /* This search function returns a node pointer, and can be used in
     214                 :            :  * conjunction with avtab_search_next_node()
     215                 :            :  */
     216                 :            : struct avtab_node*
     217                 :          0 : avtab_search_node(struct avtab *h, struct avtab_key *key)
     218                 :            : {
     219                 :          0 :         int hvalue;
     220                 :          0 :         struct avtab_node *cur;
     221                 :          0 :         u16 specified = key->specified & ~(AVTAB_ENABLED|AVTAB_ENABLED_OLD);
     222                 :            : 
     223         [ #  # ]:          0 :         if (!h)
     224                 :            :                 return NULL;
     225                 :            : 
     226                 :          0 :         hvalue = avtab_hash(key, h->mask);
     227         [ #  # ]:          0 :         for (cur = h->htable[hvalue]; cur;
     228                 :          0 :              cur = cur->next) {
     229         [ #  # ]:          0 :                 if (key->source_type == cur->key.source_type &&
     230         [ #  # ]:          0 :                     key->target_type == cur->key.target_type &&
     231         [ #  # ]:          0 :                     key->target_class == cur->key.target_class &&
     232         [ #  # ]:          0 :                     (specified & cur->key.specified))
     233                 :          0 :                         return cur;
     234                 :            : 
     235         [ #  # ]:          0 :                 if (key->source_type < cur->key.source_type)
     236                 :            :                         break;
     237         [ #  # ]:          0 :                 if (key->source_type == cur->key.source_type &&
     238         [ #  # ]:          0 :                     key->target_type < cur->key.target_type)
     239                 :            :                         break;
     240         [ #  # ]:          0 :                 if (key->source_type == cur->key.source_type &&
     241         [ #  # ]:          0 :                     key->target_type == cur->key.target_type &&
     242         [ #  # ]:          0 :                     key->target_class < cur->key.target_class)
     243                 :            :                         break;
     244                 :            :         }
     245                 :            :         return NULL;
     246                 :            : }
     247                 :            : 
     248                 :            : struct avtab_node*
     249                 :          0 : avtab_search_node_next(struct avtab_node *node, int specified)
     250                 :            : {
     251                 :          0 :         struct avtab_node *cur;
     252                 :            : 
     253         [ #  # ]:          0 :         if (!node)
     254                 :            :                 return NULL;
     255                 :            : 
     256                 :          0 :         specified &= ~(AVTAB_ENABLED|AVTAB_ENABLED_OLD);
     257         [ #  # ]:          0 :         for (cur = node->next; cur; cur = cur->next) {
     258                 :          0 :                 if (node->key.source_type == cur->key.source_type &&
     259         [ #  # ]:          0 :                     node->key.target_type == cur->key.target_type &&
     260                 :          0 :                     node->key.target_class == cur->key.target_class &&
     261         [ #  # ]:          0 :                     (specified & cur->key.specified))
     262                 :          0 :                         return cur;
     263                 :            : 
     264         [ #  # ]:          0 :                 if (node->key.source_type < cur->key.source_type)
     265                 :            :                         break;
     266         [ #  # ]:          0 :                 if (node->key.source_type == cur->key.source_type &&
     267         [ #  # ]:          0 :                     node->key.target_type < cur->key.target_type)
     268                 :            :                         break;
     269         [ #  # ]:          0 :                 if (node->key.source_type == cur->key.source_type &&
     270                 :          0 :                     node->key.target_type == cur->key.target_type &&
     271         [ #  # ]:          0 :                     node->key.target_class < cur->key.target_class)
     272                 :            :                         break;
     273                 :            :         }
     274                 :            :         return NULL;
     275                 :            : }
     276                 :            : 
     277                 :          0 : void avtab_destroy(struct avtab *h)
     278                 :            : {
     279                 :          0 :         int i;
     280                 :          0 :         struct avtab_node *cur, *temp;
     281                 :            : 
     282         [ #  # ]:          0 :         if (!h)
     283                 :            :                 return;
     284                 :            : 
     285         [ #  # ]:          0 :         for (i = 0; i < h->nslot; i++) {
     286                 :          0 :                 cur = h->htable[i];
     287         [ #  # ]:          0 :                 while (cur) {
     288                 :          0 :                         temp = cur;
     289                 :          0 :                         cur = cur->next;
     290         [ #  # ]:          0 :                         if (temp->key.specified & AVTAB_XPERMS)
     291                 :          0 :                                 kmem_cache_free(avtab_xperms_cachep,
     292                 :          0 :                                                 temp->datum.u.xperms);
     293                 :          0 :                         kmem_cache_free(avtab_node_cachep, temp);
     294                 :            :                 }
     295                 :            :         }
     296                 :          0 :         kvfree(h->htable);
     297                 :          0 :         h->htable = NULL;
     298                 :          0 :         h->nslot = 0;
     299                 :          0 :         h->mask = 0;
     300                 :            : }
     301                 :            : 
     302                 :          0 : int avtab_init(struct avtab *h)
     303                 :            : {
     304                 :          0 :         kvfree(h->htable);
     305                 :          0 :         h->htable = NULL;
     306                 :          0 :         h->nel = 0;
     307                 :          0 :         return 0;
     308                 :            : }
     309                 :            : 
     310                 :          0 : int avtab_alloc(struct avtab *h, u32 nrules)
     311                 :            : {
     312                 :          0 :         u32 mask = 0;
     313                 :          0 :         u32 shift = 0;
     314                 :          0 :         u32 work = nrules;
     315                 :          0 :         u32 nslot = 0;
     316                 :            : 
     317         [ #  # ]:          0 :         if (nrules == 0)
     318                 :          0 :                 goto avtab_alloc_out;
     319                 :            : 
     320         [ #  # ]:          0 :         while (work) {
     321                 :          0 :                 work  = work >> 1;
     322                 :          0 :                 shift++;
     323                 :            :         }
     324         [ #  # ]:          0 :         if (shift > 2)
     325                 :          0 :                 shift = shift - 2;
     326                 :          0 :         nslot = 1 << shift;
     327                 :          0 :         if (nslot > MAX_AVTAB_HASH_BUCKETS)
     328                 :            :                 nslot = MAX_AVTAB_HASH_BUCKETS;
     329                 :          0 :         mask = nslot - 1;
     330                 :            : 
     331                 :          0 :         h->htable = kvcalloc(nslot, sizeof(void *), GFP_KERNEL);
     332         [ #  # ]:          0 :         if (!h->htable)
     333                 :            :                 return -ENOMEM;
     334                 :            : 
     335                 :          0 :  avtab_alloc_out:
     336                 :          0 :         h->nel = 0;
     337                 :          0 :         h->nslot = nslot;
     338                 :          0 :         h->mask = mask;
     339                 :          0 :         pr_debug("SELinux: %d avtab hash slots, %d rules.\n",
     340                 :            :                h->nslot, nrules);
     341                 :          0 :         return 0;
     342                 :            : }
     343                 :            : 
     344                 :          0 : void avtab_hash_eval(struct avtab *h, char *tag)
     345                 :            : {
     346                 :          0 :         int i, chain_len, slots_used, max_chain_len;
     347                 :          0 :         unsigned long long chain2_len_sum;
     348                 :          0 :         struct avtab_node *cur;
     349                 :            : 
     350                 :          0 :         slots_used = 0;
     351                 :          0 :         max_chain_len = 0;
     352                 :          0 :         chain2_len_sum = 0;
     353         [ #  # ]:          0 :         for (i = 0; i < h->nslot; i++) {
     354                 :          0 :                 cur = h->htable[i];
     355         [ #  # ]:          0 :                 if (cur) {
     356                 :            :                         slots_used++;
     357                 :            :                         chain_len = 0;
     358         [ #  # ]:          0 :                         while (cur) {
     359                 :          0 :                                 chain_len++;
     360                 :          0 :                                 cur = cur->next;
     361                 :            :                         }
     362                 :            : 
     363                 :            :                         if (chain_len > max_chain_len)
     364                 :            :                                 max_chain_len = chain_len;
     365                 :            :                         chain2_len_sum += chain_len * chain_len;
     366                 :            :                 }
     367                 :            :         }
     368                 :            : 
     369                 :          0 :         pr_debug("SELinux: %s:  %d entries and %d/%d buckets used, "
     370                 :            :                "longest chain length %d sum of chain length^2 %llu\n",
     371                 :            :                tag, h->nel, slots_used, h->nslot, max_chain_len,
     372                 :            :                chain2_len_sum);
     373                 :          0 : }
     374                 :            : 
     375                 :            : static uint16_t spec_order[] = {
     376                 :            :         AVTAB_ALLOWED,
     377                 :            :         AVTAB_AUDITDENY,
     378                 :            :         AVTAB_AUDITALLOW,
     379                 :            :         AVTAB_TRANSITION,
     380                 :            :         AVTAB_CHANGE,
     381                 :            :         AVTAB_MEMBER,
     382                 :            :         AVTAB_XPERMS_ALLOWED,
     383                 :            :         AVTAB_XPERMS_AUDITALLOW,
     384                 :            :         AVTAB_XPERMS_DONTAUDIT
     385                 :            : };
     386                 :            : 
     387                 :          0 : int avtab_read_item(struct avtab *a, void *fp, struct policydb *pol,
     388                 :            :                     int (*insertf)(struct avtab *a, struct avtab_key *k,
     389                 :            :                                    struct avtab_datum *d, void *p),
     390                 :            :                     void *p)
     391                 :            : {
     392                 :          0 :         __le16 buf16[4];
     393                 :          0 :         u16 enabled;
     394                 :          0 :         u32 items, items2, val, vers = pol->policyvers;
     395                 :          0 :         struct avtab_key key;
     396                 :          0 :         struct avtab_datum datum;
     397                 :          0 :         struct avtab_extended_perms xperms;
     398                 :          0 :         __le32 buf32[ARRAY_SIZE(xperms.perms.p)];
     399                 :          0 :         int i, rc;
     400                 :          0 :         unsigned set;
     401                 :            : 
     402                 :          0 :         memset(&key, 0, sizeof(struct avtab_key));
     403                 :          0 :         memset(&datum, 0, sizeof(struct avtab_datum));
     404                 :            : 
     405         [ #  # ]:          0 :         if (vers < POLICYDB_VERSION_AVTAB) {
     406         [ #  # ]:          0 :                 rc = next_entry(buf32, fp, sizeof(u32));
     407                 :          0 :                 if (rc) {
     408                 :          0 :                         pr_err("SELinux: avtab: truncated entry\n");
     409                 :          0 :                         return rc;
     410                 :            :                 }
     411                 :          0 :                 items2 = le32_to_cpu(buf32[0]);
     412         [ #  # ]:          0 :                 if (items2 > ARRAY_SIZE(buf32)) {
     413                 :          0 :                         pr_err("SELinux: avtab: entry overflow\n");
     414                 :          0 :                         return -EINVAL;
     415                 :            : 
     416                 :            :                 }
     417         [ #  # ]:          0 :                 rc = next_entry(buf32, fp, sizeof(u32)*items2);
     418                 :          0 :                 if (rc) {
     419                 :          0 :                         pr_err("SELinux: avtab: truncated entry\n");
     420                 :          0 :                         return rc;
     421                 :            :                 }
     422                 :          0 :                 items = 0;
     423                 :            : 
     424                 :          0 :                 val = le32_to_cpu(buf32[items++]);
     425                 :          0 :                 key.source_type = (u16)val;
     426         [ #  # ]:          0 :                 if (key.source_type != val) {
     427                 :          0 :                         pr_err("SELinux: avtab: truncated source type\n");
     428                 :          0 :                         return -EINVAL;
     429                 :            :                 }
     430                 :          0 :                 val = le32_to_cpu(buf32[items++]);
     431                 :          0 :                 key.target_type = (u16)val;
     432         [ #  # ]:          0 :                 if (key.target_type != val) {
     433                 :          0 :                         pr_err("SELinux: avtab: truncated target type\n");
     434                 :          0 :                         return -EINVAL;
     435                 :            :                 }
     436                 :          0 :                 val = le32_to_cpu(buf32[items++]);
     437                 :          0 :                 key.target_class = (u16)val;
     438         [ #  # ]:          0 :                 if (key.target_class != val) {
     439                 :          0 :                         pr_err("SELinux: avtab: truncated target class\n");
     440                 :          0 :                         return -EINVAL;
     441                 :            :                 }
     442                 :            : 
     443                 :          0 :                 val = le32_to_cpu(buf32[items++]);
     444                 :          0 :                 enabled = (val & AVTAB_ENABLED_OLD) ? AVTAB_ENABLED : 0;
     445                 :            : 
     446         [ #  # ]:          0 :                 if (!(val & (AVTAB_AV | AVTAB_TYPE))) {
     447                 :          0 :                         pr_err("SELinux: avtab: null entry\n");
     448                 :          0 :                         return -EINVAL;
     449                 :            :                 }
     450         [ #  # ]:          0 :                 if ((val & AVTAB_AV) &&
     451         [ #  # ]:          0 :                     (val & AVTAB_TYPE)) {
     452                 :          0 :                         pr_err("SELinux: avtab: entry has both access vectors and types\n");
     453                 :          0 :                         return -EINVAL;
     454                 :            :                 }
     455         [ #  # ]:          0 :                 if (val & AVTAB_XPERMS) {
     456                 :          0 :                         pr_err("SELinux: avtab: entry has extended permissions\n");
     457                 :          0 :                         return -EINVAL;
     458                 :            :                 }
     459                 :            : 
     460         [ #  # ]:          0 :                 for (i = 0; i < ARRAY_SIZE(spec_order); i++) {
     461         [ #  # ]:          0 :                         if (val & spec_order[i]) {
     462                 :          0 :                                 key.specified = spec_order[i] | enabled;
     463                 :          0 :                                 datum.u.data = le32_to_cpu(buf32[items++]);
     464                 :          0 :                                 rc = insertf(a, &key, &datum, p);
     465         [ #  # ]:          0 :                                 if (rc)
     466                 :          0 :                                         return rc;
     467                 :            :                         }
     468                 :            :                 }
     469                 :            : 
     470         [ #  # ]:          0 :                 if (items != items2) {
     471                 :          0 :                         pr_err("SELinux: avtab: entry only had %d items, expected %d\n",
     472                 :            :                                items2, items);
     473                 :          0 :                         return -EINVAL;
     474                 :            :                 }
     475                 :            :                 return 0;
     476                 :            :         }
     477                 :            : 
     478         [ #  # ]:          0 :         rc = next_entry(buf16, fp, sizeof(u16)*4);
     479                 :          0 :         if (rc) {
     480                 :          0 :                 pr_err("SELinux: avtab: truncated entry\n");
     481                 :          0 :                 return rc;
     482                 :            :         }
     483                 :            : 
     484                 :          0 :         items = 0;
     485                 :          0 :         key.source_type = le16_to_cpu(buf16[items++]);
     486                 :          0 :         key.target_type = le16_to_cpu(buf16[items++]);
     487                 :          0 :         key.target_class = le16_to_cpu(buf16[items++]);
     488                 :          0 :         key.specified = le16_to_cpu(buf16[items++]);
     489                 :            : 
     490   [ #  #  #  # ]:          0 :         if (!policydb_type_isvalid(pol, key.source_type) ||
     491         [ #  # ]:          0 :             !policydb_type_isvalid(pol, key.target_type) ||
     492                 :          0 :             !policydb_class_isvalid(pol, key.target_class)) {
     493                 :          0 :                 pr_err("SELinux: avtab: invalid type or class\n");
     494                 :          0 :                 return -EINVAL;
     495                 :            :         }
     496                 :            : 
     497                 :            :         set = 0;
     498         [ #  # ]:          0 :         for (i = 0; i < ARRAY_SIZE(spec_order); i++) {
     499         [ #  # ]:          0 :                 if (key.specified & spec_order[i])
     500                 :          0 :                         set++;
     501                 :            :         }
     502         [ #  # ]:          0 :         if (!set || set > 1) {
     503                 :          0 :                 pr_err("SELinux:  avtab:  more than one specifier\n");
     504                 :          0 :                 return -EINVAL;
     505                 :            :         }
     506                 :            : 
     507         [ #  # ]:          0 :         if ((vers < POLICYDB_VERSION_XPERMS_IOCTL) &&
     508         [ #  # ]:          0 :                         (key.specified & AVTAB_XPERMS)) {
     509                 :          0 :                 pr_err("SELinux:  avtab:  policy version %u does not "
     510                 :            :                                 "support extended permissions rules and one "
     511                 :            :                                 "was specified\n", vers);
     512                 :          0 :                 return -EINVAL;
     513         [ #  # ]:          0 :         } else if (key.specified & AVTAB_XPERMS) {
     514                 :          0 :                 memset(&xperms, 0, sizeof(struct avtab_extended_perms));
     515         [ #  # ]:          0 :                 rc = next_entry(&xperms.specified, fp, sizeof(u8));
     516                 :          0 :                 if (rc) {
     517                 :          0 :                         pr_err("SELinux: avtab: truncated entry\n");
     518                 :          0 :                         return rc;
     519                 :            :                 }
     520         [ #  # ]:          0 :                 rc = next_entry(&xperms.driver, fp, sizeof(u8));
     521                 :          0 :                 if (rc) {
     522                 :          0 :                         pr_err("SELinux: avtab: truncated entry\n");
     523                 :          0 :                         return rc;
     524                 :            :                 }
     525         [ #  # ]:          0 :                 rc = next_entry(buf32, fp, sizeof(u32)*ARRAY_SIZE(xperms.perms.p));
     526                 :          0 :                 if (rc) {
     527                 :          0 :                         pr_err("SELinux: avtab: truncated entry\n");
     528                 :          0 :                         return rc;
     529                 :            :                 }
     530         [ #  # ]:          0 :                 for (i = 0; i < ARRAY_SIZE(xperms.perms.p); i++)
     531                 :          0 :                         xperms.perms.p[i] = le32_to_cpu(buf32[i]);
     532                 :          0 :                 datum.u.xperms = &xperms;
     533                 :            :         } else {
     534         [ #  # ]:          0 :                 rc = next_entry(buf32, fp, sizeof(u32));
     535                 :          0 :                 if (rc) {
     536                 :          0 :                         pr_err("SELinux: avtab: truncated entry\n");
     537                 :          0 :                         return rc;
     538                 :            :                 }
     539                 :          0 :                 datum.u.data = le32_to_cpu(*buf32);
     540                 :            :         }
     541   [ #  #  #  # ]:          0 :         if ((key.specified & AVTAB_TYPE) &&
     542                 :          0 :             !policydb_type_isvalid(pol, datum.u.data)) {
     543                 :          0 :                 pr_err("SELinux: avtab: invalid type\n");
     544                 :          0 :                 return -EINVAL;
     545                 :            :         }
     546                 :          0 :         return insertf(a, &key, &datum, p);
     547                 :            : }
     548                 :            : 
     549                 :          0 : static int avtab_insertf(struct avtab *a, struct avtab_key *k,
     550                 :            :                          struct avtab_datum *d, void *p)
     551                 :            : {
     552                 :          0 :         return avtab_insert(a, k, d);
     553                 :            : }
     554                 :            : 
     555                 :          0 : int avtab_read(struct avtab *a, void *fp, struct policydb *pol)
     556                 :            : {
     557                 :          0 :         int rc;
     558                 :          0 :         __le32 buf[1];
     559                 :          0 :         u32 nel, i;
     560                 :            : 
     561                 :            : 
     562         [ #  # ]:          0 :         rc = next_entry(buf, fp, sizeof(u32));
     563                 :          0 :         if (rc < 0) {
     564                 :          0 :                 pr_err("SELinux: avtab: truncated table\n");
     565                 :          0 :                 goto bad;
     566                 :            :         }
     567                 :          0 :         nel = le32_to_cpu(buf[0]);
     568         [ #  # ]:          0 :         if (!nel) {
     569                 :          0 :                 pr_err("SELinux: avtab: table is empty\n");
     570                 :          0 :                 rc = -EINVAL;
     571                 :          0 :                 goto bad;
     572                 :            :         }
     573                 :            : 
     574                 :          0 :         rc = avtab_alloc(a, nel);
     575         [ #  # ]:          0 :         if (rc)
     576                 :          0 :                 goto bad;
     577                 :            : 
     578         [ #  # ]:          0 :         for (i = 0; i < nel; i++) {
     579                 :          0 :                 rc = avtab_read_item(a, fp, pol, avtab_insertf, NULL);
     580         [ #  # ]:          0 :                 if (rc) {
     581         [ #  # ]:          0 :                         if (rc == -ENOMEM)
     582                 :          0 :                                 pr_err("SELinux: avtab: out of memory\n");
     583         [ #  # ]:          0 :                         else if (rc == -EEXIST)
     584                 :          0 :                                 pr_err("SELinux: avtab: duplicate entry\n");
     585                 :            : 
     586                 :          0 :                         goto bad;
     587                 :            :                 }
     588                 :            :         }
     589                 :            : 
     590                 :            :         rc = 0;
     591                 :          0 : out:
     592                 :          0 :         return rc;
     593                 :            : 
     594                 :          0 : bad:
     595                 :          0 :         avtab_destroy(a);
     596                 :          0 :         goto out;
     597                 :            : }
     598                 :            : 
     599                 :          0 : int avtab_write_item(struct policydb *p, struct avtab_node *cur, void *fp)
     600                 :            : {
     601                 :          0 :         __le16 buf16[4];
     602                 :          0 :         __le32 buf32[ARRAY_SIZE(cur->datum.u.xperms->perms.p)];
     603                 :          0 :         int rc;
     604                 :          0 :         unsigned int i;
     605                 :            : 
     606                 :          0 :         buf16[0] = cpu_to_le16(cur->key.source_type);
     607                 :          0 :         buf16[1] = cpu_to_le16(cur->key.target_type);
     608                 :          0 :         buf16[2] = cpu_to_le16(cur->key.target_class);
     609                 :          0 :         buf16[3] = cpu_to_le16(cur->key.specified);
     610         [ #  # ]:          0 :         rc = put_entry(buf16, sizeof(u16), 4, fp);
     611                 :          0 :         if (rc)
     612                 :            :                 return rc;
     613                 :            : 
     614         [ #  # ]:          0 :         if (cur->key.specified & AVTAB_XPERMS) {
     615                 :          0 :                 rc = put_entry(&cur->datum.u.xperms->specified, sizeof(u8), 1, fp);
     616                 :          0 :                 if (rc)
     617                 :            :                         return rc;
     618                 :          0 :                 rc = put_entry(&cur->datum.u.xperms->driver, sizeof(u8), 1, fp);
     619                 :          0 :                 if (rc)
     620                 :            :                         return rc;
     621         [ #  # ]:          0 :                 for (i = 0; i < ARRAY_SIZE(cur->datum.u.xperms->perms.p); i++)
     622                 :          0 :                         buf32[i] = cpu_to_le32(cur->datum.u.xperms->perms.p[i]);
     623                 :          0 :                 rc = put_entry(buf32, sizeof(u32),
     624                 :            :                                 ARRAY_SIZE(cur->datum.u.xperms->perms.p), fp);
     625                 :            :         } else {
     626                 :          0 :                 buf32[0] = cpu_to_le32(cur->datum.u.data);
     627                 :          0 :                 rc = put_entry(buf32, sizeof(u32), 1, fp);
     628                 :            :         }
     629                 :          0 :         if (rc)
     630                 :            :                 return rc;
     631                 :          0 :         return 0;
     632                 :            : }
     633                 :            : 
     634                 :          0 : int avtab_write(struct policydb *p, struct avtab *a, void *fp)
     635                 :            : {
     636                 :          0 :         unsigned int i;
     637                 :          0 :         int rc = 0;
     638                 :          0 :         struct avtab_node *cur;
     639                 :          0 :         __le32 buf[1];
     640                 :            : 
     641                 :          0 :         buf[0] = cpu_to_le32(a->nel);
     642                 :          0 :         rc = put_entry(buf, sizeof(u32), 1, fp);
     643                 :          0 :         if (rc)
     644                 :            :                 return rc;
     645                 :            : 
     646         [ #  # ]:          0 :         for (i = 0; i < a->nslot; i++) {
     647         [ #  # ]:          0 :                 for (cur = a->htable[i]; cur;
     648                 :          0 :                      cur = cur->next) {
     649                 :          0 :                         rc = avtab_write_item(p, cur, fp);
     650         [ #  # ]:          0 :                         if (rc)
     651                 :          0 :                                 return rc;
     652                 :            :                 }
     653                 :            :         }
     654                 :            : 
     655                 :            :         return rc;
     656                 :            : }
     657                 :            : 
     658                 :         28 : void __init avtab_cache_init(void)
     659                 :            : {
     660                 :         28 :         avtab_node_cachep = kmem_cache_create("avtab_node",
     661                 :            :                                               sizeof(struct avtab_node),
     662                 :            :                                               0, SLAB_PANIC, NULL);
     663                 :         28 :         avtab_xperms_cachep = kmem_cache_create("avtab_extended_perms",
     664                 :            :                                                 sizeof(struct avtab_extended_perms),
     665                 :            :                                                 0, SLAB_PANIC, NULL);
     666                 :         28 : }