Commit | Line | Data |
---|---|---|
d15c345f PM |
1 | /* |
2 | * NetLabel Management Support | |
3 | * | |
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. | |
7 | * | |
8 | * Author: Paul Moore <paul.moore@hp.com> | |
9 | * | |
10 | */ | |
11 | ||
12 | /* | |
13 | * (c) Copyright Hewlett-Packard Development Company, L.P., 2006 | |
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/types.h> | |
32 | #include <linux/socket.h> | |
33 | #include <linux/string.h> | |
34 | #include <linux/skbuff.h> | |
35 | #include <net/sock.h> | |
36 | #include <net/netlink.h> | |
37 | #include <net/genetlink.h> | |
38 | #include <net/netlabel.h> | |
39 | #include <net/cipso_ipv4.h> | |
c783f1ce | 40 | #include <asm/atomic.h> |
d15c345f PM |
41 | |
42 | #include "netlabel_domainhash.h" | |
43 | #include "netlabel_user.h" | |
44 | #include "netlabel_mgmt.h" | |
45 | ||
c783f1ce PM |
46 | /* NetLabel configured protocol counter */ |
47 | atomic_t netlabel_mgmt_protocount = ATOMIC_INIT(0); | |
23bcdc1a | 48 | |
fd385855 PM |
49 | /* Argument struct for netlbl_domhsh_walk() */ |
50 | struct netlbl_domhsh_walk_arg { | |
51 | struct netlink_callback *nl_cb; | |
52 | struct sk_buff *skb; | |
53 | u32 seq; | |
54 | }; | |
55 | ||
d15c345f PM |
56 | /* NetLabel Generic NETLINK CIPSOv4 family */ |
57 | static struct genl_family netlbl_mgmt_gnl_family = { | |
58 | .id = GENL_ID_GENERATE, | |
59 | .hdrsize = 0, | |
60 | .name = NETLBL_NLTYPE_MGMT_NAME, | |
61 | .version = NETLBL_PROTO_VERSION, | |
fd385855 | 62 | .maxattr = NLBL_MGMT_A_MAX, |
d15c345f PM |
63 | }; |
64 | ||
fd385855 | 65 | /* NetLabel Netlink attribute policy */ |
ef7c79ed | 66 | static const struct nla_policy netlbl_mgmt_genl_policy[NLBL_MGMT_A_MAX + 1] = { |
fd385855 PM |
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 | }; | |
d15c345f PM |
72 | |
73 | /* | |
74 | * NetLabel Command Handlers | |
75 | */ | |
76 | ||
77 | /** | |
78 | * netlbl_mgmt_add - Handle an ADD message | |
79 | * @skb: the NETLINK buffer | |
80 | * @info: the Generic NETLINK info block | |
81 | * | |
82 | * Description: | |
83 | * Process a user generated ADD message and add the domains from the message | |
84 | * to the hash table. See netlabel.h for a description of the message format. | |
85 | * Returns zero on success, negative values on failure. | |
86 | * | |
87 | */ | |
88 | static int netlbl_mgmt_add(struct sk_buff *skb, struct genl_info *info) | |
89 | { | |
90 | int ret_val = -EINVAL; | |
d15c345f | 91 | struct netlbl_dom_map *entry = NULL; |
fd385855 | 92 | size_t tmp_size; |
d15c345f | 93 | u32 tmp_val; |
95d4e6be | 94 | struct netlbl_audit audit_info; |
d15c345f | 95 | |
fd385855 PM |
96 | if (!info->attrs[NLBL_MGMT_A_DOMAIN] || |
97 | !info->attrs[NLBL_MGMT_A_PROTOCOL]) | |
d15c345f PM |
98 | goto add_failure; |
99 | ||
95d4e6be PM |
100 | netlbl_netlink_auditinfo(skb, &audit_info); |
101 | ||
fd385855 PM |
102 | entry = kzalloc(sizeof(*entry), GFP_KERNEL); |
103 | if (entry == NULL) { | |
104 | ret_val = -ENOMEM; | |
105 | goto add_failure; | |
106 | } | |
107 | tmp_size = nla_len(info->attrs[NLBL_MGMT_A_DOMAIN]); | |
108 | entry->domain = kmalloc(tmp_size, GFP_KERNEL); | |
109 | if (entry->domain == NULL) { | |
110 | ret_val = -ENOMEM; | |
d15c345f | 111 | goto add_failure; |
fd385855 PM |
112 | } |
113 | entry->type = nla_get_u32(info->attrs[NLBL_MGMT_A_PROTOCOL]); | |
114 | nla_strlcpy(entry->domain, info->attrs[NLBL_MGMT_A_DOMAIN], tmp_size); | |
d15c345f | 115 | |
fd385855 PM |
116 | switch (entry->type) { |
117 | case NETLBL_NLTYPE_UNLABELED: | |
95d4e6be | 118 | ret_val = netlbl_domhsh_add(entry, &audit_info); |
fd385855 PM |
119 | break; |
120 | case NETLBL_NLTYPE_CIPSOV4: | |
121 | if (!info->attrs[NLBL_MGMT_A_CV4DOI]) | |
d15c345f | 122 | goto add_failure; |
d15c345f | 123 | |
fd385855 PM |
124 | tmp_val = nla_get_u32(info->attrs[NLBL_MGMT_A_CV4DOI]); |
125 | /* We should be holding a rcu_read_lock() here while we hold | |
126 | * the result but since the entry will always be deleted when | |
127 | * the CIPSO DOI is deleted we aren't going to keep the | |
128 | * lock. */ | |
129 | rcu_read_lock(); | |
130 | entry->type_def.cipsov4 = cipso_v4_doi_getdef(tmp_val); | |
131 | if (entry->type_def.cipsov4 == NULL) { | |
d15c345f | 132 | rcu_read_unlock(); |
d15c345f | 133 | goto add_failure; |
fd385855 | 134 | } |
95d4e6be | 135 | ret_val = netlbl_domhsh_add(entry, &audit_info); |
fd385855 PM |
136 | rcu_read_unlock(); |
137 | break; | |
138 | default: | |
139 | goto add_failure; | |
d15c345f | 140 | } |
fd385855 PM |
141 | if (ret_val != 0) |
142 | goto add_failure; | |
d15c345f | 143 | |
d15c345f PM |
144 | return 0; |
145 | ||
146 | add_failure: | |
147 | if (entry) | |
148 | kfree(entry->domain); | |
149 | kfree(entry); | |
d15c345f PM |
150 | return ret_val; |
151 | } | |
152 | ||
153 | /** | |
154 | * netlbl_mgmt_remove - Handle a REMOVE message | |
155 | * @skb: the NETLINK buffer | |
156 | * @info: the Generic NETLINK info block | |
157 | * | |
158 | * Description: | |
159 | * Process a user generated REMOVE message and remove the specified domain | |
160 | * mappings. Returns zero on success, negative values on failure. | |
161 | * | |
162 | */ | |
163 | static int netlbl_mgmt_remove(struct sk_buff *skb, struct genl_info *info) | |
164 | { | |
fd385855 | 165 | char *domain; |
95d4e6be | 166 | struct netlbl_audit audit_info; |
d15c345f | 167 | |
fd385855 PM |
168 | if (!info->attrs[NLBL_MGMT_A_DOMAIN]) |
169 | return -EINVAL; | |
d15c345f | 170 | |
95d4e6be PM |
171 | netlbl_netlink_auditinfo(skb, &audit_info); |
172 | ||
fd385855 | 173 | domain = nla_data(info->attrs[NLBL_MGMT_A_DOMAIN]); |
95d4e6be | 174 | return netlbl_domhsh_remove(domain, &audit_info); |
fd385855 PM |
175 | } |
176 | ||
177 | /** | |
178 | * netlbl_mgmt_listall_cb - netlbl_domhsh_walk() callback for LISTALL | |
179 | * @entry: the domain mapping hash table entry | |
180 | * @arg: the netlbl_domhsh_walk_arg structure | |
181 | * | |
182 | * Description: | |
183 | * This function is designed to be used as a callback to the | |
184 | * netlbl_domhsh_walk() function for use in generating a response for a LISTALL | |
185 | * message. Returns the size of the message on success, negative values on | |
186 | * failure. | |
187 | * | |
188 | */ | |
189 | static int netlbl_mgmt_listall_cb(struct netlbl_dom_map *entry, void *arg) | |
190 | { | |
191 | int ret_val = -ENOMEM; | |
192 | struct netlbl_domhsh_walk_arg *cb_arg = arg; | |
193 | void *data; | |
194 | ||
17c157c8 TG |
195 | data = genlmsg_put(cb_arg->skb, NETLINK_CB(cb_arg->nl_cb->skb).pid, |
196 | cb_arg->seq, &netlbl_mgmt_gnl_family, | |
197 | NLM_F_MULTI, NLBL_MGMT_C_LISTALL); | |
fd385855 PM |
198 | if (data == NULL) |
199 | goto listall_cb_failure; | |
200 | ||
201 | ret_val = nla_put_string(cb_arg->skb, | |
202 | NLBL_MGMT_A_DOMAIN, | |
203 | entry->domain); | |
204 | if (ret_val != 0) | |
205 | goto listall_cb_failure; | |
206 | ret_val = nla_put_u32(cb_arg->skb, NLBL_MGMT_A_PROTOCOL, entry->type); | |
207 | if (ret_val != 0) | |
208 | goto listall_cb_failure; | |
209 | switch (entry->type) { | |
210 | case NETLBL_NLTYPE_CIPSOV4: | |
211 | ret_val = nla_put_u32(cb_arg->skb, | |
212 | NLBL_MGMT_A_CV4DOI, | |
213 | entry->type_def.cipsov4->doi); | |
d15c345f | 214 | if (ret_val != 0) |
fd385855 PM |
215 | goto listall_cb_failure; |
216 | break; | |
d15c345f PM |
217 | } |
218 | ||
fd385855 PM |
219 | cb_arg->seq++; |
220 | return genlmsg_end(cb_arg->skb, data); | |
d15c345f | 221 | |
fd385855 PM |
222 | listall_cb_failure: |
223 | genlmsg_cancel(cb_arg->skb, data); | |
d15c345f PM |
224 | return ret_val; |
225 | } | |
226 | ||
227 | /** | |
fd385855 | 228 | * netlbl_mgmt_listall - Handle a LISTALL message |
d15c345f | 229 | * @skb: the NETLINK buffer |
fd385855 | 230 | * @cb: the NETLINK callback |
d15c345f PM |
231 | * |
232 | * Description: | |
fd385855 PM |
233 | * Process a user generated LISTALL message and dumps the domain hash table in |
234 | * a form suitable for use in a kernel generated LISTALL message. Returns zero | |
235 | * on success, negative values on failure. | |
d15c345f PM |
236 | * |
237 | */ | |
fd385855 PM |
238 | static int netlbl_mgmt_listall(struct sk_buff *skb, |
239 | struct netlink_callback *cb) | |
d15c345f | 240 | { |
fd385855 PM |
241 | struct netlbl_domhsh_walk_arg cb_arg; |
242 | u32 skip_bkt = cb->args[0]; | |
243 | u32 skip_chain = cb->args[1]; | |
244 | ||
245 | cb_arg.nl_cb = cb; | |
246 | cb_arg.skb = skb; | |
247 | cb_arg.seq = cb->nlh->nlmsg_seq; | |
248 | ||
249 | netlbl_domhsh_walk(&skip_bkt, | |
250 | &skip_chain, | |
251 | netlbl_mgmt_listall_cb, | |
252 | &cb_arg); | |
253 | ||
254 | cb->args[0] = skip_bkt; | |
255 | cb->args[1] = skip_chain; | |
256 | return skb->len; | |
d15c345f PM |
257 | } |
258 | ||
259 | /** | |
260 | * netlbl_mgmt_adddef - Handle an ADDDEF message | |
261 | * @skb: the NETLINK buffer | |
262 | * @info: the Generic NETLINK info block | |
263 | * | |
264 | * Description: | |
265 | * Process a user generated ADDDEF message and respond accordingly. Returns | |
266 | * zero on success, negative values on failure. | |
267 | * | |
268 | */ | |
269 | static int netlbl_mgmt_adddef(struct sk_buff *skb, struct genl_info *info) | |
270 | { | |
271 | int ret_val = -EINVAL; | |
d15c345f PM |
272 | struct netlbl_dom_map *entry = NULL; |
273 | u32 tmp_val; | |
95d4e6be | 274 | struct netlbl_audit audit_info; |
d15c345f | 275 | |
fd385855 | 276 | if (!info->attrs[NLBL_MGMT_A_PROTOCOL]) |
d15c345f | 277 | goto adddef_failure; |
d15c345f | 278 | |
95d4e6be PM |
279 | netlbl_netlink_auditinfo(skb, &audit_info); |
280 | ||
d15c345f PM |
281 | entry = kzalloc(sizeof(*entry), GFP_KERNEL); |
282 | if (entry == NULL) { | |
283 | ret_val = -ENOMEM; | |
284 | goto adddef_failure; | |
285 | } | |
fd385855 | 286 | entry->type = nla_get_u32(info->attrs[NLBL_MGMT_A_PROTOCOL]); |
d15c345f | 287 | |
d15c345f PM |
288 | switch (entry->type) { |
289 | case NETLBL_NLTYPE_UNLABELED: | |
95d4e6be | 290 | ret_val = netlbl_domhsh_add_default(entry, &audit_info); |
d15c345f PM |
291 | break; |
292 | case NETLBL_NLTYPE_CIPSOV4: | |
fd385855 | 293 | if (!info->attrs[NLBL_MGMT_A_CV4DOI]) |
d15c345f | 294 | goto adddef_failure; |
fd385855 PM |
295 | |
296 | tmp_val = nla_get_u32(info->attrs[NLBL_MGMT_A_CV4DOI]); | |
297 | /* We should be holding a rcu_read_lock() here while we hold | |
298 | * the result but since the entry will always be deleted when | |
299 | * the CIPSO DOI is deleted we aren't going to keep the | |
300 | * lock. */ | |
d15c345f PM |
301 | rcu_read_lock(); |
302 | entry->type_def.cipsov4 = cipso_v4_doi_getdef(tmp_val); | |
303 | if (entry->type_def.cipsov4 == NULL) { | |
304 | rcu_read_unlock(); | |
d15c345f PM |
305 | goto adddef_failure; |
306 | } | |
95d4e6be | 307 | ret_val = netlbl_domhsh_add_default(entry, &audit_info); |
d15c345f PM |
308 | rcu_read_unlock(); |
309 | break; | |
310 | default: | |
fd385855 | 311 | goto adddef_failure; |
d15c345f PM |
312 | } |
313 | if (ret_val != 0) | |
314 | goto adddef_failure; | |
315 | ||
d15c345f PM |
316 | return 0; |
317 | ||
318 | adddef_failure: | |
319 | kfree(entry); | |
d15c345f PM |
320 | return ret_val; |
321 | } | |
322 | ||
323 | /** | |
324 | * netlbl_mgmt_removedef - Handle a REMOVEDEF message | |
325 | * @skb: the NETLINK buffer | |
326 | * @info: the Generic NETLINK info block | |
327 | * | |
328 | * Description: | |
329 | * Process a user generated REMOVEDEF message and remove the default domain | |
330 | * mapping. Returns zero on success, negative values on failure. | |
331 | * | |
332 | */ | |
333 | static int netlbl_mgmt_removedef(struct sk_buff *skb, struct genl_info *info) | |
334 | { | |
95d4e6be PM |
335 | struct netlbl_audit audit_info; |
336 | ||
337 | netlbl_netlink_auditinfo(skb, &audit_info); | |
338 | ||
339 | return netlbl_domhsh_remove_default(&audit_info); | |
d15c345f PM |
340 | } |
341 | ||
342 | /** | |
343 | * netlbl_mgmt_listdef - Handle a LISTDEF message | |
344 | * @skb: the NETLINK buffer | |
345 | * @info: the Generic NETLINK info block | |
346 | * | |
347 | * Description: | |
348 | * Process a user generated LISTDEF message and dumps the default domain | |
349 | * mapping in a form suitable for use in a kernel generated LISTDEF message. | |
350 | * Returns zero on success, negative values on failure. | |
351 | * | |
352 | */ | |
353 | static int netlbl_mgmt_listdef(struct sk_buff *skb, struct genl_info *info) | |
354 | { | |
355 | int ret_val = -ENOMEM; | |
fd385855 PM |
356 | struct sk_buff *ans_skb = NULL; |
357 | void *data; | |
358 | struct netlbl_dom_map *entry; | |
d15c345f | 359 | |
339bf98f | 360 | ans_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); |
d15c345f | 361 | if (ans_skb == NULL) |
fd385855 | 362 | return -ENOMEM; |
17c157c8 TG |
363 | data = genlmsg_put_reply(ans_skb, info, &netlbl_mgmt_gnl_family, |
364 | 0, NLBL_MGMT_C_LISTDEF); | |
fd385855 | 365 | if (data == NULL) |
d15c345f | 366 | goto listdef_failure; |
d15c345f | 367 | |
fd385855 PM |
368 | rcu_read_lock(); |
369 | entry = netlbl_domhsh_getentry(NULL); | |
370 | if (entry == NULL) { | |
371 | ret_val = -ENOENT; | |
372 | goto listdef_failure_lock; | |
373 | } | |
374 | ret_val = nla_put_u32(ans_skb, NLBL_MGMT_A_PROTOCOL, entry->type); | |
d15c345f | 375 | if (ret_val != 0) |
fd385855 PM |
376 | goto listdef_failure_lock; |
377 | switch (entry->type) { | |
378 | case NETLBL_NLTYPE_CIPSOV4: | |
379 | ret_val = nla_put_u32(ans_skb, | |
380 | NLBL_MGMT_A_CV4DOI, | |
381 | entry->type_def.cipsov4->doi); | |
382 | if (ret_val != 0) | |
383 | goto listdef_failure_lock; | |
384 | break; | |
385 | } | |
386 | rcu_read_unlock(); | |
d15c345f | 387 | |
fd385855 PM |
388 | genlmsg_end(ans_skb, data); |
389 | ||
81878d27 | 390 | ret_val = genlmsg_reply(ans_skb, info); |
fd385855 PM |
391 | if (ret_val != 0) |
392 | goto listdef_failure; | |
d15c345f PM |
393 | return 0; |
394 | ||
fd385855 PM |
395 | listdef_failure_lock: |
396 | rcu_read_unlock(); | |
d15c345f | 397 | listdef_failure: |
fd385855 | 398 | kfree_skb(ans_skb); |
d15c345f PM |
399 | return ret_val; |
400 | } | |
401 | ||
402 | /** | |
fd385855 PM |
403 | * netlbl_mgmt_protocols_cb - Write an individual PROTOCOL message response |
404 | * @skb: the skb to write to | |
405 | * @seq: the NETLINK sequence number | |
406 | * @cb: the NETLINK callback | |
407 | * @protocol: the NetLabel protocol to use in the message | |
d15c345f PM |
408 | * |
409 | * Description: | |
fd385855 PM |
410 | * This function is to be used in conjunction with netlbl_mgmt_protocols() to |
411 | * answer a application's PROTOCOLS message. Returns the size of the message | |
412 | * on success, negative values on failure. | |
d15c345f PM |
413 | * |
414 | */ | |
fd385855 PM |
415 | static int netlbl_mgmt_protocols_cb(struct sk_buff *skb, |
416 | struct netlink_callback *cb, | |
417 | u32 protocol) | |
d15c345f PM |
418 | { |
419 | int ret_val = -ENOMEM; | |
fd385855 PM |
420 | void *data; |
421 | ||
17c157c8 TG |
422 | data = genlmsg_put(skb, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq, |
423 | &netlbl_mgmt_gnl_family, NLM_F_MULTI, | |
424 | NLBL_MGMT_C_PROTOCOLS); | |
fd385855 PM |
425 | if (data == NULL) |
426 | goto protocols_cb_failure; | |
427 | ||
428 | ret_val = nla_put_u32(skb, NLBL_MGMT_A_PROTOCOL, protocol); | |
d15c345f | 429 | if (ret_val != 0) |
fd385855 | 430 | goto protocols_cb_failure; |
d15c345f | 431 | |
fd385855 | 432 | return genlmsg_end(skb, data); |
d15c345f | 433 | |
fd385855 PM |
434 | protocols_cb_failure: |
435 | genlmsg_cancel(skb, data); | |
d15c345f PM |
436 | return ret_val; |
437 | } | |
438 | ||
fd385855 PM |
439 | /** |
440 | * netlbl_mgmt_protocols - Handle a PROTOCOLS message | |
441 | * @skb: the NETLINK buffer | |
442 | * @cb: the NETLINK callback | |
443 | * | |
444 | * Description: | |
445 | * Process a user generated PROTOCOLS message and respond accordingly. | |
446 | * | |
447 | */ | |
448 | static int netlbl_mgmt_protocols(struct sk_buff *skb, | |
449 | struct netlink_callback *cb) | |
450 | { | |
451 | u32 protos_sent = cb->args[0]; | |
452 | ||
453 | if (protos_sent == 0) { | |
454 | if (netlbl_mgmt_protocols_cb(skb, | |
455 | cb, | |
456 | NETLBL_NLTYPE_UNLABELED) < 0) | |
457 | goto protocols_return; | |
458 | protos_sent++; | |
459 | } | |
460 | if (protos_sent == 1) { | |
461 | if (netlbl_mgmt_protocols_cb(skb, | |
462 | cb, | |
463 | NETLBL_NLTYPE_CIPSOV4) < 0) | |
464 | goto protocols_return; | |
465 | protos_sent++; | |
466 | } | |
467 | ||
468 | protocols_return: | |
469 | cb->args[0] = protos_sent; | |
470 | return skb->len; | |
471 | } | |
472 | ||
d15c345f PM |
473 | /** |
474 | * netlbl_mgmt_version - Handle a VERSION message | |
475 | * @skb: the NETLINK buffer | |
476 | * @info: the Generic NETLINK info block | |
477 | * | |
478 | * Description: | |
479 | * Process a user generated VERSION message and respond accordingly. Returns | |
480 | * zero on success, negative values on failure. | |
481 | * | |
482 | */ | |
483 | static int netlbl_mgmt_version(struct sk_buff *skb, struct genl_info *info) | |
484 | { | |
485 | int ret_val = -ENOMEM; | |
486 | struct sk_buff *ans_skb = NULL; | |
fd385855 | 487 | void *data; |
d15c345f | 488 | |
339bf98f | 489 | ans_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); |
d15c345f | 490 | if (ans_skb == NULL) |
fd385855 | 491 | return -ENOMEM; |
17c157c8 TG |
492 | data = genlmsg_put_reply(ans_skb, info, &netlbl_mgmt_gnl_family, |
493 | 0, NLBL_MGMT_C_VERSION); | |
fd385855 | 494 | if (data == NULL) |
d15c345f PM |
495 | goto version_failure; |
496 | ||
fd385855 PM |
497 | ret_val = nla_put_u32(ans_skb, |
498 | NLBL_MGMT_A_VERSION, | |
499 | NETLBL_PROTO_VERSION); | |
d15c345f PM |
500 | if (ret_val != 0) |
501 | goto version_failure; | |
502 | ||
fd385855 PM |
503 | genlmsg_end(ans_skb, data); |
504 | ||
81878d27 | 505 | ret_val = genlmsg_reply(ans_skb, info); |
d15c345f PM |
506 | if (ret_val != 0) |
507 | goto version_failure; | |
d15c345f PM |
508 | return 0; |
509 | ||
510 | version_failure: | |
511 | kfree_skb(ans_skb); | |
d15c345f PM |
512 | return ret_val; |
513 | } | |
514 | ||
515 | ||
516 | /* | |
517 | * NetLabel Generic NETLINK Command Definitions | |
518 | */ | |
519 | ||
520 | static struct genl_ops netlbl_mgmt_genl_c_add = { | |
521 | .cmd = NLBL_MGMT_C_ADD, | |
fd385855 PM |
522 | .flags = GENL_ADMIN_PERM, |
523 | .policy = netlbl_mgmt_genl_policy, | |
d15c345f PM |
524 | .doit = netlbl_mgmt_add, |
525 | .dumpit = NULL, | |
526 | }; | |
527 | ||
528 | static struct genl_ops netlbl_mgmt_genl_c_remove = { | |
529 | .cmd = NLBL_MGMT_C_REMOVE, | |
fd385855 PM |
530 | .flags = GENL_ADMIN_PERM, |
531 | .policy = netlbl_mgmt_genl_policy, | |
d15c345f PM |
532 | .doit = netlbl_mgmt_remove, |
533 | .dumpit = NULL, | |
534 | }; | |
535 | ||
fd385855 PM |
536 | static struct genl_ops netlbl_mgmt_genl_c_listall = { |
537 | .cmd = NLBL_MGMT_C_LISTALL, | |
d15c345f | 538 | .flags = 0, |
fd385855 PM |
539 | .policy = netlbl_mgmt_genl_policy, |
540 | .doit = NULL, | |
541 | .dumpit = netlbl_mgmt_listall, | |
d15c345f PM |
542 | }; |
543 | ||
544 | static struct genl_ops netlbl_mgmt_genl_c_adddef = { | |
545 | .cmd = NLBL_MGMT_C_ADDDEF, | |
fd385855 PM |
546 | .flags = GENL_ADMIN_PERM, |
547 | .policy = netlbl_mgmt_genl_policy, | |
d15c345f PM |
548 | .doit = netlbl_mgmt_adddef, |
549 | .dumpit = NULL, | |
550 | }; | |
551 | ||
552 | static struct genl_ops netlbl_mgmt_genl_c_removedef = { | |
553 | .cmd = NLBL_MGMT_C_REMOVEDEF, | |
fd385855 PM |
554 | .flags = GENL_ADMIN_PERM, |
555 | .policy = netlbl_mgmt_genl_policy, | |
d15c345f PM |
556 | .doit = netlbl_mgmt_removedef, |
557 | .dumpit = NULL, | |
558 | }; | |
559 | ||
560 | static struct genl_ops netlbl_mgmt_genl_c_listdef = { | |
561 | .cmd = NLBL_MGMT_C_LISTDEF, | |
562 | .flags = 0, | |
fd385855 | 563 | .policy = netlbl_mgmt_genl_policy, |
d15c345f PM |
564 | .doit = netlbl_mgmt_listdef, |
565 | .dumpit = NULL, | |
566 | }; | |
567 | ||
fd385855 PM |
568 | static struct genl_ops netlbl_mgmt_genl_c_protocols = { |
569 | .cmd = NLBL_MGMT_C_PROTOCOLS, | |
d15c345f | 570 | .flags = 0, |
fd385855 PM |
571 | .policy = netlbl_mgmt_genl_policy, |
572 | .doit = NULL, | |
573 | .dumpit = netlbl_mgmt_protocols, | |
d15c345f PM |
574 | }; |
575 | ||
576 | static struct genl_ops netlbl_mgmt_genl_c_version = { | |
577 | .cmd = NLBL_MGMT_C_VERSION, | |
578 | .flags = 0, | |
fd385855 | 579 | .policy = netlbl_mgmt_genl_policy, |
d15c345f PM |
580 | .doit = netlbl_mgmt_version, |
581 | .dumpit = NULL, | |
582 | }; | |
583 | ||
584 | /* | |
585 | * NetLabel Generic NETLINK Protocol Functions | |
586 | */ | |
587 | ||
588 | /** | |
589 | * netlbl_mgmt_genl_init - Register the NetLabel management component | |
590 | * | |
591 | * Description: | |
592 | * Register the NetLabel management component with the Generic NETLINK | |
593 | * mechanism. Returns zero on success, negative values on failure. | |
594 | * | |
595 | */ | |
596 | int netlbl_mgmt_genl_init(void) | |
597 | { | |
598 | int ret_val; | |
599 | ||
600 | ret_val = genl_register_family(&netlbl_mgmt_gnl_family); | |
601 | if (ret_val != 0) | |
602 | return ret_val; | |
603 | ||
604 | ret_val = genl_register_ops(&netlbl_mgmt_gnl_family, | |
605 | &netlbl_mgmt_genl_c_add); | |
606 | if (ret_val != 0) | |
607 | return ret_val; | |
608 | ret_val = genl_register_ops(&netlbl_mgmt_gnl_family, | |
609 | &netlbl_mgmt_genl_c_remove); | |
610 | if (ret_val != 0) | |
611 | return ret_val; | |
612 | ret_val = genl_register_ops(&netlbl_mgmt_gnl_family, | |
fd385855 | 613 | &netlbl_mgmt_genl_c_listall); |
d15c345f PM |
614 | if (ret_val != 0) |
615 | return ret_val; | |
616 | ret_val = genl_register_ops(&netlbl_mgmt_gnl_family, | |
617 | &netlbl_mgmt_genl_c_adddef); | |
618 | if (ret_val != 0) | |
619 | return ret_val; | |
620 | ret_val = genl_register_ops(&netlbl_mgmt_gnl_family, | |
621 | &netlbl_mgmt_genl_c_removedef); | |
622 | if (ret_val != 0) | |
623 | return ret_val; | |
624 | ret_val = genl_register_ops(&netlbl_mgmt_gnl_family, | |
625 | &netlbl_mgmt_genl_c_listdef); | |
626 | if (ret_val != 0) | |
627 | return ret_val; | |
628 | ret_val = genl_register_ops(&netlbl_mgmt_gnl_family, | |
fd385855 | 629 | &netlbl_mgmt_genl_c_protocols); |
d15c345f PM |
630 | if (ret_val != 0) |
631 | return ret_val; | |
632 | ret_val = genl_register_ops(&netlbl_mgmt_gnl_family, | |
633 | &netlbl_mgmt_genl_c_version); | |
634 | if (ret_val != 0) | |
635 | return ret_val; | |
636 | ||
637 | return 0; | |
638 | } |