2 * NetLabel Management Support
4 * This file defines the management functions for the NetLabel system. The
5 * NetLabel system manages static and dynamic label mappings for network
6 * protocols such as CIPSO and RIPSO.
8 * Author: Paul Moore <paul@paul-moore.com>
13 * (c) Copyright Hewlett-Packard Development Company, L.P., 2006, 2008
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.
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.
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, see <http://www.gnu.org/licenses/>.
30 #include <linux/types.h>
31 #include <linux/socket.h>
32 #include <linux/string.h>
33 #include <linux/skbuff.h>
35 #include <linux/in6.h>
36 #include <linux/slab.h>
38 #include <net/netlink.h>
39 #include <net/genetlink.h>
42 #include <net/netlabel.h>
43 #include <net/cipso_ipv4.h>
44 #include <net/calipso.h>
45 #include <linux/atomic.h>
47 #include "netlabel_calipso.h"
48 #include "netlabel_domainhash.h"
49 #include "netlabel_user.h"
50 #include "netlabel_mgmt.h"
52 /* NetLabel configured protocol counter */
53 atomic_t netlabel_mgmt_protocount = ATOMIC_INIT(0);
55 /* Argument struct for netlbl_domhsh_walk() */
56 struct netlbl_domhsh_walk_arg {
57 struct netlink_callback *nl_cb;
62 /* NetLabel Generic NETLINK CIPSOv4 family */
63 static struct genl_family netlbl_mgmt_gnl_family;
65 /* NetLabel Netlink attribute policy */
66 static const struct nla_policy netlbl_mgmt_genl_policy[NLBL_MGMT_A_MAX + 1] = {
67 [NLBL_MGMT_A_DOMAIN] = { .type = NLA_NUL_STRING },
68 [NLBL_MGMT_A_PROTOCOL] = { .type = NLA_U32 },
69 [NLBL_MGMT_A_VERSION] = { .type = NLA_U32 },
70 [NLBL_MGMT_A_CV4DOI] = { .type = NLA_U32 },
71 [NLBL_MGMT_A_FAMILY] = { .type = NLA_U16 },
72 [NLBL_MGMT_A_CLPDOI] = { .type = NLA_U32 },
80 * netlbl_mgmt_add - Handle an ADD message
81 * @info: the Generic NETLINK info block
82 * @audit_info: NetLabel audit information
85 * Helper function for the ADD and ADDDEF messages to add the domain mappings
86 * from the message to the hash table. See netlabel.h for a description of the
87 * message format. Returns zero on success, negative values on failure.
90 static int netlbl_mgmt_add_common(struct genl_info *info,
91 struct netlbl_audit *audit_info)
94 int ret_val = -EINVAL;
95 struct netlbl_domaddr_map *addrmap = NULL;
96 struct cipso_v4_doi *cipsov4 = NULL;
97 #if IS_ENABLED(CONFIG_IPV6)
98 struct calipso_doi *calipso = NULL;
101 struct netlbl_dom_map *entry = kzalloc(sizeof(*entry), GFP_KERNEL);
105 entry->def.type = nla_get_u32(info->attrs[NLBL_MGMT_A_PROTOCOL]);
106 if (info->attrs[NLBL_MGMT_A_DOMAIN]) {
107 size_t tmp_size = nla_len(info->attrs[NLBL_MGMT_A_DOMAIN]);
108 entry->domain = kmalloc(tmp_size, GFP_KERNEL);
109 if (entry->domain == NULL) {
113 nla_strlcpy(entry->domain,
114 info->attrs[NLBL_MGMT_A_DOMAIN], tmp_size);
117 /* NOTE: internally we allow/use a entry->def.type value of
118 * NETLBL_NLTYPE_ADDRSELECT but we don't currently allow users
119 * to pass that as a protocol value because we need to know the
122 switch (entry->def.type) {
123 case NETLBL_NLTYPE_UNLABELED:
124 if (info->attrs[NLBL_MGMT_A_FAMILY])
126 nla_get_u16(info->attrs[NLBL_MGMT_A_FAMILY]);
128 entry->family = AF_UNSPEC;
130 case NETLBL_NLTYPE_CIPSOV4:
131 if (!info->attrs[NLBL_MGMT_A_CV4DOI])
132 goto add_free_domain;
134 tmp_val = nla_get_u32(info->attrs[NLBL_MGMT_A_CV4DOI]);
135 cipsov4 = cipso_v4_doi_getdef(tmp_val);
137 goto add_free_domain;
138 entry->family = AF_INET;
139 entry->def.cipso = cipsov4;
141 #if IS_ENABLED(CONFIG_IPV6)
142 case NETLBL_NLTYPE_CALIPSO:
143 if (!info->attrs[NLBL_MGMT_A_CLPDOI])
144 goto add_free_domain;
146 tmp_val = nla_get_u32(info->attrs[NLBL_MGMT_A_CLPDOI]);
147 calipso = calipso_doi_getdef(tmp_val);
149 goto add_free_domain;
150 entry->family = AF_INET6;
151 entry->def.calipso = calipso;
155 goto add_free_domain;
158 if ((entry->family == AF_INET && info->attrs[NLBL_MGMT_A_IPV6ADDR]) ||
159 (entry->family == AF_INET6 && info->attrs[NLBL_MGMT_A_IPV4ADDR]))
160 goto add_doi_put_def;
162 if (info->attrs[NLBL_MGMT_A_IPV4ADDR]) {
163 struct in_addr *addr;
164 struct in_addr *mask;
165 struct netlbl_domaddr4_map *map;
167 addrmap = kzalloc(sizeof(*addrmap), GFP_KERNEL);
168 if (addrmap == NULL) {
170 goto add_doi_put_def;
172 INIT_LIST_HEAD(&addrmap->list4);
173 INIT_LIST_HEAD(&addrmap->list6);
175 if (nla_len(info->attrs[NLBL_MGMT_A_IPV4ADDR]) !=
176 sizeof(struct in_addr)) {
178 goto add_free_addrmap;
180 if (nla_len(info->attrs[NLBL_MGMT_A_IPV4MASK]) !=
181 sizeof(struct in_addr)) {
183 goto add_free_addrmap;
185 addr = nla_data(info->attrs[NLBL_MGMT_A_IPV4ADDR]);
186 mask = nla_data(info->attrs[NLBL_MGMT_A_IPV4MASK]);
188 map = kzalloc(sizeof(*map), GFP_KERNEL);
191 goto add_free_addrmap;
194 map->list.addr = addr->s_addr & mask->s_addr;
195 map->list.mask = mask->s_addr;
197 map->def.type = entry->def.type;
199 map->def.cipso = cipsov4;
201 ret_val = netlbl_af4list_add(&map->list, &addrmap->list4);
205 entry->family = AF_INET;
206 entry->def.type = NETLBL_NLTYPE_ADDRSELECT;
207 entry->def.addrsel = addrmap;
208 #if IS_ENABLED(CONFIG_IPV6)
209 } else if (info->attrs[NLBL_MGMT_A_IPV6ADDR]) {
210 struct in6_addr *addr;
211 struct in6_addr *mask;
212 struct netlbl_domaddr6_map *map;
214 addrmap = kzalloc(sizeof(*addrmap), GFP_KERNEL);
215 if (addrmap == NULL) {
217 goto add_doi_put_def;
219 INIT_LIST_HEAD(&addrmap->list4);
220 INIT_LIST_HEAD(&addrmap->list6);
222 if (nla_len(info->attrs[NLBL_MGMT_A_IPV6ADDR]) !=
223 sizeof(struct in6_addr)) {
225 goto add_free_addrmap;
227 if (nla_len(info->attrs[NLBL_MGMT_A_IPV6MASK]) !=
228 sizeof(struct in6_addr)) {
230 goto add_free_addrmap;
232 addr = nla_data(info->attrs[NLBL_MGMT_A_IPV6ADDR]);
233 mask = nla_data(info->attrs[NLBL_MGMT_A_IPV6MASK]);
235 map = kzalloc(sizeof(*map), GFP_KERNEL);
238 goto add_free_addrmap;
241 map->list.addr = *addr;
242 map->list.addr.s6_addr32[0] &= mask->s6_addr32[0];
243 map->list.addr.s6_addr32[1] &= mask->s6_addr32[1];
244 map->list.addr.s6_addr32[2] &= mask->s6_addr32[2];
245 map->list.addr.s6_addr32[3] &= mask->s6_addr32[3];
246 map->list.mask = *mask;
248 map->def.type = entry->def.type;
250 map->def.calipso = calipso;
252 ret_val = netlbl_af6list_add(&map->list, &addrmap->list6);
256 entry->family = AF_INET6;
257 entry->def.type = NETLBL_NLTYPE_ADDRSELECT;
258 entry->def.addrsel = addrmap;
262 ret_val = netlbl_domhsh_add(entry, audit_info);
273 cipso_v4_doi_putdef(cipsov4);
274 #if IS_ENABLED(CONFIG_IPV6)
275 calipso_doi_putdef(calipso);
278 kfree(entry->domain);
285 * netlbl_mgmt_listentry - List a NetLabel/LSM domain map entry
286 * @skb: the NETLINK buffer
287 * @entry: the map entry
290 * This function is a helper function used by the LISTALL and LISTDEF command
291 * handlers. The caller is responsible for ensuring that the RCU read lock
292 * is held. Returns zero on success, negative values on failure.
295 static int netlbl_mgmt_listentry(struct sk_buff *skb,
296 struct netlbl_dom_map *entry)
299 struct nlattr *nla_a;
300 struct nlattr *nla_b;
301 struct netlbl_af4list *iter4;
302 #if IS_ENABLED(CONFIG_IPV6)
303 struct netlbl_af6list *iter6;
306 if (entry->domain != NULL) {
307 ret_val = nla_put_string(skb,
308 NLBL_MGMT_A_DOMAIN, entry->domain);
313 ret_val = nla_put_u16(skb, NLBL_MGMT_A_FAMILY, entry->family);
317 switch (entry->def.type) {
318 case NETLBL_NLTYPE_ADDRSELECT:
319 nla_a = nla_nest_start(skb, NLBL_MGMT_A_SELECTORLIST);
323 netlbl_af4list_foreach_rcu(iter4, &entry->def.addrsel->list4) {
324 struct netlbl_domaddr4_map *map4;
325 struct in_addr addr_struct;
327 nla_b = nla_nest_start(skb, NLBL_MGMT_A_ADDRSELECTOR);
331 addr_struct.s_addr = iter4->addr;
332 ret_val = nla_put_in_addr(skb, NLBL_MGMT_A_IPV4ADDR,
336 addr_struct.s_addr = iter4->mask;
337 ret_val = nla_put_in_addr(skb, NLBL_MGMT_A_IPV4MASK,
341 map4 = netlbl_domhsh_addr4_entry(iter4);
342 ret_val = nla_put_u32(skb, NLBL_MGMT_A_PROTOCOL,
346 switch (map4->def.type) {
347 case NETLBL_NLTYPE_CIPSOV4:
348 ret_val = nla_put_u32(skb, NLBL_MGMT_A_CV4DOI,
349 map4->def.cipso->doi);
355 nla_nest_end(skb, nla_b);
357 #if IS_ENABLED(CONFIG_IPV6)
358 netlbl_af6list_foreach_rcu(iter6, &entry->def.addrsel->list6) {
359 struct netlbl_domaddr6_map *map6;
361 nla_b = nla_nest_start(skb, NLBL_MGMT_A_ADDRSELECTOR);
365 ret_val = nla_put_in6_addr(skb, NLBL_MGMT_A_IPV6ADDR,
369 ret_val = nla_put_in6_addr(skb, NLBL_MGMT_A_IPV6MASK,
373 map6 = netlbl_domhsh_addr6_entry(iter6);
374 ret_val = nla_put_u32(skb, NLBL_MGMT_A_PROTOCOL,
379 switch (map6->def.type) {
380 case NETLBL_NLTYPE_CALIPSO:
381 ret_val = nla_put_u32(skb, NLBL_MGMT_A_CLPDOI,
382 map6->def.calipso->doi);
388 nla_nest_end(skb, nla_b);
392 nla_nest_end(skb, nla_a);
394 case NETLBL_NLTYPE_UNLABELED:
395 ret_val = nla_put_u32(skb, NLBL_MGMT_A_PROTOCOL,
398 case NETLBL_NLTYPE_CIPSOV4:
399 ret_val = nla_put_u32(skb, NLBL_MGMT_A_PROTOCOL,
403 ret_val = nla_put_u32(skb, NLBL_MGMT_A_CV4DOI,
404 entry->def.cipso->doi);
406 case NETLBL_NLTYPE_CALIPSO:
407 ret_val = nla_put_u32(skb, NLBL_MGMT_A_PROTOCOL,
411 ret_val = nla_put_u32(skb, NLBL_MGMT_A_CLPDOI,
412 entry->def.calipso->doi);
420 * NetLabel Command Handlers
424 * netlbl_mgmt_add - Handle an ADD message
425 * @skb: the NETLINK buffer
426 * @info: the Generic NETLINK info block
429 * Process a user generated ADD message and add the domains from the message
430 * to the hash table. See netlabel.h for a description of the message format.
431 * Returns zero on success, negative values on failure.
434 static int netlbl_mgmt_add(struct sk_buff *skb, struct genl_info *info)
436 struct netlbl_audit audit_info;
438 if ((!info->attrs[NLBL_MGMT_A_DOMAIN]) ||
439 (!info->attrs[NLBL_MGMT_A_PROTOCOL]) ||
440 (info->attrs[NLBL_MGMT_A_IPV4ADDR] &&
441 info->attrs[NLBL_MGMT_A_IPV6ADDR]) ||
442 (info->attrs[NLBL_MGMT_A_IPV4MASK] &&
443 info->attrs[NLBL_MGMT_A_IPV6MASK]) ||
444 ((info->attrs[NLBL_MGMT_A_IPV4ADDR] != NULL) ^
445 (info->attrs[NLBL_MGMT_A_IPV4MASK] != NULL)) ||
446 ((info->attrs[NLBL_MGMT_A_IPV6ADDR] != NULL) ^
447 (info->attrs[NLBL_MGMT_A_IPV6MASK] != NULL)))
450 netlbl_netlink_auditinfo(skb, &audit_info);
452 return netlbl_mgmt_add_common(info, &audit_info);
456 * netlbl_mgmt_remove - Handle a REMOVE message
457 * @skb: the NETLINK buffer
458 * @info: the Generic NETLINK info block
461 * Process a user generated REMOVE message and remove the specified domain
462 * mappings. Returns zero on success, negative values on failure.
465 static int netlbl_mgmt_remove(struct sk_buff *skb, struct genl_info *info)
468 struct netlbl_audit audit_info;
470 if (!info->attrs[NLBL_MGMT_A_DOMAIN])
473 netlbl_netlink_auditinfo(skb, &audit_info);
475 domain = nla_data(info->attrs[NLBL_MGMT_A_DOMAIN]);
476 return netlbl_domhsh_remove(domain, AF_UNSPEC, &audit_info);
480 * netlbl_mgmt_listall_cb - netlbl_domhsh_walk() callback for LISTALL
481 * @entry: the domain mapping hash table entry
482 * @arg: the netlbl_domhsh_walk_arg structure
485 * This function is designed to be used as a callback to the
486 * netlbl_domhsh_walk() function for use in generating a response for a LISTALL
487 * message. Returns the size of the message on success, negative values on
491 static int netlbl_mgmt_listall_cb(struct netlbl_dom_map *entry, void *arg)
493 int ret_val = -ENOMEM;
494 struct netlbl_domhsh_walk_arg *cb_arg = arg;
497 data = genlmsg_put(cb_arg->skb, NETLINK_CB(cb_arg->nl_cb->skb).portid,
498 cb_arg->seq, &netlbl_mgmt_gnl_family,
499 NLM_F_MULTI, NLBL_MGMT_C_LISTALL);
501 goto listall_cb_failure;
503 ret_val = netlbl_mgmt_listentry(cb_arg->skb, entry);
505 goto listall_cb_failure;
508 genlmsg_end(cb_arg->skb, data);
512 genlmsg_cancel(cb_arg->skb, data);
517 * netlbl_mgmt_listall - Handle a LISTALL message
518 * @skb: the NETLINK buffer
519 * @cb: the NETLINK callback
522 * Process a user generated LISTALL message and dumps the domain hash table in
523 * a form suitable for use in a kernel generated LISTALL message. Returns zero
524 * on success, negative values on failure.
527 static int netlbl_mgmt_listall(struct sk_buff *skb,
528 struct netlink_callback *cb)
530 struct netlbl_domhsh_walk_arg cb_arg;
531 u32 skip_bkt = cb->args[0];
532 u32 skip_chain = cb->args[1];
536 cb_arg.seq = cb->nlh->nlmsg_seq;
538 netlbl_domhsh_walk(&skip_bkt,
540 netlbl_mgmt_listall_cb,
543 cb->args[0] = skip_bkt;
544 cb->args[1] = skip_chain;
549 * netlbl_mgmt_adddef - Handle an ADDDEF message
550 * @skb: the NETLINK buffer
551 * @info: the Generic NETLINK info block
554 * Process a user generated ADDDEF message and respond accordingly. Returns
555 * zero on success, negative values on failure.
558 static int netlbl_mgmt_adddef(struct sk_buff *skb, struct genl_info *info)
560 struct netlbl_audit audit_info;
562 if ((!info->attrs[NLBL_MGMT_A_PROTOCOL]) ||
563 (info->attrs[NLBL_MGMT_A_IPV4ADDR] &&
564 info->attrs[NLBL_MGMT_A_IPV6ADDR]) ||
565 (info->attrs[NLBL_MGMT_A_IPV4MASK] &&
566 info->attrs[NLBL_MGMT_A_IPV6MASK]) ||
567 ((info->attrs[NLBL_MGMT_A_IPV4ADDR] != NULL) ^
568 (info->attrs[NLBL_MGMT_A_IPV4MASK] != NULL)) ||
569 ((info->attrs[NLBL_MGMT_A_IPV6ADDR] != NULL) ^
570 (info->attrs[NLBL_MGMT_A_IPV6MASK] != NULL)))
573 netlbl_netlink_auditinfo(skb, &audit_info);
575 return netlbl_mgmt_add_common(info, &audit_info);
579 * netlbl_mgmt_removedef - Handle a REMOVEDEF message
580 * @skb: the NETLINK buffer
581 * @info: the Generic NETLINK info block
584 * Process a user generated REMOVEDEF message and remove the default domain
585 * mapping. Returns zero on success, negative values on failure.
588 static int netlbl_mgmt_removedef(struct sk_buff *skb, struct genl_info *info)
590 struct netlbl_audit audit_info;
592 netlbl_netlink_auditinfo(skb, &audit_info);
594 return netlbl_domhsh_remove_default(AF_UNSPEC, &audit_info);
598 * netlbl_mgmt_listdef - Handle a LISTDEF message
599 * @skb: the NETLINK buffer
600 * @info: the Generic NETLINK info block
603 * Process a user generated LISTDEF message and dumps the default domain
604 * mapping in a form suitable for use in a kernel generated LISTDEF message.
605 * Returns zero on success, negative values on failure.
608 static int netlbl_mgmt_listdef(struct sk_buff *skb, struct genl_info *info)
610 int ret_val = -ENOMEM;
611 struct sk_buff *ans_skb = NULL;
613 struct netlbl_dom_map *entry;
616 if (info->attrs[NLBL_MGMT_A_FAMILY])
617 family = nla_get_u16(info->attrs[NLBL_MGMT_A_FAMILY]);
621 ans_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
624 data = genlmsg_put_reply(ans_skb, info, &netlbl_mgmt_gnl_family,
625 0, NLBL_MGMT_C_LISTDEF);
627 goto listdef_failure;
630 entry = netlbl_domhsh_getentry(NULL, family);
633 goto listdef_failure_lock;
635 ret_val = netlbl_mgmt_listentry(ans_skb, entry);
638 goto listdef_failure;
640 genlmsg_end(ans_skb, data);
641 return genlmsg_reply(ans_skb, info);
643 listdef_failure_lock:
651 * netlbl_mgmt_protocols_cb - Write an individual PROTOCOL message response
652 * @skb: the skb to write to
653 * @cb: the NETLINK callback
654 * @protocol: the NetLabel protocol to use in the message
657 * This function is to be used in conjunction with netlbl_mgmt_protocols() to
658 * answer a application's PROTOCOLS message. Returns the size of the message
659 * on success, negative values on failure.
662 static int netlbl_mgmt_protocols_cb(struct sk_buff *skb,
663 struct netlink_callback *cb,
666 int ret_val = -ENOMEM;
669 data = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
670 &netlbl_mgmt_gnl_family, NLM_F_MULTI,
671 NLBL_MGMT_C_PROTOCOLS);
673 goto protocols_cb_failure;
675 ret_val = nla_put_u32(skb, NLBL_MGMT_A_PROTOCOL, protocol);
677 goto protocols_cb_failure;
679 genlmsg_end(skb, data);
682 protocols_cb_failure:
683 genlmsg_cancel(skb, data);
688 * netlbl_mgmt_protocols - Handle a PROTOCOLS message
689 * @skb: the NETLINK buffer
690 * @cb: the NETLINK callback
693 * Process a user generated PROTOCOLS message and respond accordingly.
696 static int netlbl_mgmt_protocols(struct sk_buff *skb,
697 struct netlink_callback *cb)
699 u32 protos_sent = cb->args[0];
701 if (protos_sent == 0) {
702 if (netlbl_mgmt_protocols_cb(skb,
704 NETLBL_NLTYPE_UNLABELED) < 0)
705 goto protocols_return;
708 if (protos_sent == 1) {
709 if (netlbl_mgmt_protocols_cb(skb,
711 NETLBL_NLTYPE_CIPSOV4) < 0)
712 goto protocols_return;
715 #if IS_ENABLED(CONFIG_IPV6)
716 if (protos_sent == 2) {
717 if (netlbl_mgmt_protocols_cb(skb,
719 NETLBL_NLTYPE_CALIPSO) < 0)
720 goto protocols_return;
726 cb->args[0] = protos_sent;
731 * netlbl_mgmt_version - Handle a VERSION message
732 * @skb: the NETLINK buffer
733 * @info: the Generic NETLINK info block
736 * Process a user generated VERSION message and respond accordingly. Returns
737 * zero on success, negative values on failure.
740 static int netlbl_mgmt_version(struct sk_buff *skb, struct genl_info *info)
742 int ret_val = -ENOMEM;
743 struct sk_buff *ans_skb = NULL;
746 ans_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
749 data = genlmsg_put_reply(ans_skb, info, &netlbl_mgmt_gnl_family,
750 0, NLBL_MGMT_C_VERSION);
752 goto version_failure;
754 ret_val = nla_put_u32(ans_skb,
756 NETLBL_PROTO_VERSION);
758 goto version_failure;
760 genlmsg_end(ans_skb, data);
761 return genlmsg_reply(ans_skb, info);
770 * NetLabel Generic NETLINK Command Definitions
773 static const struct genl_ops netlbl_mgmt_genl_ops[] = {
775 .cmd = NLBL_MGMT_C_ADD,
776 .flags = GENL_ADMIN_PERM,
777 .policy = netlbl_mgmt_genl_policy,
778 .doit = netlbl_mgmt_add,
782 .cmd = NLBL_MGMT_C_REMOVE,
783 .flags = GENL_ADMIN_PERM,
784 .policy = netlbl_mgmt_genl_policy,
785 .doit = netlbl_mgmt_remove,
789 .cmd = NLBL_MGMT_C_LISTALL,
791 .policy = netlbl_mgmt_genl_policy,
793 .dumpit = netlbl_mgmt_listall,
796 .cmd = NLBL_MGMT_C_ADDDEF,
797 .flags = GENL_ADMIN_PERM,
798 .policy = netlbl_mgmt_genl_policy,
799 .doit = netlbl_mgmt_adddef,
803 .cmd = NLBL_MGMT_C_REMOVEDEF,
804 .flags = GENL_ADMIN_PERM,
805 .policy = netlbl_mgmt_genl_policy,
806 .doit = netlbl_mgmt_removedef,
810 .cmd = NLBL_MGMT_C_LISTDEF,
812 .policy = netlbl_mgmt_genl_policy,
813 .doit = netlbl_mgmt_listdef,
817 .cmd = NLBL_MGMT_C_PROTOCOLS,
819 .policy = netlbl_mgmt_genl_policy,
821 .dumpit = netlbl_mgmt_protocols,
824 .cmd = NLBL_MGMT_C_VERSION,
826 .policy = netlbl_mgmt_genl_policy,
827 .doit = netlbl_mgmt_version,
832 static struct genl_family netlbl_mgmt_gnl_family __ro_after_init = {
834 .name = NETLBL_NLTYPE_MGMT_NAME,
835 .version = NETLBL_PROTO_VERSION,
836 .maxattr = NLBL_MGMT_A_MAX,
837 .module = THIS_MODULE,
838 .ops = netlbl_mgmt_genl_ops,
839 .n_ops = ARRAY_SIZE(netlbl_mgmt_genl_ops),
843 * NetLabel Generic NETLINK Protocol Functions
847 * netlbl_mgmt_genl_init - Register the NetLabel management component
850 * Register the NetLabel management component with the Generic NETLINK
851 * mechanism. Returns zero on success, negative values on failure.
854 int __init netlbl_mgmt_genl_init(void)
856 return genl_register_family(&netlbl_mgmt_gnl_family);