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