net: remove ipv6_addr_copy()
[linux-3.10.git] / net / netlabel / netlabel_kapi.c
1 /*
2  * NetLabel Kernel API
3  *
4  * This file defines the kernel API for the NetLabel system.  The NetLabel
5  * system manages static and dynamic label mappings for network protocols such
6  * as CIPSO and RIPSO.
7  *
8  * Author: Paul Moore <paul@paul-moore.com>
9  *
10  */
11
12 /*
13  * (c) Copyright Hewlett-Packard Development Company, L.P., 2006, 2008
14  *
15  * This program is free software;  you can redistribute it and/or modify
16  * it under the terms of the GNU General Public License as published by
17  * the Free Software Foundation; either version 2 of the License, or
18  * (at your option) any later version.
19  *
20  * This program is distributed in the hope that it will be useful,
21  * but WITHOUT ANY WARRANTY;  without even the implied warranty of
22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
23  * the GNU General Public License for more details.
24  *
25  * You should have received a copy of the GNU General Public License
26  * along with this program;  if not, write to the Free Software
27  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28  *
29  */
30
31 #include <linux/init.h>
32 #include <linux/types.h>
33 #include <linux/slab.h>
34 #include <linux/audit.h>
35 #include <linux/in.h>
36 #include <linux/in6.h>
37 #include <net/ip.h>
38 #include <net/ipv6.h>
39 #include <net/netlabel.h>
40 #include <net/cipso_ipv4.h>
41 #include <asm/bug.h>
42 #include <linux/atomic.h>
43
44 #include "netlabel_domainhash.h"
45 #include "netlabel_unlabeled.h"
46 #include "netlabel_cipso_v4.h"
47 #include "netlabel_user.h"
48 #include "netlabel_mgmt.h"
49 #include "netlabel_addrlist.h"
50
51 /*
52  * Configuration Functions
53  */
54
55 /**
56  * netlbl_cfg_map_del - Remove a NetLabel/LSM domain mapping
57  * @domain: the domain mapping to remove
58  * @family: address family
59  * @addr: IP address
60  * @mask: IP address mask
61  * @audit_info: NetLabel audit information
62  *
63  * Description:
64  * Removes a NetLabel/LSM domain mapping.  A @domain value of NULL causes the
65  * default domain mapping to be removed.  Returns zero on success, negative
66  * values on failure.
67  *
68  */
69 int netlbl_cfg_map_del(const char *domain,
70                        u16 family,
71                        const void *addr,
72                        const void *mask,
73                        struct netlbl_audit *audit_info)
74 {
75         if (addr == NULL && mask == NULL) {
76                 return netlbl_domhsh_remove(domain, audit_info);
77         } else if (addr != NULL && mask != NULL) {
78                 switch (family) {
79                 case AF_INET:
80                         return netlbl_domhsh_remove_af4(domain, addr, mask,
81                                                         audit_info);
82                 default:
83                         return -EPFNOSUPPORT;
84                 }
85         } else
86                 return -EINVAL;
87 }
88
89 /**
90  * netlbl_cfg_unlbl_map_add - Add a new unlabeled mapping
91  * @domain: the domain mapping to add
92  * @family: address family
93  * @addr: IP address
94  * @mask: IP address mask
95  * @audit_info: NetLabel audit information
96  *
97  * Description:
98  * Adds a new unlabeled NetLabel/LSM domain mapping.  A @domain value of NULL
99  * causes a new default domain mapping to be added.  Returns zero on success,
100  * negative values on failure.
101  *
102  */
103 int netlbl_cfg_unlbl_map_add(const char *domain,
104                              u16 family,
105                              const void *addr,
106                              const void *mask,
107                              struct netlbl_audit *audit_info)
108 {
109         int ret_val = -ENOMEM;
110         struct netlbl_dom_map *entry;
111         struct netlbl_domaddr_map *addrmap = NULL;
112         struct netlbl_domaddr4_map *map4 = NULL;
113         struct netlbl_domaddr6_map *map6 = NULL;
114         const struct in_addr *addr4, *mask4;
115         const struct in6_addr *addr6, *mask6;
116
117         entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
118         if (entry == NULL)
119                 return -ENOMEM;
120         if (domain != NULL) {
121                 entry->domain = kstrdup(domain, GFP_ATOMIC);
122                 if (entry->domain == NULL)
123                         goto cfg_unlbl_map_add_failure;
124         }
125
126         if (addr == NULL && mask == NULL)
127                 entry->type = NETLBL_NLTYPE_UNLABELED;
128         else if (addr != NULL && mask != NULL) {
129                 addrmap = kzalloc(sizeof(*addrmap), GFP_ATOMIC);
130                 if (addrmap == NULL)
131                         goto cfg_unlbl_map_add_failure;
132                 INIT_LIST_HEAD(&addrmap->list4);
133                 INIT_LIST_HEAD(&addrmap->list6);
134
135                 switch (family) {
136                 case AF_INET:
137                         addr4 = addr;
138                         mask4 = mask;
139                         map4 = kzalloc(sizeof(*map4), GFP_ATOMIC);
140                         if (map4 == NULL)
141                                 goto cfg_unlbl_map_add_failure;
142                         map4->type = NETLBL_NLTYPE_UNLABELED;
143                         map4->list.addr = addr4->s_addr & mask4->s_addr;
144                         map4->list.mask = mask4->s_addr;
145                         map4->list.valid = 1;
146                         ret_val = netlbl_af4list_add(&map4->list,
147                                                      &addrmap->list4);
148                         if (ret_val != 0)
149                                 goto cfg_unlbl_map_add_failure;
150                         break;
151                 case AF_INET6:
152                         addr6 = addr;
153                         mask6 = mask;
154                         map6 = kzalloc(sizeof(*map6), GFP_ATOMIC);
155                         if (map6 == NULL)
156                                 goto cfg_unlbl_map_add_failure;
157                         map6->type = NETLBL_NLTYPE_UNLABELED;
158                         map6->list.addr = *addr6;
159                         map6->list.addr.s6_addr32[0] &= mask6->s6_addr32[0];
160                         map6->list.addr.s6_addr32[1] &= mask6->s6_addr32[1];
161                         map6->list.addr.s6_addr32[2] &= mask6->s6_addr32[2];
162                         map6->list.addr.s6_addr32[3] &= mask6->s6_addr32[3];
163                         map6->list.mask = *mask6;
164                         map6->list.valid = 1;
165                         ret_val = netlbl_af4list_add(&map4->list,
166                                                      &addrmap->list4);
167                         if (ret_val != 0)
168                                 goto cfg_unlbl_map_add_failure;
169                         break;
170                 default:
171                         goto cfg_unlbl_map_add_failure;
172                         break;
173                 }
174
175                 entry->type_def.addrsel = addrmap;
176                 entry->type = NETLBL_NLTYPE_ADDRSELECT;
177         } else {
178                 ret_val = -EINVAL;
179                 goto cfg_unlbl_map_add_failure;
180         }
181
182         ret_val = netlbl_domhsh_add(entry, audit_info);
183         if (ret_val != 0)
184                 goto cfg_unlbl_map_add_failure;
185
186         return 0;
187
188 cfg_unlbl_map_add_failure:
189         kfree(entry->domain);
190         kfree(entry);
191         kfree(addrmap);
192         kfree(map4);
193         kfree(map6);
194         return ret_val;
195 }
196
197
198 /**
199  * netlbl_cfg_unlbl_static_add - Adds a new static label
200  * @net: network namespace
201  * @dev_name: interface name
202  * @addr: IP address in network byte order (struct in[6]_addr)
203  * @mask: address mask in network byte order (struct in[6]_addr)
204  * @family: address family
205  * @secid: LSM secid value for the entry
206  * @audit_info: NetLabel audit information
207  *
208  * Description:
209  * Adds a new NetLabel static label to be used when protocol provided labels
210  * are not present on incoming traffic.  If @dev_name is NULL then the default
211  * interface will be used.  Returns zero on success, negative values on failure.
212  *
213  */
214 int netlbl_cfg_unlbl_static_add(struct net *net,
215                                 const char *dev_name,
216                                 const void *addr,
217                                 const void *mask,
218                                 u16 family,
219                                 u32 secid,
220                                 struct netlbl_audit *audit_info)
221 {
222         u32 addr_len;
223
224         switch (family) {
225         case AF_INET:
226                 addr_len = sizeof(struct in_addr);
227                 break;
228         case AF_INET6:
229                 addr_len = sizeof(struct in6_addr);
230                 break;
231         default:
232                 return -EPFNOSUPPORT;
233         }
234
235         return netlbl_unlhsh_add(net,
236                                  dev_name, addr, mask, addr_len,
237                                  secid, audit_info);
238 }
239
240 /**
241  * netlbl_cfg_unlbl_static_del - Removes an existing static label
242  * @net: network namespace
243  * @dev_name: interface name
244  * @addr: IP address in network byte order (struct in[6]_addr)
245  * @mask: address mask in network byte order (struct in[6]_addr)
246  * @family: address family
247  * @secid: LSM secid value for the entry
248  * @audit_info: NetLabel audit information
249  *
250  * Description:
251  * Removes an existing NetLabel static label used when protocol provided labels
252  * are not present on incoming traffic.  If @dev_name is NULL then the default
253  * interface will be used.  Returns zero on success, negative values on failure.
254  *
255  */
256 int netlbl_cfg_unlbl_static_del(struct net *net,
257                                 const char *dev_name,
258                                 const void *addr,
259                                 const void *mask,
260                                 u16 family,
261                                 struct netlbl_audit *audit_info)
262 {
263         u32 addr_len;
264
265         switch (family) {
266         case AF_INET:
267                 addr_len = sizeof(struct in_addr);
268                 break;
269         case AF_INET6:
270                 addr_len = sizeof(struct in6_addr);
271                 break;
272         default:
273                 return -EPFNOSUPPORT;
274         }
275
276         return netlbl_unlhsh_remove(net,
277                                     dev_name, addr, mask, addr_len,
278                                     audit_info);
279 }
280
281 /**
282  * netlbl_cfg_cipsov4_add - Add a new CIPSOv4 DOI definition
283  * @doi_def: CIPSO DOI definition
284  * @audit_info: NetLabel audit information
285  *
286  * Description:
287  * Add a new CIPSO DOI definition as defined by @doi_def.  Returns zero on
288  * success and negative values on failure.
289  *
290  */
291 int netlbl_cfg_cipsov4_add(struct cipso_v4_doi *doi_def,
292                            struct netlbl_audit *audit_info)
293 {
294         return cipso_v4_doi_add(doi_def, audit_info);
295 }
296
297 /**
298  * netlbl_cfg_cipsov4_del - Remove an existing CIPSOv4 DOI definition
299  * @doi: CIPSO DOI
300  * @audit_info: NetLabel audit information
301  *
302  * Description:
303  * Remove an existing CIPSO DOI definition matching @doi.  Returns zero on
304  * success and negative values on failure.
305  *
306  */
307 void netlbl_cfg_cipsov4_del(u32 doi, struct netlbl_audit *audit_info)
308 {
309         cipso_v4_doi_remove(doi, audit_info);
310 }
311
312 /**
313  * netlbl_cfg_cipsov4_map_add - Add a new CIPSOv4 DOI mapping
314  * @doi: the CIPSO DOI
315  * @domain: the domain mapping to add
316  * @addr: IP address
317  * @mask: IP address mask
318  * @audit_info: NetLabel audit information
319  *
320  * Description:
321  * Add a new NetLabel/LSM domain mapping for the given CIPSO DOI to the NetLabel
322  * subsystem.  A @domain value of NULL adds a new default domain mapping.
323  * Returns zero on success, negative values on failure.
324  *
325  */
326 int netlbl_cfg_cipsov4_map_add(u32 doi,
327                                const char *domain,
328                                const struct in_addr *addr,
329                                const struct in_addr *mask,
330                                struct netlbl_audit *audit_info)
331 {
332         int ret_val = -ENOMEM;
333         struct cipso_v4_doi *doi_def;
334         struct netlbl_dom_map *entry;
335         struct netlbl_domaddr_map *addrmap = NULL;
336         struct netlbl_domaddr4_map *addrinfo = NULL;
337
338         doi_def = cipso_v4_doi_getdef(doi);
339         if (doi_def == NULL)
340                 return -ENOENT;
341
342         entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
343         if (entry == NULL)
344                 goto out_entry;
345         if (domain != NULL) {
346                 entry->domain = kstrdup(domain, GFP_ATOMIC);
347                 if (entry->domain == NULL)
348                         goto out_domain;
349         }
350
351         if (addr == NULL && mask == NULL) {
352                 entry->type_def.cipsov4 = doi_def;
353                 entry->type = NETLBL_NLTYPE_CIPSOV4;
354         } else if (addr != NULL && mask != NULL) {
355                 addrmap = kzalloc(sizeof(*addrmap), GFP_ATOMIC);
356                 if (addrmap == NULL)
357                         goto out_addrmap;
358                 INIT_LIST_HEAD(&addrmap->list4);
359                 INIT_LIST_HEAD(&addrmap->list6);
360
361                 addrinfo = kzalloc(sizeof(*addrinfo), GFP_ATOMIC);
362                 if (addrinfo == NULL)
363                         goto out_addrinfo;
364                 addrinfo->type_def.cipsov4 = doi_def;
365                 addrinfo->type = NETLBL_NLTYPE_CIPSOV4;
366                 addrinfo->list.addr = addr->s_addr & mask->s_addr;
367                 addrinfo->list.mask = mask->s_addr;
368                 addrinfo->list.valid = 1;
369                 ret_val = netlbl_af4list_add(&addrinfo->list, &addrmap->list4);
370                 if (ret_val != 0)
371                         goto cfg_cipsov4_map_add_failure;
372
373                 entry->type_def.addrsel = addrmap;
374                 entry->type = NETLBL_NLTYPE_ADDRSELECT;
375         } else {
376                 ret_val = -EINVAL;
377                 goto out_addrmap;
378         }
379
380         ret_val = netlbl_domhsh_add(entry, audit_info);
381         if (ret_val != 0)
382                 goto cfg_cipsov4_map_add_failure;
383
384         return 0;
385
386 cfg_cipsov4_map_add_failure:
387         kfree(addrinfo);
388 out_addrinfo:
389         kfree(addrmap);
390 out_addrmap:
391         kfree(entry->domain);
392 out_domain:
393         kfree(entry);
394 out_entry:
395         cipso_v4_doi_putdef(doi_def);
396         return ret_val;
397 }
398
399 /*
400  * Security Attribute Functions
401  */
402
403 /**
404  * netlbl_secattr_catmap_walk - Walk a LSM secattr catmap looking for a bit
405  * @catmap: the category bitmap
406  * @offset: the offset to start searching at, in bits
407  *
408  * Description:
409  * This function walks a LSM secattr category bitmap starting at @offset and
410  * returns the spot of the first set bit or -ENOENT if no bits are set.
411  *
412  */
413 int netlbl_secattr_catmap_walk(struct netlbl_lsm_secattr_catmap *catmap,
414                                u32 offset)
415 {
416         struct netlbl_lsm_secattr_catmap *iter = catmap;
417         u32 node_idx;
418         u32 node_bit;
419         NETLBL_CATMAP_MAPTYPE bitmap;
420
421         if (offset > iter->startbit) {
422                 while (offset >= (iter->startbit + NETLBL_CATMAP_SIZE)) {
423                         iter = iter->next;
424                         if (iter == NULL)
425                                 return -ENOENT;
426                 }
427                 node_idx = (offset - iter->startbit) / NETLBL_CATMAP_MAPSIZE;
428                 node_bit = offset - iter->startbit -
429                            (NETLBL_CATMAP_MAPSIZE * node_idx);
430         } else {
431                 node_idx = 0;
432                 node_bit = 0;
433         }
434         bitmap = iter->bitmap[node_idx] >> node_bit;
435
436         for (;;) {
437                 if (bitmap != 0) {
438                         while ((bitmap & NETLBL_CATMAP_BIT) == 0) {
439                                 bitmap >>= 1;
440                                 node_bit++;
441                         }
442                         return iter->startbit +
443                                 (NETLBL_CATMAP_MAPSIZE * node_idx) + node_bit;
444                 }
445                 if (++node_idx >= NETLBL_CATMAP_MAPCNT) {
446                         if (iter->next != NULL) {
447                                 iter = iter->next;
448                                 node_idx = 0;
449                         } else
450                                 return -ENOENT;
451                 }
452                 bitmap = iter->bitmap[node_idx];
453                 node_bit = 0;
454         }
455
456         return -ENOENT;
457 }
458
459 /**
460  * netlbl_secattr_catmap_walk_rng - Find the end of a string of set bits
461  * @catmap: the category bitmap
462  * @offset: the offset to start searching at, in bits
463  *
464  * Description:
465  * This function walks a LSM secattr category bitmap starting at @offset and
466  * returns the spot of the first cleared bit or -ENOENT if the offset is past
467  * the end of the bitmap.
468  *
469  */
470 int netlbl_secattr_catmap_walk_rng(struct netlbl_lsm_secattr_catmap *catmap,
471                                    u32 offset)
472 {
473         struct netlbl_lsm_secattr_catmap *iter = catmap;
474         u32 node_idx;
475         u32 node_bit;
476         NETLBL_CATMAP_MAPTYPE bitmask;
477         NETLBL_CATMAP_MAPTYPE bitmap;
478
479         if (offset > iter->startbit) {
480                 while (offset >= (iter->startbit + NETLBL_CATMAP_SIZE)) {
481                         iter = iter->next;
482                         if (iter == NULL)
483                                 return -ENOENT;
484                 }
485                 node_idx = (offset - iter->startbit) / NETLBL_CATMAP_MAPSIZE;
486                 node_bit = offset - iter->startbit -
487                            (NETLBL_CATMAP_MAPSIZE * node_idx);
488         } else {
489                 node_idx = 0;
490                 node_bit = 0;
491         }
492         bitmask = NETLBL_CATMAP_BIT << node_bit;
493
494         for (;;) {
495                 bitmap = iter->bitmap[node_idx];
496                 while (bitmask != 0 && (bitmap & bitmask) != 0) {
497                         bitmask <<= 1;
498                         node_bit++;
499                 }
500
501                 if (bitmask != 0)
502                         return iter->startbit +
503                                 (NETLBL_CATMAP_MAPSIZE * node_idx) +
504                                 node_bit - 1;
505                 else if (++node_idx >= NETLBL_CATMAP_MAPCNT) {
506                         if (iter->next == NULL)
507                                 return iter->startbit + NETLBL_CATMAP_SIZE - 1;
508                         iter = iter->next;
509                         node_idx = 0;
510                 }
511                 bitmask = NETLBL_CATMAP_BIT;
512                 node_bit = 0;
513         }
514
515         return -ENOENT;
516 }
517
518 /**
519  * netlbl_secattr_catmap_setbit - Set a bit in a LSM secattr catmap
520  * @catmap: the category bitmap
521  * @bit: the bit to set
522  * @flags: memory allocation flags
523  *
524  * Description:
525  * Set the bit specified by @bit in @catmap.  Returns zero on success,
526  * negative values on failure.
527  *
528  */
529 int netlbl_secattr_catmap_setbit(struct netlbl_lsm_secattr_catmap *catmap,
530                                  u32 bit,
531                                  gfp_t flags)
532 {
533         struct netlbl_lsm_secattr_catmap *iter = catmap;
534         u32 node_bit;
535         u32 node_idx;
536
537         while (iter->next != NULL &&
538                bit >= (iter->startbit + NETLBL_CATMAP_SIZE))
539                 iter = iter->next;
540         if (bit >= (iter->startbit + NETLBL_CATMAP_SIZE)) {
541                 iter->next = netlbl_secattr_catmap_alloc(flags);
542                 if (iter->next == NULL)
543                         return -ENOMEM;
544                 iter = iter->next;
545                 iter->startbit = bit & ~(NETLBL_CATMAP_SIZE - 1);
546         }
547
548         /* gcc always rounds to zero when doing integer division */
549         node_idx = (bit - iter->startbit) / NETLBL_CATMAP_MAPSIZE;
550         node_bit = bit - iter->startbit - (NETLBL_CATMAP_MAPSIZE * node_idx);
551         iter->bitmap[node_idx] |= NETLBL_CATMAP_BIT << node_bit;
552
553         return 0;
554 }
555
556 /**
557  * netlbl_secattr_catmap_setrng - Set a range of bits in a LSM secattr catmap
558  * @catmap: the category bitmap
559  * @start: the starting bit
560  * @end: the last bit in the string
561  * @flags: memory allocation flags
562  *
563  * Description:
564  * Set a range of bits, starting at @start and ending with @end.  Returns zero
565  * on success, negative values on failure.
566  *
567  */
568 int netlbl_secattr_catmap_setrng(struct netlbl_lsm_secattr_catmap *catmap,
569                                  u32 start,
570                                  u32 end,
571                                  gfp_t flags)
572 {
573         int ret_val = 0;
574         struct netlbl_lsm_secattr_catmap *iter = catmap;
575         u32 iter_max_spot;
576         u32 spot;
577
578         /* XXX - This could probably be made a bit faster by combining writes
579          * to the catmap instead of setting a single bit each time, but for
580          * right now skipping to the start of the range in the catmap should
581          * be a nice improvement over calling the individual setbit function
582          * repeatedly from a loop. */
583
584         while (iter->next != NULL &&
585                start >= (iter->startbit + NETLBL_CATMAP_SIZE))
586                 iter = iter->next;
587         iter_max_spot = iter->startbit + NETLBL_CATMAP_SIZE;
588
589         for (spot = start; spot <= end && ret_val == 0; spot++) {
590                 if (spot >= iter_max_spot && iter->next != NULL) {
591                         iter = iter->next;
592                         iter_max_spot = iter->startbit + NETLBL_CATMAP_SIZE;
593                 }
594                 ret_val = netlbl_secattr_catmap_setbit(iter, spot, GFP_ATOMIC);
595         }
596
597         return ret_val;
598 }
599
600 /*
601  * LSM Functions
602  */
603
604 /**
605  * netlbl_enabled - Determine if the NetLabel subsystem is enabled
606  *
607  * Description:
608  * The LSM can use this function to determine if it should use NetLabel
609  * security attributes in it's enforcement mechanism.  Currently, NetLabel is
610  * considered to be enabled when it's configuration contains a valid setup for
611  * at least one labeled protocol (i.e. NetLabel can understand incoming
612  * labeled packets of at least one type); otherwise NetLabel is considered to
613  * be disabled.
614  *
615  */
616 int netlbl_enabled(void)
617 {
618         /* At some point we probably want to expose this mechanism to the user
619          * as well so that admins can toggle NetLabel regardless of the
620          * configuration */
621         return (atomic_read(&netlabel_mgmt_protocount) > 0);
622 }
623
624 /**
625  * netlbl_sock_setattr - Label a socket using the correct protocol
626  * @sk: the socket to label
627  * @family: protocol family
628  * @secattr: the security attributes
629  *
630  * Description:
631  * Attach the correct label to the given socket using the security attributes
632  * specified in @secattr.  This function requires exclusive access to @sk,
633  * which means it either needs to be in the process of being created or locked.
634  * Returns zero on success, -EDESTADDRREQ if the domain is configured to use
635  * network address selectors (can't blindly label the socket), and negative
636  * values on all other failures.
637  *
638  */
639 int netlbl_sock_setattr(struct sock *sk,
640                         u16 family,
641                         const struct netlbl_lsm_secattr *secattr)
642 {
643         int ret_val;
644         struct netlbl_dom_map *dom_entry;
645
646         rcu_read_lock();
647         dom_entry = netlbl_domhsh_getentry(secattr->domain);
648         if (dom_entry == NULL) {
649                 ret_val = -ENOENT;
650                 goto socket_setattr_return;
651         }
652         switch (family) {
653         case AF_INET:
654                 switch (dom_entry->type) {
655                 case NETLBL_NLTYPE_ADDRSELECT:
656                         ret_val = -EDESTADDRREQ;
657                         break;
658                 case NETLBL_NLTYPE_CIPSOV4:
659                         ret_val = cipso_v4_sock_setattr(sk,
660                                                     dom_entry->type_def.cipsov4,
661                                                     secattr);
662                         break;
663                 case NETLBL_NLTYPE_UNLABELED:
664                         ret_val = 0;
665                         break;
666                 default:
667                         ret_val = -ENOENT;
668                 }
669                 break;
670 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
671         case AF_INET6:
672                 /* since we don't support any IPv6 labeling protocols right
673                  * now we can optimize everything away until we do */
674                 ret_val = 0;
675                 break;
676 #endif /* IPv6 */
677         default:
678                 ret_val = -EPROTONOSUPPORT;
679         }
680
681 socket_setattr_return:
682         rcu_read_unlock();
683         return ret_val;
684 }
685
686 /**
687  * netlbl_sock_delattr - Delete all the NetLabel labels on a socket
688  * @sk: the socket
689  *
690  * Description:
691  * Remove all the NetLabel labeling from @sk.  The caller is responsible for
692  * ensuring that @sk is locked.
693  *
694  */
695 void netlbl_sock_delattr(struct sock *sk)
696 {
697         cipso_v4_sock_delattr(sk);
698 }
699
700 /**
701  * netlbl_sock_getattr - Determine the security attributes of a sock
702  * @sk: the sock
703  * @secattr: the security attributes
704  *
705  * Description:
706  * Examines the given sock to see if any NetLabel style labeling has been
707  * applied to the sock, if so it parses the socket label and returns the
708  * security attributes in @secattr.  Returns zero on success, negative values
709  * on failure.
710  *
711  */
712 int netlbl_sock_getattr(struct sock *sk,
713                         struct netlbl_lsm_secattr *secattr)
714 {
715         int ret_val;
716
717         switch (sk->sk_family) {
718         case AF_INET:
719                 ret_val = cipso_v4_sock_getattr(sk, secattr);
720                 break;
721 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
722         case AF_INET6:
723                 ret_val = -ENOMSG;
724                 break;
725 #endif /* IPv6 */
726         default:
727                 ret_val = -EPROTONOSUPPORT;
728         }
729
730         return ret_val;
731 }
732
733 /**
734  * netlbl_conn_setattr - Label a connected socket using the correct protocol
735  * @sk: the socket to label
736  * @addr: the destination address
737  * @secattr: the security attributes
738  *
739  * Description:
740  * Attach the correct label to the given connected socket using the security
741  * attributes specified in @secattr.  The caller is responsible for ensuring
742  * that @sk is locked.  Returns zero on success, negative values on failure.
743  *
744  */
745 int netlbl_conn_setattr(struct sock *sk,
746                         struct sockaddr *addr,
747                         const struct netlbl_lsm_secattr *secattr)
748 {
749         int ret_val;
750         struct sockaddr_in *addr4;
751         struct netlbl_domaddr4_map *af4_entry;
752
753         rcu_read_lock();
754         switch (addr->sa_family) {
755         case AF_INET:
756                 addr4 = (struct sockaddr_in *)addr;
757                 af4_entry = netlbl_domhsh_getentry_af4(secattr->domain,
758                                                        addr4->sin_addr.s_addr);
759                 if (af4_entry == NULL) {
760                         ret_val = -ENOENT;
761                         goto conn_setattr_return;
762                 }
763                 switch (af4_entry->type) {
764                 case NETLBL_NLTYPE_CIPSOV4:
765                         ret_val = cipso_v4_sock_setattr(sk,
766                                                    af4_entry->type_def.cipsov4,
767                                                    secattr);
768                         break;
769                 case NETLBL_NLTYPE_UNLABELED:
770                         /* just delete the protocols we support for right now
771                          * but we could remove other protocols if needed */
772                         cipso_v4_sock_delattr(sk);
773                         ret_val = 0;
774                         break;
775                 default:
776                         ret_val = -ENOENT;
777                 }
778                 break;
779 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
780         case AF_INET6:
781                 /* since we don't support any IPv6 labeling protocols right
782                  * now we can optimize everything away until we do */
783                 ret_val = 0;
784                 break;
785 #endif /* IPv6 */
786         default:
787                 ret_val = -EPROTONOSUPPORT;
788         }
789
790 conn_setattr_return:
791         rcu_read_unlock();
792         return ret_val;
793 }
794
795 /**
796  * netlbl_req_setattr - Label a request socket using the correct protocol
797  * @req: the request socket to label
798  * @secattr: the security attributes
799  *
800  * Description:
801  * Attach the correct label to the given socket using the security attributes
802  * specified in @secattr.  Returns zero on success, negative values on failure.
803  *
804  */
805 int netlbl_req_setattr(struct request_sock *req,
806                        const struct netlbl_lsm_secattr *secattr)
807 {
808         int ret_val;
809         struct netlbl_dom_map *dom_entry;
810         struct netlbl_domaddr4_map *af4_entry;
811         u32 proto_type;
812         struct cipso_v4_doi *proto_cv4;
813
814         rcu_read_lock();
815         dom_entry = netlbl_domhsh_getentry(secattr->domain);
816         if (dom_entry == NULL) {
817                 ret_val = -ENOENT;
818                 goto req_setattr_return;
819         }
820         switch (req->rsk_ops->family) {
821         case AF_INET:
822                 if (dom_entry->type == NETLBL_NLTYPE_ADDRSELECT) {
823                         struct inet_request_sock *req_inet = inet_rsk(req);
824                         af4_entry = netlbl_domhsh_getentry_af4(secattr->domain,
825                                                             req_inet->rmt_addr);
826                         if (af4_entry == NULL) {
827                                 ret_val = -ENOENT;
828                                 goto req_setattr_return;
829                         }
830                         proto_type = af4_entry->type;
831                         proto_cv4 = af4_entry->type_def.cipsov4;
832                 } else {
833                         proto_type = dom_entry->type;
834                         proto_cv4 = dom_entry->type_def.cipsov4;
835                 }
836                 switch (proto_type) {
837                 case NETLBL_NLTYPE_CIPSOV4:
838                         ret_val = cipso_v4_req_setattr(req, proto_cv4, secattr);
839                         break;
840                 case NETLBL_NLTYPE_UNLABELED:
841                         /* just delete the protocols we support for right now
842                          * but we could remove other protocols if needed */
843                         cipso_v4_req_delattr(req);
844                         ret_val = 0;
845                         break;
846                 default:
847                         ret_val = -ENOENT;
848                 }
849                 break;
850 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
851         case AF_INET6:
852                 /* since we don't support any IPv6 labeling protocols right
853                  * now we can optimize everything away until we do */
854                 ret_val = 0;
855                 break;
856 #endif /* IPv6 */
857         default:
858                 ret_val = -EPROTONOSUPPORT;
859         }
860
861 req_setattr_return:
862         rcu_read_unlock();
863         return ret_val;
864 }
865
866 /**
867 * netlbl_req_delattr - Delete all the NetLabel labels on a socket
868 * @req: the socket
869 *
870 * Description:
871 * Remove all the NetLabel labeling from @req.
872 *
873 */
874 void netlbl_req_delattr(struct request_sock *req)
875 {
876         cipso_v4_req_delattr(req);
877 }
878
879 /**
880  * netlbl_skbuff_setattr - Label a packet using the correct protocol
881  * @skb: the packet
882  * @family: protocol family
883  * @secattr: the security attributes
884  *
885  * Description:
886  * Attach the correct label to the given packet using the security attributes
887  * specified in @secattr.  Returns zero on success, negative values on failure.
888  *
889  */
890 int netlbl_skbuff_setattr(struct sk_buff *skb,
891                           u16 family,
892                           const struct netlbl_lsm_secattr *secattr)
893 {
894         int ret_val;
895         struct iphdr *hdr4;
896         struct netlbl_domaddr4_map *af4_entry;
897
898         rcu_read_lock();
899         switch (family) {
900         case AF_INET:
901                 hdr4 = ip_hdr(skb);
902                 af4_entry = netlbl_domhsh_getentry_af4(secattr->domain,
903                                                        hdr4->daddr);
904                 if (af4_entry == NULL) {
905                         ret_val = -ENOENT;
906                         goto skbuff_setattr_return;
907                 }
908                 switch (af4_entry->type) {
909                 case NETLBL_NLTYPE_CIPSOV4:
910                         ret_val = cipso_v4_skbuff_setattr(skb,
911                                                    af4_entry->type_def.cipsov4,
912                                                    secattr);
913                         break;
914                 case NETLBL_NLTYPE_UNLABELED:
915                         /* just delete the protocols we support for right now
916                          * but we could remove other protocols if needed */
917                         ret_val = cipso_v4_skbuff_delattr(skb);
918                         break;
919                 default:
920                         ret_val = -ENOENT;
921                 }
922                 break;
923 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
924         case AF_INET6:
925                 /* since we don't support any IPv6 labeling protocols right
926                  * now we can optimize everything away until we do */
927                 ret_val = 0;
928                 break;
929 #endif /* IPv6 */
930         default:
931                 ret_val = -EPROTONOSUPPORT;
932         }
933
934 skbuff_setattr_return:
935         rcu_read_unlock();
936         return ret_val;
937 }
938
939 /**
940  * netlbl_skbuff_getattr - Determine the security attributes of a packet
941  * @skb: the packet
942  * @family: protocol family
943  * @secattr: the security attributes
944  *
945  * Description:
946  * Examines the given packet to see if a recognized form of packet labeling
947  * is present, if so it parses the packet label and returns the security
948  * attributes in @secattr.  Returns zero on success, negative values on
949  * failure.
950  *
951  */
952 int netlbl_skbuff_getattr(const struct sk_buff *skb,
953                           u16 family,
954                           struct netlbl_lsm_secattr *secattr)
955 {
956         switch (family) {
957         case AF_INET:
958                 if (CIPSO_V4_OPTEXIST(skb) &&
959                     cipso_v4_skbuff_getattr(skb, secattr) == 0)
960                         return 0;
961                 break;
962 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
963         case AF_INET6:
964                 break;
965 #endif /* IPv6 */
966         }
967
968         return netlbl_unlabel_getattr(skb, family, secattr);
969 }
970
971 /**
972  * netlbl_skbuff_err - Handle a LSM error on a sk_buff
973  * @skb: the packet
974  * @error: the error code
975  * @gateway: true if host is acting as a gateway, false otherwise
976  *
977  * Description:
978  * Deal with a LSM problem when handling the packet in @skb, typically this is
979  * a permission denied problem (-EACCES).  The correct action is determined
980  * according to the packet's labeling protocol.
981  *
982  */
983 void netlbl_skbuff_err(struct sk_buff *skb, int error, int gateway)
984 {
985         if (CIPSO_V4_OPTEXIST(skb))
986                 cipso_v4_error(skb, error, gateway);
987 }
988
989 /**
990  * netlbl_cache_invalidate - Invalidate all of the NetLabel protocol caches
991  *
992  * Description:
993  * For all of the NetLabel protocols that support some form of label mapping
994  * cache, invalidate the cache.  Returns zero on success, negative values on
995  * error.
996  *
997  */
998 void netlbl_cache_invalidate(void)
999 {
1000         cipso_v4_cache_invalidate();
1001 }
1002
1003 /**
1004  * netlbl_cache_add - Add an entry to a NetLabel protocol cache
1005  * @skb: the packet
1006  * @secattr: the packet's security attributes
1007  *
1008  * Description:
1009  * Add the LSM security attributes for the given packet to the underlying
1010  * NetLabel protocol's label mapping cache.  Returns zero on success, negative
1011  * values on error.
1012  *
1013  */
1014 int netlbl_cache_add(const struct sk_buff *skb,
1015                      const struct netlbl_lsm_secattr *secattr)
1016 {
1017         if ((secattr->flags & NETLBL_SECATTR_CACHE) == 0)
1018                 return -ENOMSG;
1019
1020         if (CIPSO_V4_OPTEXIST(skb))
1021                 return cipso_v4_cache_add(skb, secattr);
1022
1023         return -ENOMSG;
1024 }
1025
1026 /*
1027  * Protocol Engine Functions
1028  */
1029
1030 /**
1031  * netlbl_audit_start - Start an audit message
1032  * @type: audit message type
1033  * @audit_info: NetLabel audit information
1034  *
1035  * Description:
1036  * Start an audit message using the type specified in @type and fill the audit
1037  * message with some fields common to all NetLabel audit messages.  This
1038  * function should only be used by protocol engines, not LSMs.  Returns a
1039  * pointer to the audit buffer on success, NULL on failure.
1040  *
1041  */
1042 struct audit_buffer *netlbl_audit_start(int type,
1043                                         struct netlbl_audit *audit_info)
1044 {
1045         return netlbl_audit_start_common(type, audit_info);
1046 }
1047
1048 /*
1049  * Setup Functions
1050  */
1051
1052 /**
1053  * netlbl_init - Initialize NetLabel
1054  *
1055  * Description:
1056  * Perform the required NetLabel initialization before first use.
1057  *
1058  */
1059 static int __init netlbl_init(void)
1060 {
1061         int ret_val;
1062
1063         printk(KERN_INFO "NetLabel: Initializing\n");
1064         printk(KERN_INFO "NetLabel:  domain hash size = %u\n",
1065                (1 << NETLBL_DOMHSH_BITSIZE));
1066         printk(KERN_INFO "NetLabel:  protocols ="
1067                " UNLABELED"
1068                " CIPSOv4"
1069                "\n");
1070
1071         ret_val = netlbl_domhsh_init(NETLBL_DOMHSH_BITSIZE);
1072         if (ret_val != 0)
1073                 goto init_failure;
1074
1075         ret_val = netlbl_unlabel_init(NETLBL_UNLHSH_BITSIZE);
1076         if (ret_val != 0)
1077                 goto init_failure;
1078
1079         ret_val = netlbl_netlink_init();
1080         if (ret_val != 0)
1081                 goto init_failure;
1082
1083         ret_val = netlbl_unlabel_defconf();
1084         if (ret_val != 0)
1085                 goto init_failure;
1086         printk(KERN_INFO "NetLabel:  unlabeled traffic allowed by default\n");
1087
1088         return 0;
1089
1090 init_failure:
1091         panic("NetLabel: failed to initialize properly (%d)\n", ret_val);
1092 }
1093
1094 subsys_initcall(netlbl_init);