net/ipv6/calipso.c

   1 /*
   2  * CALIPSO - Common Architecture Label IPv6 Security Option
   3  *
   4  * This is an implementation of the CALIPSO protocol as specified in
   5  * RFC 5570.
   6  *
   7  * Authors: Paul Moore <paul.moore@hp.com>
   8  *          Huw Davies <huw@codeweavers.com>
   9  *
  10  */
  11
  12 /* (c) Copyright Hewlett-Packard Development Company, L.P., 2006, 2008
  13  * (c) Copyright Huw Davies <huw@codeweavers.com>, 2015
  14  *
  15  * This program is free software;  you can redistribute it and/or modify
  16  * it under the terms of the GNU General Public License as published by
  17  * the Free Software Foundation; either version 2 of the License, or
  18  * (at your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY;  without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  23  * the GNU General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License
  26  * along with this program;  if not, see <http://www.gnu.org/licenses/>.
  27  *
  28  */
  29
  30 #include <linux/init.h>
  31 #include <linux/types.h>
  32 #include <linux/rcupdate.h>
  33 #include <linux/list.h>
  34 #include <linux/spinlock.h>
  35 #include <linux/string.h>
  36 #include <linux/jhash.h>
  37 #include <linux/audit.h>
  38 #include <linux/slab.h>
  39 #include <net/ip.h>
  40 #include <net/icmp.h>
  41 #include <net/tcp.h>
  42 #include <net/netlabel.h>
  43 #include <net/calipso.h>
  44 #include <linux/atomic.h>
  45 #include <linux/bug.h>
  46 #include <asm/unaligned.h>
  47 #include <linux/crc-ccitt.h>
  48
  49 /* Maximium size of the calipso option including
  50  * the two-byte TLV header.
  51  */
  52 #define CALIPSO_OPT_LEN_MAX (2 + 252)
  53
  54 /* Size of the minimum calipso option including
  55  * the two-byte TLV header.
  56  */
  57 #define CALIPSO_HDR_LEN (2 + 8)
  58
  59 /* Maximium size of the calipso option including
  60  * the two-byte TLV header and upto 3 bytes of
  61  * leading pad and 7 bytes of trailing pad.
  62  */
  63 #define CALIPSO_OPT_LEN_MAX_WITH_PAD (3 + CALIPSO_OPT_LEN_MAX + 7)
  64
  65  /* Maximium size of u32 aligned buffer required to hold calipso
  66   * option.  Max of 3 initial pad bytes starting from buffer + 3.
  67   * i.e. the worst case is when the previous tlv finishes on 4n + 3.
  68   */
  69 #define CALIPSO_MAX_BUFFER (6 + CALIPSO_OPT_LEN_MAX)
  70
  71 /* List of available DOI definitions */
  72 static DEFINE_SPINLOCK(calipso_doi_list_lock);
  73 static LIST_HEAD(calipso_doi_list);
  74
  75 /* Label mapping cache */
  76 int calipso_cache_enabled = 1;
  77 int calipso_cache_bucketsize = 10;
  78 #define CALIPSO_CACHE_BUCKETBITS     7
  79 #define CALIPSO_CACHE_BUCKETS        BIT(CALIPSO_CACHE_BUCKETBITS)
  80 #define CALIPSO_CACHE_REORDERLIMIT   10
  81 struct calipso_map_cache_bkt {
  82         spinlock_t lock;
  83         u32 size;
  84         struct list_head list;
  85 };
  86
  87 struct calipso_map_cache_entry {
  88         u32 hash;
  89         unsigned char *key;
  90         size_t key_len;
  91
  92         struct netlbl_lsm_cache *lsm_data;
  93
  94         u32 activity;
  95         struct list_head list;
  96 };
  97
  98 static struct calipso_map_cache_bkt *calipso_cache;
  99
 100 /* Label Mapping Cache Functions
 101  */
 102
 103 /**
 104  * calipso_cache_entry_free - Frees a cache entry
 105  * @entry: the entry to free
 106  *
 107  * Description:
 108  * This function frees the memory associated with a cache entry including the
 109  * LSM cache data if there are no longer any users, i.e. reference count == 0.
 110  *
 111  */
 112 static void calipso_cache_entry_free(struct calipso_map_cache_entry *entry)
 113 {
 114         if (entry->lsm_data)
 115                 netlbl_secattr_cache_free(entry->lsm_data);
 116         kfree(entry->key);
 117         kfree(entry);
 118 }
 119
 120 /**
 121  * calipso_map_cache_hash - Hashing function for the CALIPSO cache
 122  * @key: the hash key
 123  * @key_len: the length of the key in bytes
 124  *
 125  * Description:
 126  * The CALIPSO tag hashing function.  Returns a 32-bit hash value.
 127  *
 128  */
 129 static u32 calipso_map_cache_hash(const unsigned char *key, u32 key_len)
 130 {
 131         return jhash(key, key_len, 0);
 132 }
 133
 134 /**
 135  * calipso_cache_init - Initialize the CALIPSO cache
 136  *
 137  * Description:
 138  * Initializes the CALIPSO label mapping cache, this function should be called
 139  * before any of the other functions defined in this file.  Returns zero on
 140  * success, negative values on error.
 141  *
 142  */
 143 static int __init calipso_cache_init(void)
 144 {
 145         u32 iter;
 146
 147         calipso_cache = kcalloc(CALIPSO_CACHE_BUCKETS,
 148                                 sizeof(struct calipso_map_cache_bkt),
 149                                 GFP_KERNEL);
 150         if (!calipso_cache)
 151                 return -ENOMEM;
 152
 153         for (iter = 0; iter < CALIPSO_CACHE_BUCKETS; iter++) {
 154                 spin_lock_init(&calipso_cache[iter].lock);
 155                 calipso_cache[iter].size = 0;
 156                 INIT_LIST_HEAD(&calipso_cache[iter].list);
 157         }
 158
 159         return 0;
 160 }
 161
 162 /**
 163  * calipso_cache_invalidate - Invalidates the current CALIPSO cache
 164  *
 165  * Description:
 166  * Invalidates and frees any entries in the CALIPSO cache.  Returns zero on
 167  * success and negative values on failure.
 168  *
 169  */
 170 static void calipso_cache_invalidate(void)
 171 {
 172         struct calipso_map_cache_entry *entry, *tmp_entry;
 173         u32 iter;
 174
 175         for (iter = 0; iter < CALIPSO_CACHE_BUCKETS; iter++) {
 176                 spin_lock_bh(&calipso_cache[iter].lock);
 177                 list_for_each_entry_safe(entry,
 178                                          tmp_entry,
 179                                          &calipso_cache[iter].list, list) {
 180                         list_del(&entry->list);
 181                         calipso_cache_entry_free(entry);
 182                 }
 183                 calipso_cache[iter].size = 0;
 184                 spin_unlock_bh(&calipso_cache[iter].lock);
 185         }
 186 }
 187
 188 /**
 189  * calipso_cache_check - Check the CALIPSO cache for a label mapping
 190  * @key: the buffer to check
 191  * @key_len: buffer length in bytes
 192  * @secattr: the security attribute struct to use
 193  *
 194  * Description:
 195  * This function checks the cache to see if a label mapping already exists for
 196  * the given key.  If there is a match then the cache is adjusted and the
 197  * @secattr struct is populated with the correct LSM security attributes.  The
 198  * cache is adjusted in the following manner if the entry is not already the
 199  * first in the cache bucket:
 200  *
 201  *  1. The cache entry's activity counter is incremented
 202  *  2. The previous (higher ranking) entry's activity counter is decremented
 203  *  3. If the difference between the two activity counters is geater than
 204  *     CALIPSO_CACHE_REORDERLIMIT the two entries are swapped
 205  *
 206  * Returns zero on success, -ENOENT for a cache miss, and other negative values
 207  * on error.
 208  *
 209  */
 210 static int calipso_cache_check(const unsigned char *key,
 211                                u32 key_len,
 212                                struct netlbl_lsm_secattr *secattr)
 213 {
 214         u32 bkt;
 215         struct calipso_map_cache_entry *entry;
 216         struct calipso_map_cache_entry *prev_entry = NULL;
 217         u32 hash;
 218
 219         if (!calipso_cache_enabled)
 220                 return -ENOENT;
 221
 222         hash = calipso_map_cache_hash(key, key_len);
 223         bkt = hash & (CALIPSO_CACHE_BUCKETS - 1);
 224         spin_lock_bh(&calipso_cache[bkt].lock);
 225         list_for_each_entry(entry, &calipso_cache[bkt].list, list) {
 226                 if (entry->hash == hash &&
 227                     entry->key_len == key_len &&
 228                     memcmp(entry->key, key, key_len) == 0) {
 229                         entry->activity += 1;
 230                         atomic_inc(&entry->lsm_data->refcount);
 231                         secattr->cache = entry->lsm_data;
 232                         secattr->flags |= NETLBL_SECATTR_CACHE;
 233                         secattr->type = NETLBL_NLTYPE_CALIPSO;
 234                         if (!prev_entry) {
 235                                 spin_unlock_bh(&calipso_cache[bkt].lock);
 236                                 return 0;
 237                         }
 238
 239                         if (prev_entry->activity > 0)
 240                                 prev_entry->activity -= 1;
 241                         if (entry->activity > prev_entry->activity &&
 242                             entry->activity - prev_entry->activity >
 243                             CALIPSO_CACHE_REORDERLIMIT) {
 244                                 __list_del(entry->list.prev, entry->list.next);
 245                                 __list_add(&entry->list,
 246                                            prev_entry->list.prev,
 247                                            &prev_entry->list);
 248                         }
 249
 250                         spin_unlock_bh(&calipso_cache[bkt].lock);
 251                         return 0;
 252                 }
 253                 prev_entry = entry;
 254         }
 255         spin_unlock_bh(&calipso_cache[bkt].lock);
 256
 257         return -ENOENT;
 258 }
 259
 260 /**
 261  * calipso_cache_add - Add an entry to the CALIPSO cache
 262  * @calipso_ptr: the CALIPSO option
 263  * @secattr: the packet's security attributes
 264  *
 265  * Description:
 266  * Add a new entry into the CALIPSO label mapping cache.  Add the new entry to
 267  * head of the cache bucket's list, if the cache bucket is out of room remove
 268  * the last entry in the list first.  It is important to note that there is
 269  * currently no checking for duplicate keys.  Returns zero on success,
 270  * negative values on failure.  The key stored starts at calipso_ptr + 2,
 271  * i.e. the type and length bytes are not stored, this corresponds to
 272  * calipso_ptr[1] bytes of data.
 273  *
 274  */
 275 static int calipso_cache_add(const unsigned char *calipso_ptr,
 276                              const struct netlbl_lsm_secattr *secattr)
 277 {
 278         int ret_val = -EPERM;
 279         u32 bkt;
 280         struct calipso_map_cache_entry *entry = NULL;
 281         struct calipso_map_cache_entry *old_entry = NULL;
 282         u32 calipso_ptr_len;
 283
 284         if (!calipso_cache_enabled || calipso_cache_bucketsize <= 0)
 285                 return 0;
 286
 287         calipso_ptr_len = calipso_ptr[1];
 288
 289         entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
 290         if (!entry)
 291                 return -ENOMEM;
 292         entry->key = kmemdup(calipso_ptr + 2, calipso_ptr_len, GFP_ATOMIC);
 293         if (!entry->key) {
 294                 ret_val = -ENOMEM;
 295                 goto cache_add_failure;
 296         }
 297         entry->key_len = calipso_ptr_len;
 298         entry->hash = calipso_map_cache_hash(calipso_ptr, calipso_ptr_len);
 299         atomic_inc(&secattr->cache->refcount);
 300         entry->lsm_data = secattr->cache;
 301
 302         bkt = entry->hash & (CALIPSO_CACHE_BUCKETS - 1);
 303         spin_lock_bh(&calipso_cache[bkt].lock);
 304         if (calipso_cache[bkt].size < calipso_cache_bucketsize) {
 305                 list_add(&entry->list, &calipso_cache[bkt].list);
 306                 calipso_cache[bkt].size += 1;
 307         } else {
 308                 old_entry = list_entry(calipso_cache[bkt].list.prev,
 309                                        struct calipso_map_cache_entry, list);
 310                 list_del(&old_entry->list);
 311                 list_add(&entry->list, &calipso_cache[bkt].list);
 312                 calipso_cache_entry_free(old_entry);
 313         }
 314         spin_unlock_bh(&calipso_cache[bkt].lock);
 315
 316         return 0;
 317
 318 cache_add_failure:
 319         if (entry)
 320                 calipso_cache_entry_free(entry);
 321         return ret_val;
 322 }
 323
 324 /* DOI List Functions
 325  */
 326
 327 /**
 328  * calipso_doi_search - Searches for a DOI definition
 329  * @doi: the DOI to search for
 330  *
 331  * Description:
 332  * Search the DOI definition list for a DOI definition with a DOI value that
 333  * matches @doi.  The caller is responsible for calling rcu_read_[un]lock().
 334  * Returns a pointer to the DOI definition on success and NULL on failure.
 335  */
 336 static struct calipso_doi *calipso_doi_search(u32 doi)
 337 {
 338         struct calipso_doi *iter;
 339
 340         list_for_each_entry_rcu(iter, &calipso_doi_list, list)
 341                 if (iter->doi == doi && atomic_read(&iter->refcount))
 342                         return iter;
 343         return NULL;
 344 }
 345
 346 /**
 347  * calipso_doi_add - Add a new DOI to the CALIPSO protocol engine
 348  * @doi_def: the DOI structure
 349  * @audit_info: NetLabel audit information
 350  *
 351  * Description:
 352  * The caller defines a new DOI for use by the CALIPSO engine and calls this
 353  * function to add it to the list of acceptable domains.  The caller must
 354  * ensure that the mapping table specified in @doi_def->map meets all of the
 355  * requirements of the mapping type (see calipso.h for details).  Returns
 356  * zero on success and non-zero on failure.
 357  *
 358  */
 359 static int calipso_doi_add(struct calipso_doi *doi_def,
 360                            struct netlbl_audit *audit_info)
 361 {
 362         int ret_val = -EINVAL;
 363         u32 doi;
 364         u32 doi_type;
 365         struct audit_buffer *audit_buf;
 366
 367         doi = doi_def->doi;
 368         doi_type = doi_def->type;
 369
 370         if (doi_def->doi == CALIPSO_DOI_UNKNOWN)
 371                 goto doi_add_return;
 372
 373         atomic_set(&doi_def->refcount, 1);
 374
 375         spin_lock(&calipso_doi_list_lock);
 376         if (calipso_doi_search(doi_def->doi)) {
 377                 spin_unlock(&calipso_doi_list_lock);
 378                 ret_val = -EEXIST;
 379                 goto doi_add_return;
 380         }
 381         list_add_tail_rcu(&doi_def->list, &calipso_doi_list);
 382         spin_unlock(&calipso_doi_list_lock);
 383         ret_val = 0;
 384
 385 doi_add_return:
 386         audit_buf = netlbl_audit_start(AUDIT_MAC_CALIPSO_ADD, audit_info);
 387         if (audit_buf) {
 388                 const char *type_str;
 389
 390                 switch (doi_type) {
 391                 case CALIPSO_MAP_PASS:
 392                         type_str = "pass";
 393                         break;
 394                 default:
 395                         type_str = "(unknown)";
 396                 }
 397                 audit_log_format(audit_buf,
 398                                  " calipso_doi=%u calipso_type=%s res=%u",
 399                                  doi, type_str, ret_val == 0 ? 1 : 0);
 400                 audit_log_end(audit_buf);
 401         }
 402
 403         return ret_val;
 404 }
 405
 406 /**
 407  * calipso_doi_free - Frees a DOI definition
 408  * @doi_def: the DOI definition
 409  *
 410  * Description:
 411  * This function frees all of the memory associated with a DOI definition.
 412  *
 413  */
 414 static void calipso_doi_free(struct calipso_doi *doi_def)
 415 {
 416         kfree(doi_def);
 417 }
 418
 419 /**
 420  * calipso_doi_free_rcu - Frees a DOI definition via the RCU pointer
 421  * @entry: the entry's RCU field
 422  *
 423  * Description:
 424  * This function is designed to be used as a callback to the call_rcu()
 425  * function so that the memory allocated to the DOI definition can be released
 426  * safely.
 427  *
 428  */
 429 static void calipso_doi_free_rcu(struct rcu_head *entry)
 430 {
 431         struct calipso_doi *doi_def;
 432
 433         doi_def = container_of(entry, struct calipso_doi, rcu);
 434         calipso_doi_free(doi_def);
 435 }
 436
 437 /**
 438  * calipso_doi_remove - Remove an existing DOI from the CALIPSO protocol engine
 439  * @doi: the DOI value
 440  * @audit_secid: the LSM secid to use in the audit message
 441  *
 442  * Description:
 443  * Removes a DOI definition from the CALIPSO engine.  The NetLabel routines will
 444  * be called to release their own LSM domain mappings as well as our own
 445  * domain list.  Returns zero on success and negative values on failure.
 446  *
 447  */
 448 static int calipso_doi_remove(u32 doi, struct netlbl_audit *audit_info)
 449 {
 450         int ret_val;
 451         struct calipso_doi *doi_def;
 452         struct audit_buffer *audit_buf;
 453
 454         spin_lock(&calipso_doi_list_lock);
 455         doi_def = calipso_doi_search(doi);
 456         if (!doi_def) {
 457                 spin_unlock(&calipso_doi_list_lock);
 458                 ret_val = -ENOENT;
 459                 goto doi_remove_return;
 460         }
 461         if (!atomic_dec_and_test(&doi_def->refcount)) {
 462                 spin_unlock(&calipso_doi_list_lock);
 463                 ret_val = -EBUSY;
 464                 goto doi_remove_return;
 465         }
 466         list_del_rcu(&doi_def->list);
 467         spin_unlock(&calipso_doi_list_lock);
 468
 469         call_rcu(&doi_def->rcu, calipso_doi_free_rcu);
 470         ret_val = 0;
 471
 472 doi_remove_return:
 473         audit_buf = netlbl_audit_start(AUDIT_MAC_CALIPSO_DEL, audit_info);
 474         if (audit_buf) {
 475                 audit_log_format(audit_buf,
 476                                  " calipso_doi=%u res=%u",
 477                                  doi, ret_val == 0 ? 1 : 0);
 478                 audit_log_end(audit_buf);
 479         }
 480
 481         return ret_val;
 482 }
 483
 484 /**
 485  * calipso_doi_getdef - Returns a reference to a valid DOI definition
 486  * @doi: the DOI value
 487  *
 488  * Description:
 489  * Searches for a valid DOI definition and if one is found it is returned to
 490  * the caller.  Otherwise NULL is returned.  The caller must ensure that
 491  * calipso_doi_putdef() is called when the caller is done.
 492  *
 493  */
 494 static struct calipso_doi *calipso_doi_getdef(u32 doi)
 495 {
 496         struct calipso_doi *doi_def;
 497
 498         rcu_read_lock();
 499         doi_def = calipso_doi_search(doi);
 500         if (!doi_def)
 501                 goto doi_getdef_return;
 502         if (!atomic_inc_not_zero(&doi_def->refcount))
 503                 doi_def = NULL;
 504
 505 doi_getdef_return:
 506         rcu_read_unlock();
 507         return doi_def;
 508 }
 509
 510 /**
 511  * calipso_doi_putdef - Releases a reference for the given DOI definition
 512  * @doi_def: the DOI definition
 513  *
 514  * Description:
 515  * Releases a DOI definition reference obtained from calipso_doi_getdef().
 516  *
 517  */
 518 static void calipso_doi_putdef(struct calipso_doi *doi_def)
 519 {
 520         if (!doi_def)
 521                 return;
 522
 523         if (!atomic_dec_and_test(&doi_def->refcount))
 524                 return;
 525         spin_lock(&calipso_doi_list_lock);
 526         list_del_rcu(&doi_def->list);
 527         spin_unlock(&calipso_doi_list_lock);
 528
 529         call_rcu(&doi_def->rcu, calipso_doi_free_rcu);
 530 }
 531
 532 /**
 533  * calipso_doi_walk - Iterate through the DOI definitions
 534  * @skip_cnt: skip past this number of DOI definitions, updated
 535  * @callback: callback for each DOI definition
 536  * @cb_arg: argument for the callback function
 537  *
 538  * Description:
 539  * Iterate over the DOI definition list, skipping the first @skip_cnt entries.
 540  * For each entry call @callback, if @callback returns a negative value stop
 541  * 'walking' through the list and return.  Updates the value in @skip_cnt upon
 542  * return.  Returns zero on success, negative values on failure.
 543  *
 544  */
 545 static int calipso_doi_walk(u32 *skip_cnt,
 546                             int (*callback)(struct calipso_doi *doi_def,
 547                                             void *arg),
 548                             void *cb_arg)
 549 {
 550         int ret_val = -ENOENT;
 551         u32 doi_cnt = 0;
 552         struct calipso_doi *iter_doi;
 553
 554         rcu_read_lock();
 555         list_for_each_entry_rcu(iter_doi, &calipso_doi_list, list)
 556                 if (atomic_read(&iter_doi->refcount) > 0) {
 557                         if (doi_cnt++ < *skip_cnt)
 558                                 continue;
 559                         ret_val = callback(iter_doi, cb_arg);
 560                         if (ret_val < 0) {
 561                                 doi_cnt--;
 562                                 goto doi_walk_return;
 563                         }
 564                 }
 565
 566 doi_walk_return:
 567         rcu_read_unlock();
 568         *skip_cnt = doi_cnt;
 569         return ret_val;
 570 }
 571
 572 /**
 573  * calipso_validate - Validate a CALIPSO option
 574  * @skb: the packet
 575  * @option: the start of the option
 576  *
 577  * Description:
 578  * This routine is called to validate a CALIPSO option.
 579  * If the option is valid then %true is returned, otherwise
 580  * %false is returned.
 581  *
 582  * The caller should have already checked that the length of the
 583  * option (including the TLV header) is >= 10 and that the catmap
 584  * length is consistent with the option length.
 585  *
 586  * We leave checks on the level and categories to the socket layer.
 587  */
 588 bool calipso_validate(const struct sk_buff *skb, const unsigned char *option)
 589 {
 590         struct calipso_doi *doi_def;
 591         bool ret_val;
 592         u16 crc, len = option[1] + 2;
 593         static const u8 zero[2];
 594
 595         /* The original CRC runs over the option including the TLV header
 596          * with the CRC-16 field (at offset 8) zeroed out. */
 597         crc = crc_ccitt(0xffff, option, 8);
 598         crc = crc_ccitt(crc, zero, sizeof(zero));
 599         if (len > 10)
 600                 crc = crc_ccitt(crc, option + 10, len - 10);
 601         crc = ~crc;
 602         if (option[8] != (crc & 0xff) || option[9] != ((crc >> 8) & 0xff))
 603                 return false;
 604
 605         rcu_read_lock();
 606         doi_def = calipso_doi_search(get_unaligned_be32(option + 2));
 607         ret_val = !!doi_def;
 608         rcu_read_unlock();
 609
 610         return ret_val;
 611 }
 612
 613 /**
 614  * calipso_map_cat_hton - Perform a category mapping from host to network
 615  * @doi_def: the DOI definition
 616  * @secattr: the security attributes
 617  * @net_cat: the zero'd out category bitmap in network/CALIPSO format
 618  * @net_cat_len: the length of the CALIPSO bitmap in bytes
 619  *
 620  * Description:
 621  * Perform a label mapping to translate a local MLS category bitmap to the
 622  * correct CALIPSO bitmap using the given DOI definition.  Returns the minimum
 623  * size in bytes of the network bitmap on success, negative values otherwise.
 624  *
 625  */
 626 static int calipso_map_cat_hton(const struct calipso_doi *doi_def,
 627                                 const struct netlbl_lsm_secattr *secattr,
 628                                 unsigned char *net_cat,
 629                                 u32 net_cat_len)
 630 {
 631         int spot = -1;
 632         u32 net_spot_max = 0;
 633         u32 net_clen_bits = net_cat_len * 8;
 634
 635         for (;;) {
 636                 spot = netlbl_catmap_walk(secattr->attr.mls.cat,
 637                                           spot + 1);
 638                 if (spot < 0)
 639                         break;
 640                 if (spot >= net_clen_bits)
 641                         return -ENOSPC;
 642                 netlbl_bitmap_setbit(net_cat, spot, 1);
 643
 644                 if (spot > net_spot_max)
 645                         net_spot_max = spot;
 646         }
 647
 648         return (net_spot_max / 32 + 1) * 4;
 649 }
 650
 651 /**
 652  * calipso_map_cat_ntoh - Perform a category mapping from network to host
 653  * @doi_def: the DOI definition
 654  * @net_cat: the category bitmap in network/CALIPSO format
 655  * @net_cat_len: the length of the CALIPSO bitmap in bytes
 656  * @secattr: the security attributes
 657  *
 658  * Description:
 659  * Perform a label mapping to translate a CALIPSO bitmap to the correct local
 660  * MLS category bitmap using the given DOI definition.  Returns zero on
 661  * success, negative values on failure.
 662  *
 663  */
 664 static int calipso_map_cat_ntoh(const struct calipso_doi *doi_def,
 665                                 const unsigned char *net_cat,
 666                                 u32 net_cat_len,
 667                                 struct netlbl_lsm_secattr *secattr)
 668 {
 669         int ret_val;
 670         int spot = -1;
 671         u32 net_clen_bits = net_cat_len * 8;
 672
 673         for (;;) {
 674                 spot = netlbl_bitmap_walk(net_cat,
 675                                           net_clen_bits,
 676                                           spot + 1,
 677                                           1);
 678                 if (spot < 0) {
 679                         if (spot == -2)
 680                                 return -EFAULT;
 681                         return 0;
 682                 }
 683
 684                 ret_val = netlbl_catmap_setbit(&secattr->attr.mls.cat,
 685                                                spot,
 686                                                GFP_ATOMIC);
 687                 if (ret_val != 0)
 688                         return ret_val;
 689         }
 690
 691         return -EINVAL;
 692 }
 693
 694 /**
 695  * calipso_pad_write - Writes pad bytes in TLV format
 696  * @buf: the buffer
 697  * @offset: offset from start of buffer to write padding
 698  * @count: number of pad bytes to write
 699  *
 700  * Description:
 701  * Write @count bytes of TLV padding into @buffer starting at offset @offset.
 702  * @count should be less than 8 - see RFC 4942.
 703  *
 704  */
 705 static int calipso_pad_write(unsigned char *buf, unsigned int offset,
 706                              unsigned int count)
 707 {
 708         if (WARN_ON_ONCE(count >= 8))
 709                 return -EINVAL;
 710
 711         switch (count) {
 712         case 0:
 713                 break;
 714         case 1:
 715                 buf[offset] = IPV6_TLV_PAD1;
 716                 break;
 717         default:
 718                 buf[offset] = IPV6_TLV_PADN;
 719                 buf[offset + 1] = count - 2;
 720                 if (count > 2)
 721                         memset(buf + offset + 2, 0, count - 2);
 722                 break;
 723         }
 724         return 0;
 725 }
 726
 727 /**
 728  * calipso_genopt - Generate a CALIPSO option
 729  * @buf: the option buffer
 730  * @start: offset from which to write
 731  * @buf_len: the size of opt_buf
 732  * @doi_def: the CALIPSO DOI to use
 733  * @secattr: the security attributes
 734  *
 735  * Description:
 736  * Generate a CALIPSO option using the DOI definition and security attributes
 737  * passed to the function. This also generates upto three bytes of leading
 738  * padding that ensures that the option is 4n + 2 aligned.  It returns the
 739  * number of bytes written (including any initial padding).
 740  */
 741 static int calipso_genopt(unsigned char *buf, u32 start, u32 buf_len,
 742                           const struct calipso_doi *doi_def,
 743                           const struct netlbl_lsm_secattr *secattr)
 744 {
 745         int ret_val;
 746         u32 len, pad;
 747         u16 crc;
 748         static const unsigned char padding[4] = {2, 1, 0, 3};
 749         unsigned char *calipso;
 750
 751         /* CALIPSO has 4n + 2 alignment */
 752         pad = padding[start & 3];
 753         if (buf_len <= start + pad + CALIPSO_HDR_LEN)
 754                 return -ENOSPC;
 755
 756         if ((secattr->flags & NETLBL_SECATTR_MLS_LVL) == 0)
 757                 return -EPERM;
 758
 759         len = CALIPSO_HDR_LEN;
 760
 761         if (secattr->flags & NETLBL_SECATTR_MLS_CAT) {
 762                 ret_val = calipso_map_cat_hton(doi_def,
 763                                                secattr,
 764                                                buf + start + pad + len,
 765                                                buf_len - start - pad - len);
 766                 if (ret_val < 0)
 767                         return ret_val;
 768                 len += ret_val;
 769         }
 770
 771         calipso_pad_write(buf, start, pad);
 772         calipso = buf + start + pad;
 773
 774         calipso[0] = IPV6_TLV_CALIPSO;
 775         calipso[1] = len - 2;
 776         *(__be32 *)(calipso + 2) = htonl(doi_def->doi);
 777         calipso[6] = (len - CALIPSO_HDR_LEN) / 4;
 778         calipso[7] = secattr->attr.mls.lvl,
 779         crc = ~crc_ccitt(0xffff, calipso, len);
 780         calipso[8] = crc & 0xff;
 781         calipso[9] = (crc >> 8) & 0xff;
 782         return pad + len;
 783 }
 784
 785 /* Hop-by-hop hdr helper functions
 786  */
 787
 788 /**
 789  * calipso_opt_update - Replaces socket's hop options with a new set
 790  * @sk: the socket
 791  * @hop: new hop options
 792  *
 793  * Description:
 794  * Replaces @sk's hop options with @hop.  @hop may be NULL to leave
 795  * the socket with no hop options.
 796  *
 797  */
 798 static int calipso_opt_update(struct sock *sk, struct ipv6_opt_hdr *hop)
 799 {
 800         struct ipv6_txoptions *old = txopt_get(inet6_sk(sk)), *txopts;
 801
 802         txopts = ipv6_renew_options_kern(sk, old, IPV6_HOPOPTS,
 803                                          hop, hop ? ipv6_optlen(hop) : 0);
 804         txopt_put(old);
 805         if (IS_ERR(txopts))
 806                 return PTR_ERR(txopts);
 807
 808         txopts = ipv6_update_options(sk, txopts);
 809         if (txopts) {
 810                 atomic_sub(txopts->tot_len, &sk->sk_omem_alloc);
 811                 txopt_put(txopts);
 812         }
 813
 814         return 0;
 815 }
 816
 817 /**
 818  * calipso_tlv_len - Returns the length of the TLV
 819  * @opt: the option header
 820  * @offset: offset of the TLV within the header
 821  *
 822  * Description:
 823  * Returns the length of the TLV option at offset @offset within
 824  * the option header @opt.  Checks that the entire TLV fits inside
 825  * the option header, returns a negative value if this is not the case.
 826  */
 827 static int calipso_tlv_len(struct ipv6_opt_hdr *opt, unsigned int offset)
 828 {
 829         unsigned char *tlv = (unsigned char *)opt;
 830         unsigned int opt_len = ipv6_optlen(opt), tlv_len;
 831
 832         if (offset < sizeof(*opt) || offset >= opt_len)
 833                 return -EINVAL;
 834         if (tlv[offset] == IPV6_TLV_PAD1)
 835                 return 1;
 836         if (offset + 1 >= opt_len)
 837                 return -EINVAL;
 838         tlv_len = tlv[offset + 1] + 2;
 839         if (offset + tlv_len > opt_len)
 840                 return -EINVAL;
 841         return tlv_len;
 842 }
 843
 844 /**
 845  * calipso_opt_find - Finds the CALIPSO option in an IPv6 hop options header
 846  * @hop: the hop options header
 847  * @start: on return holds the offset of any leading padding
 848  * @end: on return holds the offset of the first non-pad TLV after CALIPSO
 849  *
 850  * Description:
 851  * Finds the space occupied by a CALIPSO option (including any leading and
 852  * trailing padding).
 853  *
 854  * If a CALIPSO option exists set @start and @end to the
 855  * offsets within @hop of the start of padding before the first
 856  * CALIPSO option and the end of padding after the first CALIPSO
 857  * option.  In this case the function returns 0.
 858  *
 859  * In the absence of a CALIPSO option, @start and @end will be
 860  * set to the start and end of any trailing padding in the header.
 861  * This is useful when appending a new option, as the caller may want
 862  * to overwrite some of this padding.  In this case the function will
 863  * return -ENOENT.
 864  */
 865 static int calipso_opt_find(struct ipv6_opt_hdr *hop, unsigned int *start,
 866                             unsigned int *end)
 867 {
 868         int ret_val = -ENOENT, tlv_len;
 869         unsigned int opt_len, offset, offset_s = 0, offset_e = 0;
 870         unsigned char *opt = (unsigned char *)hop;
 871
 872         opt_len = ipv6_optlen(hop);
 873         offset = sizeof(*hop);
 874
 875         while (offset < opt_len) {
 876                 tlv_len = calipso_tlv_len(hop, offset);
 877                 if (tlv_len < 0)
 878                         return tlv_len;
 879
 880                 switch (opt[offset]) {
 881                 case IPV6_TLV_PAD1:
 882                 case IPV6_TLV_PADN:
 883                         if (offset_e)
 884                                 offset_e = offset;
 885                         break;
 886                 case IPV6_TLV_CALIPSO:
 887                         ret_val = 0;
 888                         offset_e = offset;
 889                         break;
 890                 default:
 891                         if (offset_e == 0)
 892                                 offset_s = offset;
 893                         else
 894                                 goto out;
 895                 }
 896                 offset += tlv_len;
 897         }
 898
 899 out:
 900         if (offset_s)
 901                 *start = offset_s + calipso_tlv_len(hop, offset_s);
 902         else
 903                 *start = sizeof(*hop);
 904         if (offset_e)
 905                 *end = offset_e + calipso_tlv_len(hop, offset_e);
 906         else
 907                 *end = opt_len;
 908
 909         return ret_val;
 910 }
 911
 912 /**
 913  * calipso_opt_insert - Inserts a CALIPSO option into an IPv6 hop opt hdr
 914  * @hop: the original hop options header
 915  * @doi_def: the CALIPSO DOI to use
 916  * @secattr: the specific security attributes of the socket
 917  *
 918  * Description:
 919  * Creates a new hop options header based on @hop with a
 920  * CALIPSO option added to it.  If @hop already contains a CALIPSO
 921  * option this is overwritten, otherwise the new option is appended
 922  * after any existing options.  If @hop is NULL then the new header
 923  * will contain just the CALIPSO option and any needed padding.
 924  *
 925  */
 926 static struct ipv6_opt_hdr *
 927 calipso_opt_insert(struct ipv6_opt_hdr *hop,
 928                    const struct calipso_doi *doi_def,
 929                    const struct netlbl_lsm_secattr *secattr)
 930 {
 931         unsigned int start, end, buf_len, pad, hop_len;
 932         struct ipv6_opt_hdr *new;
 933         int ret_val;
 934
 935         if (hop) {
 936                 hop_len = ipv6_optlen(hop);
 937                 ret_val = calipso_opt_find(hop, &start, &end);
 938                 if (ret_val && ret_val != -ENOENT)
 939                         return ERR_PTR(ret_val);
 940         } else {
 941                 hop_len = 0;
 942                 start = sizeof(*hop);
 943                 end = 0;
 944         }
 945
 946         buf_len = hop_len + start - end + CALIPSO_OPT_LEN_MAX_WITH_PAD;
 947         new = kzalloc(buf_len, GFP_ATOMIC);
 948         if (!new)
 949                 return ERR_PTR(-ENOMEM);
 950
 951         if (start > sizeof(*hop))
 952                 memcpy(new, hop, start);
 953         ret_val = calipso_genopt((unsigned char *)new, start, buf_len, doi_def,
 954                                  secattr);
 955         if (ret_val < 0) {
 956                 kfree(new);
 957                 return ERR_PTR(ret_val);
 958         }
 959
 960         buf_len = start + ret_val;
 961         /* At this point buf_len aligns to 4n, so (buf_len & 4) pads to 8n */
 962         pad = ((buf_len & 4) + (end & 7)) & 7;
 963         calipso_pad_write((unsigned char *)new, buf_len, pad);
 964         buf_len += pad;
 965
 966         if (end != hop_len) {
 967                 memcpy((char *)new + buf_len, (char *)hop + end, hop_len - end);
 968                 buf_len += hop_len - end;
 969         }
 970         new->nexthdr = 0;
 971         new->hdrlen = buf_len / 8 - 1;
 972
 973         return new;
 974 }
 975
 976 /**
 977  * calipso_opt_del - Removes the CALIPSO option from an option header
 978  * @hop: the original header
 979  * @new: the new header
 980  *
 981  * Description:
 982  * Creates a new header based on @hop without any CALIPSO option.  If @hop
 983  * doesn't contain a CALIPSO option it returns -ENOENT.  If @hop contains
 984  * no other non-padding options, it returns zero with @new set to NULL.
 985  * Otherwise it returns zero, creates a new header without the CALIPSO
 986  * option (and removing as much padding as possible) and returns with
 987  * @new set to that header.
 988  *
 989  */
 990 static int calipso_opt_del(struct ipv6_opt_hdr *hop,
 991                            struct ipv6_opt_hdr **new)
 992 {
 993         int ret_val;
 994         unsigned int start, end, delta, pad, hop_len;
 995
 996         ret_val = calipso_opt_find(hop, &start, &end);
 997         if (ret_val)
 998                 return ret_val;
 999
1000         hop_len = ipv6_optlen(hop);
1001         if (start == sizeof(*hop) && end == hop_len) {
1002                 /* There's no other option in the header so return NULL */
1003                 *new = NULL;
1004                 return 0;
1005         }
1006
1007         delta = (end - start) & ~7;
1008         *new = kzalloc(hop_len - delta, GFP_ATOMIC);
1009         if (!*new)
1010                 return -ENOMEM;
1011
1012         memcpy(*new, hop, start);
1013         (*new)->hdrlen -= delta / 8;
1014         pad = (end - start) & 7;
1015         calipso_pad_write((unsigned char *)*new, start, pad);
1016         if (end != hop_len)
1017                 memcpy((char *)*new + start + pad, (char *)hop + end,
1018                        hop_len - end);
1019
1020         return 0;
1021 }
1022
1023 /**
1024  * calipso_opt_getattr - Get the security attributes from a memory block
1025  * @calipso: the CALIPSO option
1026  * @secattr: the security attributes
1027  *
1028  * Description:
1029  * Inspect @calipso and return the security attributes in @secattr.
1030  * Returns zero on success and negative values on failure.
1031  *
1032  */
1033 static int calipso_opt_getattr(const unsigned char *calipso,
1034                                struct netlbl_lsm_secattr *secattr)
1035 {
1036         int ret_val = -ENOMSG;
1037         u32 doi, len = calipso[1], cat_len = calipso[6] * 4;
1038         struct calipso_doi *doi_def;
1039
1040         if (cat_len + 8 > len)
1041                 return -EINVAL;
1042
1043         if (calipso_cache_check(calipso + 2, calipso[1], secattr) == 0)
1044                 return 0;
1045
1046         doi = get_unaligned_be32(calipso + 2);
1047         rcu_read_lock();
1048         doi_def = calipso_doi_search(doi);
1049         if (!doi_def)
1050                 goto getattr_return;
1051
1052         secattr->attr.mls.lvl = calipso[7];
1053         secattr->flags |= NETLBL_SECATTR_MLS_LVL;
1054
1055         if (cat_len) {
1056                 ret_val = calipso_map_cat_ntoh(doi_def,
1057                                                calipso + 10,
1058                                                cat_len,
1059                                                secattr);
1060                 if (ret_val != 0) {
1061                         netlbl_catmap_free(secattr->attr.mls.cat);
1062                         goto getattr_return;
1063                 }
1064
1065                 secattr->flags |= NETLBL_SECATTR_MLS_CAT;
1066         }
1067
1068         secattr->type = NETLBL_NLTYPE_CALIPSO;
1069
1070 getattr_return:
1071         rcu_read_unlock();
1072         return ret_val;
1073 }
1074
1075 /* sock functions.
1076  */
1077
1078 /**
1079  * calipso_sock_getattr - Get the security attributes from a sock
1080  * @sk: the sock
1081  * @secattr: the security attributes
1082  *
1083  * Description:
1084  * Query @sk to see if there is a CALIPSO option attached to the sock and if
1085  * there is return the CALIPSO security attributes in @secattr.  This function
1086  * requires that @sk be locked, or privately held, but it does not do any
1087  * locking itself.  Returns zero on success and negative values on failure.
1088  *
1089  */
1090 static int calipso_sock_getattr(struct sock *sk,
1091                                 struct netlbl_lsm_secattr *secattr)
1092 {
1093         struct ipv6_opt_hdr *hop;
1094         int opt_len, len, ret_val = -ENOMSG, offset;
1095         unsigned char *opt;
1096         struct ipv6_txoptions *txopts = txopt_get(inet6_sk(sk));
1097
1098         if (!txopts || !txopts->hopopt)
1099                 goto done;
1100
1101         hop = txopts->hopopt;
1102         opt = (unsigned char *)hop;
1103         opt_len = ipv6_optlen(hop);
1104         offset = sizeof(*hop);
1105         while (offset < opt_len) {
1106                 len = calipso_tlv_len(hop, offset);
1107                 if (len < 0) {
1108                         ret_val = len;
1109                         goto done;
1110                 }
1111                 switch (opt[offset]) {
1112                 case IPV6_TLV_CALIPSO:
1113                         if (len < CALIPSO_HDR_LEN)
1114                                 ret_val = -EINVAL;
1115                         else
1116                                 ret_val = calipso_opt_getattr(&opt[offset],
1117                                                               secattr);
1118                         goto done;
1119                 default:
1120                         offset += len;
1121                         break;
1122                 }
1123         }
1124 done:
1125         txopt_put(txopts);
1126         return ret_val;
1127 }
1128
1129 /**
1130  * calipso_sock_setattr - Add a CALIPSO option to a socket
1131  * @sk: the socket
1132  * @doi_def: the CALIPSO DOI to use
1133  * @secattr: the specific security attributes of the socket
1134  *
1135  * Description:
1136  * Set the CALIPSO option on the given socket using the DOI definition and
1137  * security attributes passed to the function.  This function requires
1138  * exclusive access to @sk, which means it either needs to be in the
1139  * process of being created or locked.  Returns zero on success and negative
1140  * values on failure.
1141  *
1142  */
1143 static int calipso_sock_setattr(struct sock *sk,
1144                                 const struct calipso_doi *doi_def,
1145                                 const struct netlbl_lsm_secattr *secattr)
1146 {
1147         int ret_val;
1148         struct ipv6_opt_hdr *old, *new;
1149         struct ipv6_txoptions *txopts = txopt_get(inet6_sk(sk));
1150
1151         old = NULL;
1152         if (txopts)
1153                 old = txopts->hopopt;
1154
1155         new = calipso_opt_insert(old, doi_def, secattr);
1156         txopt_put(txopts);
1157         if (IS_ERR(new))
1158                 return PTR_ERR(new);
1159
1160         ret_val = calipso_opt_update(sk, new);
1161
1162         kfree(new);
1163         return ret_val;
1164 }
1165
1166 /**
1167  * calipso_sock_delattr - Delete the CALIPSO option from a socket
1168  * @sk: the socket
1169  *
1170  * Description:
1171  * Removes the CALIPSO option from a socket, if present.
1172  *
1173  */
1174 static void calipso_sock_delattr(struct sock *sk)
1175 {
1176         struct ipv6_opt_hdr *new_hop;
1177         struct ipv6_txoptions *txopts = txopt_get(inet6_sk(sk));
1178
1179         if (!txopts || !txopts->hopopt)
1180                 goto done;
1181
1182         if (calipso_opt_del(txopts->hopopt, &new_hop))
1183                 goto done;
1184
1185         calipso_opt_update(sk, new_hop);
1186         kfree(new_hop);
1187
1188 done:
1189         txopt_put(txopts);
1190 }
1191
1192 /* request sock functions.
1193  */
1194
1195 /**
1196  * calipso_req_setattr - Add a CALIPSO option to a connection request socket
1197  * @req: the connection request socket
1198  * @doi_def: the CALIPSO DOI to use
1199  * @secattr: the specific security attributes of the socket
1200  *
1201  * Description:
1202  * Set the CALIPSO option on the given socket using the DOI definition and
1203  * security attributes passed to the function.  Returns zero on success and
1204  * negative values on failure.
1205  *
1206  */
1207 static int calipso_req_setattr(struct request_sock *req,
1208                                const struct calipso_doi *doi_def,
1209                                const struct netlbl_lsm_secattr *secattr)
1210 {
1211         struct ipv6_txoptions *txopts;
1212         struct inet_request_sock *req_inet = inet_rsk(req);
1213         struct ipv6_opt_hdr *old, *new;
1214         struct sock *sk = sk_to_full_sk(req_to_sk(req));
1215
1216         if (req_inet->ipv6_opt && req_inet->ipv6_opt->hopopt)
1217                 old = req_inet->ipv6_opt->hopopt;
1218         else
1219                 old = NULL;
1220
1221         new = calipso_opt_insert(old, doi_def, secattr);
1222         if (IS_ERR(new))
1223                 return PTR_ERR(new);
1224
1225         txopts = ipv6_renew_options_kern(sk, req_inet->ipv6_opt, IPV6_HOPOPTS,
1226                                          new, new ? ipv6_optlen(new) : 0);
1227
1228         kfree(new);
1229
1230         if (IS_ERR(txopts))
1231                 return PTR_ERR(txopts);
1232
1233         txopts = xchg(&req_inet->ipv6_opt, txopts);
1234         if (txopts) {
1235                 atomic_sub(txopts->tot_len, &sk->sk_omem_alloc);
1236                 txopt_put(txopts);
1237         }
1238
1239         return 0;
1240 }
1241
1242 /**
1243  * calipso_req_delattr - Delete the CALIPSO option from a request socket
1244  * @reg: the request socket
1245  *
1246  * Description:
1247  * Removes the CALIPSO option from a request socket, if present.
1248  *
1249  */
1250 static void calipso_req_delattr(struct request_sock *req)
1251 {
1252         struct inet_request_sock *req_inet = inet_rsk(req);
1253         struct ipv6_opt_hdr *new;
1254         struct ipv6_txoptions *txopts;
1255         struct sock *sk = sk_to_full_sk(req_to_sk(req));
1256
1257         if (!req_inet->ipv6_opt || !req_inet->ipv6_opt->hopopt)
1258                 return;
1259
1260         if (calipso_opt_del(req_inet->ipv6_opt->hopopt, &new))
1261                 return; /* Nothing to do */
1262
1263         txopts = ipv6_renew_options_kern(sk, req_inet->ipv6_opt, IPV6_HOPOPTS,
1264                                          new, new ? ipv6_optlen(new) : 0);
1265
1266         if (!IS_ERR(txopts)) {
1267                 txopts = xchg(&req_inet->ipv6_opt, txopts);
1268                 if (txopts) {
1269                         atomic_sub(txopts->tot_len, &sk->sk_omem_alloc);
1270                         txopt_put(txopts);
1271                 }
1272         }
1273         kfree(new);
1274 }
1275
1276 /* skbuff functions.
1277  */
1278
1279 /**
1280  * calipso_skbuff_optptr - Find the CALIPSO option in the packet
1281  * @skb: the packet
1282  *
1283  * Description:
1284  * Parse the packet's IP header looking for a CALIPSO option.  Returns a pointer
1285  * to the start of the CALIPSO option on success, NULL if one if not found.
1286  *
1287  */
1288 static unsigned char *calipso_skbuff_optptr(const struct sk_buff *skb)
1289 {
1290         const struct ipv6hdr *ip6_hdr = ipv6_hdr(skb);
1291         int offset;
1292
1293         if (ip6_hdr->nexthdr != NEXTHDR_HOP)
1294                 return NULL;
1295
1296         offset = ipv6_find_tlv(skb, sizeof(*ip6_hdr), IPV6_TLV_CALIPSO);
1297         if (offset >= 0)
1298                 return (unsigned char *)ip6_hdr + offset;
1299
1300         return NULL;
1301 }
1302
1303 /**
1304  * calipso_skbuff_setattr - Set the CALIPSO option on a packet
1305  * @skb: the packet
1306  * @doi_def: the CALIPSO DOI to use
1307  * @secattr: the security attributes
1308  *
1309  * Description:
1310  * Set the CALIPSO option on the given packet based on the security attributes.
1311  * Returns a pointer to the IP header on success and NULL on failure.
1312  *
1313  */
1314 static int calipso_skbuff_setattr(struct sk_buff *skb,
1315                                   const struct calipso_doi *doi_def,
1316                                   const struct netlbl_lsm_secattr *secattr)
1317 {
1318         int ret_val;
1319         struct ipv6hdr *ip6_hdr;
1320         struct ipv6_opt_hdr *hop;
1321         unsigned char buf[CALIPSO_MAX_BUFFER];
1322         int len_delta, new_end, pad;
1323         unsigned int start, end;
1324
1325         ip6_hdr = ipv6_hdr(skb);
1326         if (ip6_hdr->nexthdr == NEXTHDR_HOP) {
1327                 hop = (struct ipv6_opt_hdr *)(ip6_hdr + 1);
1328                 ret_val = calipso_opt_find(hop, &start, &end);
1329                 if (ret_val && ret_val != -ENOENT)
1330                         return ret_val;
1331         } else {
1332                 start = 0;
1333                 end = 0;
1334         }
1335
1336         memset(buf, 0, sizeof(buf));
1337         ret_val = calipso_genopt(buf, start & 3, sizeof(buf), doi_def, secattr);
1338         if (ret_val < 0)
1339                 return ret_val;
1340
1341         new_end = start + ret_val;
1342         /* At this point new_end aligns to 4n, so (new_end & 4) pads to 8n */
1343         pad = ((new_end & 4) + (end & 7)) & 7;
1344         len_delta = new_end - (int)end + pad;
1345         ret_val = skb_cow(skb, skb_headroom(skb) + len_delta);
1346         if (ret_val < 0)
1347                 return ret_val;
1348
1349         if (len_delta) {
1350                 if (len_delta > 0)
1351                         skb_push(skb, len_delta);
1352                 else
1353                         skb_pull(skb, -len_delta);
1354                 memmove((char *)ip6_hdr - len_delta, ip6_hdr,
1355                         sizeof(*ip6_hdr) + start);
1356                 skb_reset_network_header(skb);
1357                 ip6_hdr = ipv6_hdr(skb);
1358         }
1359
1360         hop = (struct ipv6_opt_hdr *)(ip6_hdr + 1);
1361         if (start == 0) {
1362                 struct ipv6_opt_hdr *new_hop = (struct ipv6_opt_hdr *)buf;
1363
1364                 new_hop->nexthdr = ip6_hdr->nexthdr;
1365                 new_hop->hdrlen = len_delta / 8 - 1;
1366                 ip6_hdr->nexthdr = NEXTHDR_HOP;
1367         } else {
1368                 hop->hdrlen += len_delta / 8;
1369         }
1370         memcpy((char *)hop + start, buf + (start & 3), new_end - start);
1371         calipso_pad_write((unsigned char *)hop, new_end, pad);
1372
1373         return 0;
1374 }
1375
1376 /**
1377  * calipso_skbuff_delattr - Delete any CALIPSO options from a packet
1378  * @skb: the packet
1379  *
1380  * Description:
1381  * Removes any and all CALIPSO options from the given packet.  Returns zero on
1382  * success, negative values on failure.
1383  *
1384  */
1385 static int calipso_skbuff_delattr(struct sk_buff *skb)
1386 {
1387         int ret_val;
1388         struct ipv6hdr *ip6_hdr;
1389         struct ipv6_opt_hdr *old_hop;
1390         u32 old_hop_len, start = 0, end = 0, delta, size, pad;
1391
1392         if (!calipso_skbuff_optptr(skb))
1393                 return 0;
1394
1395         /* since we are changing the packet we should make a copy */
1396         ret_val = skb_cow(skb, skb_headroom(skb));
1397         if (ret_val < 0)
1398                 return ret_val;
1399
1400         ip6_hdr = ipv6_hdr(skb);
1401         old_hop = (struct ipv6_opt_hdr *)(ip6_hdr + 1);
1402         old_hop_len = ipv6_optlen(old_hop);
1403
1404         ret_val = calipso_opt_find(old_hop, &start, &end);
1405         if (ret_val)
1406                 return ret_val;
1407
1408         if (start == sizeof(*old_hop) && end == old_hop_len) {
1409                 /* There's no other option in the header so we delete
1410                  * the whole thing. */
1411                 delta = old_hop_len;
1412                 size = sizeof(*ip6_hdr);
1413                 ip6_hdr->nexthdr = old_hop->nexthdr;
1414         } else {
1415                 delta = (end - start) & ~7;
1416                 if (delta)
1417                         old_hop->hdrlen -= delta / 8;
1418                 pad = (end - start) & 7;
1419                 size = sizeof(*ip6_hdr) + start + pad;
1420                 calipso_pad_write((unsigned char *)old_hop, start, pad);
1421         }
1422
1423         if (delta) {
1424                 skb_pull(skb, delta);
1425                 memmove((char *)ip6_hdr + delta, ip6_hdr, size);
1426                 skb_reset_network_header(skb);
1427         }
1428
1429         return 0;
1430 }
1431
1432 static const struct netlbl_calipso_ops ops = {
1433         .doi_add          = calipso_doi_add,
1434         .doi_free         = calipso_doi_free,
1435         .doi_remove       = calipso_doi_remove,
1436         .doi_getdef       = calipso_doi_getdef,
1437         .doi_putdef       = calipso_doi_putdef,
1438         .doi_walk         = calipso_doi_walk,
1439         .sock_getattr     = calipso_sock_getattr,
1440         .sock_setattr     = calipso_sock_setattr,
1441         .sock_delattr     = calipso_sock_delattr,
1442         .req_setattr      = calipso_req_setattr,
1443         .req_delattr      = calipso_req_delattr,
1444         .opt_getattr      = calipso_opt_getattr,
1445         .skbuff_optptr    = calipso_skbuff_optptr,
1446         .skbuff_setattr   = calipso_skbuff_setattr,
1447         .skbuff_delattr   = calipso_skbuff_delattr,
1448         .cache_invalidate = calipso_cache_invalidate,
1449         .cache_add        = calipso_cache_add
1450 };
1451
1452 /**
1453  * calipso_init - Initialize the CALIPSO module
1454  *
1455  * Description:
1456  * Initialize the CALIPSO module and prepare it for use.  Returns zero on
1457  * success and negative values on failure.
1458  *
1459  */
1460 int __init calipso_init(void)
1461 {
1462         int ret_val;
1463
1464         ret_val = calipso_cache_init();
1465         if (!ret_val)
1466                 netlbl_calipso_ops_register(&ops);
1467         return ret_val;
1468 }
1469
1470 void calipso_exit(void)
1471 {
1472         netlbl_calipso_ops_register(NULL);
1473         calipso_cache_invalidate();
1474         kfree(calipso_cache);
1475 }