net/ipv4/cipso_ipv4.c

   1 /*
   2  * CIPSO - Commercial IP Security Option
   3  *
   4  * This is an implementation of the CIPSO 2.2 protocol as specified in
   5  * draft-ietf-cipso-ipsecurity-01.txt with additional tag types as found in
   6  * FIPS-188.  While CIPSO never became a full IETF RFC standard many vendors
   7  * have chosen to adopt the protocol and over the years it has become a
   8  * de-facto standard for labeled networking.
   9  *
  10  * The CIPSO draft specification can be found in the kernel's Documentation
  11  * directory as well as the following URL:
  12  *   http://tools.ietf.org/id/draft-ietf-cipso-ipsecurity-01.txt
  13  * The FIPS-188 specification can be found at the following URL:
  14  *   http://www.itl.nist.gov/fipspubs/fip188.htm
  15  *
  16  * Author: Paul Moore <paul.moore@hp.com>
  17  *
  18  */
  19
  20 /*
  21  * (c) Copyright Hewlett-Packard Development Company, L.P., 2006, 2008
  22  *
  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; either version 2 of the License, or
  26  * (at your option) any later version.
  27  *
  28  * This program is distributed in the hope that it will be useful,
  29  * but WITHOUT ANY WARRANTY;  without even the implied warranty of
  30  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  31  * the GNU General Public License for more details.
  32  *
  33  * You should have received a copy of the GNU General Public License
  34  * along with this program;  if not, see <http://www.gnu.org/licenses/>.
  35  *
  36  */
  37
  38 #include <linux/init.h>
  39 #include <linux/types.h>
  40 #include <linux/rcupdate.h>
  41 #include <linux/list.h>
  42 #include <linux/spinlock.h>
  43 #include <linux/string.h>
  44 #include <linux/jhash.h>
  45 #include <linux/audit.h>
  46 #include <linux/slab.h>
  47 #include <net/ip.h>
  48 #include <net/icmp.h>
  49 #include <net/tcp.h>
  50 #include <net/netlabel.h>
  51 #include <net/cipso_ipv4.h>
  52 #include <linux/atomic.h>
  53 #include <asm/bug.h>
  54 #include <asm/unaligned.h>
  55
  56 /* List of available DOI definitions */
  57 /* XXX - This currently assumes a minimal number of different DOIs in use,
  58  * if in practice there are a lot of different DOIs this list should
  59  * probably be turned into a hash table or something similar so we
  60  * can do quick lookups. */
  61 static DEFINE_SPINLOCK(cipso_v4_doi_list_lock);
  62 static LIST_HEAD(cipso_v4_doi_list);
  63
  64 /* Label mapping cache */
  65 int cipso_v4_cache_enabled = 1;
  66 int cipso_v4_cache_bucketsize = 10;
  67 #define CIPSO_V4_CACHE_BUCKETBITS     7
  68 #define CIPSO_V4_CACHE_BUCKETS        (1 << CIPSO_V4_CACHE_BUCKETBITS)
  69 #define CIPSO_V4_CACHE_REORDERLIMIT   10
  70 struct cipso_v4_map_cache_bkt {
  71         spinlock_t lock;
  72         u32 size;
  73         struct list_head list;
  74 };
  75 struct cipso_v4_map_cache_entry {
  76         u32 hash;
  77         unsigned char *key;
  78         size_t key_len;
  79
  80         struct netlbl_lsm_cache *lsm_data;
  81
  82         u32 activity;
  83         struct list_head list;
  84 };
  85 static struct cipso_v4_map_cache_bkt *cipso_v4_cache = NULL;
  86
  87 /* Restricted bitmap (tag #1) flags */
  88 int cipso_v4_rbm_optfmt = 0;
  89 int cipso_v4_rbm_strictvalid = 1;
  90
  91 /*
  92  * Protocol Constants
  93  */
  94
  95 /* Maximum size of the CIPSO IP option, derived from the fact that the maximum
  96  * IPv4 header size is 60 bytes and the base IPv4 header is 20 bytes long. */
  97 #define CIPSO_V4_OPT_LEN_MAX          40
  98
  99 /* Length of the base CIPSO option, this includes the option type (1 byte), the
 100  * option length (1 byte), and the DOI (4 bytes). */
 101 #define CIPSO_V4_HDR_LEN              6
 102
 103 /* Base length of the restrictive category bitmap tag (tag #1). */
 104 #define CIPSO_V4_TAG_RBM_BLEN         4
 105
 106 /* Base length of the enumerated category tag (tag #2). */
 107 #define CIPSO_V4_TAG_ENUM_BLEN        4
 108
 109 /* Base length of the ranged categories bitmap tag (tag #5). */
 110 #define CIPSO_V4_TAG_RNG_BLEN         4
 111 /* The maximum number of category ranges permitted in the ranged category tag
 112  * (tag #5).  You may note that the IETF draft states that the maximum number
 113  * of category ranges is 7, but if the low end of the last category range is
 114  * zero then it is possible to fit 8 category ranges because the zero should
 115  * be omitted. */
 116 #define CIPSO_V4_TAG_RNG_CAT_MAX      8
 117
 118 /* Base length of the local tag (non-standard tag).
 119  *  Tag definition (may change between kernel versions)
 120  *
 121  * 0          8          16         24         32
 122  * +----------+----------+----------+----------+
 123  * | 10000000 | 00000110 | 32-bit secid value  |
 124  * +----------+----------+----------+----------+
 125  * | in (host byte order)|
 126  * +----------+----------+
 127  *
 128  */
 129 #define CIPSO_V4_TAG_LOC_BLEN         6
 130
 131 /*
 132  * Helper Functions
 133  */
 134
 135 /**
 136  * cipso_v4_bitmap_walk - Walk a bitmap looking for a bit
 137  * @bitmap: the bitmap
 138  * @bitmap_len: length in bits
 139  * @offset: starting offset
 140  * @state: if non-zero, look for a set (1) bit else look for a cleared (0) bit
 141  *
 142  * Description:
 143  * Starting at @offset, walk the bitmap from left to right until either the
 144  * desired bit is found or we reach the end.  Return the bit offset, -1 if
 145  * not found, or -2 if error.
 146  */
 147 static int cipso_v4_bitmap_walk(const unsigned char *bitmap,
 148                                 u32 bitmap_len,
 149                                 u32 offset,
 150                                 u8 state)
 151 {
 152         u32 bit_spot;
 153         u32 byte_offset;
 154         unsigned char bitmask;
 155         unsigned char byte;
 156
 157         /* gcc always rounds to zero when doing integer division */
 158         byte_offset = offset / 8;
 159         byte = bitmap[byte_offset];
 160         bit_spot = offset;
 161         bitmask = 0x80 >> (offset % 8);
 162
 163         while (bit_spot < bitmap_len) {
 164                 if ((state && (byte & bitmask) == bitmask) ||
 165                     (state == 0 && (byte & bitmask) == 0))
 166                         return bit_spot;
 167
 168                 bit_spot++;
 169                 bitmask >>= 1;
 170                 if (bitmask == 0) {
 171                         byte = bitmap[++byte_offset];
 172                         bitmask = 0x80;
 173                 }
 174         }
 175
 176         return -1;
 177 }
 178
 179 /**
 180  * cipso_v4_bitmap_setbit - Sets a single bit in a bitmap
 181  * @bitmap: the bitmap
 182  * @bit: the bit
 183  * @state: if non-zero, set the bit (1) else clear the bit (0)
 184  *
 185  * Description:
 186  * Set a single bit in the bitmask.  Returns zero on success, negative values
 187  * on error.
 188  */
 189 static void cipso_v4_bitmap_setbit(unsigned char *bitmap,
 190                                    u32 bit,
 191                                    u8 state)
 192 {
 193         u32 byte_spot;
 194         u8 bitmask;
 195
 196         /* gcc always rounds to zero when doing integer division */
 197         byte_spot = bit / 8;
 198         bitmask = 0x80 >> (bit % 8);
 199         if (state)
 200                 bitmap[byte_spot] |= bitmask;
 201         else
 202                 bitmap[byte_spot] &= ~bitmask;
 203 }
 204
 205 /**
 206  * cipso_v4_cache_entry_free - Frees a cache entry
 207  * @entry: the entry to free
 208  *
 209  * Description:
 210  * This function frees the memory associated with a cache entry including the
 211  * LSM cache data if there are no longer any users, i.e. reference count == 0.
 212  *
 213  */
 214 static void cipso_v4_cache_entry_free(struct cipso_v4_map_cache_entry *entry)
 215 {
 216         if (entry->lsm_data)
 217                 netlbl_secattr_cache_free(entry->lsm_data);
 218         kfree(entry->key);
 219         kfree(entry);
 220 }
 221
 222 /**
 223  * cipso_v4_map_cache_hash - Hashing function for the CIPSO cache
 224  * @key: the hash key
 225  * @key_len: the length of the key in bytes
 226  *
 227  * Description:
 228  * The CIPSO tag hashing function.  Returns a 32-bit hash value.
 229  *
 230  */
 231 static u32 cipso_v4_map_cache_hash(const unsigned char *key, u32 key_len)
 232 {
 233         return jhash(key, key_len, 0);
 234 }
 235
 236 /*
 237  * Label Mapping Cache Functions
 238  */
 239
 240 /**
 241  * cipso_v4_cache_init - Initialize the CIPSO cache
 242  *
 243  * Description:
 244  * Initializes the CIPSO label mapping cache, this function should be called
 245  * before any of the other functions defined in this file.  Returns zero on
 246  * success, negative values on error.
 247  *
 248  */
 249 static int cipso_v4_cache_init(void)
 250 {
 251         u32 iter;
 252
 253         cipso_v4_cache = kcalloc(CIPSO_V4_CACHE_BUCKETS,
 254                                  sizeof(struct cipso_v4_map_cache_bkt),
 255                                  GFP_KERNEL);
 256         if (cipso_v4_cache == NULL)
 257                 return -ENOMEM;
 258
 259         for (iter = 0; iter < CIPSO_V4_CACHE_BUCKETS; iter++) {
 260                 spin_lock_init(&cipso_v4_cache[iter].lock);
 261                 cipso_v4_cache[iter].size = 0;
 262                 INIT_LIST_HEAD(&cipso_v4_cache[iter].list);
 263         }
 264
 265         return 0;
 266 }
 267
 268 /**
 269  * cipso_v4_cache_invalidate - Invalidates the current CIPSO cache
 270  *
 271  * Description:
 272  * Invalidates and frees any entries in the CIPSO cache.  Returns zero on
 273  * success and negative values on failure.
 274  *
 275  */
 276 void cipso_v4_cache_invalidate(void)
 277 {
 278         struct cipso_v4_map_cache_entry *entry, *tmp_entry;
 279         u32 iter;
 280
 281         for (iter = 0; iter < CIPSO_V4_CACHE_BUCKETS; iter++) {
 282                 spin_lock_bh(&cipso_v4_cache[iter].lock);
 283                 list_for_each_entry_safe(entry,
 284                                          tmp_entry,
 285                                          &cipso_v4_cache[iter].list, list) {
 286                         list_del(&entry->list);
 287                         cipso_v4_cache_entry_free(entry);
 288                 }
 289                 cipso_v4_cache[iter].size = 0;
 290                 spin_unlock_bh(&cipso_v4_cache[iter].lock);
 291         }
 292 }
 293
 294 /**
 295  * cipso_v4_cache_check - Check the CIPSO cache for a label mapping
 296  * @key: the buffer to check
 297  * @key_len: buffer length in bytes
 298  * @secattr: the security attribute struct to use
 299  *
 300  * Description:
 301  * This function checks the cache to see if a label mapping already exists for
 302  * the given key.  If there is a match then the cache is adjusted and the
 303  * @secattr struct is populated with the correct LSM security attributes.  The
 304  * cache is adjusted in the following manner if the entry is not already the
 305  * first in the cache bucket:
 306  *
 307  *  1. The cache entry's activity counter is incremented
 308  *  2. The previous (higher ranking) entry's activity counter is decremented
 309  *  3. If the difference between the two activity counters is geater than
 310  *     CIPSO_V4_CACHE_REORDERLIMIT the two entries are swapped
 311  *
 312  * Returns zero on success, -ENOENT for a cache miss, and other negative values
 313  * on error.
 314  *
 315  */
 316 static int cipso_v4_cache_check(const unsigned char *key,
 317                                 u32 key_len,
 318                                 struct netlbl_lsm_secattr *secattr)
 319 {
 320         u32 bkt;
 321         struct cipso_v4_map_cache_entry *entry;
 322         struct cipso_v4_map_cache_entry *prev_entry = NULL;
 323         u32 hash;
 324
 325         if (!cipso_v4_cache_enabled)
 326                 return -ENOENT;
 327
 328         hash = cipso_v4_map_cache_hash(key, key_len);
 329         bkt = hash & (CIPSO_V4_CACHE_BUCKETS - 1);
 330         spin_lock_bh(&cipso_v4_cache[bkt].lock);
 331         list_for_each_entry(entry, &cipso_v4_cache[bkt].list, list) {
 332                 if (entry->hash == hash &&
 333                     entry->key_len == key_len &&
 334                     memcmp(entry->key, key, key_len) == 0) {
 335                         entry->activity += 1;
 336                         atomic_inc(&entry->lsm_data->refcount);
 337                         secattr->cache = entry->lsm_data;
 338                         secattr->flags |= NETLBL_SECATTR_CACHE;
 339                         secattr->type = NETLBL_NLTYPE_CIPSOV4;
 340                         if (prev_entry == NULL) {
 341                                 spin_unlock_bh(&cipso_v4_cache[bkt].lock);
 342                                 return 0;
 343                         }
 344
 345                         if (prev_entry->activity > 0)
 346                                 prev_entry->activity -= 1;
 347                         if (entry->activity > prev_entry->activity &&
 348                             entry->activity - prev_entry->activity >
 349                             CIPSO_V4_CACHE_REORDERLIMIT) {
 350                                 __list_del(entry->list.prev, entry->list.next);
 351                                 __list_add(&entry->list,
 352                                            prev_entry->list.prev,
 353                                            &prev_entry->list);
 354                         }
 355
 356                         spin_unlock_bh(&cipso_v4_cache[bkt].lock);
 357                         return 0;
 358                 }
 359                 prev_entry = entry;
 360         }
 361         spin_unlock_bh(&cipso_v4_cache[bkt].lock);
 362
 363         return -ENOENT;
 364 }
 365
 366 /**
 367  * cipso_v4_cache_add - Add an entry to the CIPSO cache
 368  * @skb: the packet
 369  * @secattr: the packet's security attributes
 370  *
 371  * Description:
 372  * Add a new entry into the CIPSO label mapping cache.  Add the new entry to
 373  * head of the cache bucket's list, if the cache bucket is out of room remove
 374  * the last entry in the list first.  It is important to note that there is
 375  * currently no checking for duplicate keys.  Returns zero on success,
 376  * negative values on failure.
 377  *
 378  */
 379 int cipso_v4_cache_add(const struct sk_buff *skb,
 380                        const struct netlbl_lsm_secattr *secattr)
 381 {
 382         int ret_val = -EPERM;
 383         u32 bkt;
 384         struct cipso_v4_map_cache_entry *entry = NULL;
 385         struct cipso_v4_map_cache_entry *old_entry = NULL;
 386         unsigned char *cipso_ptr;
 387         u32 cipso_ptr_len;
 388
 389         if (!cipso_v4_cache_enabled || cipso_v4_cache_bucketsize <= 0)
 390                 return 0;
 391
 392         cipso_ptr = CIPSO_V4_OPTPTR(skb);
 393         cipso_ptr_len = cipso_ptr[1];
 394
 395         entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
 396         if (entry == NULL)
 397                 return -ENOMEM;
 398         entry->key = kmemdup(cipso_ptr, cipso_ptr_len, GFP_ATOMIC);
 399         if (entry->key == NULL) {
 400                 ret_val = -ENOMEM;
 401                 goto cache_add_failure;
 402         }
 403         entry->key_len = cipso_ptr_len;
 404         entry->hash = cipso_v4_map_cache_hash(cipso_ptr, cipso_ptr_len);
 405         atomic_inc(&secattr->cache->refcount);
 406         entry->lsm_data = secattr->cache;
 407
 408         bkt = entry->hash & (CIPSO_V4_CACHE_BUCKETS - 1);
 409         spin_lock_bh(&cipso_v4_cache[bkt].lock);
 410         if (cipso_v4_cache[bkt].size < cipso_v4_cache_bucketsize) {
 411                 list_add(&entry->list, &cipso_v4_cache[bkt].list);
 412                 cipso_v4_cache[bkt].size += 1;
 413         } else {
 414                 old_entry = list_entry(cipso_v4_cache[bkt].list.prev,
 415                                        struct cipso_v4_map_cache_entry, list);
 416                 list_del(&old_entry->list);
 417                 list_add(&entry->list, &cipso_v4_cache[bkt].list);
 418                 cipso_v4_cache_entry_free(old_entry);
 419         }
 420         spin_unlock_bh(&cipso_v4_cache[bkt].lock);
 421
 422         return 0;
 423
 424 cache_add_failure:
 425         if (entry)
 426                 cipso_v4_cache_entry_free(entry);
 427         return ret_val;
 428 }
 429
 430 /*
 431  * DOI List Functions
 432  */
 433
 434 /**
 435  * cipso_v4_doi_search - Searches for a DOI definition
 436  * @doi: the DOI to search for
 437  *
 438  * Description:
 439  * Search the DOI definition list for a DOI definition with a DOI value that
 440  * matches @doi.  The caller is responsible for calling rcu_read_[un]lock().
 441  * Returns a pointer to the DOI definition on success and NULL on failure.
 442  */
 443 static struct cipso_v4_doi *cipso_v4_doi_search(u32 doi)
 444 {
 445         struct cipso_v4_doi *iter;
 446
 447         list_for_each_entry_rcu(iter, &cipso_v4_doi_list, list)
 448                 if (iter->doi == doi && atomic_read(&iter->refcount))
 449                         return iter;
 450         return NULL;
 451 }
 452
 453 /**
 454  * cipso_v4_doi_add - Add a new DOI to the CIPSO protocol engine
 455  * @doi_def: the DOI structure
 456  * @audit_info: NetLabel audit information
 457  *
 458  * Description:
 459  * The caller defines a new DOI for use by the CIPSO engine and calls this
 460  * function to add it to the list of acceptable domains.  The caller must
 461  * ensure that the mapping table specified in @doi_def->map meets all of the
 462  * requirements of the mapping type (see cipso_ipv4.h for details).  Returns
 463  * zero on success and non-zero on failure.
 464  *
 465  */
 466 int cipso_v4_doi_add(struct cipso_v4_doi *doi_def,
 467                      struct netlbl_audit *audit_info)
 468 {
 469         int ret_val = -EINVAL;
 470         u32 iter;
 471         u32 doi;
 472         u32 doi_type;
 473         struct audit_buffer *audit_buf;
 474
 475         doi = doi_def->doi;
 476         doi_type = doi_def->type;
 477
 478         if (doi_def->doi == CIPSO_V4_DOI_UNKNOWN)
 479                 goto doi_add_return;
 480         for (iter = 0; iter < CIPSO_V4_TAG_MAXCNT; iter++) {
 481                 switch (doi_def->tags[iter]) {
 482                 case CIPSO_V4_TAG_RBITMAP:
 483                         break;
 484                 case CIPSO_V4_TAG_RANGE:
 485                 case CIPSO_V4_TAG_ENUM:
 486                         if (doi_def->type != CIPSO_V4_MAP_PASS)
 487                                 goto doi_add_return;
 488                         break;
 489                 case CIPSO_V4_TAG_LOCAL:
 490                         if (doi_def->type != CIPSO_V4_MAP_LOCAL)
 491                                 goto doi_add_return;
 492                         break;
 493                 case CIPSO_V4_TAG_INVALID:
 494                         if (iter == 0)
 495                                 goto doi_add_return;
 496                         break;
 497                 default:
 498                         goto doi_add_return;
 499                 }
 500         }
 501
 502         atomic_set(&doi_def->refcount, 1);
 503
 504         spin_lock(&cipso_v4_doi_list_lock);
 505         if (cipso_v4_doi_search(doi_def->doi) != NULL) {
 506                 spin_unlock(&cipso_v4_doi_list_lock);
 507                 ret_val = -EEXIST;
 508                 goto doi_add_return;
 509         }
 510         list_add_tail_rcu(&doi_def->list, &cipso_v4_doi_list);
 511         spin_unlock(&cipso_v4_doi_list_lock);
 512         ret_val = 0;
 513
 514 doi_add_return:
 515         audit_buf = netlbl_audit_start(AUDIT_MAC_CIPSOV4_ADD, audit_info);
 516         if (audit_buf != NULL) {
 517                 const char *type_str;
 518                 switch (doi_type) {
 519                 case CIPSO_V4_MAP_TRANS:
 520                         type_str = "trans";
 521                         break;
 522                 case CIPSO_V4_MAP_PASS:
 523                         type_str = "pass";
 524                         break;
 525                 case CIPSO_V4_MAP_LOCAL:
 526                         type_str = "local";
 527                         break;
 528                 default:
 529                         type_str = "(unknown)";
 530                 }
 531                 audit_log_format(audit_buf,
 532                                  " cipso_doi=%u cipso_type=%s res=%u",
 533                                  doi, type_str, ret_val == 0 ? 1 : 0);
 534                 audit_log_end(audit_buf);
 535         }
 536
 537         return ret_val;
 538 }
 539
 540 /**
 541  * cipso_v4_doi_free - Frees a DOI definition
 542  * @entry: the entry's RCU field
 543  *
 544  * Description:
 545  * This function frees all of the memory associated with a DOI definition.
 546  *
 547  */
 548 void cipso_v4_doi_free(struct cipso_v4_doi *doi_def)
 549 {
 550         if (doi_def == NULL)
 551                 return;
 552
 553         switch (doi_def->type) {
 554         case CIPSO_V4_MAP_TRANS:
 555                 kfree(doi_def->map.std->lvl.cipso);
 556                 kfree(doi_def->map.std->lvl.local);
 557                 kfree(doi_def->map.std->cat.cipso);
 558                 kfree(doi_def->map.std->cat.local);
 559                 break;
 560         }
 561         kfree(doi_def);
 562 }
 563
 564 /**
 565  * cipso_v4_doi_free_rcu - Frees a DOI definition via the RCU pointer
 566  * @entry: the entry's RCU field
 567  *
 568  * Description:
 569  * This function is designed to be used as a callback to the call_rcu()
 570  * function so that the memory allocated to the DOI definition can be released
 571  * safely.
 572  *
 573  */
 574 static void cipso_v4_doi_free_rcu(struct rcu_head *entry)
 575 {
 576         struct cipso_v4_doi *doi_def;
 577
 578         doi_def = container_of(entry, struct cipso_v4_doi, rcu);
 579         cipso_v4_doi_free(doi_def);
 580 }
 581
 582 /**
 583  * cipso_v4_doi_remove - Remove an existing DOI from the CIPSO protocol engine
 584  * @doi: the DOI value
 585  * @audit_secid: the LSM secid to use in the audit message
 586  *
 587  * Description:
 588  * Removes a DOI definition from the CIPSO engine.  The NetLabel routines will
 589  * be called to release their own LSM domain mappings as well as our own
 590  * domain list.  Returns zero on success and negative values on failure.
 591  *
 592  */
 593 int cipso_v4_doi_remove(u32 doi, struct netlbl_audit *audit_info)
 594 {
 595         int ret_val;
 596         struct cipso_v4_doi *doi_def;
 597         struct audit_buffer *audit_buf;
 598
 599         spin_lock(&cipso_v4_doi_list_lock);
 600         doi_def = cipso_v4_doi_search(doi);
 601         if (doi_def == NULL) {
 602                 spin_unlock(&cipso_v4_doi_list_lock);
 603                 ret_val = -ENOENT;
 604                 goto doi_remove_return;
 605         }
 606         if (!atomic_dec_and_test(&doi_def->refcount)) {
 607                 spin_unlock(&cipso_v4_doi_list_lock);
 608                 ret_val = -EBUSY;
 609                 goto doi_remove_return;
 610         }
 611         list_del_rcu(&doi_def->list);
 612         spin_unlock(&cipso_v4_doi_list_lock);
 613
 614         cipso_v4_cache_invalidate();
 615         call_rcu(&doi_def->rcu, cipso_v4_doi_free_rcu);
 616         ret_val = 0;
 617
 618 doi_remove_return:
 619         audit_buf = netlbl_audit_start(AUDIT_MAC_CIPSOV4_DEL, audit_info);
 620         if (audit_buf != NULL) {
 621                 audit_log_format(audit_buf,
 622                                  " cipso_doi=%u res=%u",
 623                                  doi, ret_val == 0 ? 1 : 0);
 624                 audit_log_end(audit_buf);
 625         }
 626
 627         return ret_val;
 628 }
 629
 630 /**
 631  * cipso_v4_doi_getdef - Returns a reference to a valid DOI definition
 632  * @doi: the DOI value
 633  *
 634  * Description:
 635  * Searches for a valid DOI definition and if one is found it is returned to
 636  * the caller.  Otherwise NULL is returned.  The caller must ensure that
 637  * rcu_read_lock() is held while accessing the returned definition and the DOI
 638  * definition reference count is decremented when the caller is done.
 639  *
 640  */
 641 struct cipso_v4_doi *cipso_v4_doi_getdef(u32 doi)
 642 {
 643         struct cipso_v4_doi *doi_def;
 644
 645         rcu_read_lock();
 646         doi_def = cipso_v4_doi_search(doi);
 647         if (doi_def == NULL)
 648                 goto doi_getdef_return;
 649         if (!atomic_inc_not_zero(&doi_def->refcount))
 650                 doi_def = NULL;
 651
 652 doi_getdef_return:
 653         rcu_read_unlock();
 654         return doi_def;
 655 }
 656
 657 /**
 658  * cipso_v4_doi_putdef - Releases a reference for the given DOI definition
 659  * @doi_def: the DOI definition
 660  *
 661  * Description:
 662  * Releases a DOI definition reference obtained from cipso_v4_doi_getdef().
 663  *
 664  */
 665 void cipso_v4_doi_putdef(struct cipso_v4_doi *doi_def)
 666 {
 667         if (doi_def == NULL)
 668                 return;
 669
 670         if (!atomic_dec_and_test(&doi_def->refcount))
 671                 return;
 672         spin_lock(&cipso_v4_doi_list_lock);
 673         list_del_rcu(&doi_def->list);
 674         spin_unlock(&cipso_v4_doi_list_lock);
 675
 676         cipso_v4_cache_invalidate();
 677         call_rcu(&doi_def->rcu, cipso_v4_doi_free_rcu);
 678 }
 679
 680 /**
 681  * cipso_v4_doi_walk - Iterate through the DOI definitions
 682  * @skip_cnt: skip past this number of DOI definitions, updated
 683  * @callback: callback for each DOI definition
 684  * @cb_arg: argument for the callback function
 685  *
 686  * Description:
 687  * Iterate over the DOI definition list, skipping the first @skip_cnt entries.
 688  * For each entry call @callback, if @callback returns a negative value stop
 689  * 'walking' through the list and return.  Updates the value in @skip_cnt upon
 690  * return.  Returns zero on success, negative values on failure.
 691  *
 692  */
 693 int cipso_v4_doi_walk(u32 *skip_cnt,
 694                      int (*callback) (struct cipso_v4_doi *doi_def, void *arg),
 695                      void *cb_arg)
 696 {
 697         int ret_val = -ENOENT;
 698         u32 doi_cnt = 0;
 699         struct cipso_v4_doi *iter_doi;
 700
 701         rcu_read_lock();
 702         list_for_each_entry_rcu(iter_doi, &cipso_v4_doi_list, list)
 703                 if (atomic_read(&iter_doi->refcount) > 0) {
 704                         if (doi_cnt++ < *skip_cnt)
 705                                 continue;
 706                         ret_val = callback(iter_doi, cb_arg);
 707                         if (ret_val < 0) {
 708                                 doi_cnt--;
 709                                 goto doi_walk_return;
 710                         }
 711                 }
 712
 713 doi_walk_return:
 714         rcu_read_unlock();
 715         *skip_cnt = doi_cnt;
 716         return ret_val;
 717 }
 718
 719 /*
 720  * Label Mapping Functions
 721  */
 722
 723 /**
 724  * cipso_v4_map_lvl_valid - Checks to see if the given level is understood
 725  * @doi_def: the DOI definition
 726  * @level: the level to check
 727  *
 728  * Description:
 729  * Checks the given level against the given DOI definition and returns a
 730  * negative value if the level does not have a valid mapping and a zero value
 731  * if the level is defined by the DOI.
 732  *
 733  */
 734 static int cipso_v4_map_lvl_valid(const struct cipso_v4_doi *doi_def, u8 level)
 735 {
 736         switch (doi_def->type) {
 737         case CIPSO_V4_MAP_PASS:
 738                 return 0;
 739         case CIPSO_V4_MAP_TRANS:
 740                 if (doi_def->map.std->lvl.cipso[level] < CIPSO_V4_INV_LVL)
 741                         return 0;
 742                 break;
 743         }
 744
 745         return -EFAULT;
 746 }
 747
 748 /**
 749  * cipso_v4_map_lvl_hton - Perform a level mapping from the host to the network
 750  * @doi_def: the DOI definition
 751  * @host_lvl: the host MLS level
 752  * @net_lvl: the network/CIPSO MLS level
 753  *
 754  * Description:
 755  * Perform a label mapping to translate a local MLS level to the correct
 756  * CIPSO level using the given DOI definition.  Returns zero on success,
 757  * negative values otherwise.
 758  *
 759  */
 760 static int cipso_v4_map_lvl_hton(const struct cipso_v4_doi *doi_def,
 761                                  u32 host_lvl,
 762                                  u32 *net_lvl)
 763 {
 764         switch (doi_def->type) {
 765         case CIPSO_V4_MAP_PASS:
 766                 *net_lvl = host_lvl;
 767                 return 0;
 768         case CIPSO_V4_MAP_TRANS:
 769                 if (host_lvl < doi_def->map.std->lvl.local_size &&
 770                     doi_def->map.std->lvl.local[host_lvl] < CIPSO_V4_INV_LVL) {
 771                         *net_lvl = doi_def->map.std->lvl.local[host_lvl];
 772                         return 0;
 773                 }
 774                 return -EPERM;
 775         }
 776
 777         return -EINVAL;
 778 }
 779
 780 /**
 781  * cipso_v4_map_lvl_ntoh - Perform a level mapping from the network to the host
 782  * @doi_def: the DOI definition
 783  * @net_lvl: the network/CIPSO MLS level
 784  * @host_lvl: the host MLS level
 785  *
 786  * Description:
 787  * Perform a label mapping to translate a CIPSO level to the correct local MLS
 788  * level using the given DOI definition.  Returns zero on success, negative
 789  * values otherwise.
 790  *
 791  */
 792 static int cipso_v4_map_lvl_ntoh(const struct cipso_v4_doi *doi_def,
 793                                  u32 net_lvl,
 794                                  u32 *host_lvl)
 795 {
 796         struct cipso_v4_std_map_tbl *map_tbl;
 797
 798         switch (doi_def->type) {
 799         case CIPSO_V4_MAP_PASS:
 800                 *host_lvl = net_lvl;
 801                 return 0;
 802         case CIPSO_V4_MAP_TRANS:
 803                 map_tbl = doi_def->map.std;
 804                 if (net_lvl < map_tbl->lvl.cipso_size &&
 805                     map_tbl->lvl.cipso[net_lvl] < CIPSO_V4_INV_LVL) {
 806                         *host_lvl = doi_def->map.std->lvl.cipso[net_lvl];
 807                         return 0;
 808                 }
 809                 return -EPERM;
 810         }
 811
 812         return -EINVAL;
 813 }
 814
 815 /**
 816  * cipso_v4_map_cat_rbm_valid - Checks to see if the category bitmap is valid
 817  * @doi_def: the DOI definition
 818  * @bitmap: category bitmap
 819  * @bitmap_len: bitmap length in bytes
 820  *
 821  * Description:
 822  * Checks the given category bitmap against the given DOI definition and
 823  * returns a negative value if any of the categories in the bitmap do not have
 824  * a valid mapping and a zero value if all of the categories are valid.
 825  *
 826  */
 827 static int cipso_v4_map_cat_rbm_valid(const struct cipso_v4_doi *doi_def,
 828                                       const unsigned char *bitmap,
 829                                       u32 bitmap_len)
 830 {
 831         int cat = -1;
 832         u32 bitmap_len_bits = bitmap_len * 8;
 833         u32 cipso_cat_size;
 834         u32 *cipso_array;
 835
 836         switch (doi_def->type) {
 837         case CIPSO_V4_MAP_PASS:
 838                 return 0;
 839         case CIPSO_V4_MAP_TRANS:
 840                 cipso_cat_size = doi_def->map.std->cat.cipso_size;
 841                 cipso_array = doi_def->map.std->cat.cipso;
 842                 for (;;) {
 843                         cat = cipso_v4_bitmap_walk(bitmap,
 844                                                    bitmap_len_bits,
 845                                                    cat + 1,
 846                                                    1);
 847                         if (cat < 0)
 848                                 break;
 849                         if (cat >= cipso_cat_size ||
 850                             cipso_array[cat] >= CIPSO_V4_INV_CAT)
 851                                 return -EFAULT;
 852                 }
 853
 854                 if (cat == -1)
 855                         return 0;
 856                 break;
 857         }
 858
 859         return -EFAULT;
 860 }
 861
 862 /**
 863  * cipso_v4_map_cat_rbm_hton - Perform a category mapping from host to network
 864  * @doi_def: the DOI definition
 865  * @secattr: the security attributes
 866  * @net_cat: the zero'd out category bitmap in network/CIPSO format
 867  * @net_cat_len: the length of the CIPSO bitmap in bytes
 868  *
 869  * Description:
 870  * Perform a label mapping to translate a local MLS category bitmap to the
 871  * correct CIPSO bitmap using the given DOI definition.  Returns the minimum
 872  * size in bytes of the network bitmap on success, negative values otherwise.
 873  *
 874  */
 875 static int cipso_v4_map_cat_rbm_hton(const struct cipso_v4_doi *doi_def,
 876                                      const struct netlbl_lsm_secattr *secattr,
 877                                      unsigned char *net_cat,
 878                                      u32 net_cat_len)
 879 {
 880         int host_spot = -1;
 881         u32 net_spot = CIPSO_V4_INV_CAT;
 882         u32 net_spot_max = 0;
 883         u32 net_clen_bits = net_cat_len * 8;
 884         u32 host_cat_size = 0;
 885         u32 *host_cat_array = NULL;
 886
 887         if (doi_def->type == CIPSO_V4_MAP_TRANS) {
 888                 host_cat_size = doi_def->map.std->cat.local_size;
 889                 host_cat_array = doi_def->map.std->cat.local;
 890         }
 891
 892         for (;;) {
 893                 host_spot = netlbl_catmap_walk(secattr->attr.mls.cat,
 894                                                host_spot + 1);
 895                 if (host_spot < 0)
 896                         break;
 897
 898                 switch (doi_def->type) {
 899                 case CIPSO_V4_MAP_PASS:
 900                         net_spot = host_spot;
 901                         break;
 902                 case CIPSO_V4_MAP_TRANS:
 903                         if (host_spot >= host_cat_size)
 904                                 return -EPERM;
 905                         net_spot = host_cat_array[host_spot];
 906                         if (net_spot >= CIPSO_V4_INV_CAT)
 907                                 return -EPERM;
 908                         break;
 909                 }
 910                 if (net_spot >= net_clen_bits)
 911                         return -ENOSPC;
 912                 cipso_v4_bitmap_setbit(net_cat, net_spot, 1);
 913
 914                 if (net_spot > net_spot_max)
 915                         net_spot_max = net_spot;
 916         }
 917
 918         if (++net_spot_max % 8)
 919                 return net_spot_max / 8 + 1;
 920         return net_spot_max / 8;
 921 }
 922
 923 /**
 924  * cipso_v4_map_cat_rbm_ntoh - Perform a category mapping from network to host
 925  * @doi_def: the DOI definition
 926  * @net_cat: the category bitmap in network/CIPSO format
 927  * @net_cat_len: the length of the CIPSO bitmap in bytes
 928  * @secattr: the security attributes
 929  *
 930  * Description:
 931  * Perform a label mapping to translate a CIPSO bitmap to the correct local
 932  * MLS category bitmap using the given DOI definition.  Returns zero on
 933  * success, negative values on failure.
 934  *
 935  */
 936 static int cipso_v4_map_cat_rbm_ntoh(const struct cipso_v4_doi *doi_def,
 937                                      const unsigned char *net_cat,
 938                                      u32 net_cat_len,
 939                                      struct netlbl_lsm_secattr *secattr)
 940 {
 941         int ret_val;
 942         int net_spot = -1;
 943         u32 host_spot = CIPSO_V4_INV_CAT;
 944         u32 net_clen_bits = net_cat_len * 8;
 945         u32 net_cat_size = 0;
 946         u32 *net_cat_array = NULL;
 947
 948         if (doi_def->type == CIPSO_V4_MAP_TRANS) {
 949                 net_cat_size = doi_def->map.std->cat.cipso_size;
 950                 net_cat_array = doi_def->map.std->cat.cipso;
 951         }
 952
 953         for (;;) {
 954                 net_spot = cipso_v4_bitmap_walk(net_cat,
 955                                                 net_clen_bits,
 956                                                 net_spot + 1,
 957                                                 1);
 958                 if (net_spot < 0) {
 959                         if (net_spot == -2)
 960                                 return -EFAULT;
 961                         return 0;
 962                 }
 963
 964                 switch (doi_def->type) {
 965                 case CIPSO_V4_MAP_PASS:
 966                         host_spot = net_spot;
 967                         break;
 968                 case CIPSO_V4_MAP_TRANS:
 969                         if (net_spot >= net_cat_size)
 970                                 return -EPERM;
 971                         host_spot = net_cat_array[net_spot];
 972                         if (host_spot >= CIPSO_V4_INV_CAT)
 973                                 return -EPERM;
 974                         break;
 975                 }
 976                 ret_val = netlbl_catmap_setbit(&secattr->attr.mls.cat,
 977                                                        host_spot,
 978                                                        GFP_ATOMIC);
 979                 if (ret_val != 0)
 980                         return ret_val;
 981         }
 982
 983         return -EINVAL;
 984 }
 985
 986 /**
 987  * cipso_v4_map_cat_enum_valid - Checks to see if the categories are valid
 988  * @doi_def: the DOI definition
 989  * @enumcat: category list
 990  * @enumcat_len: length of the category list in bytes
 991  *
 992  * Description:
 993  * Checks the given categories against the given DOI definition and returns a
 994  * negative value if any of the categories do not have a valid mapping and a
 995  * zero value if all of the categories are valid.
 996  *
 997  */
 998 static int cipso_v4_map_cat_enum_valid(const struct cipso_v4_doi *doi_def,
 999                                        const unsigned char *enumcat,
1000                                        u32 enumcat_len)
1001 {
1002         u16 cat;
1003         int cat_prev = -1;
1004         u32 iter;
1005
1006         if (doi_def->type != CIPSO_V4_MAP_PASS || enumcat_len & 0x01)
1007                 return -EFAULT;
1008
1009         for (iter = 0; iter < enumcat_len; iter += 2) {
1010                 cat = get_unaligned_be16(&enumcat[iter]);
1011                 if (cat <= cat_prev)
1012                         return -EFAULT;
1013                 cat_prev = cat;
1014         }
1015
1016         return 0;
1017 }
1018
1019 /**
1020  * cipso_v4_map_cat_enum_hton - Perform a category mapping from host to network
1021  * @doi_def: the DOI definition
1022  * @secattr: the security attributes
1023  * @net_cat: the zero'd out category list in network/CIPSO format
1024  * @net_cat_len: the length of the CIPSO category list in bytes
1025  *
1026  * Description:
1027  * Perform a label mapping to translate a local MLS category bitmap to the
1028  * correct CIPSO category list using the given DOI definition.   Returns the
1029  * size in bytes of the network category bitmap on success, negative values
1030  * otherwise.
1031  *
1032  */
1033 static int cipso_v4_map_cat_enum_hton(const struct cipso_v4_doi *doi_def,
1034                                       const struct netlbl_lsm_secattr *secattr,
1035                                       unsigned char *net_cat,
1036                                       u32 net_cat_len)
1037 {
1038         int cat = -1;
1039         u32 cat_iter = 0;
1040
1041         for (;;) {
1042                 cat = netlbl_catmap_walk(secattr->attr.mls.cat, cat + 1);
1043                 if (cat < 0)
1044                         break;
1045                 if ((cat_iter + 2) > net_cat_len)
1046                         return -ENOSPC;
1047
1048                 *((__be16 *)&net_cat[cat_iter]) = htons(cat);
1049                 cat_iter += 2;
1050         }
1051
1052         return cat_iter;
1053 }
1054
1055 /**
1056  * cipso_v4_map_cat_enum_ntoh - Perform a category mapping from network to host
1057  * @doi_def: the DOI definition
1058  * @net_cat: the category list in network/CIPSO format
1059  * @net_cat_len: the length of the CIPSO bitmap in bytes
1060  * @secattr: the security attributes
1061  *
1062  * Description:
1063  * Perform a label mapping to translate a CIPSO category list to the correct
1064  * local MLS category bitmap using the given DOI definition.  Returns zero on
1065  * success, negative values on failure.
1066  *
1067  */
1068 static int cipso_v4_map_cat_enum_ntoh(const struct cipso_v4_doi *doi_def,
1069                                       const unsigned char *net_cat,
1070                                       u32 net_cat_len,
1071                                       struct netlbl_lsm_secattr *secattr)
1072 {
1073         int ret_val;
1074         u32 iter;
1075
1076         for (iter = 0; iter < net_cat_len; iter += 2) {
1077                 ret_val = netlbl_catmap_setbit(&secattr->attr.mls.cat,
1078                                              get_unaligned_be16(&net_cat[iter]),
1079                                              GFP_ATOMIC);
1080                 if (ret_val != 0)
1081                         return ret_val;
1082         }
1083
1084         return 0;
1085 }
1086
1087 /**
1088  * cipso_v4_map_cat_rng_valid - Checks to see if the categories are valid
1089  * @doi_def: the DOI definition
1090  * @rngcat: category list
1091  * @rngcat_len: length of the category list in bytes
1092  *
1093  * Description:
1094  * Checks the given categories against the given DOI definition and returns a
1095  * negative value if any of the categories do not have a valid mapping and a
1096  * zero value if all of the categories are valid.
1097  *
1098  */
1099 static int cipso_v4_map_cat_rng_valid(const struct cipso_v4_doi *doi_def,
1100                                       const unsigned char *rngcat,
1101                                       u32 rngcat_len)
1102 {
1103         u16 cat_high;
1104         u16 cat_low;
1105         u32 cat_prev = CIPSO_V4_MAX_REM_CATS + 1;
1106         u32 iter;
1107
1108         if (doi_def->type != CIPSO_V4_MAP_PASS || rngcat_len & 0x01)
1109                 return -EFAULT;
1110
1111         for (iter = 0; iter < rngcat_len; iter += 4) {
1112                 cat_high = get_unaligned_be16(&rngcat[iter]);
1113                 if ((iter + 4) <= rngcat_len)
1114                         cat_low = get_unaligned_be16(&rngcat[iter + 2]);
1115                 else
1116                         cat_low = 0;
1117
1118                 if (cat_high > cat_prev)
1119                         return -EFAULT;
1120
1121                 cat_prev = cat_low;
1122         }
1123
1124         return 0;
1125 }
1126
1127 /**
1128  * cipso_v4_map_cat_rng_hton - Perform a category mapping from host to network
1129  * @doi_def: the DOI definition
1130  * @secattr: the security attributes
1131  * @net_cat: the zero'd out category list in network/CIPSO format
1132  * @net_cat_len: the length of the CIPSO category list in bytes
1133  *
1134  * Description:
1135  * Perform a label mapping to translate a local MLS category bitmap to the
1136  * correct CIPSO category list using the given DOI definition.   Returns the
1137  * size in bytes of the network category bitmap on success, negative values
1138  * otherwise.
1139  *
1140  */
1141 static int cipso_v4_map_cat_rng_hton(const struct cipso_v4_doi *doi_def,
1142                                      const struct netlbl_lsm_secattr *secattr,
1143                                      unsigned char *net_cat,
1144                                      u32 net_cat_len)
1145 {
1146         int iter = -1;
1147         u16 array[CIPSO_V4_TAG_RNG_CAT_MAX * 2];
1148         u32 array_cnt = 0;
1149         u32 cat_size = 0;
1150
1151         /* make sure we don't overflow the 'array[]' variable */
1152         if (net_cat_len >
1153             (CIPSO_V4_OPT_LEN_MAX - CIPSO_V4_HDR_LEN - CIPSO_V4_TAG_RNG_BLEN))
1154                 return -ENOSPC;
1155
1156         for (;;) {
1157                 iter = netlbl_catmap_walk(secattr->attr.mls.cat, iter + 1);
1158                 if (iter < 0)
1159                         break;
1160                 cat_size += (iter == 0 ? 0 : sizeof(u16));
1161                 if (cat_size > net_cat_len)
1162                         return -ENOSPC;
1163                 array[array_cnt++] = iter;
1164
1165                 iter = netlbl_catmap_walkrng(secattr->attr.mls.cat, iter);
1166                 if (iter < 0)
1167                         return -EFAULT;
1168                 cat_size += sizeof(u16);
1169                 if (cat_size > net_cat_len)
1170                         return -ENOSPC;
1171                 array[array_cnt++] = iter;
1172         }
1173
1174         for (iter = 0; array_cnt > 0;) {
1175                 *((__be16 *)&net_cat[iter]) = htons(array[--array_cnt]);
1176                 iter += 2;
1177                 array_cnt--;
1178                 if (array[array_cnt] != 0) {
1179                         *((__be16 *)&net_cat[iter]) = htons(array[array_cnt]);
1180                         iter += 2;
1181                 }
1182         }
1183
1184         return cat_size;
1185 }
1186
1187 /**
1188  * cipso_v4_map_cat_rng_ntoh - Perform a category mapping from network to host
1189  * @doi_def: the DOI definition
1190  * @net_cat: the category list in network/CIPSO format
1191  * @net_cat_len: the length of the CIPSO bitmap in bytes
1192  * @secattr: the security attributes
1193  *
1194  * Description:
1195  * Perform a label mapping to translate a CIPSO category list to the correct
1196  * local MLS category bitmap using the given DOI definition.  Returns zero on
1197  * success, negative values on failure.
1198  *
1199  */
1200 static int cipso_v4_map_cat_rng_ntoh(const struct cipso_v4_doi *doi_def,
1201                                      const unsigned char *net_cat,
1202                                      u32 net_cat_len,
1203                                      struct netlbl_lsm_secattr *secattr)
1204 {
1205         int ret_val;
1206         u32 net_iter;
1207         u16 cat_low;
1208         u16 cat_high;
1209
1210         for (net_iter = 0; net_iter < net_cat_len; net_iter += 4) {
1211                 cat_high = get_unaligned_be16(&net_cat[net_iter]);
1212                 if ((net_iter + 4) <= net_cat_len)
1213                         cat_low = get_unaligned_be16(&net_cat[net_iter + 2]);
1214                 else
1215                         cat_low = 0;
1216
1217                 ret_val = netlbl_catmap_setrng(&secattr->attr.mls.cat,
1218                                                cat_low,
1219                                                cat_high,
1220                                                GFP_ATOMIC);
1221                 if (ret_val != 0)
1222                         return ret_val;
1223         }
1224
1225         return 0;
1226 }
1227
1228 /*
1229  * Protocol Handling Functions
1230  */
1231
1232 /**
1233  * cipso_v4_gentag_hdr - Generate a CIPSO option header
1234  * @doi_def: the DOI definition
1235  * @len: the total tag length in bytes, not including this header
1236  * @buf: the CIPSO option buffer
1237  *
1238  * Description:
1239  * Write a CIPSO header into the beginning of @buffer.
1240  *
1241  */
1242 static void cipso_v4_gentag_hdr(const struct cipso_v4_doi *doi_def,
1243                                 unsigned char *buf,
1244                                 u32 len)
1245 {
1246         buf[0] = IPOPT_CIPSO;
1247         buf[1] = CIPSO_V4_HDR_LEN + len;
1248         *(__be32 *)&buf[2] = htonl(doi_def->doi);
1249 }
1250
1251 /**
1252  * cipso_v4_gentag_rbm - Generate a CIPSO restricted bitmap tag (type #1)
1253  * @doi_def: the DOI definition
1254  * @secattr: the security attributes
1255  * @buffer: the option buffer
1256  * @buffer_len: length of buffer in bytes
1257  *
1258  * Description:
1259  * Generate a CIPSO option using the restricted bitmap tag, tag type #1.  The
1260  * actual buffer length may be larger than the indicated size due to
1261  * translation between host and network category bitmaps.  Returns the size of
1262  * the tag on success, negative values on failure.
1263  *
1264  */
1265 static int cipso_v4_gentag_rbm(const struct cipso_v4_doi *doi_def,
1266                                const struct netlbl_lsm_secattr *secattr,
1267                                unsigned char *buffer,
1268                                u32 buffer_len)
1269 {
1270         int ret_val;
1271         u32 tag_len;
1272         u32 level;
1273
1274         if ((secattr->flags & NETLBL_SECATTR_MLS_LVL) == 0)
1275                 return -EPERM;
1276
1277         ret_val = cipso_v4_map_lvl_hton(doi_def,
1278                                         secattr->attr.mls.lvl,
1279                                         &level);
1280         if (ret_val != 0)
1281                 return ret_val;
1282
1283         if (secattr->flags & NETLBL_SECATTR_MLS_CAT) {
1284                 ret_val = cipso_v4_map_cat_rbm_hton(doi_def,
1285                                                     secattr,
1286                                                     &buffer[4],
1287                                                     buffer_len - 4);
1288                 if (ret_val < 0)
1289                         return ret_val;
1290
1291                 /* This will send packets using the "optimized" format when
1292                  * possible as specified in  section 3.4.2.6 of the
1293                  * CIPSO draft. */
1294                 if (cipso_v4_rbm_optfmt && ret_val > 0 && ret_val <= 10)
1295                         tag_len = 14;
1296                 else
1297                         tag_len = 4 + ret_val;
1298         } else
1299                 tag_len = 4;
1300
1301         buffer[0] = CIPSO_V4_TAG_RBITMAP;
1302         buffer[1] = tag_len;
1303         buffer[3] = level;
1304
1305         return tag_len;
1306 }
1307
1308 /**
1309  * cipso_v4_parsetag_rbm - Parse a CIPSO restricted bitmap tag
1310  * @doi_def: the DOI definition
1311  * @tag: the CIPSO tag
1312  * @secattr: the security attributes
1313  *
1314  * Description:
1315  * Parse a CIPSO restricted bitmap tag (tag type #1) and return the security
1316  * attributes in @secattr.  Return zero on success, negatives values on
1317  * failure.
1318  *
1319  */
1320 static int cipso_v4_parsetag_rbm(const struct cipso_v4_doi *doi_def,
1321                                  const unsigned char *tag,
1322                                  struct netlbl_lsm_secattr *secattr)
1323 {
1324         int ret_val;
1325         u8 tag_len = tag[1];
1326         u32 level;
1327
1328         ret_val = cipso_v4_map_lvl_ntoh(doi_def, tag[3], &level);
1329         if (ret_val != 0)
1330                 return ret_val;
1331         secattr->attr.mls.lvl = level;
1332         secattr->flags |= NETLBL_SECATTR_MLS_LVL;
1333
1334         if (tag_len > 4) {
1335                 ret_val = cipso_v4_map_cat_rbm_ntoh(doi_def,
1336                                                     &tag[4],
1337                                                     tag_len - 4,
1338                                                     secattr);
1339                 if (ret_val != 0) {
1340                         netlbl_catmap_free(secattr->attr.mls.cat);
1341                         return ret_val;
1342                 }
1343
1344                 secattr->flags |= NETLBL_SECATTR_MLS_CAT;
1345         }
1346
1347         return 0;
1348 }
1349
1350 /**
1351  * cipso_v4_gentag_enum - Generate a CIPSO enumerated tag (type #2)
1352  * @doi_def: the DOI definition
1353  * @secattr: the security attributes
1354  * @buffer: the option buffer
1355  * @buffer_len: length of buffer in bytes
1356  *
1357  * Description:
1358  * Generate a CIPSO option using the enumerated tag, tag type #2.  Returns the
1359  * size of the tag on success, negative values on failure.
1360  *
1361  */
1362 static int cipso_v4_gentag_enum(const struct cipso_v4_doi *doi_def,
1363                                 const struct netlbl_lsm_secattr *secattr,
1364                                 unsigned char *buffer,
1365                                 u32 buffer_len)
1366 {
1367         int ret_val;
1368         u32 tag_len;
1369         u32 level;
1370
1371         if (!(secattr->flags & NETLBL_SECATTR_MLS_LVL))
1372                 return -EPERM;
1373
1374         ret_val = cipso_v4_map_lvl_hton(doi_def,
1375                                         secattr->attr.mls.lvl,
1376                                         &level);
1377         if (ret_val != 0)
1378                 return ret_val;
1379
1380         if (secattr->flags & NETLBL_SECATTR_MLS_CAT) {
1381                 ret_val = cipso_v4_map_cat_enum_hton(doi_def,
1382                                                      secattr,
1383                                                      &buffer[4],
1384                                                      buffer_len - 4);
1385                 if (ret_val < 0)
1386                         return ret_val;
1387
1388                 tag_len = 4 + ret_val;
1389         } else
1390                 tag_len = 4;
1391
1392         buffer[0] = CIPSO_V4_TAG_ENUM;
1393         buffer[1] = tag_len;
1394         buffer[3] = level;
1395
1396         return tag_len;
1397 }
1398
1399 /**
1400  * cipso_v4_parsetag_enum - Parse a CIPSO enumerated tag
1401  * @doi_def: the DOI definition
1402  * @tag: the CIPSO tag
1403  * @secattr: the security attributes
1404  *
1405  * Description:
1406  * Parse a CIPSO enumerated tag (tag type #2) and return the security
1407  * attributes in @secattr.  Return zero on success, negatives values on
1408  * failure.
1409  *
1410  */
1411 static int cipso_v4_parsetag_enum(const struct cipso_v4_doi *doi_def,
1412                                   const unsigned char *tag,
1413                                   struct netlbl_lsm_secattr *secattr)
1414 {
1415         int ret_val;
1416         u8 tag_len = tag[1];
1417         u32 level;
1418
1419         ret_val = cipso_v4_map_lvl_ntoh(doi_def, tag[3], &level);
1420         if (ret_val != 0)
1421                 return ret_val;
1422         secattr->attr.mls.lvl = level;
1423         secattr->flags |= NETLBL_SECATTR_MLS_LVL;
1424
1425         if (tag_len > 4) {
1426                 ret_val = cipso_v4_map_cat_enum_ntoh(doi_def,
1427                                                      &tag[4],
1428                                                      tag_len - 4,
1429                                                      secattr);
1430                 if (ret_val != 0) {
1431                         netlbl_catmap_free(secattr->attr.mls.cat);
1432                         return ret_val;
1433                 }
1434
1435                 secattr->flags |= NETLBL_SECATTR_MLS_CAT;
1436         }
1437
1438         return 0;
1439 }
1440
1441 /**
1442  * cipso_v4_gentag_rng - Generate a CIPSO ranged tag (type #5)
1443  * @doi_def: the DOI definition
1444  * @secattr: the security attributes
1445  * @buffer: the option buffer
1446  * @buffer_len: length of buffer in bytes
1447  *
1448  * Description:
1449  * Generate a CIPSO option using the ranged tag, tag type #5.  Returns the
1450  * size of the tag on success, negative values on failure.
1451  *
1452  */
1453 static int cipso_v4_gentag_rng(const struct cipso_v4_doi *doi_def,
1454                                const struct netlbl_lsm_secattr *secattr,
1455                                unsigned char *buffer,
1456                                u32 buffer_len)
1457 {
1458         int ret_val;
1459         u32 tag_len;
1460         u32 level;
1461
1462         if (!(secattr->flags & NETLBL_SECATTR_MLS_LVL))
1463                 return -EPERM;
1464
1465         ret_val = cipso_v4_map_lvl_hton(doi_def,
1466                                         secattr->attr.mls.lvl,
1467                                         &level);
1468         if (ret_val != 0)
1469                 return ret_val;
1470
1471         if (secattr->flags & NETLBL_SECATTR_MLS_CAT) {
1472                 ret_val = cipso_v4_map_cat_rng_hton(doi_def,
1473                                                     secattr,
1474                                                     &buffer[4],
1475                                                     buffer_len - 4);
1476                 if (ret_val < 0)
1477                         return ret_val;
1478
1479                 tag_len = 4 + ret_val;
1480         } else
1481                 tag_len = 4;
1482
1483         buffer[0] = CIPSO_V4_TAG_RANGE;
1484         buffer[1] = tag_len;
1485         buffer[3] = level;
1486
1487         return tag_len;
1488 }
1489
1490 /**
1491  * cipso_v4_parsetag_rng - Parse a CIPSO ranged tag
1492  * @doi_def: the DOI definition
1493  * @tag: the CIPSO tag
1494  * @secattr: the security attributes
1495  *
1496  * Description:
1497  * Parse a CIPSO ranged tag (tag type #5) and return the security attributes
1498  * in @secattr.  Return zero on success, negatives values on failure.
1499  *
1500  */
1501 static int cipso_v4_parsetag_rng(const struct cipso_v4_doi *doi_def,
1502                                  const unsigned char *tag,
1503                                  struct netlbl_lsm_secattr *secattr)
1504 {
1505         int ret_val;
1506         u8 tag_len = tag[1];
1507         u32 level;
1508
1509         ret_val = cipso_v4_map_lvl_ntoh(doi_def, tag[3], &level);
1510         if (ret_val != 0)
1511                 return ret_val;
1512         secattr->attr.mls.lvl = level;
1513         secattr->flags |= NETLBL_SECATTR_MLS_LVL;
1514
1515         if (tag_len > 4) {
1516                 ret_val = cipso_v4_map_cat_rng_ntoh(doi_def,
1517                                                     &tag[4],
1518                                                     tag_len - 4,
1519                                                     secattr);
1520                 if (ret_val != 0) {
1521                         netlbl_catmap_free(secattr->attr.mls.cat);
1522                         return ret_val;
1523                 }
1524
1525                 secattr->flags |= NETLBL_SECATTR_MLS_CAT;
1526         }
1527
1528         return 0;
1529 }
1530
1531 /**
1532  * cipso_v4_gentag_loc - Generate a CIPSO local tag (non-standard)
1533  * @doi_def: the DOI definition
1534  * @secattr: the security attributes
1535  * @buffer: the option buffer
1536  * @buffer_len: length of buffer in bytes
1537  *
1538  * Description:
1539  * Generate a CIPSO option using the local tag.  Returns the size of the tag
1540  * on success, negative values on failure.
1541  *
1542  */
1543 static int cipso_v4_gentag_loc(const struct cipso_v4_doi *doi_def,
1544                                const struct netlbl_lsm_secattr *secattr,
1545                                unsigned char *buffer,
1546                                u32 buffer_len)
1547 {
1548         if (!(secattr->flags & NETLBL_SECATTR_SECID))
1549                 return -EPERM;
1550
1551         buffer[0] = CIPSO_V4_TAG_LOCAL;
1552         buffer[1] = CIPSO_V4_TAG_LOC_BLEN;
1553         *(u32 *)&buffer[2] = secattr->attr.secid;
1554
1555         return CIPSO_V4_TAG_LOC_BLEN;
1556 }
1557
1558 /**
1559  * cipso_v4_parsetag_loc - Parse a CIPSO local tag
1560  * @doi_def: the DOI definition
1561  * @tag: the CIPSO tag
1562  * @secattr: the security attributes
1563  *
1564  * Description:
1565  * Parse a CIPSO local tag and return the security attributes in @secattr.
1566  * Return zero on success, negatives values on failure.
1567  *
1568  */
1569 static int cipso_v4_parsetag_loc(const struct cipso_v4_doi *doi_def,
1570                                  const unsigned char *tag,
1571                                  struct netlbl_lsm_secattr *secattr)
1572 {
1573         secattr->attr.secid = *(u32 *)&tag[2];
1574         secattr->flags |= NETLBL_SECATTR_SECID;
1575
1576         return 0;
1577 }
1578
1579 /**
1580  * cipso_v4_validate - Validate a CIPSO option
1581  * @option: the start of the option, on error it is set to point to the error
1582  *
1583  * Description:
1584  * This routine is called to validate a CIPSO option, it checks all of the
1585  * fields to ensure that they are at least valid, see the draft snippet below
1586  * for details.  If the option is valid then a zero value is returned and
1587  * the value of @option is unchanged.  If the option is invalid then a
1588  * non-zero value is returned and @option is adjusted to point to the
1589  * offending portion of the option.  From the IETF draft ...
1590  *
1591  *  "If any field within the CIPSO options, such as the DOI identifier, is not
1592  *   recognized the IP datagram is discarded and an ICMP 'parameter problem'
1593  *   (type 12) is generated and returned.  The ICMP code field is set to 'bad
1594  *   parameter' (code 0) and the pointer is set to the start of the CIPSO field
1595  *   that is unrecognized."
1596  *
1597  */
1598 int cipso_v4_validate(const struct sk_buff *skb, unsigned char **option)
1599 {
1600         unsigned char *opt = *option;
1601         unsigned char *tag;
1602         unsigned char opt_iter;
1603         unsigned char err_offset = 0;
1604         u8 opt_len;
1605         u8 tag_len;
1606         struct cipso_v4_doi *doi_def = NULL;
1607         u32 tag_iter;
1608
1609         /* caller already checks for length values that are too large */
1610         opt_len = opt[1];
1611         if (opt_len < 8) {
1612                 err_offset = 1;
1613                 goto validate_return;
1614         }
1615
1616         rcu_read_lock();
1617         doi_def = cipso_v4_doi_search(get_unaligned_be32(&opt[2]));
1618         if (doi_def == NULL) {
1619                 err_offset = 2;
1620                 goto validate_return_locked;
1621         }
1622
1623         opt_iter = CIPSO_V4_HDR_LEN;
1624         tag = opt + opt_iter;
1625         while (opt_iter < opt_len) {
1626                 for (tag_iter = 0; doi_def->tags[tag_iter] != tag[0];)
1627                         if (doi_def->tags[tag_iter] == CIPSO_V4_TAG_INVALID ||
1628                             ++tag_iter == CIPSO_V4_TAG_MAXCNT) {
1629                                 err_offset = opt_iter;
1630                                 goto validate_return_locked;
1631                         }
1632
1633                 tag_len = tag[1];
1634                 if (tag_len > (opt_len - opt_iter)) {
1635                         err_offset = opt_iter + 1;
1636                         goto validate_return_locked;
1637                 }
1638
1639                 switch (tag[0]) {
1640                 case CIPSO_V4_TAG_RBITMAP:
1641                         if (tag_len < CIPSO_V4_TAG_RBM_BLEN) {
1642                                 err_offset = opt_iter + 1;
1643                                 goto validate_return_locked;
1644                         }
1645
1646                         /* We are already going to do all the verification
1647                          * necessary at the socket layer so from our point of
1648                          * view it is safe to turn these checks off (and less
1649                          * work), however, the CIPSO draft says we should do
1650                          * all the CIPSO validations here but it doesn't
1651                          * really specify _exactly_ what we need to validate
1652                          * ... so, just make it a sysctl tunable. */
1653                         if (cipso_v4_rbm_strictvalid) {
1654                                 if (cipso_v4_map_lvl_valid(doi_def,
1655                                                            tag[3]) < 0) {
1656                                         err_offset = opt_iter + 3;
1657                                         goto validate_return_locked;
1658                                 }
1659                                 if (tag_len > CIPSO_V4_TAG_RBM_BLEN &&
1660                                     cipso_v4_map_cat_rbm_valid(doi_def,
1661                                                             &tag[4],
1662                                                             tag_len - 4) < 0) {
1663                                         err_offset = opt_iter + 4;
1664                                         goto validate_return_locked;
1665                                 }
1666                         }
1667                         break;
1668                 case CIPSO_V4_TAG_ENUM:
1669                         if (tag_len < CIPSO_V4_TAG_ENUM_BLEN) {
1670                                 err_offset = opt_iter + 1;
1671                                 goto validate_return_locked;
1672                         }
1673
1674                         if (cipso_v4_map_lvl_valid(doi_def,
1675                                                    tag[3]) < 0) {
1676                                 err_offset = opt_iter + 3;
1677                                 goto validate_return_locked;
1678                         }
1679                         if (tag_len > CIPSO_V4_TAG_ENUM_BLEN &&
1680                             cipso_v4_map_cat_enum_valid(doi_def,
1681                                                         &tag[4],
1682                                                         tag_len - 4) < 0) {
1683                                 err_offset = opt_iter + 4;
1684                                 goto validate_return_locked;
1685                         }
1686                         break;
1687                 case CIPSO_V4_TAG_RANGE:
1688                         if (tag_len < CIPSO_V4_TAG_RNG_BLEN) {
1689                                 err_offset = opt_iter + 1;
1690                                 goto validate_return_locked;
1691                         }
1692
1693                         if (cipso_v4_map_lvl_valid(doi_def,
1694                                                    tag[3]) < 0) {
1695                                 err_offset = opt_iter + 3;
1696                                 goto validate_return_locked;
1697                         }
1698                         if (tag_len > CIPSO_V4_TAG_RNG_BLEN &&
1699                             cipso_v4_map_cat_rng_valid(doi_def,
1700                                                        &tag[4],
1701                                                        tag_len - 4) < 0) {
1702                                 err_offset = opt_iter + 4;
1703                                 goto validate_return_locked;
1704                         }
1705                         break;
1706                 case CIPSO_V4_TAG_LOCAL:
1707                         /* This is a non-standard tag that we only allow for
1708                          * local connections, so if the incoming interface is
1709                          * not the loopback device drop the packet. Further,
1710                          * there is no legitimate reason for setting this from
1711                          * userspace so reject it if skb is NULL. */
1712                         if (skb == NULL || !(skb->dev->flags & IFF_LOOPBACK)) {
1713                                 err_offset = opt_iter;
1714                                 goto validate_return_locked;
1715                         }
1716                         if (tag_len != CIPSO_V4_TAG_LOC_BLEN) {
1717                                 err_offset = opt_iter + 1;
1718                                 goto validate_return_locked;
1719                         }
1720                         break;
1721                 default:
1722                         err_offset = opt_iter;
1723                         goto validate_return_locked;
1724                 }
1725
1726                 tag += tag_len;
1727                 opt_iter += tag_len;
1728         }
1729
1730 validate_return_locked:
1731         rcu_read_unlock();
1732 validate_return:
1733         *option = opt + err_offset;
1734         return err_offset;
1735 }
1736
1737 /**
1738  * cipso_v4_error - Send the correct response for a bad packet
1739  * @skb: the packet
1740  * @error: the error code
1741  * @gateway: CIPSO gateway flag
1742  *
1743  * Description:
1744  * Based on the error code given in @error, send an ICMP error message back to
1745  * the originating host.  From the IETF draft ...
1746  *
1747  *  "If the contents of the CIPSO [option] are valid but the security label is
1748  *   outside of the configured host or port label range, the datagram is
1749  *   discarded and an ICMP 'destination unreachable' (type 3) is generated and
1750  *   returned.  The code field of the ICMP is set to 'communication with
1751  *   destination network administratively prohibited' (code 9) or to
1752  *   'communication with destination host administratively prohibited'
1753  *   (code 10).  The value of the code is dependent on whether the originator
1754  *   of the ICMP message is acting as a CIPSO host or a CIPSO gateway.  The
1755  *   recipient of the ICMP message MUST be able to handle either value.  The
1756  *   same procedure is performed if a CIPSO [option] can not be added to an
1757  *   IP packet because it is too large to fit in the IP options area."
1758  *
1759  *  "If the error is triggered by receipt of an ICMP message, the message is
1760  *   discarded and no response is permitted (consistent with general ICMP
1761  *   processing rules)."
1762  *
1763  */
1764 void cipso_v4_error(struct sk_buff *skb, int error, u32 gateway)
1765 {
1766         if (ip_hdr(skb)->protocol == IPPROTO_ICMP || error != -EACCES)
1767                 return;
1768
1769         if (gateway)
1770                 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_NET_ANO, 0);
1771         else
1772                 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_ANO, 0);
1773 }
1774
1775 /**
1776  * cipso_v4_genopt - Generate a CIPSO option
1777  * @buf: the option buffer
1778  * @buf_len: the size of opt_buf
1779  * @doi_def: the CIPSO DOI to use
1780  * @secattr: the security attributes
1781  *
1782  * Description:
1783  * Generate a CIPSO option using the DOI definition and security attributes
1784  * passed to the function.  Returns the length of the option on success and
1785  * negative values on failure.
1786  *
1787  */
1788 static int cipso_v4_genopt(unsigned char *buf, u32 buf_len,
1789                            const struct cipso_v4_doi *doi_def,
1790                            const struct netlbl_lsm_secattr *secattr)
1791 {
1792         int ret_val;
1793         u32 iter;
1794
1795         if (buf_len <= CIPSO_V4_HDR_LEN)
1796                 return -ENOSPC;
1797
1798         /* XXX - This code assumes only one tag per CIPSO option which isn't
1799          * really a good assumption to make but since we only support the MAC
1800          * tags right now it is a safe assumption. */
1801         iter = 0;
1802         do {
1803                 memset(buf, 0, buf_len);
1804                 switch (doi_def->tags[iter]) {
1805                 case CIPSO_V4_TAG_RBITMAP:
1806                         ret_val = cipso_v4_gentag_rbm(doi_def,
1807                                                    secattr,
1808                                                    &buf[CIPSO_V4_HDR_LEN],
1809                                                    buf_len - CIPSO_V4_HDR_LEN);
1810                         break;
1811                 case CIPSO_V4_TAG_ENUM:
1812                         ret_val = cipso_v4_gentag_enum(doi_def,
1813                                                    secattr,
1814                                                    &buf[CIPSO_V4_HDR_LEN],
1815                                                    buf_len - CIPSO_V4_HDR_LEN);
1816                         break;
1817                 case CIPSO_V4_TAG_RANGE:
1818                         ret_val = cipso_v4_gentag_rng(doi_def,
1819                                                    secattr,
1820                                                    &buf[CIPSO_V4_HDR_LEN],
1821                                                    buf_len - CIPSO_V4_HDR_LEN);
1822                         break;
1823                 case CIPSO_V4_TAG_LOCAL:
1824                         ret_val = cipso_v4_gentag_loc(doi_def,
1825                                                    secattr,
1826                                                    &buf[CIPSO_V4_HDR_LEN],
1827                                                    buf_len - CIPSO_V4_HDR_LEN);
1828                         break;
1829                 default:
1830                         return -EPERM;
1831                 }
1832
1833                 iter++;
1834         } while (ret_val < 0 &&
1835                  iter < CIPSO_V4_TAG_MAXCNT &&
1836                  doi_def->tags[iter] != CIPSO_V4_TAG_INVALID);
1837         if (ret_val < 0)
1838                 return ret_val;
1839         cipso_v4_gentag_hdr(doi_def, buf, ret_val);
1840         return CIPSO_V4_HDR_LEN + ret_val;
1841 }
1842
1843 /**
1844  * cipso_v4_sock_setattr - Add a CIPSO option to a socket
1845  * @sk: the socket
1846  * @doi_def: the CIPSO DOI to use
1847  * @secattr: the specific security attributes of the socket
1848  *
1849  * Description:
1850  * Set the CIPSO option on the given socket using the DOI definition and
1851  * security attributes passed to the function.  This function requires
1852  * exclusive access to @sk, which means it either needs to be in the
1853  * process of being created or locked.  Returns zero on success and negative
1854  * values on failure.
1855  *
1856  */
1857 int cipso_v4_sock_setattr(struct sock *sk,
1858                           const struct cipso_v4_doi *doi_def,
1859                           const struct netlbl_lsm_secattr *secattr)
1860 {
1861         int ret_val = -EPERM;
1862         unsigned char *buf = NULL;
1863         u32 buf_len;
1864         u32 opt_len;
1865         struct ip_options_rcu *old, *opt = NULL;
1866         struct inet_sock *sk_inet;
1867         struct inet_connection_sock *sk_conn;
1868
1869         /* In the case of sock_create_lite(), the sock->sk field is not
1870          * defined yet but it is not a problem as the only users of these
1871          * "lite" PF_INET sockets are functions which do an accept() call
1872          * afterwards so we will label the socket as part of the accept(). */
1873         if (sk == NULL)
1874                 return 0;
1875
1876         /* We allocate the maximum CIPSO option size here so we are probably
1877          * being a little wasteful, but it makes our life _much_ easier later
1878          * on and after all we are only talking about 40 bytes. */
1879         buf_len = CIPSO_V4_OPT_LEN_MAX;
1880         buf = kmalloc(buf_len, GFP_ATOMIC);
1881         if (buf == NULL) {
1882                 ret_val = -ENOMEM;
1883                 goto socket_setattr_failure;
1884         }
1885
1886         ret_val = cipso_v4_genopt(buf, buf_len, doi_def, secattr);
1887         if (ret_val < 0)
1888                 goto socket_setattr_failure;
1889         buf_len = ret_val;
1890
1891         /* We can't use ip_options_get() directly because it makes a call to
1892          * ip_options_get_alloc() which allocates memory with GFP_KERNEL and
1893          * we won't always have CAP_NET_RAW even though we _always_ want to
1894          * set the IPOPT_CIPSO option. */
1895         opt_len = (buf_len + 3) & ~3;
1896         opt = kzalloc(sizeof(*opt) + opt_len, GFP_ATOMIC);
1897         if (opt == NULL) {
1898                 ret_val = -ENOMEM;
1899                 goto socket_setattr_failure;
1900         }
1901         memcpy(opt->opt.__data, buf, buf_len);
1902         opt->opt.optlen = opt_len;
1903         opt->opt.cipso = sizeof(struct iphdr);
1904         kfree(buf);
1905         buf = NULL;
1906
1907         sk_inet = inet_sk(sk);
1908
1909         old = rcu_dereference_protected(sk_inet->inet_opt, sock_owned_by_user(sk));
1910         if (sk_inet->is_icsk) {
1911                 sk_conn = inet_csk(sk);
1912                 if (old)
1913                         sk_conn->icsk_ext_hdr_len -= old->opt.optlen;
1914                 sk_conn->icsk_ext_hdr_len += opt->opt.optlen;
1915                 sk_conn->icsk_sync_mss(sk, sk_conn->icsk_pmtu_cookie);
1916         }
1917         rcu_assign_pointer(sk_inet->inet_opt, opt);
1918         if (old)
1919                 kfree_rcu(old, rcu);
1920
1921         return 0;
1922
1923 socket_setattr_failure:
1924         kfree(buf);
1925         kfree(opt);
1926         return ret_val;
1927 }
1928
1929 /**
1930  * cipso_v4_req_setattr - Add a CIPSO option to a connection request socket
1931  * @req: the connection request socket
1932  * @doi_def: the CIPSO DOI to use
1933  * @secattr: the specific security attributes of the socket
1934  *
1935  * Description:
1936  * Set the CIPSO option on the given socket using the DOI definition and
1937  * security attributes passed to the function.  Returns zero on success and
1938  * negative values on failure.
1939  *
1940  */
1941 int cipso_v4_req_setattr(struct request_sock *req,
1942                          const struct cipso_v4_doi *doi_def,
1943                          const struct netlbl_lsm_secattr *secattr)
1944 {
1945         int ret_val = -EPERM;
1946         unsigned char *buf = NULL;
1947         u32 buf_len;
1948         u32 opt_len;
1949         struct ip_options_rcu *opt = NULL;
1950         struct inet_request_sock *req_inet;
1951
1952         /* We allocate the maximum CIPSO option size here so we are probably
1953          * being a little wasteful, but it makes our life _much_ easier later
1954          * on and after all we are only talking about 40 bytes. */
1955         buf_len = CIPSO_V4_OPT_LEN_MAX;
1956         buf = kmalloc(buf_len, GFP_ATOMIC);
1957         if (buf == NULL) {
1958                 ret_val = -ENOMEM;
1959                 goto req_setattr_failure;
1960         }
1961
1962         ret_val = cipso_v4_genopt(buf, buf_len, doi_def, secattr);
1963         if (ret_val < 0)
1964                 goto req_setattr_failure;
1965         buf_len = ret_val;
1966
1967         /* We can't use ip_options_get() directly because it makes a call to
1968          * ip_options_get_alloc() which allocates memory with GFP_KERNEL and
1969          * we won't always have CAP_NET_RAW even though we _always_ want to
1970          * set the IPOPT_CIPSO option. */
1971         opt_len = (buf_len + 3) & ~3;
1972         opt = kzalloc(sizeof(*opt) + opt_len, GFP_ATOMIC);
1973         if (opt == NULL) {
1974                 ret_val = -ENOMEM;
1975                 goto req_setattr_failure;
1976         }
1977         memcpy(opt->opt.__data, buf, buf_len);
1978         opt->opt.optlen = opt_len;
1979         opt->opt.cipso = sizeof(struct iphdr);
1980         kfree(buf);
1981         buf = NULL;
1982
1983         req_inet = inet_rsk(req);
1984         opt = xchg(&req_inet->opt, opt);
1985         if (opt)
1986                 kfree_rcu(opt, rcu);
1987
1988         return 0;
1989
1990 req_setattr_failure:
1991         kfree(buf);
1992         kfree(opt);
1993         return ret_val;
1994 }
1995
1996 /**
1997  * cipso_v4_delopt - Delete the CIPSO option from a set of IP options
1998  * @opt_ptr: IP option pointer
1999  *
2000  * Description:
2001  * Deletes the CIPSO IP option from a set of IP options and makes the necessary
2002  * adjustments to the IP option structure.  Returns zero on success, negative
2003  * values on failure.
2004  *
2005  */
2006 static int cipso_v4_delopt(struct ip_options_rcu **opt_ptr)
2007 {
2008         int hdr_delta = 0;
2009         struct ip_options_rcu *opt = *opt_ptr;
2010
2011         if (opt->opt.srr || opt->opt.rr || opt->opt.ts || opt->opt.router_alert) {
2012                 u8 cipso_len;
2013                 u8 cipso_off;
2014                 unsigned char *cipso_ptr;
2015                 int iter;
2016                 int optlen_new;
2017
2018                 cipso_off = opt->opt.cipso - sizeof(struct iphdr);
2019                 cipso_ptr = &opt->opt.__data[cipso_off];
2020                 cipso_len = cipso_ptr[1];
2021
2022                 if (opt->opt.srr > opt->opt.cipso)
2023                         opt->opt.srr -= cipso_len;
2024                 if (opt->opt.rr > opt->opt.cipso)
2025                         opt->opt.rr -= cipso_len;
2026                 if (opt->opt.ts > opt->opt.cipso)
2027                         opt->opt.ts -= cipso_len;
2028                 if (opt->opt.router_alert > opt->opt.cipso)
2029                         opt->opt.router_alert -= cipso_len;
2030                 opt->opt.cipso = 0;
2031
2032                 memmove(cipso_ptr, cipso_ptr + cipso_len,
2033                         opt->opt.optlen - cipso_off - cipso_len);
2034
2035                 /* determining the new total option length is tricky because of
2036                  * the padding necessary, the only thing i can think to do at
2037                  * this point is walk the options one-by-one, skipping the
2038                  * padding at the end to determine the actual option size and
2039                  * from there we can determine the new total option length */
2040                 iter = 0;
2041                 optlen_new = 0;
2042                 while (iter < opt->opt.optlen)
2043                         if (opt->opt.__data[iter] != IPOPT_NOP) {
2044                                 iter += opt->opt.__data[iter + 1];
2045                                 optlen_new = iter;
2046                         } else
2047                                 iter++;
2048                 hdr_delta = opt->opt.optlen;
2049                 opt->opt.optlen = (optlen_new + 3) & ~3;
2050                 hdr_delta -= opt->opt.optlen;
2051         } else {
2052                 /* only the cipso option was present on the socket so we can
2053                  * remove the entire option struct */
2054                 *opt_ptr = NULL;
2055                 hdr_delta = opt->opt.optlen;
2056                 kfree_rcu(opt, rcu);
2057         }
2058
2059         return hdr_delta;
2060 }
2061
2062 /**
2063  * cipso_v4_sock_delattr - Delete the CIPSO option from a socket
2064  * @sk: the socket
2065  *
2066  * Description:
2067  * Removes the CIPSO option from a socket, if present.
2068  *
2069  */
2070 void cipso_v4_sock_delattr(struct sock *sk)
2071 {
2072         int hdr_delta;
2073         struct ip_options_rcu *opt;
2074         struct inet_sock *sk_inet;
2075
2076         sk_inet = inet_sk(sk);
2077         opt = rcu_dereference_protected(sk_inet->inet_opt, 1);
2078         if (opt == NULL || opt->opt.cipso == 0)
2079                 return;
2080
2081         hdr_delta = cipso_v4_delopt(&sk_inet->inet_opt);
2082         if (sk_inet->is_icsk && hdr_delta > 0) {
2083                 struct inet_connection_sock *sk_conn = inet_csk(sk);
2084                 sk_conn->icsk_ext_hdr_len -= hdr_delta;
2085                 sk_conn->icsk_sync_mss(sk, sk_conn->icsk_pmtu_cookie);
2086         }
2087 }
2088
2089 /**
2090  * cipso_v4_req_delattr - Delete the CIPSO option from a request socket
2091  * @reg: the request socket
2092  *
2093  * Description:
2094  * Removes the CIPSO option from a request socket, if present.
2095  *
2096  */
2097 void cipso_v4_req_delattr(struct request_sock *req)
2098 {
2099         struct ip_options_rcu *opt;
2100         struct inet_request_sock *req_inet;
2101
2102         req_inet = inet_rsk(req);
2103         opt = req_inet->opt;
2104         if (opt == NULL || opt->opt.cipso == 0)
2105                 return;
2106
2107         cipso_v4_delopt(&req_inet->opt);
2108 }
2109
2110 /**
2111  * cipso_v4_getattr - Helper function for the cipso_v4_*_getattr functions
2112  * @cipso: the CIPSO v4 option
2113  * @secattr: the security attributes
2114  *
2115  * Description:
2116  * Inspect @cipso and return the security attributes in @secattr.  Returns zero
2117  * on success and negative values on failure.
2118  *
2119  */
2120 static int cipso_v4_getattr(const unsigned char *cipso,
2121                             struct netlbl_lsm_secattr *secattr)
2122 {
2123         int ret_val = -ENOMSG;
2124         u32 doi;
2125         struct cipso_v4_doi *doi_def;
2126
2127         if (cipso_v4_cache_check(cipso, cipso[1], secattr) == 0)
2128                 return 0;
2129
2130         doi = get_unaligned_be32(&cipso[2]);
2131         rcu_read_lock();
2132         doi_def = cipso_v4_doi_search(doi);
2133         if (doi_def == NULL)
2134                 goto getattr_return;
2135         /* XXX - This code assumes only one tag per CIPSO option which isn't
2136          * really a good assumption to make but since we only support the MAC
2137          * tags right now it is a safe assumption. */
2138         switch (cipso[6]) {
2139         case CIPSO_V4_TAG_RBITMAP:
2140                 ret_val = cipso_v4_parsetag_rbm(doi_def, &cipso[6], secattr);
2141                 break;
2142         case CIPSO_V4_TAG_ENUM:
2143                 ret_val = cipso_v4_parsetag_enum(doi_def, &cipso[6], secattr);
2144                 break;
2145         case CIPSO_V4_TAG_RANGE:
2146                 ret_val = cipso_v4_parsetag_rng(doi_def, &cipso[6], secattr);
2147                 break;
2148         case CIPSO_V4_TAG_LOCAL:
2149                 ret_val = cipso_v4_parsetag_loc(doi_def, &cipso[6], secattr);
2150                 break;
2151         }
2152         if (ret_val == 0)
2153                 secattr->type = NETLBL_NLTYPE_CIPSOV4;
2154
2155 getattr_return:
2156         rcu_read_unlock();
2157         return ret_val;
2158 }
2159
2160 /**
2161  * cipso_v4_sock_getattr - Get the security attributes from a sock
2162  * @sk: the sock
2163  * @secattr: the security attributes
2164  *
2165  * Description:
2166  * Query @sk to see if there is a CIPSO option attached to the sock and if
2167  * there is return the CIPSO security attributes in @secattr.  This function
2168  * requires that @sk be locked, or privately held, but it does not do any
2169  * locking itself.  Returns zero on success and negative values on failure.
2170  *
2171  */
2172 int cipso_v4_sock_getattr(struct sock *sk, struct netlbl_lsm_secattr *secattr)
2173 {
2174         struct ip_options_rcu *opt;
2175         int res = -ENOMSG;
2176
2177         rcu_read_lock();
2178         opt = rcu_dereference(inet_sk(sk)->inet_opt);
2179         if (opt && opt->opt.cipso)
2180                 res = cipso_v4_getattr(opt->opt.__data +
2181                                                 opt->opt.cipso -
2182                                                 sizeof(struct iphdr),
2183                                        secattr);
2184         rcu_read_unlock();
2185         return res;
2186 }
2187
2188 /**
2189  * cipso_v4_skbuff_setattr - Set the CIPSO option on a packet
2190  * @skb: the packet
2191  * @secattr: the security attributes
2192  *
2193  * Description:
2194  * Set the CIPSO option on the given packet based on the security attributes.
2195  * Returns a pointer to the IP header on success and NULL on failure.
2196  *
2197  */
2198 int cipso_v4_skbuff_setattr(struct sk_buff *skb,
2199                             const struct cipso_v4_doi *doi_def,
2200                             const struct netlbl_lsm_secattr *secattr)
2201 {
2202         int ret_val;
2203         struct iphdr *iph;
2204         struct ip_options *opt = &IPCB(skb)->opt;
2205         unsigned char buf[CIPSO_V4_OPT_LEN_MAX];
2206         u32 buf_len = CIPSO_V4_OPT_LEN_MAX;
2207         u32 opt_len;
2208         int len_delta;
2209
2210         ret_val = cipso_v4_genopt(buf, buf_len, doi_def, secattr);
2211         if (ret_val < 0)
2212                 return ret_val;
2213         buf_len = ret_val;
2214         opt_len = (buf_len + 3) & ~3;
2215
2216         /* we overwrite any existing options to ensure that we have enough
2217          * room for the CIPSO option, the reason is that we _need_ to guarantee
2218          * that the security label is applied to the packet - we do the same
2219          * thing when using the socket options and it hasn't caused a problem,
2220          * if we need to we can always revisit this choice later */
2221
2222         len_delta = opt_len - opt->optlen;
2223         /* if we don't ensure enough headroom we could panic on the skb_push()
2224          * call below so make sure we have enough, we are also "mangling" the
2225          * packet so we should probably do a copy-on-write call anyway */
2226         ret_val = skb_cow(skb, skb_headroom(skb) + len_delta);
2227         if (ret_val < 0)
2228                 return ret_val;
2229
2230         if (len_delta > 0) {
2231                 /* we assume that the header + opt->optlen have already been
2232                  * "pushed" in ip_options_build() or similar */
2233                 iph = ip_hdr(skb);
2234                 skb_push(skb, len_delta);
2235                 memmove((char *)iph - len_delta, iph, iph->ihl << 2);
2236                 skb_reset_network_header(skb);
2237                 iph = ip_hdr(skb);
2238         } else if (len_delta < 0) {
2239                 iph = ip_hdr(skb);
2240                 memset(iph + 1, IPOPT_NOP, opt->optlen);
2241         } else
2242                 iph = ip_hdr(skb);
2243
2244         if (opt->optlen > 0)
2245                 memset(opt, 0, sizeof(*opt));
2246         opt->optlen = opt_len;
2247         opt->cipso = sizeof(struct iphdr);
2248         opt->is_changed = 1;
2249
2250         /* we have to do the following because we are being called from a
2251          * netfilter hook which means the packet already has had the header
2252          * fields populated and the checksum calculated - yes this means we
2253          * are doing more work than needed but we do it to keep the core
2254          * stack clean and tidy */
2255         memcpy(iph + 1, buf, buf_len);
2256         if (opt_len > buf_len)
2257                 memset((char *)(iph + 1) + buf_len, 0, opt_len - buf_len);
2258         if (len_delta != 0) {
2259                 iph->ihl = 5 + (opt_len >> 2);
2260                 iph->tot_len = htons(skb->len);
2261         }
2262         ip_send_check(iph);
2263
2264         return 0;
2265 }
2266
2267 /**
2268  * cipso_v4_skbuff_delattr - Delete any CIPSO options from a packet
2269  * @skb: the packet
2270  *
2271  * Description:
2272  * Removes any and all CIPSO options from the given packet.  Returns zero on
2273  * success, negative values on failure.
2274  *
2275  */
2276 int cipso_v4_skbuff_delattr(struct sk_buff *skb)
2277 {
2278         int ret_val;
2279         struct iphdr *iph;
2280         struct ip_options *opt = &IPCB(skb)->opt;
2281         unsigned char *cipso_ptr;
2282
2283         if (opt->cipso == 0)
2284                 return 0;
2285
2286         /* since we are changing the packet we should make a copy */
2287         ret_val = skb_cow(skb, skb_headroom(skb));
2288         if (ret_val < 0)
2289                 return ret_val;
2290
2291         /* the easiest thing to do is just replace the cipso option with noop
2292          * options since we don't change the size of the packet, although we
2293          * still need to recalculate the checksum */
2294
2295         iph = ip_hdr(skb);
2296         cipso_ptr = (unsigned char *)iph + opt->cipso;
2297         memset(cipso_ptr, IPOPT_NOOP, cipso_ptr[1]);
2298         opt->cipso = 0;
2299         opt->is_changed = 1;
2300
2301         ip_send_check(iph);
2302
2303         return 0;
2304 }
2305
2306 /**
2307  * cipso_v4_skbuff_getattr - Get the security attributes from the CIPSO option
2308  * @skb: the packet
2309  * @secattr: the security attributes
2310  *
2311  * Description:
2312  * Parse the given packet's CIPSO option and return the security attributes.
2313  * Returns zero on success and negative values on failure.
2314  *
2315  */
2316 int cipso_v4_skbuff_getattr(const struct sk_buff *skb,
2317                             struct netlbl_lsm_secattr *secattr)
2318 {
2319         return cipso_v4_getattr(CIPSO_V4_OPTPTR(skb), secattr);
2320 }
2321
2322 /*
2323  * Setup Functions
2324  */
2325
2326 /**
2327  * cipso_v4_init - Initialize the CIPSO module
2328  *
2329  * Description:
2330  * Initialize the CIPSO module and prepare it for use.  Returns zero on success
2331  * and negative values on failure.
2332  *
2333  */
2334 static int __init cipso_v4_init(void)
2335 {
2336         int ret_val;
2337
2338         ret_val = cipso_v4_cache_init();
2339         if (ret_val != 0)
2340                 panic("Failed to initialize the CIPSO/IPv4 cache (%d)\n",
2341                       ret_val);
2342
2343         return 0;
2344 }
2345
2346 subsys_initcall(cipso_v4_init);