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