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