net/netlabel/netlabel_domainhash.c

   1 /*
   2  * NetLabel Domain Hash Table
   3  *
   4  * This file manages the domain hash table that NetLabel uses to determine
   5  * which network labeling protocol to use for a given domain.  The NetLabel
   6  * system manages static and dynamic label mappings for network protocols such
   7  * as CIPSO and RIPSO.
   8  *
   9  * Author: Paul Moore <paul.moore@hp.com>
  10  *
  11  */
  12
  13 /*
  14  * (c) Copyright Hewlett-Packard Development Company, L.P., 2006
  15  *
  16  * This program is free software;  you can redistribute it and/or modify
  17  * it under the terms of the GNU General Public License as published by
  18  * the Free Software Foundation; either version 2 of the License, or
  19  * (at your option) any later version.
  20  *
  21  * This program is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY;  without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  24  * the GNU General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU General Public License
  27  * along with this program;  if not, write to the Free Software
  28  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  29  *
  30  */
  31
  32 #include <linux/types.h>
  33 #include <linux/rcupdate.h>
  34 #include <linux/list.h>
  35 #include <linux/skbuff.h>
  36 #include <linux/spinlock.h>
  37 #include <linux/string.h>
  38 #include <net/netlabel.h>
  39 #include <net/cipso_ipv4.h>
  40 #include <asm/bug.h>
  41
  42 #include "netlabel_mgmt.h"
  43 #include "netlabel_domainhash.h"
  44
  45 struct netlbl_domhsh_tbl {
  46         struct list_head *tbl;
  47         u32 size;
  48 };
  49
  50 /* Domain hash table */
  51 /* XXX - updates should be so rare that having one spinlock for the entire
  52  * hash table should be okay */
  53 static DEFINE_SPINLOCK(netlbl_domhsh_lock);
  54 static struct netlbl_domhsh_tbl *netlbl_domhsh = NULL;
  55
  56 /* Default domain mapping */
  57 static DEFINE_SPINLOCK(netlbl_domhsh_def_lock);
  58 static struct netlbl_dom_map *netlbl_domhsh_def = NULL;
  59
  60 /*
  61  * Domain Hash Table Helper Functions
  62  */
  63
  64 /**
  65  * netlbl_domhsh_free_entry - Frees a domain hash table entry
  66  * @entry: the entry's RCU field
  67  *
  68  * Description:
  69  * This function is designed to be used as a callback to the call_rcu()
  70  * function so that the memory allocated to a hash table entry can be released
  71  * safely.
  72  *
  73  */
  74 static void netlbl_domhsh_free_entry(struct rcu_head *entry)
  75 {
  76         struct netlbl_dom_map *ptr;
  77
  78         ptr = container_of(entry, struct netlbl_dom_map, rcu);
  79         kfree(ptr->domain);
  80         kfree(ptr);
  81 }
  82
  83 /**
  84  * netlbl_domhsh_hash - Hashing function for the domain hash table
  85  * @domain: the domain name to hash
  86  *
  87  * Description:
  88  * This is the hashing function for the domain hash table, it returns the
  89  * correct bucket number for the domain.  The caller is responsibile for
  90  * calling the rcu_read_[un]lock() functions.
  91  *
  92  */
  93 static u32 netlbl_domhsh_hash(const char *key)
  94 {
  95         u32 iter;
  96         u32 val;
  97         u32 len;
  98
  99         /* This is taken (with slight modification) from
 100          * security/selinux/ss/symtab.c:symhash() */
 101
 102         for (iter = 0, val = 0, len = strlen(key); iter < len; iter++)
 103                 val = (val << 4 | (val >> (8 * sizeof(u32) - 4))) ^ key[iter];
 104         return val & (rcu_dereference(netlbl_domhsh)->size - 1);
 105 }
 106
 107 /**
 108  * netlbl_domhsh_search - Search for a domain entry
 109  * @domain: the domain
 110  * @def: return default if no match is found
 111  *
 112  * Description:
 113  * Searches the domain hash table and returns a pointer to the hash table
 114  * entry if found, otherwise NULL is returned.  If @def is non-zero and a
 115  * match is not found in the domain hash table the default mapping is returned
 116  * if it exists.  The caller is responsibile for the rcu hash table locks
 117  * (i.e. the caller much call rcu_read_[un]lock()).
 118  *
 119  */
 120 static struct netlbl_dom_map *netlbl_domhsh_search(const char *domain, u32 def)
 121 {
 122         u32 bkt;
 123         struct netlbl_dom_map *iter;
 124
 125         if (domain != NULL) {
 126                 bkt = netlbl_domhsh_hash(domain);
 127                 list_for_each_entry_rcu(iter, &netlbl_domhsh->tbl[bkt], list)
 128                         if (iter->valid && strcmp(iter->domain, domain) == 0)
 129                                 return iter;
 130         }
 131
 132         if (def != 0) {
 133                 iter = rcu_dereference(netlbl_domhsh_def);
 134                 if (iter != NULL && iter->valid)
 135                         return iter;
 136         }
 137
 138         return NULL;
 139 }
 140
 141 /*
 142  * Domain Hash Table Functions
 143  */
 144
 145 /**
 146  * netlbl_domhsh_init - Init for the domain hash
 147  * @size: the number of bits to use for the hash buckets
 148  *
 149  * Description:
 150  * Initializes the domain hash table, should be called only by
 151  * netlbl_user_init() during initialization.  Returns zero on success, non-zero
 152  * values on error.
 153  *
 154  */
 155 int netlbl_domhsh_init(u32 size)
 156 {
 157         u32 iter;
 158         struct netlbl_domhsh_tbl *hsh_tbl;
 159
 160         if (size == 0)
 161                 return -EINVAL;
 162
 163         hsh_tbl = kmalloc(sizeof(*hsh_tbl), GFP_KERNEL);
 164         if (hsh_tbl == NULL)
 165                 return -ENOMEM;
 166         hsh_tbl->size = 1 << size;
 167         hsh_tbl->tbl = kcalloc(hsh_tbl->size,
 168                                sizeof(struct list_head),
 169                                GFP_KERNEL);
 170         if (hsh_tbl->tbl == NULL) {
 171                 kfree(hsh_tbl);
 172                 return -ENOMEM;
 173         }
 174         for (iter = 0; iter < hsh_tbl->size; iter++)
 175                 INIT_LIST_HEAD(&hsh_tbl->tbl[iter]);
 176
 177         rcu_read_lock();
 178         spin_lock(&netlbl_domhsh_lock);
 179         rcu_assign_pointer(netlbl_domhsh, hsh_tbl);
 180         spin_unlock(&netlbl_domhsh_lock);
 181         rcu_read_unlock();
 182
 183         return 0;
 184 }
 185
 186 /**
 187  * netlbl_domhsh_add - Adds a entry to the domain hash table
 188  * @entry: the entry to add
 189  *
 190  * Description:
 191  * Adds a new entry to the domain hash table and handles any updates to the
 192  * lower level protocol handler (i.e. CIPSO).  Returns zero on success,
 193  * negative on failure.
 194  *
 195  */
 196 int netlbl_domhsh_add(struct netlbl_dom_map *entry)
 197 {
 198         int ret_val;
 199         u32 bkt;
 200
 201         switch (entry->type) {
 202         case NETLBL_NLTYPE_UNLABELED:
 203                 ret_val = 0;
 204                 break;
 205         case NETLBL_NLTYPE_CIPSOV4:
 206                 ret_val = cipso_v4_doi_domhsh_add(entry->type_def.cipsov4,
 207                                                   entry->domain);
 208                 break;
 209         default:
 210                 return -EINVAL;
 211         }
 212         if (ret_val != 0)
 213                 return ret_val;
 214
 215         entry->valid = 1;
 216         INIT_RCU_HEAD(&entry->rcu);
 217
 218         ret_val = 0;
 219         rcu_read_lock();
 220         if (entry->domain != NULL) {
 221                 bkt = netlbl_domhsh_hash(entry->domain);
 222                 spin_lock(&netlbl_domhsh_lock);
 223                 if (netlbl_domhsh_search(entry->domain, 0) == NULL)
 224                         list_add_tail_rcu(&entry->list,
 225                                           &netlbl_domhsh->tbl[bkt]);
 226                 else
 227                         ret_val = -EEXIST;
 228                 spin_unlock(&netlbl_domhsh_lock);
 229         } else if (entry->domain == NULL) {
 230                 INIT_LIST_HEAD(&entry->list);
 231                 spin_lock(&netlbl_domhsh_def_lock);
 232                 if (rcu_dereference(netlbl_domhsh_def) == NULL)
 233                         rcu_assign_pointer(netlbl_domhsh_def, entry);
 234                 else
 235                         ret_val = -EEXIST;
 236                 spin_unlock(&netlbl_domhsh_def_lock);
 237         } else
 238                 ret_val = -EINVAL;
 239         rcu_read_unlock();
 240
 241         if (ret_val != 0) {
 242                 switch (entry->type) {
 243                 case NETLBL_NLTYPE_CIPSOV4:
 244                         if (cipso_v4_doi_domhsh_remove(entry->type_def.cipsov4,
 245                                                        entry->domain) != 0)
 246                                 BUG();
 247                         break;
 248                 }
 249         }
 250
 251         return ret_val;
 252 }
 253
 254 /**
 255  * netlbl_domhsh_add_default - Adds the default entry to the domain hash table
 256  * @entry: the entry to add
 257  *
 258  * Description:
 259  * Adds a new default entry to the domain hash table and handles any updates
 260  * to the lower level protocol handler (i.e. CIPSO).  Returns zero on success,
 261  * negative on failure.
 262  *
 263  */
 264 int netlbl_domhsh_add_default(struct netlbl_dom_map *entry)
 265 {
 266         return netlbl_domhsh_add(entry);
 267 }
 268
 269 /**
 270  * netlbl_domhsh_remove - Removes an entry from the domain hash table
 271  * @domain: the domain to remove
 272  *
 273  * Description:
 274  * Removes an entry from the domain hash table and handles any updates to the
 275  * lower level protocol handler (i.e. CIPSO).  Returns zero on success,
 276  * negative on failure.
 277  *
 278  */
 279 int netlbl_domhsh_remove(const char *domain)
 280 {
 281         int ret_val = -ENOENT;
 282         struct netlbl_dom_map *entry;
 283
 284         rcu_read_lock();
 285         if (domain != NULL)
 286                 entry = netlbl_domhsh_search(domain, 0);
 287         else
 288                 entry = netlbl_domhsh_search(domain, 1);
 289         if (entry == NULL)
 290                 goto remove_return;
 291         switch (entry->type) {
 292         case NETLBL_NLTYPE_UNLABELED:
 293                 break;
 294         case NETLBL_NLTYPE_CIPSOV4:
 295                 ret_val = cipso_v4_doi_domhsh_remove(entry->type_def.cipsov4,
 296                                                      entry->domain);
 297                 if (ret_val != 0)
 298                         goto remove_return;
 299                 break;
 300         }
 301         ret_val = 0;
 302         if (entry != rcu_dereference(netlbl_domhsh_def)) {
 303                 spin_lock(&netlbl_domhsh_lock);
 304                 if (entry->valid) {
 305                         entry->valid = 0;
 306                         list_del_rcu(&entry->list);
 307                 } else
 308                         ret_val = -ENOENT;
 309                 spin_unlock(&netlbl_domhsh_lock);
 310         } else {
 311                 spin_lock(&netlbl_domhsh_def_lock);
 312                 if (entry->valid) {
 313                         entry->valid = 0;
 314                         rcu_assign_pointer(netlbl_domhsh_def, NULL);
 315                 } else
 316                         ret_val = -ENOENT;
 317                 spin_unlock(&netlbl_domhsh_def_lock);
 318         }
 319         if (ret_val == 0)
 320                 call_rcu(&entry->rcu, netlbl_domhsh_free_entry);
 321
 322 remove_return:
 323         rcu_read_unlock();
 324         return ret_val;
 325 }
 326
 327 /**
 328  * netlbl_domhsh_remove_default - Removes the default entry from the table
 329  *
 330  * Description:
 331  * Removes/resets the default entry for the domain hash table and handles any
 332  * updates to the lower level protocol handler (i.e. CIPSO).  Returns zero on
 333  * success, non-zero on failure.
 334  *
 335  */
 336 int netlbl_domhsh_remove_default(void)
 337 {
 338         return netlbl_domhsh_remove(NULL);
 339 }
 340
 341 /**
 342  * netlbl_domhsh_getentry - Get an entry from the domain hash table
 343  * @domain: the domain name to search for
 344  *
 345  * Description:
 346  * Look through the domain hash table searching for an entry to match @domain,
 347  * return a pointer to a copy of the entry or NULL.  The caller is responsibile
 348  * for ensuring that rcu_read_[un]lock() is called.
 349  *
 350  */
 351 struct netlbl_dom_map *netlbl_domhsh_getentry(const char *domain)
 352 {
 353         return netlbl_domhsh_search(domain, 1);
 354 }
 355
 356 /**
 357  * netlbl_domhsh_dump - Dump the domain hash table into a sk_buff
 358  *
 359  * Description:
 360  * Dump the domain hash table into a buffer suitable for returning to an
 361  * application in response to a NetLabel management DOMAIN message.  This
 362  * function may fail if another process is growing the hash table at the same
 363  * time.  The returned sk_buff has room at the front of the sk_buff for
 364  * @headroom bytes.  See netlabel.h for the DOMAIN message format.  Returns a
 365  * pointer to a sk_buff on success, NULL on error.
 366  *
 367  */
 368 struct sk_buff *netlbl_domhsh_dump(size_t headroom)
 369 {
 370         struct sk_buff *skb = NULL;
 371         ssize_t buf_len;
 372         u32 bkt_iter;
 373         u32 dom_cnt = 0;
 374         struct netlbl_domhsh_tbl *hsh_tbl;
 375         struct netlbl_dom_map *list_iter;
 376         ssize_t tmp_len;
 377
 378         buf_len = NETLBL_LEN_U32;
 379         rcu_read_lock();
 380         hsh_tbl = rcu_dereference(netlbl_domhsh);
 381         for (bkt_iter = 0; bkt_iter < hsh_tbl->size; bkt_iter++)
 382                 list_for_each_entry_rcu(list_iter,
 383                                         &hsh_tbl->tbl[bkt_iter], list) {
 384                         buf_len += NETLBL_LEN_U32 +
 385                                 nla_total_size(strlen(list_iter->domain) + 1);
 386                         switch (list_iter->type) {
 387                         case NETLBL_NLTYPE_UNLABELED:
 388                                 break;
 389                         case NETLBL_NLTYPE_CIPSOV4:
 390                                 buf_len += 2 * NETLBL_LEN_U32;
 391                                 break;
 392                         }
 393                         dom_cnt++;
 394                 }
 395
 396         skb = netlbl_netlink_alloc_skb(headroom, buf_len, GFP_ATOMIC);
 397         if (skb == NULL)
 398                 goto dump_failure;
 399
 400         if (nla_put_u32(skb, NLA_U32, dom_cnt) != 0)
 401                 goto dump_failure;
 402         buf_len -= NETLBL_LEN_U32;
 403         hsh_tbl = rcu_dereference(netlbl_domhsh);
 404         for (bkt_iter = 0; bkt_iter < hsh_tbl->size; bkt_iter++)
 405                 list_for_each_entry_rcu(list_iter,
 406                                         &hsh_tbl->tbl[bkt_iter], list) {
 407                         tmp_len = nla_total_size(strlen(list_iter->domain) +
 408                                                  1);
 409                         if (buf_len < NETLBL_LEN_U32 + tmp_len)
 410                                 goto dump_failure;
 411                         if (nla_put_string(skb,
 412                                            NLA_STRING,
 413                                            list_iter->domain) != 0)
 414                                 goto dump_failure;
 415                         if (nla_put_u32(skb, NLA_U32, list_iter->type) != 0)
 416                                 goto dump_failure;
 417                         buf_len -= NETLBL_LEN_U32 + tmp_len;
 418                         switch (list_iter->type) {
 419                         case NETLBL_NLTYPE_UNLABELED:
 420                                 break;
 421                         case NETLBL_NLTYPE_CIPSOV4:
 422                                 if (buf_len < 2 * NETLBL_LEN_U32)
 423                                         goto dump_failure;
 424                                 if (nla_put_u32(skb,
 425                                        NLA_U32,
 426                                        list_iter->type_def.cipsov4->type) != 0)
 427                                         goto dump_failure;
 428                                 if (nla_put_u32(skb,
 429                                        NLA_U32,
 430                                        list_iter->type_def.cipsov4->doi) != 0)
 431                                         goto dump_failure;
 432                                 buf_len -= 2 * NETLBL_LEN_U32;
 433                                 break;
 434                         }
 435                 }
 436         rcu_read_unlock();
 437
 438         return skb;
 439
 440 dump_failure:
 441         rcu_read_unlock();
 442         kfree_skb(skb);
 443         return NULL;
 444 }
 445
 446 /**
 447  * netlbl_domhsh_dump_default - Dump the default domain mapping into a sk_buff
 448  *
 449  * Description:
 450  * Dump the default domain mapping into a buffer suitable for returning to an
 451  * application in response to a NetLabel management DEFDOMAIN message.  This
 452  * function may fail if another process is changing the default domain mapping
 453  * at the same time.  The returned sk_buff has room at the front of the
 454  * skb_buff for @headroom bytes.  See netlabel.h for the DEFDOMAIN message
 455  * format.  Returns a pointer to a sk_buff on success, NULL on error.
 456  *
 457  */
 458 struct sk_buff *netlbl_domhsh_dump_default(size_t headroom)
 459 {
 460         struct sk_buff *skb;
 461         ssize_t buf_len;
 462         struct netlbl_dom_map *entry;
 463
 464         buf_len = NETLBL_LEN_U32;
 465         rcu_read_lock();
 466         entry = rcu_dereference(netlbl_domhsh_def);
 467         if (entry != NULL)
 468                 switch (entry->type) {
 469                 case NETLBL_NLTYPE_UNLABELED:
 470                         break;
 471                 case NETLBL_NLTYPE_CIPSOV4:
 472                         buf_len += 2 * NETLBL_LEN_U32;
 473                         break;
 474                 }
 475
 476         skb = netlbl_netlink_alloc_skb(headroom, buf_len, GFP_ATOMIC);
 477         if (skb == NULL)
 478                 goto dump_default_failure;
 479
 480         if (entry != rcu_dereference(netlbl_domhsh_def))
 481                 goto dump_default_failure;
 482         if (entry != NULL) {
 483                 if (nla_put_u32(skb, NLA_U32, entry->type) != 0)
 484                         goto dump_default_failure;
 485                 buf_len -= NETLBL_LEN_U32;
 486                 switch (entry->type) {
 487                 case NETLBL_NLTYPE_UNLABELED:
 488                         break;
 489                 case NETLBL_NLTYPE_CIPSOV4:
 490                         if (buf_len < 2 * NETLBL_LEN_U32)
 491                                 goto dump_default_failure;
 492                         if (nla_put_u32(skb,
 493                                         NLA_U32,
 494                                         entry->type_def.cipsov4->type) != 0)
 495                                 goto dump_default_failure;
 496                         if (nla_put_u32(skb,
 497                                         NLA_U32,
 498                                         entry->type_def.cipsov4->doi) != 0)
 499                                 goto dump_default_failure;
 500                         buf_len -= 2 * NETLBL_LEN_U32;
 501                         break;
 502                 }
 503         } else
 504                 nla_put_u32(skb, NLA_U32, NETLBL_NLTYPE_NONE);
 505         rcu_read_unlock();
 506
 507         return skb;
 508
 509 dump_default_failure:
 510         rcu_read_unlock();
 511         kfree_skb(skb);
 512         return NULL;
 513 }