Branch data Line data Source code
1 : : /*
2 : : * NetLabel System
3 : : *
4 : : * The NetLabel system manages static and dynamic label mappings for network
5 : : * protocols such as CIPSO and RIPSO.
6 : : *
7 : : * Author: Paul Moore <paul@paul-moore.com>
8 : : *
9 : : */
10 : :
11 : : /*
12 : : * (c) Copyright Hewlett-Packard Development Company, L.P., 2006, 2008
13 : : *
14 : : * This program is free software; you can redistribute it and/or modify
15 : : * it under the terms of the GNU General Public License as published by
16 : : * the Free Software Foundation; either version 2 of the License, or
17 : : * (at your option) any later version.
18 : : *
19 : : * This program is distributed in the hope that it will be useful,
20 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
22 : : * the GNU General Public License for more details.
23 : : *
24 : : * You should have received a copy of the GNU General Public License
25 : : * along with this program; if not, see <http://www.gnu.org/licenses/>.
26 : : *
27 : : */
28 : :
29 : : #ifndef _NETLABEL_H
30 : : #define _NETLABEL_H
31 : :
32 : : #include <linux/types.h>
33 : : #include <linux/slab.h>
34 : : #include <linux/net.h>
35 : : #include <linux/skbuff.h>
36 : : #include <linux/in.h>
37 : : #include <linux/in6.h>
38 : : #include <net/netlink.h>
39 : : #include <net/request_sock.h>
40 : : #include <linux/atomic.h>
41 : :
42 : : struct cipso_v4_doi;
43 : :
44 : : /*
45 : : * NetLabel - A management interface for maintaining network packet label
46 : : * mapping tables for explicit packet labling protocols.
47 : : *
48 : : * Network protocols such as CIPSO and RIPSO require a label translation layer
49 : : * to convert the label on the packet into something meaningful on the host
50 : : * machine. In the current Linux implementation these mapping tables live
51 : : * inside the kernel; NetLabel provides a mechanism for user space applications
52 : : * to manage these mapping tables.
53 : : *
54 : : * NetLabel makes use of the Generic NETLINK mechanism as a transport layer to
55 : : * send messages between kernel and user space. The general format of a
56 : : * NetLabel message is shown below:
57 : : *
58 : : * +-----------------+-------------------+--------- --- -- -
59 : : * | struct nlmsghdr | struct genlmsghdr | payload
60 : : * +-----------------+-------------------+--------- --- -- -
61 : : *
62 : : * The 'nlmsghdr' and 'genlmsghdr' structs should be dealt with like normal.
63 : : * The payload is dependent on the subsystem specified in the
64 : : * 'nlmsghdr->nlmsg_type' and should be defined below, supporting functions
65 : : * should be defined in the corresponding net/netlabel/netlabel_<subsys>.h|c
66 : : * file. All of the fields in the NetLabel payload are NETLINK attributes, see
67 : : * the include/net/netlink.h file for more information on NETLINK attributes.
68 : : *
69 : : */
70 : :
71 : : /*
72 : : * NetLabel NETLINK protocol
73 : : */
74 : :
75 : : /* NetLabel NETLINK protocol version
76 : : * 1: initial version
77 : : * 2: added static labels for unlabeled connections
78 : : * 3: network selectors added to the NetLabel/LSM domain mapping and the
79 : : * CIPSO_V4_MAP_LOCAL CIPSO mapping was added
80 : : */
81 : : #define NETLBL_PROTO_VERSION 3
82 : :
83 : : /* NetLabel NETLINK types/families */
84 : : #define NETLBL_NLTYPE_NONE 0
85 : : #define NETLBL_NLTYPE_MGMT 1
86 : : #define NETLBL_NLTYPE_MGMT_NAME "NLBL_MGMT"
87 : : #define NETLBL_NLTYPE_RIPSO 2
88 : : #define NETLBL_NLTYPE_RIPSO_NAME "NLBL_RIPSO"
89 : : #define NETLBL_NLTYPE_CIPSOV4 3
90 : : #define NETLBL_NLTYPE_CIPSOV4_NAME "NLBL_CIPSOv4"
91 : : #define NETLBL_NLTYPE_CIPSOV6 4
92 : : #define NETLBL_NLTYPE_CIPSOV6_NAME "NLBL_CIPSOv6"
93 : : #define NETLBL_NLTYPE_UNLABELED 5
94 : : #define NETLBL_NLTYPE_UNLABELED_NAME "NLBL_UNLBL"
95 : : #define NETLBL_NLTYPE_ADDRSELECT 6
96 : : #define NETLBL_NLTYPE_ADDRSELECT_NAME "NLBL_ADRSEL"
97 : :
98 : : /*
99 : : * NetLabel - Kernel API for accessing the network packet label mappings.
100 : : *
101 : : * The following functions are provided for use by other kernel modules,
102 : : * specifically kernel LSM modules, to provide a consistent, transparent API
103 : : * for dealing with explicit packet labeling protocols such as CIPSO and
104 : : * RIPSO. The functions defined here are implemented in the
105 : : * net/netlabel/netlabel_kapi.c file.
106 : : *
107 : : */
108 : :
109 : : /* NetLabel audit information */
110 : : struct netlbl_audit {
111 : : u32 secid;
112 : : kuid_t loginuid;
113 : : unsigned int sessionid;
114 : : };
115 : :
116 : : /*
117 : : * LSM security attributes
118 : : */
119 : :
120 : : /**
121 : : * struct netlbl_lsm_cache - NetLabel LSM security attribute cache
122 : : * @refcount: atomic reference counter
123 : : * @free: LSM supplied function to free the cache data
124 : : * @data: LSM supplied cache data
125 : : *
126 : : * Description:
127 : : * This structure is provided for LSMs which wish to make use of the NetLabel
128 : : * caching mechanism to store LSM specific data/attributes in the NetLabel
129 : : * cache. If the LSM has to perform a lot of translation from the NetLabel
130 : : * security attributes into it's own internal representation then the cache
131 : : * mechanism can provide a way to eliminate some or all of that translation
132 : : * overhead on a cache hit.
133 : : *
134 : : */
135 : : struct netlbl_lsm_cache {
136 : : atomic_t refcount;
137 : : void (*free) (const void *data);
138 : : void *data;
139 : : };
140 : :
141 : : /**
142 : : * struct netlbl_lsm_secattr_catmap - NetLabel LSM secattr category bitmap
143 : : * @startbit: the value of the lowest order bit in the bitmap
144 : : * @bitmap: the category bitmap
145 : : * @next: pointer to the next bitmap "node" or NULL
146 : : *
147 : : * Description:
148 : : * This structure is used to represent category bitmaps. Due to the large
149 : : * number of categories supported by most labeling protocols it is not
150 : : * practical to transfer a full bitmap internally so NetLabel adopts a sparse
151 : : * bitmap structure modeled after SELinux's ebitmap structure.
152 : : * The catmap bitmap field MUST be a power of two in length and large
153 : : * enough to hold at least 240 bits. Special care (i.e. check the code!)
154 : : * should be used when changing these values as the LSM implementation
155 : : * probably has functions which rely on the sizes of these types to speed
156 : : * processing.
157 : : *
158 : : */
159 : : #define NETLBL_CATMAP_MAPTYPE u64
160 : : #define NETLBL_CATMAP_MAPCNT 4
161 : : #define NETLBL_CATMAP_MAPSIZE (sizeof(NETLBL_CATMAP_MAPTYPE) * 8)
162 : : #define NETLBL_CATMAP_SIZE (NETLBL_CATMAP_MAPSIZE * \
163 : : NETLBL_CATMAP_MAPCNT)
164 : : #define NETLBL_CATMAP_BIT (NETLBL_CATMAP_MAPTYPE)0x01
165 : : struct netlbl_lsm_secattr_catmap {
166 : : u32 startbit;
167 : : NETLBL_CATMAP_MAPTYPE bitmap[NETLBL_CATMAP_MAPCNT];
168 : : struct netlbl_lsm_secattr_catmap *next;
169 : : };
170 : :
171 : : /**
172 : : * struct netlbl_lsm_secattr - NetLabel LSM security attributes
173 : : * @flags: indicate structure attributes, see NETLBL_SECATTR_*
174 : : * @type: indicate the NLTYPE of the attributes
175 : : * @domain: the NetLabel LSM domain
176 : : * @cache: NetLabel LSM specific cache
177 : : * @attr.mls: MLS sensitivity label
178 : : * @attr.mls.cat: MLS category bitmap
179 : : * @attr.mls.lvl: MLS sensitivity level
180 : : * @attr.secid: LSM specific secid token
181 : : *
182 : : * Description:
183 : : * This structure is used to pass security attributes between NetLabel and the
184 : : * LSM modules. The flags field is used to specify which fields within the
185 : : * struct are valid and valid values can be created by bitwise OR'ing the
186 : : * NETLBL_SECATTR_* defines. The domain field is typically set by the LSM to
187 : : * specify domain specific configuration settings and is not usually used by
188 : : * NetLabel itself when returning security attributes to the LSM.
189 : : *
190 : : */
191 : : struct netlbl_lsm_secattr {
192 : : u32 flags;
193 : : /* bitmap values for 'flags' */
194 : : #define NETLBL_SECATTR_NONE 0x00000000
195 : : #define NETLBL_SECATTR_DOMAIN 0x00000001
196 : : #define NETLBL_SECATTR_DOMAIN_CPY (NETLBL_SECATTR_DOMAIN | \
197 : : NETLBL_SECATTR_FREE_DOMAIN)
198 : : #define NETLBL_SECATTR_CACHE 0x00000002
199 : : #define NETLBL_SECATTR_MLS_LVL 0x00000004
200 : : #define NETLBL_SECATTR_MLS_CAT 0x00000008
201 : : #define NETLBL_SECATTR_SECID 0x00000010
202 : : /* bitmap meta-values for 'flags' */
203 : : #define NETLBL_SECATTR_FREE_DOMAIN 0x01000000
204 : : #define NETLBL_SECATTR_CACHEABLE (NETLBL_SECATTR_MLS_LVL | \
205 : : NETLBL_SECATTR_MLS_CAT | \
206 : : NETLBL_SECATTR_SECID)
207 : : u32 type;
208 : : char *domain;
209 : : struct netlbl_lsm_cache *cache;
210 : : struct {
211 : : struct {
212 : : struct netlbl_lsm_secattr_catmap *cat;
213 : : u32 lvl;
214 : : } mls;
215 : : u32 secid;
216 : : } attr;
217 : : };
218 : :
219 : : /*
220 : : * LSM security attribute operations (inline)
221 : : */
222 : :
223 : : /**
224 : : * netlbl_secattr_cache_alloc - Allocate and initialize a secattr cache
225 : : * @flags: the memory allocation flags
226 : : *
227 : : * Description:
228 : : * Allocate and initialize a netlbl_lsm_cache structure. Returns a pointer
229 : : * on success, NULL on failure.
230 : : *
231 : : */
232 : : static inline struct netlbl_lsm_cache *netlbl_secattr_cache_alloc(gfp_t flags)
233 : : {
234 : : struct netlbl_lsm_cache *cache;
235 : :
236 : : cache = kzalloc(sizeof(*cache), flags);
237 [ # # ]: 0 : if (cache)
238 : 0 : atomic_set(&cache->refcount, 1);
239 : : return cache;
240 : : }
241 : :
242 : : /**
243 : : * netlbl_secattr_cache_free - Frees a netlbl_lsm_cache struct
244 : : * @cache: the struct to free
245 : : *
246 : : * Description:
247 : : * Frees @secattr including all of the internal buffers.
248 : : *
249 : : */
250 : : static inline void netlbl_secattr_cache_free(struct netlbl_lsm_cache *cache)
251 : : {
252 [ # # # # : 0 : if (!atomic_dec_and_test(&cache->refcount))
# # # # #
# # # #
# ]
253 : : return;
254 : :
255 [ # # ][ # # ]: 0 : if (cache->free)
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
256 : 0 : cache->free(cache->data);
257 : 0 : kfree(cache);
258 : : }
259 : :
260 : : /**
261 : : * netlbl_secattr_catmap_alloc - Allocate a LSM secattr catmap
262 : : * @flags: memory allocation flags
263 : : *
264 : : * Description:
265 : : * Allocate memory for a LSM secattr catmap, returns a pointer on success, NULL
266 : : * on failure.
267 : : *
268 : : */
269 : : static inline struct netlbl_lsm_secattr_catmap *netlbl_secattr_catmap_alloc(
270 : : gfp_t flags)
271 : : {
272 : : return kzalloc(sizeof(struct netlbl_lsm_secattr_catmap), flags);
273 : : }
274 : :
275 : : /**
276 : : * netlbl_secattr_catmap_free - Free a LSM secattr catmap
277 : : * @catmap: the category bitmap
278 : : *
279 : : * Description:
280 : : * Free a LSM secattr catmap.
281 : : *
282 : : */
283 : : static inline void netlbl_secattr_catmap_free(
284 : : struct netlbl_lsm_secattr_catmap *catmap)
285 : : {
286 : : struct netlbl_lsm_secattr_catmap *iter;
287 : :
288 : : do {
289 : : iter = catmap;
290 : 0 : catmap = catmap->next;
291 : 0 : kfree(iter);
292 [ # # ][ # # ]: 0 : } while (catmap);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
293 : : }
294 : :
295 : : /**
296 : : * netlbl_secattr_init - Initialize a netlbl_lsm_secattr struct
297 : : * @secattr: the struct to initialize
298 : : *
299 : : * Description:
300 : : * Initialize an already allocated netlbl_lsm_secattr struct.
301 : : *
302 : : */
303 : : static inline void netlbl_secattr_init(struct netlbl_lsm_secattr *secattr)
304 : : {
305 : 0 : memset(secattr, 0, sizeof(*secattr));
306 : : }
307 : :
308 : : /**
309 : : * netlbl_secattr_destroy - Clears a netlbl_lsm_secattr struct
310 : : * @secattr: the struct to clear
311 : : *
312 : : * Description:
313 : : * Destroys the @secattr struct, including freeing all of the internal buffers.
314 : : * The struct must be reset with a call to netlbl_secattr_init() before reuse.
315 : : *
316 : : */
317 : : static inline void netlbl_secattr_destroy(struct netlbl_lsm_secattr *secattr)
318 : : {
319 [ # # ][ # # ]: 0 : if (secattr->flags & NETLBL_SECATTR_FREE_DOMAIN)
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
320 : 0 : kfree(secattr->domain);
321 [ # # ][ # # ]: 0 : if (secattr->flags & NETLBL_SECATTR_CACHE)
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
322 : 0 : netlbl_secattr_cache_free(secattr->cache);
323 [ # # ][ # # ]: 0 : if (secattr->flags & NETLBL_SECATTR_MLS_CAT)
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
324 : 0 : netlbl_secattr_catmap_free(secattr->attr.mls.cat);
325 : : }
326 : :
327 : : /**
328 : : * netlbl_secattr_alloc - Allocate and initialize a netlbl_lsm_secattr struct
329 : : * @flags: the memory allocation flags
330 : : *
331 : : * Description:
332 : : * Allocate and initialize a netlbl_lsm_secattr struct. Returns a valid
333 : : * pointer on success, or NULL on failure.
334 : : *
335 : : */
336 : : static inline struct netlbl_lsm_secattr *netlbl_secattr_alloc(gfp_t flags)
337 : : {
338 : : return kzalloc(sizeof(struct netlbl_lsm_secattr), flags);
339 : : }
340 : :
341 : : /**
342 : : * netlbl_secattr_free - Frees a netlbl_lsm_secattr struct
343 : : * @secattr: the struct to free
344 : : *
345 : : * Description:
346 : : * Frees @secattr including all of the internal buffers.
347 : : *
348 : : */
349 : : static inline void netlbl_secattr_free(struct netlbl_lsm_secattr *secattr)
350 : : {
351 : : netlbl_secattr_destroy(secattr);
352 : 0 : kfree(secattr);
353 : : }
354 : :
355 : : #ifdef CONFIG_NETLABEL
356 : : /*
357 : : * LSM configuration operations
358 : : */
359 : : int netlbl_cfg_map_del(const char *domain,
360 : : u16 family,
361 : : const void *addr,
362 : : const void *mask,
363 : : struct netlbl_audit *audit_info);
364 : : int netlbl_cfg_unlbl_map_add(const char *domain,
365 : : u16 family,
366 : : const void *addr,
367 : : const void *mask,
368 : : struct netlbl_audit *audit_info);
369 : : int netlbl_cfg_unlbl_static_add(struct net *net,
370 : : const char *dev_name,
371 : : const void *addr,
372 : : const void *mask,
373 : : u16 family,
374 : : u32 secid,
375 : : struct netlbl_audit *audit_info);
376 : : int netlbl_cfg_unlbl_static_del(struct net *net,
377 : : const char *dev_name,
378 : : const void *addr,
379 : : const void *mask,
380 : : u16 family,
381 : : struct netlbl_audit *audit_info);
382 : : int netlbl_cfg_cipsov4_add(struct cipso_v4_doi *doi_def,
383 : : struct netlbl_audit *audit_info);
384 : : void netlbl_cfg_cipsov4_del(u32 doi, struct netlbl_audit *audit_info);
385 : : int netlbl_cfg_cipsov4_map_add(u32 doi,
386 : : const char *domain,
387 : : const struct in_addr *addr,
388 : : const struct in_addr *mask,
389 : : struct netlbl_audit *audit_info);
390 : : /*
391 : : * LSM security attribute operations
392 : : */
393 : : int netlbl_secattr_catmap_walk(struct netlbl_lsm_secattr_catmap *catmap,
394 : : u32 offset);
395 : : int netlbl_secattr_catmap_walk_rng(struct netlbl_lsm_secattr_catmap *catmap,
396 : : u32 offset);
397 : : int netlbl_secattr_catmap_setbit(struct netlbl_lsm_secattr_catmap *catmap,
398 : : u32 bit,
399 : : gfp_t flags);
400 : : int netlbl_secattr_catmap_setrng(struct netlbl_lsm_secattr_catmap *catmap,
401 : : u32 start,
402 : : u32 end,
403 : : gfp_t flags);
404 : :
405 : : /*
406 : : * LSM protocol operations (NetLabel LSM/kernel API)
407 : : */
408 : : int netlbl_enabled(void);
409 : : int netlbl_sock_setattr(struct sock *sk,
410 : : u16 family,
411 : : const struct netlbl_lsm_secattr *secattr);
412 : : void netlbl_sock_delattr(struct sock *sk);
413 : : int netlbl_sock_getattr(struct sock *sk,
414 : : struct netlbl_lsm_secattr *secattr);
415 : : int netlbl_conn_setattr(struct sock *sk,
416 : : struct sockaddr *addr,
417 : : const struct netlbl_lsm_secattr *secattr);
418 : : int netlbl_req_setattr(struct request_sock *req,
419 : : const struct netlbl_lsm_secattr *secattr);
420 : : void netlbl_req_delattr(struct request_sock *req);
421 : : int netlbl_skbuff_setattr(struct sk_buff *skb,
422 : : u16 family,
423 : : const struct netlbl_lsm_secattr *secattr);
424 : : int netlbl_skbuff_getattr(const struct sk_buff *skb,
425 : : u16 family,
426 : : struct netlbl_lsm_secattr *secattr);
427 : : void netlbl_skbuff_err(struct sk_buff *skb, int error, int gateway);
428 : :
429 : : /*
430 : : * LSM label mapping cache operations
431 : : */
432 : : void netlbl_cache_invalidate(void);
433 : : int netlbl_cache_add(const struct sk_buff *skb,
434 : : const struct netlbl_lsm_secattr *secattr);
435 : :
436 : : /*
437 : : * Protocol engine operations
438 : : */
439 : : struct audit_buffer *netlbl_audit_start(int type,
440 : : struct netlbl_audit *audit_info);
441 : : #else
442 : : static inline int netlbl_cfg_map_del(const char *domain,
443 : : u16 family,
444 : : const void *addr,
445 : : const void *mask,
446 : : struct netlbl_audit *audit_info)
447 : : {
448 : : return -ENOSYS;
449 : : }
450 : : static inline int netlbl_cfg_unlbl_map_add(const char *domain,
451 : : u16 family,
452 : : void *addr,
453 : : void *mask,
454 : : struct netlbl_audit *audit_info)
455 : : {
456 : : return -ENOSYS;
457 : : }
458 : : static inline int netlbl_cfg_unlbl_static_add(struct net *net,
459 : : const char *dev_name,
460 : : const void *addr,
461 : : const void *mask,
462 : : u16 family,
463 : : u32 secid,
464 : : struct netlbl_audit *audit_info)
465 : : {
466 : : return -ENOSYS;
467 : : }
468 : : static inline int netlbl_cfg_unlbl_static_del(struct net *net,
469 : : const char *dev_name,
470 : : const void *addr,
471 : : const void *mask,
472 : : u16 family,
473 : : struct netlbl_audit *audit_info)
474 : : {
475 : : return -ENOSYS;
476 : : }
477 : : static inline int netlbl_cfg_cipsov4_add(struct cipso_v4_doi *doi_def,
478 : : struct netlbl_audit *audit_info)
479 : : {
480 : : return -ENOSYS;
481 : : }
482 : : static inline void netlbl_cfg_cipsov4_del(u32 doi,
483 : : struct netlbl_audit *audit_info)
484 : : {
485 : : return;
486 : : }
487 : : static inline int netlbl_cfg_cipsov4_map_add(u32 doi,
488 : : const char *domain,
489 : : const struct in_addr *addr,
490 : : const struct in_addr *mask,
491 : : struct netlbl_audit *audit_info)
492 : : {
493 : : return -ENOSYS;
494 : : }
495 : : static inline int netlbl_secattr_catmap_walk(
496 : : struct netlbl_lsm_secattr_catmap *catmap,
497 : : u32 offset)
498 : : {
499 : : return -ENOENT;
500 : : }
501 : : static inline int netlbl_secattr_catmap_walk_rng(
502 : : struct netlbl_lsm_secattr_catmap *catmap,
503 : : u32 offset)
504 : : {
505 : : return -ENOENT;
506 : : }
507 : : static inline int netlbl_secattr_catmap_setbit(
508 : : struct netlbl_lsm_secattr_catmap *catmap,
509 : : u32 bit,
510 : : gfp_t flags)
511 : : {
512 : : return 0;
513 : : }
514 : : static inline int netlbl_secattr_catmap_setrng(
515 : : struct netlbl_lsm_secattr_catmap *catmap,
516 : : u32 start,
517 : : u32 end,
518 : : gfp_t flags)
519 : : {
520 : : return 0;
521 : : }
522 : : static inline int netlbl_enabled(void)
523 : : {
524 : : return 0;
525 : : }
526 : : static inline int netlbl_sock_setattr(struct sock *sk,
527 : : u16 family,
528 : : const struct netlbl_lsm_secattr *secattr)
529 : : {
530 : : return -ENOSYS;
531 : : }
532 : : static inline void netlbl_sock_delattr(struct sock *sk)
533 : : {
534 : : }
535 : : static inline int netlbl_sock_getattr(struct sock *sk,
536 : : struct netlbl_lsm_secattr *secattr)
537 : : {
538 : : return -ENOSYS;
539 : : }
540 : : static inline int netlbl_conn_setattr(struct sock *sk,
541 : : struct sockaddr *addr,
542 : : const struct netlbl_lsm_secattr *secattr)
543 : : {
544 : : return -ENOSYS;
545 : : }
546 : : static inline int netlbl_req_setattr(struct request_sock *req,
547 : : const struct netlbl_lsm_secattr *secattr)
548 : : {
549 : : return -ENOSYS;
550 : : }
551 : : static inline void netlbl_req_delattr(struct request_sock *req)
552 : : {
553 : : return;
554 : : }
555 : : static inline int netlbl_skbuff_setattr(struct sk_buff *skb,
556 : : u16 family,
557 : : const struct netlbl_lsm_secattr *secattr)
558 : : {
559 : : return -ENOSYS;
560 : : }
561 : : static inline int netlbl_skbuff_getattr(const struct sk_buff *skb,
562 : : u16 family,
563 : : struct netlbl_lsm_secattr *secattr)
564 : : {
565 : : return -ENOSYS;
566 : : }
567 : : static inline void netlbl_skbuff_err(struct sk_buff *skb,
568 : : int error,
569 : : int gateway)
570 : : {
571 : : return;
572 : : }
573 : : static inline void netlbl_cache_invalidate(void)
574 : : {
575 : : return;
576 : : }
577 : : static inline int netlbl_cache_add(const struct sk_buff *skb,
578 : : const struct netlbl_lsm_secattr *secattr)
579 : : {
580 : : return 0;
581 : : }
582 : : static inline struct audit_buffer *netlbl_audit_start(int type,
583 : : struct netlbl_audit *audit_info)
584 : : {
585 : : return NULL;
586 : : }
587 : : #endif /* CONFIG_NETLABEL */
588 : :
589 : : #endif /* _NETLABEL_H */
|
