projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'drm-nouveau-next' of git://git.freedesktop.org/git/nouveau/linux-2...
[deliverable/linux.git] / net / xfrm / xfrm_user.c
CommitLineData
1da177e4
LT		 1/* xfrm_user.c: User interface to configure xfrm engine.
2 *
3 * Copyright (C) 2002 David S. Miller (davem@redhat.com)
4 *
5 * Changes:
6 * Mitsuru KANDA @USAGI
7 * Kazunori MIYAZAWA @USAGI
8 * Kunihiro Ishiguro <kunihiro@ipinfusion.com>
9 * IPv6 support
df71837d 10 *
1da177e4
LT		 11 */
12
9409f38a 13#include <linux/crypto.h>
1da177e4
LT		 14#include <linux/module.h>
15#include <linux/kernel.h>
16#include <linux/types.h>
17#include <linux/slab.h>
18#include <linux/socket.h>
19#include <linux/string.h>
20#include <linux/net.h>
21#include <linux/skbuff.h>
1da177e4
LT		 22#include <linux/pfkeyv2.h>
23#include <linux/ipsec.h>
24#include <linux/init.h>
25#include <linux/security.h>
26#include <net/sock.h>
27#include <net/xfrm.h>
88fc2c84 28#include <net/netlink.h>
fa6dd8a2 29#include <net/ah.h>
1da177e4 30#include <asm/uaccess.h>
e23c7194
MN		 31#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
32#include <linux/in6.h>
33#endif
1da177e4 34
1a6509d9
HX		 35static inline int aead_len(struct xfrm_algo_aead *alg)
36{
37 return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
38}
39
5424f32e 40static int verify_one_alg(struct nlattr **attrs, enum xfrm_attr_type_t type)
1da177e4 41{
5424f32e 42 struct nlattr *rt = attrs[type];
1da177e4
LT		 43 struct xfrm_algo *algp;
44
45 if (!rt)
46 return 0;
47
5424f32e 48 algp = nla_data(rt);
0f99be0d 49 if (nla_len(rt) < xfrm_alg_len(algp))
31c26852
HX		 50 return -EINVAL;
51
1da177e4
LT		 52 switch (type) {
53 case XFRMA_ALG_AUTH:
1da177e4 54 case XFRMA_ALG_CRYPT:
1da177e4 55 case XFRMA_ALG_COMP:
1da177e4
LT		 56 break;
57
58 default:
59 return -EINVAL;
3ff50b79 60 }
1da177e4
LT		 61
62 algp->alg_name[CRYPTO_MAX_ALG_NAME - 1] = '\0';
63 return 0;
64}
65
4447bb33
MW		 66static int verify_auth_trunc(struct nlattr **attrs)
67{
68 struct nlattr *rt = attrs[XFRMA_ALG_AUTH_TRUNC];
69 struct xfrm_algo_auth *algp;
70
71 if (!rt)
72 return 0;
73
74 algp = nla_data(rt);
75 if (nla_len(rt) < xfrm_alg_auth_len(algp))
76 return -EINVAL;
77
78 algp->alg_name[CRYPTO_MAX_ALG_NAME - 1] = '\0';
79 return 0;
80}
81
1a6509d9
HX		 82static int verify_aead(struct nlattr **attrs)
83{
84 struct nlattr *rt = attrs[XFRMA_ALG_AEAD];
85 struct xfrm_algo_aead *algp;
86
87 if (!rt)
88 return 0;
89
90 algp = nla_data(rt);
91 if (nla_len(rt) < aead_len(algp))
92 return -EINVAL;
93
94 algp->alg_name[CRYPTO_MAX_ALG_NAME - 1] = '\0';
95 return 0;
96}
97
5424f32e 98static void verify_one_addr(struct nlattr **attrs, enum xfrm_attr_type_t type,
eb2971b6
MN		 99 xfrm_address_t **addrp)
100{
5424f32e 101 struct nlattr *rt = attrs[type];
eb2971b6 102
cf5cb79f 103 if (rt && addrp)
5424f32e 104 *addrp = nla_data(rt);
eb2971b6 105}
df71837d 106
5424f32e 107static inline int verify_sec_ctx_len(struct nlattr **attrs)
df71837d 108{
5424f32e 109 struct nlattr *rt = attrs[XFRMA_SEC_CTX];
df71837d 110 struct xfrm_user_sec_ctx *uctx;
df71837d
TJ		 111
112 if (!rt)
113 return 0;
114
5424f32e 115 uctx = nla_data(rt);
cf5cb79f 116 if (uctx->len != (sizeof(struct xfrm_user_sec_ctx) + uctx->ctx_len))
df71837d
TJ		 117 return -EINVAL;
118
119 return 0;
120}
121
122
1da177e4 123static int verify_newsa_info(struct xfrm_usersa_info *p,
5424f32e 124 struct nlattr **attrs)
1da177e4
LT		 125{
126 int err;
127
128 err = -EINVAL;
129 switch (p->family) {
130 case AF_INET:
131 break;
132
133 case AF_INET6:
134#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
135 break;
136#else
137 err = -EAFNOSUPPORT;
138 goto out;
139#endif
140
141 default:
142 goto out;
3ff50b79 143 }
1da177e4
LT		 144
145 err = -EINVAL;
146 switch (p->id.proto) {
147 case IPPROTO_AH:
4447bb33
MW		 148 if ((!attrs[XFRMA_ALG_AUTH] &&
149 !attrs[XFRMA_ALG_AUTH_TRUNC]) ||
1a6509d9 150 attrs[XFRMA_ALG_AEAD] ||
35a7aa08 151 attrs[XFRMA_ALG_CRYPT] ||
35d2856b
MW		 152 attrs[XFRMA_ALG_COMP] ||
153 attrs[XFRMA_TFCPAD])
1da177e4
LT		 154 goto out;
155 break;
156
157 case IPPROTO_ESP:
1a6509d9
HX		 158 if (attrs[XFRMA_ALG_COMP])
159 goto out;
160 if (!attrs[XFRMA_ALG_AUTH] &&
4447bb33 161 !attrs[XFRMA_ALG_AUTH_TRUNC] &&
1a6509d9
HX		 162 !attrs[XFRMA_ALG_CRYPT] &&
163 !attrs[XFRMA_ALG_AEAD])
164 goto out;
165 if ((attrs[XFRMA_ALG_AUTH] ||
4447bb33 166 attrs[XFRMA_ALG_AUTH_TRUNC] ||
1a6509d9
HX		 167 attrs[XFRMA_ALG_CRYPT]) &&
168 attrs[XFRMA_ALG_AEAD])
1da177e4 169 goto out;
35d2856b
MW		 170 if (attrs[XFRMA_TFCPAD] &&
171 p->mode != XFRM_MODE_TUNNEL)
172 goto out;
1da177e4
LT		 173 break;
174
175 case IPPROTO_COMP:
35a7aa08 176 if (!attrs[XFRMA_ALG_COMP] ||
1a6509d9 177 attrs[XFRMA_ALG_AEAD] ||
35a7aa08 178 attrs[XFRMA_ALG_AUTH] ||
4447bb33 179 attrs[XFRMA_ALG_AUTH_TRUNC] ||
35d2856b
MW		 180 attrs[XFRMA_ALG_CRYPT] ||
181 attrs[XFRMA_TFCPAD])
1da177e4
LT		 182 goto out;
183 break;
184
e23c7194
MN		 185#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
186 case IPPROTO_DSTOPTS:
187 case IPPROTO_ROUTING:
35a7aa08
TG		 188 if (attrs[XFRMA_ALG_COMP] ||
189 attrs[XFRMA_ALG_AUTH] ||
4447bb33 190 attrs[XFRMA_ALG_AUTH_TRUNC] ||
1a6509d9 191 attrs[XFRMA_ALG_AEAD] ||
35a7aa08
TG		 192 attrs[XFRMA_ALG_CRYPT] ||
193 attrs[XFRMA_ENCAP] ||
194 attrs[XFRMA_SEC_CTX] ||
35d2856b 195 attrs[XFRMA_TFCPAD] ||
35a7aa08 196 !attrs[XFRMA_COADDR])
e23c7194
MN		 197 goto out;
198 break;
199#endif
200
1da177e4
LT		 201 default:
202 goto out;
3ff50b79 203 }
1da177e4 204
1a6509d9
HX		 205 if ((err = verify_aead(attrs)))
206 goto out;
4447bb33
MW		 207 if ((err = verify_auth_trunc(attrs)))
208 goto out;
35a7aa08 209 if ((err = verify_one_alg(attrs, XFRMA_ALG_AUTH)))
1da177e4 210 goto out;
35a7aa08 211 if ((err = verify_one_alg(attrs, XFRMA_ALG_CRYPT)))
1da177e4 212 goto out;
35a7aa08 213 if ((err = verify_one_alg(attrs, XFRMA_ALG_COMP)))
1da177e4 214 goto out;
35a7aa08 215 if ((err = verify_sec_ctx_len(attrs)))
df71837d 216 goto out;
1da177e4
LT		 217
218 err = -EINVAL;
219 switch (p->mode) {
7e49e6de
MN		 220 case XFRM_MODE_TRANSPORT:
221 case XFRM_MODE_TUNNEL:
060f02a3 222 case XFRM_MODE_ROUTEOPTIMIZATION:
0a69452c 223 case XFRM_MODE_BEET:
1da177e4
LT		 224 break;
225
226 default:
227 goto out;
3ff50b79 228 }
1da177e4
LT		 229
230 err = 0;
231
232out:
233 return err;
234}
235
236static int attach_one_algo(struct xfrm_algo **algpp, u8 *props,
237 struct xfrm_algo_desc *(*get_byname)(char *, int),
5424f32e 238 struct nlattr *rta)
1da177e4 239{
1da177e4
LT		 240 struct xfrm_algo *p, *ualg;
241 struct xfrm_algo_desc *algo;
242
243 if (!rta)
244 return 0;
245
5424f32e 246 ualg = nla_data(rta);
1da177e4
LT		 247
248 algo = get_byname(ualg->alg_name, 1);
249 if (!algo)
250 return -ENOSYS;
251 *props = algo->desc.sadb_alg_id;
252
0f99be0d 253 p = kmemdup(ualg, xfrm_alg_len(ualg), GFP_KERNEL);
1da177e4
LT		 254 if (!p)
255 return -ENOMEM;
256
04ff1260 257 strcpy(p->alg_name, algo->name);
1da177e4
LT		 258 *algpp = p;
259 return 0;
260}
261
4447bb33
MW		 262static int attach_auth(struct xfrm_algo_auth **algpp, u8 *props,
263 struct nlattr *rta)
264{
265 struct xfrm_algo *ualg;
266 struct xfrm_algo_auth *p;
267 struct xfrm_algo_desc *algo;
268
269 if (!rta)
270 return 0;
271
272 ualg = nla_data(rta);
273
274 algo = xfrm_aalg_get_byname(ualg->alg_name, 1);
275 if (!algo)
276 return -ENOSYS;
277 *props = algo->desc.sadb_alg_id;
278
279 p = kmalloc(sizeof(*p) + (ualg->alg_key_len + 7) / 8, GFP_KERNEL);
280 if (!p)
281 return -ENOMEM;
282
283 strcpy(p->alg_name, algo->name);
284 p->alg_key_len = ualg->alg_key_len;
285 p->alg_trunc_len = algo->uinfo.auth.icv_truncbits;
286 memcpy(p->alg_key, ualg->alg_key, (ualg->alg_key_len + 7) / 8);
287
288 *algpp = p;
289 return 0;
290}
291
292static int attach_auth_trunc(struct xfrm_algo_auth **algpp, u8 *props,
293 struct nlattr *rta)
294{
295 struct xfrm_algo_auth *p, *ualg;
296 struct xfrm_algo_desc *algo;
297
298 if (!rta)
299 return 0;
300
301 ualg = nla_data(rta);
302
303 algo = xfrm_aalg_get_byname(ualg->alg_name, 1);
304 if (!algo)
305 return -ENOSYS;
fa6dd8a2
ND		 306 if ((ualg->alg_trunc_len / 8) > MAX_AH_AUTH_LEN ||
307 ualg->alg_trunc_len > algo->uinfo.auth.icv_fullbits)
4447bb33
MW		 308 return -EINVAL;
309 *props = algo->desc.sadb_alg_id;
310
311 p = kmemdup(ualg, xfrm_alg_auth_len(ualg), GFP_KERNEL);
312 if (!p)
313 return -ENOMEM;
314
315 strcpy(p->alg_name, algo->name);
316 if (!p->alg_trunc_len)
317 p->alg_trunc_len = algo->uinfo.auth.icv_truncbits;
318
319 *algpp = p;
320 return 0;
321}
322
1a6509d9
HX		 323static int attach_aead(struct xfrm_algo_aead **algpp, u8 *props,
324 struct nlattr *rta)
325{
326 struct xfrm_algo_aead *p, *ualg;
327 struct xfrm_algo_desc *algo;
328
329 if (!rta)
330 return 0;
331
332 ualg = nla_data(rta);
333
334 algo = xfrm_aead_get_byname(ualg->alg_name, ualg->alg_icv_len, 1);
335 if (!algo)
336 return -ENOSYS;
337 *props = algo->desc.sadb_alg_id;
338
339 p = kmemdup(ualg, aead_len(ualg), GFP_KERNEL);
340 if (!p)
341 return -ENOMEM;
342
343 strcpy(p->alg_name, algo->name);
344 *algpp = p;
345 return 0;
346}
347
661697f7 348static inline int xfrm_user_sec_ctx_size(struct xfrm_sec_ctx *xfrm_ctx)
df71837d 349{
df71837d
TJ		 350 int len = 0;
351
352 if (xfrm_ctx) {
353 len += sizeof(struct xfrm_user_sec_ctx);
354 len += xfrm_ctx->ctx_len;
355 }
356 return len;
357}
358
1da177e4
LT		 359static void copy_from_user_state(struct xfrm_state *x, struct xfrm_usersa_info *p)
360{
361 memcpy(&x->id, &p->id, sizeof(x->id));
362 memcpy(&x->sel, &p->sel, sizeof(x->sel));
363 memcpy(&x->lft, &p->lft, sizeof(x->lft));
364 x->props.mode = p->mode;
365 x->props.replay_window = p->replay_window;
366 x->props.reqid = p->reqid;
367 x->props.family = p->family;
54489c14 368 memcpy(&x->props.saddr, &p->saddr, sizeof(x->props.saddr));
1da177e4 369 x->props.flags = p->flags;
196b0036 370
ccf9b3b8 371 if (!x->sel.family && !(p->flags & XFRM_STATE_AF_UNSPEC))
196b0036 372 x->sel.family = p->family;
1da177e4
LT		 373}
374
d51d081d
JHS		 375/*
376 * someday when pfkey also has support, we could have the code
377 * somehow made shareable and move it to xfrm_state.c - JHS
378 *
379*/
5424f32e 380static void xfrm_update_ae_params(struct xfrm_state *x, struct nlattr **attrs)
d51d081d 381{
5424f32e
TG		 382 struct nlattr *rp = attrs[XFRMA_REPLAY_VAL];
383 struct nlattr *lt = attrs[XFRMA_LTIME_VAL];
384 struct nlattr *et = attrs[XFRMA_ETIMER_THRESH];
385 struct nlattr *rt = attrs[XFRMA_REPLAY_THRESH];
d51d081d
JHS		 386
387 if (rp) {
388 struct xfrm_replay_state *replay;
5424f32e 389 replay = nla_data(rp);
d51d081d
JHS		 390 memcpy(&x->replay, replay, sizeof(*replay));
391 memcpy(&x->preplay, replay, sizeof(*replay));
392 }
393
394 if (lt) {
395 struct xfrm_lifetime_cur *ltime;
5424f32e 396 ltime = nla_data(lt);
d51d081d
JHS		 397 x->curlft.bytes = ltime->bytes;
398 x->curlft.packets = ltime->packets;
399 x->curlft.add_time = ltime->add_time;
400 x->curlft.use_time = ltime->use_time;
401 }
402
cf5cb79f 403 if (et)
5424f32e 404 x->replay_maxage = nla_get_u32(et);
d51d081d 405
cf5cb79f 406 if (rt)
5424f32e 407 x->replay_maxdiff = nla_get_u32(rt);
d51d081d
JHS		 408}
409
fc34acd3
AD		 410static struct xfrm_state *xfrm_state_construct(struct net *net,
411 struct xfrm_usersa_info *p,
5424f32e 412 struct nlattr **attrs,
1da177e4
LT		 413 int *errp)
414{
fc34acd3 415 struct xfrm_state *x = xfrm_state_alloc(net);
1da177e4
LT		 416 int err = -ENOMEM;
417
418 if (!x)
419 goto error_no_put;
420
421 copy_from_user_state(x, p);
422
1a6509d9
HX		 423 if ((err = attach_aead(&x->aead, &x->props.ealgo,
424 attrs[XFRMA_ALG_AEAD])))
425 goto error;
4447bb33
MW		 426 if ((err = attach_auth_trunc(&x->aalg, &x->props.aalgo,
427 attrs[XFRMA_ALG_AUTH_TRUNC])))
1da177e4 428 goto error;
4447bb33
MW		 429 if (!x->props.aalgo) {
430 if ((err = attach_auth(&x->aalg, &x->props.aalgo,
431 attrs[XFRMA_ALG_AUTH])))
432 goto error;
433 }
1da177e4
LT		 434 if ((err = attach_one_algo(&x->ealg, &x->props.ealgo,
435 xfrm_ealg_get_byname,
35a7aa08 436 attrs[XFRMA_ALG_CRYPT])))
1da177e4
LT		 437 goto error;
438 if ((err = attach_one_algo(&x->calg, &x->props.calgo,
439 xfrm_calg_get_byname,
35a7aa08 440 attrs[XFRMA_ALG_COMP])))
1da177e4 441 goto error;
fd21150a
TG		 442
443 if (attrs[XFRMA_ENCAP]) {
444 x->encap = kmemdup(nla_data(attrs[XFRMA_ENCAP]),
445 sizeof(*x->encap), GFP_KERNEL);
446 if (x->encap == NULL)
447 goto error;
448 }
449
35d2856b
MW		 450 if (attrs[XFRMA_TFCPAD])
451 x->tfcpad = nla_get_u32(attrs[XFRMA_TFCPAD]);
452
fd21150a
TG		 453 if (attrs[XFRMA_COADDR]) {
454 x->coaddr = kmemdup(nla_data(attrs[XFRMA_COADDR]),
455 sizeof(*x->coaddr), GFP_KERNEL);
456 if (x->coaddr == NULL)
457 goto error;
458 }
459
6f26b61e
JHS		 460 xfrm_mark_get(attrs, &x->mark);
461
72cb6962 462 err = xfrm_init_state(x);
1da177e4
LT		 463 if (err)
464 goto error;
465
fd21150a
TG		 466 if (attrs[XFRMA_SEC_CTX] &&
467 security_xfrm_state_alloc(x, nla_data(attrs[XFRMA_SEC_CTX])))
df71837d
TJ		 468 goto error;
469
1da177e4 470 x->km.seq = p->seq;
b27aeadb 471 x->replay_maxdiff = net->xfrm.sysctl_aevent_rseqth;
d51d081d 472 /* sysctl_xfrm_aevent_etime is in 100ms units */
b27aeadb 473 x->replay_maxage = (net->xfrm.sysctl_aevent_etime*HZ)/XFRM_AE_ETH_M;
d51d081d
JHS		 474 x->preplay.bitmap = 0;
475 x->preplay.seq = x->replay.seq+x->replay_maxdiff;
476 x->preplay.oseq = x->replay.oseq +x->replay_maxdiff;
477
478 /* override default values from above */
479
5424f32e 480 xfrm_update_ae_params(x, attrs);
1da177e4
LT		 481
482 return x;
483
484error:
485 x->km.state = XFRM_STATE_DEAD;
486 xfrm_state_put(x);
487error_no_put:
488 *errp = err;
489 return NULL;
490}
491
22e70050 492static int xfrm_add_sa(struct sk_buff *skb, struct nlmsghdr *nlh,
5424f32e 493 struct nlattr **attrs)
1da177e4 494{
fc34acd3 495 struct net *net = sock_net(skb->sk);
7b67c857 496 struct xfrm_usersa_info *p = nlmsg_data(nlh);
1da177e4
LT		 497 struct xfrm_state *x;
498 int err;
26b15dad 499 struct km_event c;
2532386f
EP		 500 uid_t loginuid = NETLINK_CB(skb).loginuid;
501 u32 sessionid = NETLINK_CB(skb).sessionid;
502 u32 sid = NETLINK_CB(skb).sid;
1da177e4 503
35a7aa08 504 err = verify_newsa_info(p, attrs);
1da177e4
LT		 505 if (err)
506 return err;
507
fc34acd3 508 x = xfrm_state_construct(net, p, attrs, &err);
1da177e4
LT		 509 if (!x)
510 return err;
511
26b15dad 512 xfrm_state_hold(x);
1da177e4
LT		 513 if (nlh->nlmsg_type == XFRM_MSG_NEWSA)
514 err = xfrm_state_add(x);
515 else
516 err = xfrm_state_update(x);
517
2532386f 518 xfrm_audit_state_add(x, err ? 0 : 1, loginuid, sessionid, sid);
161a09e7 519
1da177e4
LT		 520 if (err < 0) {
521 x->km.state = XFRM_STATE_DEAD;
21380b81 522 __xfrm_state_put(x);
7d6dfe1f 523 goto out;
1da177e4
LT		 524 }
525
26b15dad
JHS		 526 c.seq = nlh->nlmsg_seq;
527 c.pid = nlh->nlmsg_pid;
f60f6b8f 528 c.event = nlh->nlmsg_type;
26b15dad
JHS		 529
530 km_state_notify(x, &c);
7d6dfe1f 531out:
26b15dad 532 xfrm_state_put(x);
1da177e4
LT		 533 return err;
534}
535
fc34acd3
AD		 536static struct xfrm_state *xfrm_user_state_lookup(struct net *net,
537 struct xfrm_usersa_id *p,
5424f32e 538 struct nlattr **attrs,
eb2971b6
MN		 539 int *errp)
540{
541 struct xfrm_state *x = NULL;
6f26b61e 542 struct xfrm_mark m;
eb2971b6 543 int err;
6f26b61e 544 u32 mark = xfrm_mark_get(attrs, &m);
eb2971b6
MN		 545
546 if (xfrm_id_proto_match(p->proto, IPSEC_PROTO_ANY)) {
547 err = -ESRCH;
6f26b61e 548 x = xfrm_state_lookup(net, mark, &p->daddr, p->spi, p->proto, p->family);
eb2971b6
MN		 549 } else {
550 xfrm_address_t *saddr = NULL;
551
35a7aa08 552 verify_one_addr(attrs, XFRMA_SRCADDR, &saddr);
eb2971b6
MN		 553 if (!saddr) {
554 err = -EINVAL;
555 goto out;
556 }
557
9abbffee 558 err = -ESRCH;
6f26b61e
JHS		 559 x = xfrm_state_lookup_byaddr(net, mark,
560 &p->daddr, saddr,
221df1ed 561 p->proto, p->family);
eb2971b6
MN		 562 }
563
564 out:
565 if (!x && errp)
566 *errp = err;
567 return x;
568}
569
22e70050 570static int xfrm_del_sa(struct sk_buff *skb, struct nlmsghdr *nlh,
5424f32e 571 struct nlattr **attrs)
1da177e4 572{
fc34acd3 573 struct net *net = sock_net(skb->sk);
1da177e4 574 struct xfrm_state *x;
eb2971b6 575 int err = -ESRCH;
26b15dad 576 struct km_event c;
7b67c857 577 struct xfrm_usersa_id *p = nlmsg_data(nlh);
2532386f
EP		 578 uid_t loginuid = NETLINK_CB(skb).loginuid;
579 u32 sessionid = NETLINK_CB(skb).sessionid;
580 u32 sid = NETLINK_CB(skb).sid;
1da177e4 581
fc34acd3 582 x = xfrm_user_state_lookup(net, p, attrs, &err);
1da177e4 583 if (x == NULL)
eb2971b6 584 return err;
1da177e4 585
6f68dc37 586 if ((err = security_xfrm_state_delete(x)) != 0)
c8c05a8e
CZ		 587 goto out;
588
1da177e4 589 if (xfrm_state_kern(x)) {
c8c05a8e
CZ		 590 err = -EPERM;
591 goto out;
1da177e4
LT		 592 }
593
26b15dad 594 err = xfrm_state_delete(x);
161a09e7 595
c8c05a8e
CZ		 596 if (err < 0)
597 goto out;
26b15dad
JHS		 598
599 c.seq = nlh->nlmsg_seq;
600 c.pid = nlh->nlmsg_pid;
f60f6b8f 601 c.event = nlh->nlmsg_type;
26b15dad 602 km_state_notify(x, &c);
1da177e4 603
c8c05a8e 604out:
2532386f 605 xfrm_audit_state_delete(x, err ? 0 : 1, loginuid, sessionid, sid);
c8c05a8e 606 xfrm_state_put(x);
26b15dad 607 return err;
1da177e4
LT		 608}
609
610static void copy_to_user_state(struct xfrm_state *x, struct xfrm_usersa_info *p)
611{
612 memcpy(&p->id, &x->id, sizeof(p->id));
613 memcpy(&p->sel, &x->sel, sizeof(p->sel));
614 memcpy(&p->lft, &x->lft, sizeof(p->lft));
615 memcpy(&p->curlft, &x->curlft, sizeof(p->curlft));
616 memcpy(&p->stats, &x->stats, sizeof(p->stats));
54489c14 617 memcpy(&p->saddr, &x->props.saddr, sizeof(p->saddr));
1da177e4
LT		 618 p->mode = x->props.mode;
619 p->replay_window = x->props.replay_window;
620 p->reqid = x->props.reqid;
621 p->family = x->props.family;
622 p->flags = x->props.flags;
623 p->seq = x->km.seq;
624}
625
626struct xfrm_dump_info {
627 struct sk_buff *in_skb;
628 struct sk_buff *out_skb;
629 u32 nlmsg_seq;
630 u16 nlmsg_flags;
1da177e4
LT		 631};
632
c0144bea
TG		 633static int copy_sec_ctx(struct xfrm_sec_ctx *s, struct sk_buff *skb)
634{
c0144bea
TG		 635 struct xfrm_user_sec_ctx *uctx;
636 struct nlattr *attr;
68325d3b 637 int ctx_size = sizeof(*uctx) + s->ctx_len;
c0144bea
TG		 638
639 attr = nla_reserve(skb, XFRMA_SEC_CTX, ctx_size);
640 if (attr == NULL)
641 return -EMSGSIZE;
642
643 uctx = nla_data(attr);
644 uctx->exttype = XFRMA_SEC_CTX;
645 uctx->len = ctx_size;
646 uctx->ctx_doi = s->ctx_doi;
647 uctx->ctx_alg = s->ctx_alg;
648 uctx->ctx_len = s->ctx_len;
649 memcpy(uctx + 1, s->ctx_str, s->ctx_len);
650
651 return 0;
652}
653
4447bb33
MW		 654static int copy_to_user_auth(struct xfrm_algo_auth *auth, struct sk_buff *skb)
655{
656 struct xfrm_algo *algo;
657 struct nlattr *nla;
658
659 nla = nla_reserve(skb, XFRMA_ALG_AUTH,
660 sizeof(*algo) + (auth->alg_key_len + 7) / 8);
661 if (!nla)
662 return -EMSGSIZE;
663
664 algo = nla_data(nla);
665 strcpy(algo->alg_name, auth->alg_name);
666 memcpy(algo->alg_key, auth->alg_key, (auth->alg_key_len + 7) / 8);
667 algo->alg_key_len = auth->alg_key_len;
668
669 return 0;
670}
671
68325d3b
HX		 672/* Don't change this without updating xfrm_sa_len! */
673static int copy_to_user_state_extra(struct xfrm_state *x,
674 struct xfrm_usersa_info *p,
675 struct sk_buff *skb)
1da177e4 676{
1da177e4
LT		 677 copy_to_user_state(x, p);
678
050f009e
HX		 679 if (x->coaddr)
680 NLA_PUT(skb, XFRMA_COADDR, sizeof(*x->coaddr), x->coaddr);
681
682 if (x->lastused)
683 NLA_PUT_U64(skb, XFRMA_LASTUSED, x->lastused);
050f009e 684
1a6509d9
HX		 685 if (x->aead)
686 NLA_PUT(skb, XFRMA_ALG_AEAD, aead_len(x->aead), x->aead);
4447bb33
MW		 687 if (x->aalg) {
688 if (copy_to_user_auth(x->aalg, skb))
689 goto nla_put_failure;
690
691 NLA_PUT(skb, XFRMA_ALG_AUTH_TRUNC,
692 xfrm_alg_auth_len(x->aalg), x->aalg);
693 }
1da177e4 694 if (x->ealg)
0f99be0d 695 NLA_PUT(skb, XFRMA_ALG_CRYPT, xfrm_alg_len(x->ealg), x->ealg);
1da177e4 696 if (x->calg)
c0144bea 697 NLA_PUT(skb, XFRMA_ALG_COMP, sizeof(*(x->calg)), x->calg);
1da177e4
LT		 698
699 if (x->encap)
c0144bea 700 NLA_PUT(skb, XFRMA_ENCAP, sizeof(*x->encap), x->encap);
1da177e4 701
35d2856b
MW		 702 if (x->tfcpad)
703 NLA_PUT_U32(skb, XFRMA_TFCPAD, x->tfcpad);
704
6f26b61e
JHS		 705 if (xfrm_mark_put(skb, &x->mark))
706 goto nla_put_failure;
707
c0144bea
TG		 708 if (x->security && copy_sec_ctx(x->security, skb) < 0)
709 goto nla_put_failure;
060f02a3 710
68325d3b
HX		 711 return 0;
712
713nla_put_failure:
714 return -EMSGSIZE;
715}
716
717static int dump_one_state(struct xfrm_state *x, int count, void *ptr)
718{
719 struct xfrm_dump_info *sp = ptr;
720 struct sk_buff *in_skb = sp->in_skb;
721 struct sk_buff *skb = sp->out_skb;
722 struct xfrm_usersa_info *p;
723 struct nlmsghdr *nlh;
724 int err;
725
68325d3b
HX		 726 nlh = nlmsg_put(skb, NETLINK_CB(in_skb).pid, sp->nlmsg_seq,
727 XFRM_MSG_NEWSA, sizeof(*p), sp->nlmsg_flags);
728 if (nlh == NULL)
729 return -EMSGSIZE;
730
731 p = nlmsg_data(nlh);
732
733 err = copy_to_user_state_extra(x, p, skb);
734 if (err)
735 goto nla_put_failure;
736
9825069d 737 nlmsg_end(skb, nlh);
1da177e4
LT		 738 return 0;
739
c0144bea 740nla_put_failure:
9825069d 741 nlmsg_cancel(skb, nlh);
68325d3b 742 return err;
1da177e4
LT		 743}
744
4c563f76
TT		 745static int xfrm_dump_sa_done(struct netlink_callback *cb)
746{
747 struct xfrm_state_walk *walk = (struct xfrm_state_walk *) &cb->args[1];
748 xfrm_state_walk_done(walk);
749 return 0;
750}
751
1da177e4
LT		 752static int xfrm_dump_sa(struct sk_buff *skb, struct netlink_callback *cb)
753{
fc34acd3 754 struct net *net = sock_net(skb->sk);
4c563f76 755 struct xfrm_state_walk *walk = (struct xfrm_state_walk *) &cb->args[1];
1da177e4
LT		 756 struct xfrm_dump_info info;
757
4c563f76
TT		 758 BUILD_BUG_ON(sizeof(struct xfrm_state_walk) >
759 sizeof(cb->args) - sizeof(cb->args[0]));
760
1da177e4
LT		 761 info.in_skb = cb->skb;
762 info.out_skb = skb;
763 info.nlmsg_seq = cb->nlh->nlmsg_seq;
764 info.nlmsg_flags = NLM_F_MULTI;
4c563f76
TT		 765
766 if (!cb->args[0]) {
767 cb->args[0] = 1;
768 xfrm_state_walk_init(walk, 0);
769 }
770
fc34acd3 771 (void) xfrm_state_walk(net, walk, dump_one_state, &info);
1da177e4
LT		 772
773 return skb->len;
774}
775
776static struct sk_buff *xfrm_state_netlink(struct sk_buff *in_skb,
777 struct xfrm_state *x, u32 seq)
778{
779 struct xfrm_dump_info info;
780 struct sk_buff *skb;
781
7deb2264 782 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
1da177e4
LT		 783 if (!skb)
784 return ERR_PTR(-ENOMEM);
785
1da177e4
LT		 786 info.in_skb = in_skb;
787 info.out_skb = skb;
788 info.nlmsg_seq = seq;
789 info.nlmsg_flags = 0;
1da177e4
LT		 790
791 if (dump_one_state(x, 0, &info)) {
792 kfree_skb(skb);
793 return NULL;
794 }
795
796 return skb;
797}
798
7deb2264
TG		 799static inline size_t xfrm_spdinfo_msgsize(void)
800{
801 return NLMSG_ALIGN(4)
802 + nla_total_size(sizeof(struct xfrmu_spdinfo))
803 + nla_total_size(sizeof(struct xfrmu_spdhinfo));
804}
805
e071041b
AD		 806static int build_spdinfo(struct sk_buff *skb, struct net *net,
807 u32 pid, u32 seq, u32 flags)
ecfd6b18 808{
5a6d3416
JHS		 809 struct xfrmk_spdinfo si;
810 struct xfrmu_spdinfo spc;
811 struct xfrmu_spdhinfo sph;
ecfd6b18
JHS		 812 struct nlmsghdr *nlh;
813 u32 *f;
814
815 nlh = nlmsg_put(skb, pid, seq, XFRM_MSG_NEWSPDINFO, sizeof(u32), 0);
816 if (nlh == NULL) /* shouldnt really happen ... */
817 return -EMSGSIZE;
818
819 f = nlmsg_data(nlh);
820 *f = flags;
e071041b 821 xfrm_spd_getinfo(net, &si);
5a6d3416
JHS		 822 spc.incnt = si.incnt;
823 spc.outcnt = si.outcnt;
824 spc.fwdcnt = si.fwdcnt;
825 spc.inscnt = si.inscnt;
826 spc.outscnt = si.outscnt;
827 spc.fwdscnt = si.fwdscnt;
828 sph.spdhcnt = si.spdhcnt;
829 sph.spdhmcnt = si.spdhmcnt;
830
831 NLA_PUT(skb, XFRMA_SPD_INFO, sizeof(spc), &spc);
832 NLA_PUT(skb, XFRMA_SPD_HINFO, sizeof(sph), &sph);
ecfd6b18
JHS		 833
834 return nlmsg_end(skb, nlh);
835
836nla_put_failure:
837 nlmsg_cancel(skb, nlh);
838 return -EMSGSIZE;
839}
840
841static int xfrm_get_spdinfo(struct sk_buff *skb, struct nlmsghdr *nlh,
5424f32e 842 struct nlattr **attrs)
ecfd6b18 843{
a6483b79 844 struct net *net = sock_net(skb->sk);
ecfd6b18 845 struct sk_buff *r_skb;
7b67c857 846 u32 *flags = nlmsg_data(nlh);
ecfd6b18
JHS		 847 u32 spid = NETLINK_CB(skb).pid;
848 u32 seq = nlh->nlmsg_seq;
ecfd6b18 849
7deb2264 850 r_skb = nlmsg_new(xfrm_spdinfo_msgsize(), GFP_ATOMIC);
ecfd6b18
JHS		 851 if (r_skb == NULL)
852 return -ENOMEM;
853
e071041b 854 if (build_spdinfo(r_skb, net, spid, seq, *flags) < 0)
ecfd6b18
JHS		 855 BUG();
856
a6483b79 857 return nlmsg_unicast(net->xfrm.nlsk, r_skb, spid);
ecfd6b18
JHS		 858}
859
7deb2264
TG		 860static inline size_t xfrm_sadinfo_msgsize(void)
861{
862 return NLMSG_ALIGN(4)
863 + nla_total_size(sizeof(struct xfrmu_sadhinfo))
864 + nla_total_size(4); /* XFRMA_SAD_CNT */
865}
866
e071041b
AD		 867static int build_sadinfo(struct sk_buff *skb, struct net *net,
868 u32 pid, u32 seq, u32 flags)
28d8909b 869{
af11e316
JHS		 870 struct xfrmk_sadinfo si;
871 struct xfrmu_sadhinfo sh;
28d8909b
JHS		 872 struct nlmsghdr *nlh;
873 u32 *f;
874
875 nlh = nlmsg_put(skb, pid, seq, XFRM_MSG_NEWSADINFO, sizeof(u32), 0);
876 if (nlh == NULL) /* shouldnt really happen ... */
877 return -EMSGSIZE;
878
879 f = nlmsg_data(nlh);
880 *f = flags;
e071041b 881 xfrm_sad_getinfo(net, &si);
28d8909b 882
af11e316
JHS		 883 sh.sadhmcnt = si.sadhmcnt;
884 sh.sadhcnt = si.sadhcnt;
885
886 NLA_PUT_U32(skb, XFRMA_SAD_CNT, si.sadcnt);
887 NLA_PUT(skb, XFRMA_SAD_HINFO, sizeof(sh), &sh);
28d8909b
JHS		 888
889 return nlmsg_end(skb, nlh);
890
891nla_put_failure:
892 nlmsg_cancel(skb, nlh);
893 return -EMSGSIZE;
894}
895
896static int xfrm_get_sadinfo(struct sk_buff *skb, struct nlmsghdr *nlh,
5424f32e 897 struct nlattr **attrs)
28d8909b 898{
a6483b79 899 struct net *net = sock_net(skb->sk);
28d8909b 900 struct sk_buff *r_skb;
7b67c857 901 u32 *flags = nlmsg_data(nlh);
28d8909b
JHS		 902 u32 spid = NETLINK_CB(skb).pid;
903 u32 seq = nlh->nlmsg_seq;
28d8909b 904
7deb2264 905 r_skb = nlmsg_new(xfrm_sadinfo_msgsize(), GFP_ATOMIC);
28d8909b
JHS		 906 if (r_skb == NULL)
907 return -ENOMEM;
908
e071041b 909 if (build_sadinfo(r_skb, net, spid, seq, *flags) < 0)
28d8909b
JHS		 910 BUG();
911
a6483b79 912 return nlmsg_unicast(net->xfrm.nlsk, r_skb, spid);
28d8909b
JHS		 913}
914
22e70050 915static int xfrm_get_sa(struct sk_buff *skb, struct nlmsghdr *nlh,
5424f32e 916 struct nlattr **attrs)
1da177e4 917{
fc34acd3 918 struct net *net = sock_net(skb->sk);
7b67c857 919 struct xfrm_usersa_id *p = nlmsg_data(nlh);
1da177e4
LT		 920 struct xfrm_state *x;
921 struct sk_buff *resp_skb;
eb2971b6 922 int err = -ESRCH;
1da177e4 923
fc34acd3 924 x = xfrm_user_state_lookup(net, p, attrs, &err);
1da177e4
LT		 925 if (x == NULL)
926 goto out_noput;
927
928 resp_skb = xfrm_state_netlink(skb, x, nlh->nlmsg_seq);
929 if (IS_ERR(resp_skb)) {
930 err = PTR_ERR(resp_skb);
931 } else {
a6483b79 932 err = nlmsg_unicast(net->xfrm.nlsk, resp_skb, NETLINK_CB(skb).pid);
1da177e4
LT		 933 }
934 xfrm_state_put(x);
935out_noput:
936 return err;
937}
938
939static int verify_userspi_info(struct xfrm_userspi_info *p)
940{
941 switch (p->info.id.proto) {
942 case IPPROTO_AH:
943 case IPPROTO_ESP:
944 break;
945
946 case IPPROTO_COMP:
947 /* IPCOMP spi is 16-bits. */
948 if (p->max >= 0x10000)
949 return -EINVAL;
950 break;
951
952 default:
953 return -EINVAL;
3ff50b79 954 }
1da177e4
LT		 955
956 if (p->min > p->max)
957 return -EINVAL;
958
959 return 0;
960}
961
22e70050 962static int xfrm_alloc_userspi(struct sk_buff *skb, struct nlmsghdr *nlh,
5424f32e 963 struct nlattr **attrs)
1da177e4 964{
fc34acd3 965 struct net *net = sock_net(skb->sk);
1da177e4
LT		 966 struct xfrm_state *x;
967 struct xfrm_userspi_info *p;
968 struct sk_buff *resp_skb;
969 xfrm_address_t *daddr;
970 int family;
971 int err;
6f26b61e
JHS		 972 u32 mark;
973 struct xfrm_mark m;
1da177e4 974
7b67c857 975 p = nlmsg_data(nlh);
1da177e4
LT		 976 err = verify_userspi_info(p);
977 if (err)
978 goto out_noput;
979
980 family = p->info.family;
981 daddr = &p->info.id.daddr;
982
983 x = NULL;
6f26b61e
JHS		 984
985 mark = xfrm_mark_get(attrs, &m);
1da177e4 986 if (p->info.seq) {
6f26b61e 987 x = xfrm_find_acq_byseq(net, mark, p->info.seq);
1da177e4
LT		 988 if (x && xfrm_addr_cmp(&x->id.daddr, daddr, family)) {
989 xfrm_state_put(x);
990 x = NULL;
991 }
992 }
993
994 if (!x)
6f26b61e 995 x = xfrm_find_acq(net, &m, p->info.mode, p->info.reqid,
1da177e4
LT		 996 p->info.id.proto, daddr,
997 &p->info.saddr, 1,
998 family);
999 err = -ENOENT;
1000 if (x == NULL)
1001 goto out_noput;
1002
658b219e
HX		 1003 err = xfrm_alloc_spi(x, p->min, p->max);
1004 if (err)
1005 goto out;
1da177e4 1006
658b219e 1007 resp_skb = xfrm_state_netlink(skb, x, nlh->nlmsg_seq);
1da177e4
LT		 1008 if (IS_ERR(resp_skb)) {
1009 err = PTR_ERR(resp_skb);
1010 goto out;
1011 }
1012
a6483b79 1013 err = nlmsg_unicast(net->xfrm.nlsk, resp_skb, NETLINK_CB(skb).pid);
1da177e4
LT		 1014
1015out:
1016 xfrm_state_put(x);
1017out_noput:
1018 return err;
1019}
1020
b798a9ed 1021static int verify_policy_dir(u8 dir)
1da177e4
LT		 1022{
1023 switch (dir) {
1024 case XFRM_POLICY_IN:
1025 case XFRM_POLICY_OUT:
1026 case XFRM_POLICY_FWD:
1027 break;
1028
1029 default:
1030 return -EINVAL;
3ff50b79 1031 }
1da177e4
LT		 1032
1033 return 0;
1034}
1035
b798a9ed 1036static int verify_policy_type(u8 type)
f7b6983f
MN		 1037{
1038 switch (type) {
1039 case XFRM_POLICY_TYPE_MAIN:
1040#ifdef CONFIG_XFRM_SUB_POLICY
1041 case XFRM_POLICY_TYPE_SUB:
1042#endif
1043 break;
1044
1045 default:
1046 return -EINVAL;
3ff50b79 1047 }
f7b6983f
MN		 1048
1049 return 0;
1050}
1051
1da177e4
LT		 1052static int verify_newpolicy_info(struct xfrm_userpolicy_info *p)
1053{
1054 switch (p->share) {
1055 case XFRM_SHARE_ANY:
1056 case XFRM_SHARE_SESSION:
1057 case XFRM_SHARE_USER:
1058 case XFRM_SHARE_UNIQUE:
1059 break;
1060
1061 default:
1062 return -EINVAL;
3ff50b79 1063 }
1da177e4
LT		 1064
1065 switch (p->action) {
1066 case XFRM_POLICY_ALLOW:
1067 case XFRM_POLICY_BLOCK:
1068 break;
1069
1070 default:
1071 return -EINVAL;
3ff50b79 1072 }
1da177e4
LT		 1073
1074 switch (p->sel.family) {
1075 case AF_INET:
1076 break;
1077
1078 case AF_INET6:
1079#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
1080 break;
1081#else
1082 return -EAFNOSUPPORT;
1083#endif
1084
1085 default:
1086 return -EINVAL;
3ff50b79 1087 }
1da177e4
LT		 1088
1089 return verify_policy_dir(p->dir);
1090}
1091
5424f32e 1092static int copy_from_user_sec_ctx(struct xfrm_policy *pol, struct nlattr **attrs)
df71837d 1093{
5424f32e 1094 struct nlattr *rt = attrs[XFRMA_SEC_CTX];
df71837d
TJ		 1095 struct xfrm_user_sec_ctx *uctx;
1096
1097 if (!rt)
1098 return 0;
1099
5424f32e 1100 uctx = nla_data(rt);
03e1ad7b 1101 return security_xfrm_policy_alloc(&pol->security, uctx);
df71837d
TJ		 1102}
1103
1da177e4
LT		 1104static void copy_templates(struct xfrm_policy *xp, struct xfrm_user_tmpl *ut,
1105 int nr)
1106{
1107 int i;
1108
1109 xp->xfrm_nr = nr;
1110 for (i = 0; i < nr; i++, ut++) {
1111 struct xfrm_tmpl *t = &xp->xfrm_vec[i];
1112
1113 memcpy(&t->id, &ut->id, sizeof(struct xfrm_id));
1114 memcpy(&t->saddr, &ut->saddr,
1115 sizeof(xfrm_address_t));
1116 t->reqid = ut->reqid;
1117 t->mode = ut->mode;
1118 t->share = ut->share;
1119 t->optional = ut->optional;
1120 t->aalgos = ut->aalgos;
1121 t->ealgos = ut->ealgos;
1122 t->calgos = ut->calgos;
c5d18e98
HX		 1123 /* If all masks are ~0, then we allow all algorithms. */
1124 t->allalgs = !~(t->aalgos & t->ealgos & t->calgos);
8511d01d 1125 t->encap_family = ut->family;
1da177e4
LT		 1126 }
1127}
1128
b4ad86bf
DM		 1129static int validate_tmpl(int nr, struct xfrm_user_tmpl *ut, u16 family)
1130{
1131 int i;
1132
1133 if (nr > XFRM_MAX_DEPTH)
1134 return -EINVAL;
1135
1136 for (i = 0; i < nr; i++) {
1137 /* We never validated the ut->family value, so many
1138 * applications simply leave it at zero. The check was
1139 * never made and ut->family was ignored because all
1140 * templates could be assumed to have the same family as
1141 * the policy itself. Now that we will have ipv4-in-ipv6
1142 * and ipv6-in-ipv4 tunnels, this is no longer true.
1143 */
1144 if (!ut[i].family)
1145 ut[i].family = family;
1146
1147 switch (ut[i].family) {
1148 case AF_INET:
1149 break;
1150#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
1151 case AF_INET6:
1152 break;
1153#endif
1154 default:
1155 return -EINVAL;
3ff50b79 1156 }
b4ad86bf
DM		 1157 }
1158
1159 return 0;
1160}
1161
5424f32e 1162static int copy_from_user_tmpl(struct xfrm_policy *pol, struct nlattr **attrs)
1da177e4 1163{
5424f32e 1164 struct nlattr *rt = attrs[XFRMA_TMPL];
1da177e4
LT		 1165
1166 if (!rt) {
1167 pol->xfrm_nr = 0;
1168 } else {
5424f32e
TG		 1169 struct xfrm_user_tmpl *utmpl = nla_data(rt);
1170 int nr = nla_len(rt) / sizeof(*utmpl);
b4ad86bf 1171 int err;
1da177e4 1172
b4ad86bf
DM		 1173 err = validate_tmpl(nr, utmpl, pol->family);
1174 if (err)
1175 return err;
1da177e4 1176
5424f32e 1177 copy_templates(pol, utmpl, nr);
1da177e4
LT		 1178 }
1179 return 0;
1180}
1181
5424f32e 1182static int copy_from_user_policy_type(u8 *tp, struct nlattr **attrs)
f7b6983f 1183{
5424f32e 1184 struct nlattr *rt = attrs[XFRMA_POLICY_TYPE];
f7b6983f 1185 struct xfrm_userpolicy_type *upt;
b798a9ed 1186 u8 type = XFRM_POLICY_TYPE_MAIN;
f7b6983f
MN		 1187 int err;
1188
1189 if (rt) {
5424f32e 1190 upt = nla_data(rt);
f7b6983f
MN		 1191 type = upt->type;
1192 }
1193
1194 err = verify_policy_type(type);
1195 if (err)
1196 return err;
1197
1198 *tp = type;
1199 return 0;
1200}
1201
1da177e4
LT		 1202static void copy_from_user_policy(struct xfrm_policy *xp, struct xfrm_userpolicy_info *p)
1203{
1204 xp->priority = p->priority;
1205 xp->index = p->index;
1206 memcpy(&xp->selector, &p->sel, sizeof(xp->selector));
1207 memcpy(&xp->lft, &p->lft, sizeof(xp->lft));
1208 xp->action = p->action;
1209 xp->flags = p->flags;
1210 xp->family = p->sel.family;
1211 /* XXX xp->share = p->share; */
1212}
1213
1214static void copy_to_user_policy(struct xfrm_policy *xp, struct xfrm_userpolicy_info *p, int dir)
1215{
1216 memcpy(&p->sel, &xp->selector, sizeof(p->sel));
1217 memcpy(&p->lft, &xp->lft, sizeof(p->lft));
1218 memcpy(&p->curlft, &xp->curlft, sizeof(p->curlft));
1219 p->priority = xp->priority;
1220 p->index = xp->index;
1221 p->sel.family = xp->family;
1222 p->dir = dir;
1223 p->action = xp->action;
1224 p->flags = xp->flags;
1225 p->share = XFRM_SHARE_ANY; /* XXX xp->share */
1226}
1227
fc34acd3 1228static struct xfrm_policy *xfrm_policy_construct(struct net *net, struct xfrm_userpolicy_info *p, struct nlattr **attrs, int *errp)
1da177e4 1229{
fc34acd3 1230 struct xfrm_policy *xp = xfrm_policy_alloc(net, GFP_KERNEL);
1da177e4
LT		 1231 int err;
1232
1233 if (!xp) {
1234 *errp = -ENOMEM;
1235 return NULL;
1236 }
1237
1238 copy_from_user_policy(xp, p);
df71837d 1239
35a7aa08 1240 err = copy_from_user_policy_type(&xp->type, attrs);
f7b6983f
MN		 1241 if (err)
1242 goto error;
1243
35a7aa08
TG		 1244 if (!(err = copy_from_user_tmpl(xp, attrs)))
1245 err = copy_from_user_sec_ctx(xp, attrs);
f7b6983f
MN		 1246 if (err)
1247 goto error;
1da177e4 1248
295fae56
JHS		 1249 xfrm_mark_get(attrs, &xp->mark);
1250
1da177e4 1251 return xp;
f7b6983f
MN		 1252 error:
1253 *errp = err;
12a169e7 1254 xp->walk.dead = 1;
64c31b3f 1255 xfrm_policy_destroy(xp);
f7b6983f 1256 return NULL;
1da177e4
LT		 1257}
1258
22e70050 1259static int xfrm_add_policy(struct sk_buff *skb, struct nlmsghdr *nlh,
5424f32e 1260 struct nlattr **attrs)
1da177e4 1261{
fc34acd3 1262 struct net *net = sock_net(skb->sk);
7b67c857 1263 struct xfrm_userpolicy_info *p = nlmsg_data(nlh);
1da177e4 1264 struct xfrm_policy *xp;
26b15dad 1265 struct km_event c;
1da177e4
LT		 1266 int err;
1267 int excl;
2532386f
EP		 1268 uid_t loginuid = NETLINK_CB(skb).loginuid;
1269 u32 sessionid = NETLINK_CB(skb).sessionid;
1270 u32 sid = NETLINK_CB(skb).sid;
1da177e4
LT		 1271
1272 err = verify_newpolicy_info(p);
df71837d
TJ		 1273 if (err)
1274 return err;
35a7aa08 1275 err = verify_sec_ctx_len(attrs);
1da177e4
LT		 1276 if (err)
1277 return err;
1278
fc34acd3 1279 xp = xfrm_policy_construct(net, p, attrs, &err);
1da177e4
LT		 1280 if (!xp)
1281 return err;
1282
26b15dad
JHS		 1283 /* shouldnt excl be based on nlh flags??
1284 * Aha! this is anti-netlink really i.e more pfkey derived
1285 * in netlink excl is a flag and you wouldnt need
1286 * a type XFRM_MSG_UPDPOLICY - JHS */
1da177e4
LT		 1287 excl = nlh->nlmsg_type == XFRM_MSG_NEWPOLICY;
1288 err = xfrm_policy_insert(p->dir, xp, excl);
2532386f 1289 xfrm_audit_policy_add(xp, err ? 0 : 1, loginuid, sessionid, sid);
161a09e7 1290
1da177e4 1291 if (err) {
03e1ad7b 1292 security_xfrm_policy_free(xp->security);
1da177e4
LT		 1293 kfree(xp);
1294 return err;
1295 }
1296
f60f6b8f 1297 c.event = nlh->nlmsg_type;
26b15dad
JHS		 1298 c.seq = nlh->nlmsg_seq;
1299 c.pid = nlh->nlmsg_pid;
1300 km_policy_notify(xp, p->dir, &c);
1301
1da177e4
LT		 1302 xfrm_pol_put(xp);
1303
1304 return 0;
1305}
1306
1307static int copy_to_user_tmpl(struct xfrm_policy *xp, struct sk_buff *skb)
1308{
1309 struct xfrm_user_tmpl vec[XFRM_MAX_DEPTH];
1310 int i;
1311
1312 if (xp->xfrm_nr == 0)
1313 return 0;
1314
1315 for (i = 0; i < xp->xfrm_nr; i++) {
1316 struct xfrm_user_tmpl *up = &vec[i];
1317 struct xfrm_tmpl *kp = &xp->xfrm_vec[i];
1318
1319 memcpy(&up->id, &kp->id, sizeof(up->id));
8511d01d 1320 up->family = kp->encap_family;
1da177e4
LT		 1321 memcpy(&up->saddr, &kp->saddr, sizeof(up->saddr));
1322 up->reqid = kp->reqid;
1323 up->mode = kp->mode;
1324 up->share = kp->share;
1325 up->optional = kp->optional;
1326 up->aalgos = kp->aalgos;
1327 up->ealgos = kp->ealgos;
1328 up->calgos = kp->calgos;
1329 }
df71837d 1330
c0144bea
TG		 1331 return nla_put(skb, XFRMA_TMPL,
1332 sizeof(struct xfrm_user_tmpl) * xp->xfrm_nr, vec);
0d681623
SH		 1333}
1334
1335static inline int copy_to_user_state_sec_ctx(struct xfrm_state *x, struct sk_buff *skb)
1336{
1337 if (x->security) {
1338 return copy_sec_ctx(x->security, skb);
df71837d
TJ		 1339 }
1340 return 0;
0d681623 1341}
df71837d 1342
0d681623
SH		 1343static inline int copy_to_user_sec_ctx(struct xfrm_policy *xp, struct sk_buff *skb)
1344{
1345 if (xp->security) {
1346 return copy_sec_ctx(xp->security, skb);
1347 }
1348 return 0;
df71837d 1349}
cfbfd45a
TG		 1350static inline size_t userpolicy_type_attrsize(void)
1351{
1352#ifdef CONFIG_XFRM_SUB_POLICY
1353 return nla_total_size(sizeof(struct xfrm_userpolicy_type));
1354#else
1355 return 0;
1356#endif
1357}
df71837d 1358
f7b6983f 1359#ifdef CONFIG_XFRM_SUB_POLICY
b798a9ed 1360static int copy_to_user_policy_type(u8 type, struct sk_buff *skb)
f7b6983f 1361{
c0144bea
TG		 1362 struct xfrm_userpolicy_type upt = {
1363 .type = type,
1364 };
f7b6983f 1365
c0144bea 1366 return nla_put(skb, XFRMA_POLICY_TYPE, sizeof(upt), &upt);
f7b6983f
MN		 1367}
1368
1369#else
b798a9ed 1370static inline int copy_to_user_policy_type(u8 type, struct sk_buff *skb)
f7b6983f
MN		 1371{
1372 return 0;
1373}
1374#endif
1375
1da177e4
LT		 1376static int dump_one_policy(struct xfrm_policy *xp, int dir, int count, void *ptr)
1377{
1378 struct xfrm_dump_info *sp = ptr;
1379 struct xfrm_userpolicy_info *p;
1380 struct sk_buff *in_skb = sp->in_skb;
1381 struct sk_buff *skb = sp->out_skb;
1382 struct nlmsghdr *nlh;
1da177e4 1383
79b8b7f4
TG		 1384 nlh = nlmsg_put(skb, NETLINK_CB(in_skb).pid, sp->nlmsg_seq,
1385 XFRM_MSG_NEWPOLICY, sizeof(*p), sp->nlmsg_flags);
1386 if (nlh == NULL)
1387 return -EMSGSIZE;
1da177e4 1388
7b67c857 1389 p = nlmsg_data(nlh);
1da177e4
LT		 1390 copy_to_user_policy(xp, p, dir);
1391 if (copy_to_user_tmpl(xp, skb) < 0)
1392 goto nlmsg_failure;
df71837d
TJ		 1393 if (copy_to_user_sec_ctx(xp, skb))
1394 goto nlmsg_failure;
1459bb36 1395 if (copy_to_user_policy_type(xp->type, skb) < 0)
f7b6983f 1396 goto nlmsg_failure;
295fae56
JHS		 1397 if (xfrm_mark_put(skb, &xp->mark))
1398 goto nla_put_failure;
1da177e4 1399
9825069d 1400 nlmsg_end(skb, nlh);
1da177e4
LT		 1401 return 0;
1402
295fae56 1403nla_put_failure:
1da177e4 1404nlmsg_failure:
9825069d
TG		 1405 nlmsg_cancel(skb, nlh);
1406 return -EMSGSIZE;
1da177e4
LT		 1407}
1408
4c563f76
TT		 1409static int xfrm_dump_policy_done(struct netlink_callback *cb)
1410{
1411 struct xfrm_policy_walk *walk = (struct xfrm_policy_walk *) &cb->args[1];
1412
1413 xfrm_policy_walk_done(walk);
1414 return 0;
1415}
1416
1da177e4
LT		 1417static int xfrm_dump_policy(struct sk_buff *skb, struct netlink_callback *cb)
1418{
fc34acd3 1419 struct net *net = sock_net(skb->sk);
4c563f76 1420 struct xfrm_policy_walk *walk = (struct xfrm_policy_walk *) &cb->args[1];
1da177e4
LT		 1421 struct xfrm_dump_info info;
1422
4c563f76
TT		 1423 BUILD_BUG_ON(sizeof(struct xfrm_policy_walk) >
1424 sizeof(cb->args) - sizeof(cb->args[0]));
1425
1da177e4
LT		 1426 info.in_skb = cb->skb;
1427 info.out_skb = skb;
1428 info.nlmsg_seq = cb->nlh->nlmsg_seq;
1429 info.nlmsg_flags = NLM_F_MULTI;
4c563f76
TT		 1430
1431 if (!cb->args[0]) {
1432 cb->args[0] = 1;
1433 xfrm_policy_walk_init(walk, XFRM_POLICY_TYPE_ANY);
1434 }
1435
fc34acd3 1436 (void) xfrm_policy_walk(net, walk, dump_one_policy, &info);
1da177e4
LT		 1437
1438 return skb->len;
1439}
1440
1441static struct sk_buff *xfrm_policy_netlink(struct sk_buff *in_skb,
1442 struct xfrm_policy *xp,
1443 int dir, u32 seq)
1444{
1445 struct xfrm_dump_info info;
1446 struct sk_buff *skb;
1447
7deb2264 1448 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1da177e4
LT		 1449 if (!skb)
1450 return ERR_PTR(-ENOMEM);
1451
1da177e4
LT		 1452 info.in_skb = in_skb;
1453 info.out_skb = skb;
1454 info.nlmsg_seq = seq;
1455 info.nlmsg_flags = 0;
1da177e4
LT		 1456
1457 if (dump_one_policy(xp, dir, 0, &info) < 0) {
1458 kfree_skb(skb);
1459 return NULL;
1460 }
1461
1462 return skb;
1463}
1464
22e70050 1465static int xfrm_get_policy(struct sk_buff *skb, struct nlmsghdr *nlh,
5424f32e 1466 struct nlattr **attrs)
1da177e4 1467{
fc34acd3 1468 struct net *net = sock_net(skb->sk);
1da177e4
LT		 1469 struct xfrm_policy *xp;
1470 struct xfrm_userpolicy_id *p;
b798a9ed 1471 u8 type = XFRM_POLICY_TYPE_MAIN;
1da177e4 1472 int err;
26b15dad 1473 struct km_event c;
1da177e4 1474 int delete;
295fae56
JHS		 1475 struct xfrm_mark m;
1476 u32 mark = xfrm_mark_get(attrs, &m);
1da177e4 1477
7b67c857 1478 p = nlmsg_data(nlh);
1da177e4
LT		 1479 delete = nlh->nlmsg_type == XFRM_MSG_DELPOLICY;
1480
35a7aa08 1481 err = copy_from_user_policy_type(&type, attrs);
f7b6983f
MN		 1482 if (err)
1483 return err;
1484
1da177e4
LT		 1485 err = verify_policy_dir(p->dir);
1486 if (err)
1487 return err;
1488
1489 if (p->index)
295fae56 1490 xp = xfrm_policy_byid(net, mark, type, p->dir, p->index, delete, &err);
df71837d 1491 else {
5424f32e 1492 struct nlattr *rt = attrs[XFRMA_SEC_CTX];
03e1ad7b 1493 struct xfrm_sec_ctx *ctx;
df71837d 1494
35a7aa08 1495 err = verify_sec_ctx_len(attrs);
df71837d
TJ		 1496 if (err)
1497 return err;
1498
2c8dd116 1499 ctx = NULL;
df71837d 1500 if (rt) {
5424f32e 1501 struct xfrm_user_sec_ctx *uctx = nla_data(rt);
df71837d 1502
03e1ad7b
PM		 1503 err = security_xfrm_policy_alloc(&ctx, uctx);
1504 if (err)
df71837d 1505 return err;
2c8dd116 1506 }
295fae56 1507 xp = xfrm_policy_bysel_ctx(net, mark, type, p->dir, &p->sel,
6f26b61e 1508 ctx, delete, &err);
03e1ad7b 1509 security_xfrm_policy_free(ctx);
df71837d 1510 }
1da177e4
LT		 1511 if (xp == NULL)
1512 return -ENOENT;
1513
1514 if (!delete) {
1515 struct sk_buff *resp_skb;
1516
1517 resp_skb = xfrm_policy_netlink(skb, xp, p->dir, nlh->nlmsg_seq);
1518 if (IS_ERR(resp_skb)) {
1519 err = PTR_ERR(resp_skb);
1520 } else {
a6483b79 1521 err = nlmsg_unicast(net->xfrm.nlsk, resp_skb,
082a1ad5 1522 NETLINK_CB(skb).pid);
1da177e4 1523 }
26b15dad 1524 } else {
2532386f
EP		 1525 uid_t loginuid = NETLINK_CB(skb).loginuid;
1526 u32 sessionid = NETLINK_CB(skb).sessionid;
1527 u32 sid = NETLINK_CB(skb).sid;
1528
1529 xfrm_audit_policy_delete(xp, err ? 0 : 1, loginuid, sessionid,
1530 sid);
13fcfbb0
DM		 1531
1532 if (err != 0)
c8c05a8e 1533 goto out;
13fcfbb0 1534
e7443892 1535 c.data.byid = p->index;
f60f6b8f 1536 c.event = nlh->nlmsg_type;
26b15dad
JHS		 1537 c.seq = nlh->nlmsg_seq;
1538 c.pid = nlh->nlmsg_pid;
1539 km_policy_notify(xp, p->dir, &c);
1da177e4
LT		 1540 }
1541
c8c05a8e 1542out:
ef41aaa0 1543 xfrm_pol_put(xp);
1da177e4
LT		 1544 return err;
1545}
1546
22e70050 1547static int xfrm_flush_sa(struct sk_buff *skb, struct nlmsghdr *nlh,
5424f32e 1548 struct nlattr **attrs)
1da177e4 1549{
fc34acd3 1550 struct net *net = sock_net(skb->sk);
26b15dad 1551 struct km_event c;
7b67c857 1552 struct xfrm_usersa_flush *p = nlmsg_data(nlh);
161a09e7 1553 struct xfrm_audit audit_info;
4aa2e62c 1554 int err;
1da177e4 1555
161a09e7 1556 audit_info.loginuid = NETLINK_CB(skb).loginuid;
2532386f 1557 audit_info.sessionid = NETLINK_CB(skb).sessionid;
161a09e7 1558 audit_info.secid = NETLINK_CB(skb).sid;
fc34acd3 1559 err = xfrm_state_flush(net, p->proto, &audit_info);
9e64cc95
JHS		 1560 if (err) {
1561 if (err == -ESRCH) /* empty table */
1562 return 0;
069c474e 1563 return err;
9e64cc95 1564 }
bf08867f 1565 c.data.proto = p->proto;
f60f6b8f 1566 c.event = nlh->nlmsg_type;
26b15dad
JHS		 1567 c.seq = nlh->nlmsg_seq;
1568 c.pid = nlh->nlmsg_pid;
7067802e 1569 c.net = net;
26b15dad
JHS		 1570 km_state_notify(NULL, &c);
1571
1da177e4
LT		 1572 return 0;
1573}
1574
7deb2264
TG		 1575static inline size_t xfrm_aevent_msgsize(void)
1576{
1577 return NLMSG_ALIGN(sizeof(struct xfrm_aevent_id))
1578 + nla_total_size(sizeof(struct xfrm_replay_state))
1579 + nla_total_size(sizeof(struct xfrm_lifetime_cur))
6f26b61e 1580 + nla_total_size(sizeof(struct xfrm_mark))
7deb2264
TG		 1581 + nla_total_size(4) /* XFRM_AE_RTHR */
1582 + nla_total_size(4); /* XFRM_AE_ETHR */
1583}
d51d081d
JHS		 1584
1585static int build_aevent(struct sk_buff *skb, struct xfrm_state *x, struct km_event *c)
1586{
1587 struct xfrm_aevent_id *id;
1588 struct nlmsghdr *nlh;
d51d081d 1589
79b8b7f4
TG		 1590 nlh = nlmsg_put(skb, c->pid, c->seq, XFRM_MSG_NEWAE, sizeof(*id), 0);
1591 if (nlh == NULL)
1592 return -EMSGSIZE;
d51d081d 1593
7b67c857 1594 id = nlmsg_data(nlh);
2b5f6dcc 1595 memcpy(&id->sa_id.daddr, &x->id.daddr,sizeof(x->id.daddr));
d51d081d
JHS		 1596 id->sa_id.spi = x->id.spi;
1597 id->sa_id.family = x->props.family;
1598 id->sa_id.proto = x->id.proto;
2b5f6dcc
JHS		 1599 memcpy(&id->saddr, &x->props.saddr,sizeof(x->props.saddr));
1600 id->reqid = x->props.reqid;
d51d081d
JHS		 1601 id->flags = c->data.aevent;
1602
c0144bea
TG		 1603 NLA_PUT(skb, XFRMA_REPLAY_VAL, sizeof(x->replay), &x->replay);
1604 NLA_PUT(skb, XFRMA_LTIME_VAL, sizeof(x->curlft), &x->curlft);
d51d081d 1605
c0144bea
TG		 1606 if (id->flags & XFRM_AE_RTHR)
1607 NLA_PUT_U32(skb, XFRMA_REPLAY_THRESH, x->replay_maxdiff);
d51d081d 1608
c0144bea
TG		 1609 if (id->flags & XFRM_AE_ETHR)
1610 NLA_PUT_U32(skb, XFRMA_ETIMER_THRESH,
1611 x->replay_maxage * 10 / HZ);
d51d081d 1612
6f26b61e
JHS		 1613 if (xfrm_mark_put(skb, &x->mark))
1614 goto nla_put_failure;
1615
9825069d 1616 return nlmsg_end(skb, nlh);
d51d081d 1617
c0144bea 1618nla_put_failure:
9825069d
TG		 1619 nlmsg_cancel(skb, nlh);
1620 return -EMSGSIZE;
d51d081d
JHS		 1621}
1622
22e70050 1623static int xfrm_get_ae(struct sk_buff *skb, struct nlmsghdr *nlh,
5424f32e 1624 struct nlattr **attrs)
d51d081d 1625{
fc34acd3 1626 struct net *net = sock_net(skb->sk);
d51d081d
JHS		 1627 struct xfrm_state *x;
1628 struct sk_buff *r_skb;
1629 int err;
1630 struct km_event c;
6f26b61e
JHS		 1631 u32 mark;
1632 struct xfrm_mark m;
7b67c857 1633 struct xfrm_aevent_id *p = nlmsg_data(nlh);
d51d081d
JHS		 1634 struct xfrm_usersa_id *id = &p->sa_id;
1635
7deb2264 1636 r_skb = nlmsg_new(xfrm_aevent_msgsize(), GFP_ATOMIC);
d51d081d
JHS		 1637 if (r_skb == NULL)
1638 return -ENOMEM;
1639
6f26b61e
JHS		 1640 mark = xfrm_mark_get(attrs, &m);
1641
1642 x = xfrm_state_lookup(net, mark, &id->daddr, id->spi, id->proto, id->family);
d51d081d 1643 if (x == NULL) {
b08d5840 1644 kfree_skb(r_skb);
d51d081d
JHS		 1645 return -ESRCH;
1646 }
1647
1648 /*
1649 * XXX: is this lock really needed - none of the other
1650 * gets lock (the concern is things getting updated
1651 * while we are still reading) - jhs
1652 */
1653 spin_lock_bh(&x->lock);
1654 c.data.aevent = p->flags;
1655 c.seq = nlh->nlmsg_seq;
1656 c.pid = nlh->nlmsg_pid;
1657
1658 if (build_aevent(r_skb, x, &c) < 0)
1659 BUG();
a6483b79 1660 err = nlmsg_unicast(net->xfrm.nlsk, r_skb, NETLINK_CB(skb).pid);
d51d081d
JHS		 1661 spin_unlock_bh(&x->lock);
1662 xfrm_state_put(x);
1663 return err;
1664}
1665
22e70050 1666static int xfrm_new_ae(struct sk_buff *skb, struct nlmsghdr *nlh,
5424f32e 1667 struct nlattr **attrs)
d51d081d 1668{
fc34acd3 1669 struct net *net = sock_net(skb->sk);
d51d081d
JHS		 1670 struct xfrm_state *x;
1671 struct km_event c;
1672 int err = - EINVAL;
6f26b61e
JHS		 1673 u32 mark = 0;
1674 struct xfrm_mark m;
7b67c857 1675 struct xfrm_aevent_id *p = nlmsg_data(nlh);
5424f32e
TG		 1676 struct nlattr *rp = attrs[XFRMA_REPLAY_VAL];
1677 struct nlattr *lt = attrs[XFRMA_LTIME_VAL];
d51d081d
JHS		 1678
1679 if (!lt && !rp)
1680 return err;
1681
1682 /* pedantic mode - thou shalt sayeth replaceth */
1683 if (!(nlh->nlmsg_flags&NLM_F_REPLACE))
1684 return err;
1685
6f26b61e
JHS		 1686 mark = xfrm_mark_get(attrs, &m);
1687
1688 x = xfrm_state_lookup(net, mark, &p->sa_id.daddr, p->sa_id.spi, p->sa_id.proto, p->sa_id.family);
d51d081d
JHS		 1689 if (x == NULL)
1690 return -ESRCH;
1691
1692 if (x->km.state != XFRM_STATE_VALID)
1693 goto out;
1694
1695 spin_lock_bh(&x->lock);
35a7aa08 1696 xfrm_update_ae_params(x, attrs);
d51d081d 1697 spin_unlock_bh(&x->lock);
d51d081d
JHS		 1698
1699 c.event = nlh->nlmsg_type;
1700 c.seq = nlh->nlmsg_seq;
1701 c.pid = nlh->nlmsg_pid;
1702 c.data.aevent = XFRM_AE_CU;
1703 km_state_notify(x, &c);
1704 err = 0;
1705out:
1706 xfrm_state_put(x);
1707 return err;
1708}
1709
22e70050 1710static int xfrm_flush_policy(struct sk_buff *skb, struct nlmsghdr *nlh,
5424f32e 1711 struct nlattr **attrs)
1da177e4 1712{
fc34acd3 1713 struct net *net = sock_net(skb->sk);
f7b6983f 1714 struct km_event c;
b798a9ed 1715 u8 type = XFRM_POLICY_TYPE_MAIN;
f7b6983f 1716 int err;
161a09e7 1717 struct xfrm_audit audit_info;
f7b6983f 1718
35a7aa08 1719 err = copy_from_user_policy_type(&type, attrs);
f7b6983f
MN		 1720 if (err)
1721 return err;
26b15dad 1722
161a09e7 1723 audit_info.loginuid = NETLINK_CB(skb).loginuid;
2532386f 1724 audit_info.sessionid = NETLINK_CB(skb).sessionid;
161a09e7 1725 audit_info.secid = NETLINK_CB(skb).sid;
fc34acd3 1726 err = xfrm_policy_flush(net, type, &audit_info);
2f1eb65f
JHS		 1727 if (err) {
1728 if (err == -ESRCH) /* empty table */
1729 return 0;
069c474e 1730 return err;
2f1eb65f
JHS		 1731 }
1732
f7b6983f 1733 c.data.type = type;
f60f6b8f 1734 c.event = nlh->nlmsg_type;
26b15dad
JHS		 1735 c.seq = nlh->nlmsg_seq;
1736 c.pid = nlh->nlmsg_pid;
7067802e 1737 c.net = net;
26b15dad 1738 km_policy_notify(NULL, 0, &c);
1da177e4
LT		 1739 return 0;
1740}
1741
22e70050 1742static int xfrm_add_pol_expire(struct sk_buff *skb, struct nlmsghdr *nlh,
5424f32e 1743 struct nlattr **attrs)
6c5c8ca7 1744{
fc34acd3 1745 struct net *net = sock_net(skb->sk);
6c5c8ca7 1746 struct xfrm_policy *xp;
7b67c857 1747 struct xfrm_user_polexpire *up = nlmsg_data(nlh);
6c5c8ca7 1748 struct xfrm_userpolicy_info *p = &up->pol;
b798a9ed 1749 u8 type = XFRM_POLICY_TYPE_MAIN;
6c5c8ca7 1750 int err = -ENOENT;
295fae56
JHS		 1751 struct xfrm_mark m;
1752 u32 mark = xfrm_mark_get(attrs, &m);
6c5c8ca7 1753
35a7aa08 1754 err = copy_from_user_policy_type(&type, attrs);
f7b6983f
MN		 1755 if (err)
1756 return err;
1757
c8bf4d04
TT		 1758 err = verify_policy_dir(p->dir);
1759 if (err)
1760 return err;
1761
6c5c8ca7 1762 if (p->index)
295fae56 1763 xp = xfrm_policy_byid(net, mark, type, p->dir, p->index, 0, &err);
6c5c8ca7 1764 else {
5424f32e 1765 struct nlattr *rt = attrs[XFRMA_SEC_CTX];
03e1ad7b 1766 struct xfrm_sec_ctx *ctx;
6c5c8ca7 1767
35a7aa08 1768 err = verify_sec_ctx_len(attrs);
6c5c8ca7
JHS		 1769 if (err)
1770 return err;
1771
2c8dd116 1772 ctx = NULL;
6c5c8ca7 1773 if (rt) {
5424f32e 1774 struct xfrm_user_sec_ctx *uctx = nla_data(rt);
6c5c8ca7 1775
03e1ad7b
PM		 1776 err = security_xfrm_policy_alloc(&ctx, uctx);
1777 if (err)
6c5c8ca7 1778 return err;
2c8dd116 1779 }
295fae56 1780 xp = xfrm_policy_bysel_ctx(net, mark, type, p->dir,
6f26b61e 1781 &p->sel, ctx, 0, &err);
03e1ad7b 1782 security_xfrm_policy_free(ctx);
6c5c8ca7 1783 }
6c5c8ca7 1784 if (xp == NULL)
ef41aaa0 1785 return -ENOENT;
03e1ad7b 1786
ea2dea9d 1787 if (unlikely(xp->walk.dead))
6c5c8ca7 1788 goto out;
6c5c8ca7 1789
6c5c8ca7
JHS		 1790 err = 0;
1791 if (up->hard) {
2532386f
EP		 1792 uid_t loginuid = NETLINK_CB(skb).loginuid;
1793 uid_t sessionid = NETLINK_CB(skb).sessionid;
1794 u32 sid = NETLINK_CB(skb).sid;
6c5c8ca7 1795 xfrm_policy_delete(xp, p->dir);
2532386f 1796 xfrm_audit_policy_delete(xp, 1, loginuid, sessionid, sid);
161a09e7 1797
6c5c8ca7
JHS		 1798 } else {
1799 // reset the timers here?
62db5cfd 1800 WARN(1, "Dont know what to do with soft policy expire\n");
6c5c8ca7
JHS		 1801 }
1802 km_policy_expired(xp, p->dir, up->hard, current->pid);
1803
1804out:
1805 xfrm_pol_put(xp);
1806 return err;
1807}
1808
22e70050 1809static int xfrm_add_sa_expire(struct sk_buff *skb, struct nlmsghdr *nlh,
5424f32e 1810 struct nlattr **attrs)
53bc6b4d 1811{
fc34acd3 1812 struct net *net = sock_net(skb->sk);
53bc6b4d
JHS		 1813 struct xfrm_state *x;
1814 int err;
7b67c857 1815 struct xfrm_user_expire *ue = nlmsg_data(nlh);
53bc6b4d 1816 struct xfrm_usersa_info *p = &ue->state;
6f26b61e 1817 struct xfrm_mark m;
928497f0 1818 u32 mark = xfrm_mark_get(attrs, &m);
53bc6b4d 1819
6f26b61e 1820 x = xfrm_state_lookup(net, mark, &p->id.daddr, p->id.spi, p->id.proto, p->family);
53bc6b4d 1821
3a765aa5 1822 err = -ENOENT;
53bc6b4d
JHS		 1823 if (x == NULL)
1824 return err;
1825
53bc6b4d 1826 spin_lock_bh(&x->lock);
3a765aa5 1827 err = -EINVAL;
53bc6b4d
JHS		 1828 if (x->km.state != XFRM_STATE_VALID)
1829 goto out;
1830 km_state_expired(x, ue->hard, current->pid);
1831
161a09e7 1832 if (ue->hard) {
2532386f
EP		 1833 uid_t loginuid = NETLINK_CB(skb).loginuid;
1834 uid_t sessionid = NETLINK_CB(skb).sessionid;
1835 u32 sid = NETLINK_CB(skb).sid;
53bc6b4d 1836 __xfrm_state_delete(x);
2532386f 1837 xfrm_audit_state_delete(x, 1, loginuid, sessionid, sid);
161a09e7 1838 }
3a765aa5 1839 err = 0;
53bc6b4d
JHS		 1840out:
1841 spin_unlock_bh(&x->lock);
1842 xfrm_state_put(x);
1843 return err;
1844}
1845
22e70050 1846static int xfrm_add_acquire(struct sk_buff *skb, struct nlmsghdr *nlh,
5424f32e 1847 struct nlattr **attrs)
980ebd25 1848{
fc34acd3 1849 struct net *net = sock_net(skb->sk);
980ebd25
JHS		 1850 struct xfrm_policy *xp;
1851 struct xfrm_user_tmpl *ut;
1852 int i;
5424f32e 1853 struct nlattr *rt = attrs[XFRMA_TMPL];
6f26b61e 1854 struct xfrm_mark mark;
980ebd25 1855
7b67c857 1856 struct xfrm_user_acquire *ua = nlmsg_data(nlh);
fc34acd3 1857 struct xfrm_state *x = xfrm_state_alloc(net);
980ebd25
JHS		 1858 int err = -ENOMEM;
1859
1860 if (!x)
d8eb9307 1861 goto nomem;
980ebd25 1862
6f26b61e
JHS		 1863 xfrm_mark_get(attrs, &mark);
1864
980ebd25 1865 err = verify_newpolicy_info(&ua->policy);
d8eb9307
IJ		 1866 if (err)
1867 goto bad_policy;
980ebd25
JHS		 1868
1869 /* build an XP */
fc34acd3 1870 xp = xfrm_policy_construct(net, &ua->policy, attrs, &err);
d8eb9307
IJ		 1871 if (!xp)
1872 goto free_state;
980ebd25
JHS		 1873
1874 memcpy(&x->id, &ua->id, sizeof(ua->id));
1875 memcpy(&x->props.saddr, &ua->saddr, sizeof(ua->saddr));
1876 memcpy(&x->sel, &ua->sel, sizeof(ua->sel));
6f26b61e
JHS		 1877 xp->mark.m = x->mark.m = mark.m;
1878 xp->mark.v = x->mark.v = mark.v;
5424f32e 1879 ut = nla_data(rt);
980ebd25
JHS		 1880 /* extract the templates and for each call km_key */
1881 for (i = 0; i < xp->xfrm_nr; i++, ut++) {
1882 struct xfrm_tmpl *t = &xp->xfrm_vec[i];
1883 memcpy(&x->id, &t->id, sizeof(x->id));
1884 x->props.mode = t->mode;
1885 x->props.reqid = t->reqid;
1886 x->props.family = ut->family;
1887 t->aalgos = ua->aalgos;
1888 t->ealgos = ua->ealgos;
1889 t->calgos = ua->calgos;
1890 err = km_query(x, t, xp);
1891
1892 }
1893
1894 kfree(x);
1895 kfree(xp);
1896
1897 return 0;
d8eb9307
IJ		 1898
1899bad_policy:
62db5cfd 1900 WARN(1, "BAD policy passed\n");
d8eb9307
IJ		 1901free_state:
1902 kfree(x);
1903nomem:
1904 return err;
980ebd25
JHS		 1905}
1906
5c79de6e 1907#ifdef CONFIG_XFRM_MIGRATE
5c79de6e 1908static int copy_from_user_migrate(struct xfrm_migrate *ma,
13c1d189 1909 struct xfrm_kmaddress *k,
5424f32e 1910 struct nlattr **attrs, int *num)
5c79de6e 1911{
5424f32e 1912 struct nlattr *rt = attrs[XFRMA_MIGRATE];
5c79de6e
SS		 1913 struct xfrm_user_migrate *um;
1914 int i, num_migrate;
1915
13c1d189
AE		 1916 if (k != NULL) {
1917 struct xfrm_user_kmaddress *uk;
1918
1919 uk = nla_data(attrs[XFRMA_KMADDRESS]);
1920 memcpy(&k->local, &uk->local, sizeof(k->local));
1921 memcpy(&k->remote, &uk->remote, sizeof(k->remote));
1922 k->family = uk->family;
1923 k->reserved = uk->reserved;
1924 }
1925
5424f32e
TG		 1926 um = nla_data(rt);
1927 num_migrate = nla_len(rt) / sizeof(*um);
5c79de6e
SS		 1928
1929 if (num_migrate <= 0 || num_migrate > XFRM_MAX_DEPTH)
1930 return -EINVAL;
1931
1932 for (i = 0; i < num_migrate; i++, um++, ma++) {
1933 memcpy(&ma->old_daddr, &um->old_daddr, sizeof(ma->old_daddr));
1934 memcpy(&ma->old_saddr, &um->old_saddr, sizeof(ma->old_saddr));
1935 memcpy(&ma->new_daddr, &um->new_daddr, sizeof(ma->new_daddr));
1936 memcpy(&ma->new_saddr, &um->new_saddr, sizeof(ma->new_saddr));
1937
1938 ma->proto = um->proto;
1939 ma->mode = um->mode;
1940 ma->reqid = um->reqid;
1941
1942 ma->old_family = um->old_family;
1943 ma->new_family = um->new_family;
1944 }
1945
1946 *num = i;
1947 return 0;
1948}
1949
1950static int xfrm_do_migrate(struct sk_buff *skb, struct nlmsghdr *nlh,
5424f32e 1951 struct nlattr **attrs)
5c79de6e 1952{
7b67c857 1953 struct xfrm_userpolicy_id *pi = nlmsg_data(nlh);
5c79de6e 1954 struct xfrm_migrate m[XFRM_MAX_DEPTH];
13c1d189 1955 struct xfrm_kmaddress km, *kmp;
5c79de6e
SS		 1956 u8 type;
1957 int err;
1958 int n = 0;
1959
35a7aa08 1960 if (attrs[XFRMA_MIGRATE] == NULL)
cf5cb79f 1961 return -EINVAL;
5c79de6e 1962
13c1d189
AE		 1963 kmp = attrs[XFRMA_KMADDRESS] ? &km : NULL;
1964
5424f32e 1965 err = copy_from_user_policy_type(&type, attrs);
5c79de6e
SS		 1966 if (err)
1967 return err;
1968
13c1d189 1969 err = copy_from_user_migrate((struct xfrm_migrate *)m, kmp, attrs, &n);
5c79de6e
SS		 1970 if (err)
1971 return err;
1972
1973 if (!n)
1974 return 0;
1975
13c1d189 1976 xfrm_migrate(&pi->sel, pi->dir, type, m, n, kmp);
5c79de6e
SS		 1977
1978 return 0;
1979}
1980#else
1981static int xfrm_do_migrate(struct sk_buff *skb, struct nlmsghdr *nlh,
5424f32e 1982 struct nlattr **attrs)
5c79de6e
SS		 1983{
1984 return -ENOPROTOOPT;
1985}
1986#endif
1987
1988#ifdef CONFIG_XFRM_MIGRATE
1989static int copy_to_user_migrate(struct xfrm_migrate *m, struct sk_buff *skb)
1990{
1991 struct xfrm_user_migrate um;
1992
1993 memset(&um, 0, sizeof(um));
1994 um.proto = m->proto;
1995 um.mode = m->mode;
1996 um.reqid = m->reqid;
1997 um.old_family = m->old_family;
1998 memcpy(&um.old_daddr, &m->old_daddr, sizeof(um.old_daddr));
1999 memcpy(&um.old_saddr, &m->old_saddr, sizeof(um.old_saddr));
2000 um.new_family = m->new_family;
2001 memcpy(&um.new_daddr, &m->new_daddr, sizeof(um.new_daddr));
2002 memcpy(&um.new_saddr, &m->new_saddr, sizeof(um.new_saddr));
2003
c0144bea 2004 return nla_put(skb, XFRMA_MIGRATE, sizeof(um), &um);
5c79de6e
SS		 2005}
2006
13c1d189
AE		 2007static int copy_to_user_kmaddress(struct xfrm_kmaddress *k, struct sk_buff *skb)
2008{
2009 struct xfrm_user_kmaddress uk;
2010
2011 memset(&uk, 0, sizeof(uk));
2012 uk.family = k->family;
2013 uk.reserved = k->reserved;
2014 memcpy(&uk.local, &k->local, sizeof(uk.local));
a1caa322 2015 memcpy(&uk.remote, &k->remote, sizeof(uk.remote));
13c1d189
AE		 2016
2017 return nla_put(skb, XFRMA_KMADDRESS, sizeof(uk), &uk);
2018}
2019
2020static inline size_t xfrm_migrate_msgsize(int num_migrate, int with_kma)
7deb2264
TG		 2021{
2022 return NLMSG_ALIGN(sizeof(struct xfrm_userpolicy_id))
13c1d189
AE		 2023 + (with_kma ? nla_total_size(sizeof(struct xfrm_kmaddress)) : 0)
2024 + nla_total_size(sizeof(struct xfrm_user_migrate) * num_migrate)
2025 + userpolicy_type_attrsize();
7deb2264
TG		 2026}
2027
5c79de6e 2028static int build_migrate(struct sk_buff *skb, struct xfrm_migrate *m,
13c1d189
AE		 2029 int num_migrate, struct xfrm_kmaddress *k,
2030 struct xfrm_selector *sel, u8 dir, u8 type)
5c79de6e
SS		 2031{
2032 struct xfrm_migrate *mp;
2033 struct xfrm_userpolicy_id *pol_id;
2034 struct nlmsghdr *nlh;
5c79de6e
SS		 2035 int i;
2036
79b8b7f4
TG		 2037 nlh = nlmsg_put(skb, 0, 0, XFRM_MSG_MIGRATE, sizeof(*pol_id), 0);
2038 if (nlh == NULL)
2039 return -EMSGSIZE;
5c79de6e 2040
7b67c857 2041 pol_id = nlmsg_data(nlh);
5c79de6e
SS		 2042 /* copy data from selector, dir, and type to the pol_id */
2043 memset(pol_id, 0, sizeof(*pol_id));
2044 memcpy(&pol_id->sel, sel, sizeof(pol_id->sel));
2045 pol_id->dir = dir;
2046
13c1d189
AE		 2047 if (k != NULL && (copy_to_user_kmaddress(k, skb) < 0))
2048 goto nlmsg_failure;
2049
5c79de6e
SS		 2050 if (copy_to_user_policy_type(type, skb) < 0)
2051 goto nlmsg_failure;
2052
2053 for (i = 0, mp = m ; i < num_migrate; i++, mp++) {
2054 if (copy_to_user_migrate(mp, skb) < 0)
2055 goto nlmsg_failure;
2056 }
2057
9825069d 2058 return nlmsg_end(skb, nlh);
5c79de6e 2059nlmsg_failure:
9825069d
TG		 2060 nlmsg_cancel(skb, nlh);
2061 return -EMSGSIZE;
5c79de6e
SS		 2062}
2063
2064static int xfrm_send_migrate(struct xfrm_selector *sel, u8 dir, u8 type,
13c1d189
AE		 2065 struct xfrm_migrate *m, int num_migrate,
2066 struct xfrm_kmaddress *k)
5c79de6e 2067{
a6483b79 2068 struct net *net = &init_net;
5c79de6e 2069 struct sk_buff *skb;
5c79de6e 2070
13c1d189 2071 skb = nlmsg_new(xfrm_migrate_msgsize(num_migrate, !!k), GFP_ATOMIC);
5c79de6e
SS		 2072 if (skb == NULL)
2073 return -ENOMEM;
2074
2075 /* build migrate */
13c1d189 2076 if (build_migrate(skb, m, num_migrate, k, sel, dir, type) < 0)
5c79de6e
SS		 2077 BUG();
2078
a6483b79 2079 return nlmsg_multicast(net->xfrm.nlsk, skb, 0, XFRMNLGRP_MIGRATE, GFP_ATOMIC);
5c79de6e
SS		 2080}
2081#else
2082static int xfrm_send_migrate(struct xfrm_selector *sel, u8 dir, u8 type,
13c1d189
AE		 2083 struct xfrm_migrate *m, int num_migrate,
2084 struct xfrm_kmaddress *k)
5c79de6e
SS		 2085{
2086 return -ENOPROTOOPT;
2087}
2088#endif
d51d081d 2089
a7bd9a45 2090#define XMSGSIZE(type) sizeof(struct type)
492b558b
TG		 2091
2092static const int xfrm_msg_min[XFRM_NR_MSGTYPES] = {
66f9a259 2093 [XFRM_MSG_NEWSA - XFRM_MSG_BASE] = XMSGSIZE(xfrm_usersa_info),
492b558b
TG		 2094 [XFRM_MSG_DELSA - XFRM_MSG_BASE] = XMSGSIZE(xfrm_usersa_id),
2095 [XFRM_MSG_GETSA - XFRM_MSG_BASE] = XMSGSIZE(xfrm_usersa_id),
2096 [XFRM_MSG_NEWPOLICY - XFRM_MSG_BASE] = XMSGSIZE(xfrm_userpolicy_info),
2097 [XFRM_MSG_DELPOLICY - XFRM_MSG_BASE] = XMSGSIZE(xfrm_userpolicy_id),
2098 [XFRM_MSG_GETPOLICY - XFRM_MSG_BASE] = XMSGSIZE(xfrm_userpolicy_id),
2099 [XFRM_MSG_ALLOCSPI - XFRM_MSG_BASE] = XMSGSIZE(xfrm_userspi_info),
980ebd25 2100 [XFRM_MSG_ACQUIRE - XFRM_MSG_BASE] = XMSGSIZE(xfrm_user_acquire),
53bc6b4d 2101 [XFRM_MSG_EXPIRE - XFRM_MSG_BASE] = XMSGSIZE(xfrm_user_expire),
492b558b 2102 [XFRM_MSG_UPDPOLICY - XFRM_MSG_BASE] = XMSGSIZE(xfrm_userpolicy_info),
66f9a259 2103 [XFRM_MSG_UPDSA - XFRM_MSG_BASE] = XMSGSIZE(xfrm_usersa_info),
6c5c8ca7 2104 [XFRM_MSG_POLEXPIRE - XFRM_MSG_BASE] = XMSGSIZE(xfrm_user_polexpire),
492b558b 2105 [XFRM_MSG_FLUSHSA - XFRM_MSG_BASE] = XMSGSIZE(xfrm_usersa_flush),
a7bd9a45 2106 [XFRM_MSG_FLUSHPOLICY - XFRM_MSG_BASE] = 0,
d51d081d
JHS		 2107 [XFRM_MSG_NEWAE - XFRM_MSG_BASE] = XMSGSIZE(xfrm_aevent_id),
2108 [XFRM_MSG_GETAE - XFRM_MSG_BASE] = XMSGSIZE(xfrm_aevent_id),
97a64b45 2109 [XFRM_MSG_REPORT - XFRM_MSG_BASE] = XMSGSIZE(xfrm_user_report),
5c79de6e 2110 [XFRM_MSG_MIGRATE - XFRM_MSG_BASE] = XMSGSIZE(xfrm_userpolicy_id),
a7bd9a45
TG		 2111 [XFRM_MSG_GETSADINFO - XFRM_MSG_BASE] = sizeof(u32),
2112 [XFRM_MSG_GETSPDINFO - XFRM_MSG_BASE] = sizeof(u32),
1da177e4
LT		 2113};
2114
492b558b
TG		 2115#undef XMSGSIZE
2116
cf5cb79f 2117static const struct nla_policy xfrma_policy[XFRMA_MAX+1] = {
c28e9304 2118 [XFRMA_SA] = { .len = sizeof(struct xfrm_usersa_info)},
2119 [XFRMA_POLICY] = { .len = sizeof(struct xfrm_userpolicy_info)},
2120 [XFRMA_LASTUSED] = { .type = NLA_U64},
2121 [XFRMA_ALG_AUTH_TRUNC] = { .len = sizeof(struct xfrm_algo_auth)},
1a6509d9 2122 [XFRMA_ALG_AEAD] = { .len = sizeof(struct xfrm_algo_aead) },
cf5cb79f
TG		 2123 [XFRMA_ALG_AUTH] = { .len = sizeof(struct xfrm_algo) },
2124 [XFRMA_ALG_CRYPT] = { .len = sizeof(struct xfrm_algo) },
2125 [XFRMA_ALG_COMP] = { .len = sizeof(struct xfrm_algo) },
2126 [XFRMA_ENCAP] = { .len = sizeof(struct xfrm_encap_tmpl) },
2127 [XFRMA_TMPL] = { .len = sizeof(struct xfrm_user_tmpl) },
2128 [XFRMA_SEC_CTX] = { .len = sizeof(struct xfrm_sec_ctx) },
2129 [XFRMA_LTIME_VAL] = { .len = sizeof(struct xfrm_lifetime_cur) },
2130 [XFRMA_REPLAY_VAL] = { .len = sizeof(struct xfrm_replay_state) },
2131 [XFRMA_REPLAY_THRESH] = { .type = NLA_U32 },
2132 [XFRMA_ETIMER_THRESH] = { .type = NLA_U32 },
2133 [XFRMA_SRCADDR] = { .len = sizeof(xfrm_address_t) },
2134 [XFRMA_COADDR] = { .len = sizeof(xfrm_address_t) },
2135 [XFRMA_POLICY_TYPE] = { .len = sizeof(struct xfrm_userpolicy_type)},
2136 [XFRMA_MIGRATE] = { .len = sizeof(struct xfrm_user_migrate) },
13c1d189 2137 [XFRMA_KMADDRESS] = { .len = sizeof(struct xfrm_user_kmaddress) },
6f26b61e 2138 [XFRMA_MARK] = { .len = sizeof(struct xfrm_mark) },
35d2856b 2139 [XFRMA_TFCPAD] = { .type = NLA_U32 },
cf5cb79f
TG		 2140};
2141
1da177e4 2142static struct xfrm_link {
5424f32e 2143 int (*doit)(struct sk_buff *, struct nlmsghdr *, struct nlattr **);
1da177e4 2144 int (*dump)(struct sk_buff *, struct netlink_callback *);
4c563f76 2145 int (*done)(struct netlink_callback *);
492b558b
TG		 2146} xfrm_dispatch[XFRM_NR_MSGTYPES] = {
2147 [XFRM_MSG_NEWSA - XFRM_MSG_BASE] = { .doit = xfrm_add_sa },
2148 [XFRM_MSG_DELSA - XFRM_MSG_BASE] = { .doit = xfrm_del_sa },
2149 [XFRM_MSG_GETSA - XFRM_MSG_BASE] = { .doit = xfrm_get_sa,
4c563f76
TT		 2150 .dump = xfrm_dump_sa,
2151 .done = xfrm_dump_sa_done },
492b558b
TG		 2152 [XFRM_MSG_NEWPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_add_policy },
2153 [XFRM_MSG_DELPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_get_policy },
2154 [XFRM_MSG_GETPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_get_policy,
4c563f76
TT		 2155 .dump = xfrm_dump_policy,
2156 .done = xfrm_dump_policy_done },
492b558b 2157 [XFRM_MSG_ALLOCSPI - XFRM_MSG_BASE] = { .doit = xfrm_alloc_userspi },
980ebd25 2158 [XFRM_MSG_ACQUIRE - XFRM_MSG_BASE] = { .doit = xfrm_add_acquire },
53bc6b4d 2159 [XFRM_MSG_EXPIRE - XFRM_MSG_BASE] = { .doit = xfrm_add_sa_expire },
492b558b
TG		 2160 [XFRM_MSG_UPDPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_add_policy },
2161 [XFRM_MSG_UPDSA - XFRM_MSG_BASE] = { .doit = xfrm_add_sa },
6c5c8ca7 2162 [XFRM_MSG_POLEXPIRE - XFRM_MSG_BASE] = { .doit = xfrm_add_pol_expire},
492b558b
TG		 2163 [XFRM_MSG_FLUSHSA - XFRM_MSG_BASE] = { .doit = xfrm_flush_sa },
2164 [XFRM_MSG_FLUSHPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_flush_policy },
d51d081d
JHS		 2165 [XFRM_MSG_NEWAE - XFRM_MSG_BASE] = { .doit = xfrm_new_ae },
2166 [XFRM_MSG_GETAE - XFRM_MSG_BASE] = { .doit = xfrm_get_ae },
5c79de6e 2167 [XFRM_MSG_MIGRATE - XFRM_MSG_BASE] = { .doit = xfrm_do_migrate },
566ec034 2168 [XFRM_MSG_GETSADINFO - XFRM_MSG_BASE] = { .doit = xfrm_get_sadinfo },
ecfd6b18 2169 [XFRM_MSG_GETSPDINFO - XFRM_MSG_BASE] = { .doit = xfrm_get_spdinfo },
1da177e4
LT		 2170};
2171
1d00a4eb 2172static int xfrm_user_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
1da177e4 2173{
a6483b79 2174 struct net *net = sock_net(skb->sk);
35a7aa08 2175 struct nlattr *attrs[XFRMA_MAX+1];
1da177e4 2176 struct xfrm_link *link;
a7bd9a45 2177 int type, err;
1da177e4 2178
1da177e4 2179 type = nlh->nlmsg_type;
1da177e4 2180 if (type > XFRM_MSG_MAX)
1d00a4eb 2181 return -EINVAL;
1da177e4
LT		 2182
2183 type -= XFRM_MSG_BASE;
2184 link = &xfrm_dispatch[type];
2185
2186 /* All operations require privileges, even GET */
1d00a4eb
TG		 2187 if (security_netlink_recv(skb, CAP_NET_ADMIN))
2188 return -EPERM;
1da177e4 2189
492b558b
TG		 2190 if ((type == (XFRM_MSG_GETSA - XFRM_MSG_BASE) ||
2191 type == (XFRM_MSG_GETPOLICY - XFRM_MSG_BASE)) &&
b8f3ab42 2192 (nlh->nlmsg_flags & NLM_F_DUMP)) {
1da177e4 2193 if (link->dump == NULL)
1d00a4eb 2194 return -EINVAL;
88fc2c84 2195
a6483b79 2196 return netlink_dump_start(net->xfrm.nlsk, skb, nlh, link->dump, link->done);
1da177e4
LT		 2197 }
2198
35a7aa08 2199 err = nlmsg_parse(nlh, xfrm_msg_min[type], attrs, XFRMA_MAX,
cf5cb79f 2200 xfrma_policy);
a7bd9a45
TG		 2201 if (err < 0)
2202 return err;
1da177e4
LT		 2203
2204 if (link->doit == NULL)
1d00a4eb 2205 return -EINVAL;
1da177e4 2206
5424f32e 2207 return link->doit(skb, nlh, attrs);
1da177e4
LT		 2208}
2209
cd40b7d3 2210static void xfrm_netlink_rcv(struct sk_buff *skb)
1da177e4 2211{
cd40b7d3
DL		 2212 mutex_lock(&xfrm_cfg_mutex);
2213 netlink_rcv_skb(skb, &xfrm_user_rcv_msg);
2214 mutex_unlock(&xfrm_cfg_mutex);
1da177e4
LT		 2215}
2216
7deb2264
TG		 2217static inline size_t xfrm_expire_msgsize(void)
2218{
6f26b61e
JHS		 2219 return NLMSG_ALIGN(sizeof(struct xfrm_user_expire))
2220 + nla_total_size(sizeof(struct xfrm_mark));
7deb2264
TG		 2221}
2222
d51d081d 2223static int build_expire(struct sk_buff *skb, struct xfrm_state *x, struct km_event *c)
1da177e4
LT		 2224{
2225 struct xfrm_user_expire *ue;
2226 struct nlmsghdr *nlh;
1da177e4 2227
79b8b7f4
TG		 2228 nlh = nlmsg_put(skb, c->pid, 0, XFRM_MSG_EXPIRE, sizeof(*ue), 0);
2229 if (nlh == NULL)
2230 return -EMSGSIZE;
1da177e4 2231
7b67c857 2232 ue = nlmsg_data(nlh);
1da177e4 2233 copy_to_user_state(x, &ue->state);
d51d081d 2234 ue->hard = (c->data.hard != 0) ? 1 : 0;
1da177e4 2235
6f26b61e
JHS		 2236 if (xfrm_mark_put(skb, &x->mark))
2237 goto nla_put_failure;
2238
9825069d 2239 return nlmsg_end(skb, nlh);
6f26b61e
JHS		 2240
2241nla_put_failure:
2242 return -EMSGSIZE;
1da177e4
LT		 2243}
2244
26b15dad 2245static int xfrm_exp_state_notify(struct xfrm_state *x, struct km_event *c)
1da177e4 2246{
fc34acd3 2247 struct net *net = xs_net(x);
1da177e4
LT		 2248 struct sk_buff *skb;
2249
7deb2264 2250 skb = nlmsg_new(xfrm_expire_msgsize(), GFP_ATOMIC);
1da177e4
LT		 2251 if (skb == NULL)
2252 return -ENOMEM;
2253
6f26b61e
JHS		 2254 if (build_expire(skb, x, c) < 0) {
2255 kfree_skb(skb);
2256 return -EMSGSIZE;
2257 }
1da177e4 2258
a6483b79 2259 return nlmsg_multicast(net->xfrm.nlsk, skb, 0, XFRMNLGRP_EXPIRE, GFP_ATOMIC);
1da177e4
LT		 2260}
2261
d51d081d
JHS		 2262static int xfrm_aevent_state_notify(struct xfrm_state *x, struct km_event *c)
2263{
fc34acd3 2264 struct net *net = xs_net(x);
d51d081d 2265 struct sk_buff *skb;
d51d081d 2266
7deb2264 2267 skb = nlmsg_new(xfrm_aevent_msgsize(), GFP_ATOMIC);
d51d081d
JHS		 2268 if (skb == NULL)
2269 return -ENOMEM;
2270
2271 if (build_aevent(skb, x, c) < 0)
2272 BUG();
2273
a6483b79 2274 return nlmsg_multicast(net->xfrm.nlsk, skb, 0, XFRMNLGRP_AEVENTS, GFP_ATOMIC);
d51d081d
JHS		 2275}
2276
26b15dad
JHS		 2277static int xfrm_notify_sa_flush(struct km_event *c)
2278{
7067802e 2279 struct net *net = c->net;
26b15dad
JHS		 2280 struct xfrm_usersa_flush *p;
2281 struct nlmsghdr *nlh;
2282 struct sk_buff *skb;
7deb2264 2283 int len = NLMSG_ALIGN(sizeof(struct xfrm_usersa_flush));
26b15dad 2284
7deb2264 2285 skb = nlmsg_new(len, GFP_ATOMIC);
26b15dad
JHS		 2286 if (skb == NULL)
2287 return -ENOMEM;
26b15dad 2288
79b8b7f4
TG		 2289 nlh = nlmsg_put(skb, c->pid, c->seq, XFRM_MSG_FLUSHSA, sizeof(*p), 0);
2290 if (nlh == NULL) {
2291 kfree_skb(skb);
2292 return -EMSGSIZE;
2293 }
26b15dad 2294
7b67c857 2295 p = nlmsg_data(nlh);
bf08867f 2296 p->proto = c->data.proto;
26b15dad 2297
9825069d 2298 nlmsg_end(skb, nlh);
26b15dad 2299
a6483b79 2300 return nlmsg_multicast(net->xfrm.nlsk, skb, 0, XFRMNLGRP_SA, GFP_ATOMIC);
26b15dad
JHS		 2301}
2302
7deb2264 2303static inline size_t xfrm_sa_len(struct xfrm_state *x)
26b15dad 2304{
7deb2264 2305 size_t l = 0;
1a6509d9
HX		 2306 if (x->aead)
2307 l += nla_total_size(aead_len(x->aead));
4447bb33
MW		 2308 if (x->aalg) {
2309 l += nla_total_size(sizeof(struct xfrm_algo) +
2310 (x->aalg->alg_key_len + 7) / 8);
2311 l += nla_total_size(xfrm_alg_auth_len(x->aalg));
2312 }
26b15dad 2313 if (x->ealg)
0f99be0d 2314 l += nla_total_size(xfrm_alg_len(x->ealg));
26b15dad 2315 if (x->calg)
7deb2264 2316 l += nla_total_size(sizeof(*x->calg));
26b15dad 2317 if (x->encap)
7deb2264 2318 l += nla_total_size(sizeof(*x->encap));
35d2856b
MW		 2319 if (x->tfcpad)
2320 l += nla_total_size(sizeof(x->tfcpad));
68325d3b
HX		 2321 if (x->security)
2322 l += nla_total_size(sizeof(struct xfrm_user_sec_ctx) +
2323 x->security->ctx_len);
2324 if (x->coaddr)
2325 l += nla_total_size(sizeof(*x->coaddr));
2326
d26f3984
HX		 2327 /* Must count x->lastused as it may become non-zero behind our back. */
2328 l += nla_total_size(sizeof(u64));
26b15dad
JHS		 2329
2330 return l;
2331}
2332
2333static int xfrm_notify_sa(struct xfrm_state *x, struct km_event *c)
2334{
fc34acd3 2335 struct net *net = xs_net(x);
26b15dad 2336 struct xfrm_usersa_info *p;
0603eac0 2337 struct xfrm_usersa_id *id;
26b15dad
JHS		 2338 struct nlmsghdr *nlh;
2339 struct sk_buff *skb;
26b15dad 2340 int len = xfrm_sa_len(x);
0603eac0
HX		 2341 int headlen;
2342
2343 headlen = sizeof(*p);
2344 if (c->event == XFRM_MSG_DELSA) {
7deb2264 2345 len += nla_total_size(headlen);
0603eac0 2346 headlen = sizeof(*id);
6f26b61e 2347 len += nla_total_size(sizeof(struct xfrm_mark));
0603eac0 2348 }
7deb2264 2349 len += NLMSG_ALIGN(headlen);
26b15dad 2350
7deb2264 2351 skb = nlmsg_new(len, GFP_ATOMIC);
26b15dad
JHS		 2352 if (skb == NULL)
2353 return -ENOMEM;
26b15dad 2354
79b8b7f4
TG		 2355 nlh = nlmsg_put(skb, c->pid, c->seq, c->event, headlen, 0);
2356 if (nlh == NULL)
c0144bea 2357 goto nla_put_failure;
26b15dad 2358
7b67c857 2359 p = nlmsg_data(nlh);
0603eac0 2360 if (c->event == XFRM_MSG_DELSA) {
c0144bea
TG		 2361 struct nlattr *attr;
2362
7b67c857 2363 id = nlmsg_data(nlh);
0603eac0
HX		 2364 memcpy(&id->daddr, &x->id.daddr, sizeof(id->daddr));
2365 id->spi = x->id.spi;
2366 id->family = x->props.family;
2367 id->proto = x->id.proto;
2368
c0144bea
TG		 2369 attr = nla_reserve(skb, XFRMA_SA, sizeof(*p));
2370 if (attr == NULL)
2371 goto nla_put_failure;
2372
2373 p = nla_data(attr);
0603eac0
HX		 2374 }
2375
68325d3b
HX		 2376 if (copy_to_user_state_extra(x, p, skb))
2377 goto nla_put_failure;
26b15dad 2378
9825069d 2379 nlmsg_end(skb, nlh);
26b15dad 2380
a6483b79 2381 return nlmsg_multicast(net->xfrm.nlsk, skb, 0, XFRMNLGRP_SA, GFP_ATOMIC);
26b15dad 2382
c0144bea 2383nla_put_failure:
68325d3b
HX		 2384 /* Somebody screwed up with xfrm_sa_len! */
2385 WARN_ON(1);
26b15dad
JHS		 2386 kfree_skb(skb);
2387 return -1;
2388}
2389
2390static int xfrm_send_state_notify(struct xfrm_state *x, struct km_event *c)
2391{
2392
2393 switch (c->event) {
f60f6b8f 2394 case XFRM_MSG_EXPIRE:
26b15dad 2395 return xfrm_exp_state_notify(x, c);
d51d081d
JHS		 2396 case XFRM_MSG_NEWAE:
2397 return xfrm_aevent_state_notify(x, c);
f60f6b8f
HX		 2398 case XFRM_MSG_DELSA:
2399 case XFRM_MSG_UPDSA:
2400 case XFRM_MSG_NEWSA:
26b15dad 2401 return xfrm_notify_sa(x, c);
f60f6b8f 2402 case XFRM_MSG_FLUSHSA:
26b15dad
JHS		 2403 return xfrm_notify_sa_flush(c);
2404 default:
62db5cfd 2405 printk(KERN_NOTICE "xfrm_user: Unknown SA event %d\n",
2406 c->event);
2407 break;
26b15dad
JHS		 2408 }
2409
2410 return 0;
2411
2412}
2413
7deb2264
TG		 2414static inline size_t xfrm_acquire_msgsize(struct xfrm_state *x,
2415 struct xfrm_policy *xp)
2416{
2417 return NLMSG_ALIGN(sizeof(struct xfrm_user_acquire))
2418 + nla_total_size(sizeof(struct xfrm_user_tmpl) * xp->xfrm_nr)
6f26b61e 2419 + nla_total_size(sizeof(struct xfrm_mark))
7deb2264
TG		 2420 + nla_total_size(xfrm_user_sec_ctx_size(x->security))
2421 + userpolicy_type_attrsize();
2422}
2423
1da177e4
LT		 2424static int build_acquire(struct sk_buff *skb, struct xfrm_state *x,
2425 struct xfrm_tmpl *xt, struct xfrm_policy *xp,
2426 int dir)
2427{
2428 struct xfrm_user_acquire *ua;
2429 struct nlmsghdr *nlh;
1da177e4
LT		 2430 __u32 seq = xfrm_get_acqseq();
2431
79b8b7f4
TG		 2432 nlh = nlmsg_put(skb, 0, 0, XFRM_MSG_ACQUIRE, sizeof(*ua), 0);
2433 if (nlh == NULL)
2434 return -EMSGSIZE;
1da177e4 2435
7b67c857 2436 ua = nlmsg_data(nlh);
1da177e4
LT		 2437 memcpy(&ua->id, &x->id, sizeof(ua->id));
2438 memcpy(&ua->saddr, &x->props.saddr, sizeof(ua->saddr));
2439 memcpy(&ua->sel, &x->sel, sizeof(ua->sel));
2440 copy_to_user_policy(xp, &ua->policy, dir);
2441 ua->aalgos = xt->aalgos;
2442 ua->ealgos = xt->ealgos;
2443 ua->calgos = xt->calgos;
2444 ua->seq = x->km.seq = seq;
2445
2446 if (copy_to_user_tmpl(xp, skb) < 0)
2447 goto nlmsg_failure;
0d681623 2448 if (copy_to_user_state_sec_ctx(x, skb))
df71837d 2449 goto nlmsg_failure;
1459bb36 2450 if (copy_to_user_policy_type(xp->type, skb) < 0)
f7b6983f 2451 goto nlmsg_failure;
295fae56
JHS		 2452 if (xfrm_mark_put(skb, &xp->mark))
2453 goto nla_put_failure;
1da177e4 2454
9825069d 2455 return nlmsg_end(skb, nlh);
1da177e4 2456
295fae56 2457nla_put_failure:
1da177e4 2458nlmsg_failure:
9825069d
TG		 2459 nlmsg_cancel(skb, nlh);
2460 return -EMSGSIZE;
1da177e4
LT		 2461}
2462
2463static int xfrm_send_acquire(struct xfrm_state *x, struct xfrm_tmpl *xt,
2464 struct xfrm_policy *xp, int dir)
2465{
a6483b79 2466 struct net *net = xs_net(x);
1da177e4 2467 struct sk_buff *skb;
1da177e4 2468
7deb2264 2469 skb = nlmsg_new(xfrm_acquire_msgsize(x, xp), GFP_ATOMIC);
1da177e4
LT		 2470 if (skb == NULL)
2471 return -ENOMEM;
2472
2473 if (build_acquire(skb, x, xt, xp, dir) < 0)
2474 BUG();
2475
a6483b79 2476 return nlmsg_multicast(net->xfrm.nlsk, skb, 0, XFRMNLGRP_ACQUIRE, GFP_ATOMIC);
1da177e4
LT		 2477}
2478
2479/* User gives us xfrm_user_policy_info followed by an array of 0
2480 * or more templates.
2481 */
cb969f07 2482static struct xfrm_policy *xfrm_compile_policy(struct sock *sk, int opt,
1da177e4
LT		 2483 u8 *data, int len, int *dir)
2484{
fc34acd3 2485 struct net *net = sock_net(sk);
1da177e4
LT		 2486 struct xfrm_userpolicy_info *p = (struct xfrm_userpolicy_info *)data;
2487 struct xfrm_user_tmpl *ut = (struct xfrm_user_tmpl *) (p + 1);
2488 struct xfrm_policy *xp;
2489 int nr;
2490
cb969f07 2491 switch (sk->sk_family) {
1da177e4
LT		 2492 case AF_INET:
2493 if (opt != IP_XFRM_POLICY) {
2494 *dir = -EOPNOTSUPP;
2495 return NULL;
2496 }
2497 break;
2498#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
2499 case AF_INET6:
2500 if (opt != IPV6_XFRM_POLICY) {
2501 *dir = -EOPNOTSUPP;
2502 return NULL;
2503 }
2504 break;
2505#endif
2506 default:
2507 *dir = -EINVAL;
2508 return NULL;
2509 }
2510
2511 *dir = -EINVAL;
2512
2513 if (len < sizeof(*p) ||
2514 verify_newpolicy_info(p))
2515 return NULL;
2516
2517 nr = ((len - sizeof(*p)) / sizeof(*ut));
b4ad86bf 2518 if (validate_tmpl(nr, ut, p->sel.family))
1da177e4
LT		 2519 return NULL;
2520
a4f1bac6
HX		 2521 if (p->dir > XFRM_POLICY_OUT)
2522 return NULL;
2523
2f09a4d5 2524 xp = xfrm_policy_alloc(net, GFP_ATOMIC);
1da177e4
LT		 2525 if (xp == NULL) {
2526 *dir = -ENOBUFS;
2527 return NULL;
2528 }
2529
2530 copy_from_user_policy(xp, p);
f7b6983f 2531 xp->type = XFRM_POLICY_TYPE_MAIN;
1da177e4
LT		 2532 copy_templates(xp, ut, nr);
2533
2534 *dir = p->dir;
2535
2536 return xp;
2537}
2538
7deb2264
TG		 2539static inline size_t xfrm_polexpire_msgsize(struct xfrm_policy *xp)
2540{
2541 return NLMSG_ALIGN(sizeof(struct xfrm_user_polexpire))
2542 + nla_total_size(sizeof(struct xfrm_user_tmpl) * xp->xfrm_nr)
2543 + nla_total_size(xfrm_user_sec_ctx_size(xp->security))
295fae56 2544 + nla_total_size(sizeof(struct xfrm_mark))
7deb2264
TG		 2545 + userpolicy_type_attrsize();
2546}
2547
1da177e4 2548static int build_polexpire(struct sk_buff *skb, struct xfrm_policy *xp,
d51d081d 2549 int dir, struct km_event *c)
1da177e4
LT		 2550{
2551 struct xfrm_user_polexpire *upe;
2552 struct nlmsghdr *nlh;
d51d081d 2553 int hard = c->data.hard;
1da177e4 2554
79b8b7f4
TG		 2555 nlh = nlmsg_put(skb, c->pid, 0, XFRM_MSG_POLEXPIRE, sizeof(*upe), 0);
2556 if (nlh == NULL)
2557 return -EMSGSIZE;
1da177e4 2558
7b67c857 2559 upe = nlmsg_data(nlh);
1da177e4
LT		 2560 copy_to_user_policy(xp, &upe->pol, dir);
2561 if (copy_to_user_tmpl(xp, skb) < 0)
2562 goto nlmsg_failure;
df71837d
TJ		 2563 if (copy_to_user_sec_ctx(xp, skb))
2564 goto nlmsg_failure;
1459bb36 2565 if (copy_to_user_policy_type(xp->type, skb) < 0)
f7b6983f 2566 goto nlmsg_failure;
295fae56
JHS		 2567 if (xfrm_mark_put(skb, &xp->mark))
2568 goto nla_put_failure;
1da177e4
LT		 2569 upe->hard = !!hard;
2570
9825069d 2571 return nlmsg_end(skb, nlh);
1da177e4 2572
295fae56 2573nla_put_failure:
1da177e4 2574nlmsg_failure:
9825069d
TG		 2575 nlmsg_cancel(skb, nlh);
2576 return -EMSGSIZE;
1da177e4
LT		 2577}
2578
26b15dad 2579static int xfrm_exp_policy_notify(struct xfrm_policy *xp, int dir, struct km_event *c)
1da177e4 2580{
fc34acd3 2581 struct net *net = xp_net(xp);
1da177e4 2582 struct sk_buff *skb;
1da177e4 2583
7deb2264 2584 skb = nlmsg_new(xfrm_polexpire_msgsize(xp), GFP_ATOMIC);
1da177e4
LT		 2585 if (skb == NULL)
2586 return -ENOMEM;
2587
d51d081d 2588 if (build_polexpire(skb, xp, dir, c) < 0)
1da177e4
LT		 2589 BUG();
2590
a6483b79 2591 return nlmsg_multicast(net->xfrm.nlsk, skb, 0, XFRMNLGRP_EXPIRE, GFP_ATOMIC);
1da177e4
LT		 2592}
2593
26b15dad
JHS		 2594static int xfrm_notify_policy(struct xfrm_policy *xp, int dir, struct km_event *c)
2595{
fc34acd3 2596 struct net *net = xp_net(xp);
26b15dad 2597 struct xfrm_userpolicy_info *p;
0603eac0 2598 struct xfrm_userpolicy_id *id;
26b15dad
JHS		 2599 struct nlmsghdr *nlh;
2600 struct sk_buff *skb;
7deb2264 2601 int len = nla_total_size(sizeof(struct xfrm_user_tmpl) * xp->xfrm_nr);
0603eac0
HX		 2602 int headlen;
2603
2604 headlen = sizeof(*p);
2605 if (c->event == XFRM_MSG_DELPOLICY) {
7deb2264 2606 len += nla_total_size(headlen);
0603eac0
HX		 2607 headlen = sizeof(*id);
2608 }
cfbfd45a 2609 len += userpolicy_type_attrsize();
295fae56 2610 len += nla_total_size(sizeof(struct xfrm_mark));
7deb2264 2611 len += NLMSG_ALIGN(headlen);
26b15dad 2612
7deb2264 2613 skb = nlmsg_new(len, GFP_ATOMIC);
26b15dad
JHS		 2614 if (skb == NULL)
2615 return -ENOMEM;
26b15dad 2616
79b8b7f4
TG		 2617 nlh = nlmsg_put(skb, c->pid, c->seq, c->event, headlen, 0);
2618 if (nlh == NULL)
2619 goto nlmsg_failure;
26b15dad 2620
7b67c857 2621 p = nlmsg_data(nlh);
0603eac0 2622 if (c->event == XFRM_MSG_DELPOLICY) {
c0144bea
TG		 2623 struct nlattr *attr;
2624
7b67c857 2625 id = nlmsg_data(nlh);
0603eac0
HX		 2626 memset(id, 0, sizeof(*id));
2627 id->dir = dir;
2628 if (c->data.byid)
2629 id->index = xp->index;
2630 else
2631 memcpy(&id->sel, &xp->selector, sizeof(id->sel));
2632
c0144bea
TG		 2633 attr = nla_reserve(skb, XFRMA_POLICY, sizeof(*p));
2634 if (attr == NULL)
2635 goto nlmsg_failure;
2636
2637 p = nla_data(attr);
0603eac0 2638 }
26b15dad 2639
26b15dad
JHS		 2640 copy_to_user_policy(xp, p, dir);
2641 if (copy_to_user_tmpl(xp, skb) < 0)
2642 goto nlmsg_failure;
1459bb36 2643 if (copy_to_user_policy_type(xp->type, skb) < 0)
f7b6983f 2644 goto nlmsg_failure;
26b15dad 2645
295fae56
JHS		 2646 if (xfrm_mark_put(skb, &xp->mark))
2647 goto nla_put_failure;
2648
9825069d 2649 nlmsg_end(skb, nlh);
26b15dad 2650
a6483b79 2651 return nlmsg_multicast(net->xfrm.nlsk, skb, 0, XFRMNLGRP_POLICY, GFP_ATOMIC);
26b15dad 2652
295fae56 2653nla_put_failure:
26b15dad
JHS		 2654nlmsg_failure:
2655 kfree_skb(skb);
2656 return -1;
2657}
2658
2659static int xfrm_notify_policy_flush(struct km_event *c)
2660{
7067802e 2661 struct net *net = c->net;
26b15dad
JHS		 2662 struct nlmsghdr *nlh;
2663 struct sk_buff *skb;
26b15dad 2664
7deb2264 2665 skb = nlmsg_new(userpolicy_type_attrsize(), GFP_ATOMIC);
26b15dad
JHS		 2666 if (skb == NULL)
2667 return -ENOMEM;
26b15dad 2668
79b8b7f4
TG		 2669 nlh = nlmsg_put(skb, c->pid, c->seq, XFRM_MSG_FLUSHPOLICY, 0, 0);
2670 if (nlh == NULL)
2671 goto nlmsg_failure;
0c51f53c
JHS		 2672 if (copy_to_user_policy_type(c->data.type, skb) < 0)
2673 goto nlmsg_failure;
26b15dad 2674
9825069d 2675 nlmsg_end(skb, nlh);
26b15dad 2676
a6483b79 2677 return nlmsg_multicast(net->xfrm.nlsk, skb, 0, XFRMNLGRP_POLICY, GFP_ATOMIC);
26b15dad
JHS		 2678
2679nlmsg_failure:
2680 kfree_skb(skb);
2681 return -1;
2682}
2683
2684static int xfrm_send_policy_notify(struct xfrm_policy *xp, int dir, struct km_event *c)
2685{
2686
2687 switch (c->event) {
f60f6b8f
HX		 2688 case XFRM_MSG_NEWPOLICY:
2689 case XFRM_MSG_UPDPOLICY:
2690 case XFRM_MSG_DELPOLICY:
26b15dad 2691 return xfrm_notify_policy(xp, dir, c);
f60f6b8f 2692 case XFRM_MSG_FLUSHPOLICY:
26b15dad 2693 return xfrm_notify_policy_flush(c);
f60f6b8f 2694 case XFRM_MSG_POLEXPIRE:
26b15dad
JHS		 2695 return xfrm_exp_policy_notify(xp, dir, c);
2696 default:
62db5cfd 2697 printk(KERN_NOTICE "xfrm_user: Unknown Policy event %d\n",
2698 c->event);
26b15dad
JHS		 2699 }
2700
2701 return 0;
2702
2703}
2704
7deb2264
TG		 2705static inline size_t xfrm_report_msgsize(void)
2706{
2707 return NLMSG_ALIGN(sizeof(struct xfrm_user_report));
2708}
2709
97a64b45
MN		 2710static int build_report(struct sk_buff *skb, u8 proto,
2711 struct xfrm_selector *sel, xfrm_address_t *addr)
2712{
2713 struct xfrm_user_report *ur;
2714 struct nlmsghdr *nlh;
97a64b45 2715
79b8b7f4
TG		 2716 nlh = nlmsg_put(skb, 0, 0, XFRM_MSG_REPORT, sizeof(*ur), 0);
2717 if (nlh == NULL)
2718 return -EMSGSIZE;
97a64b45 2719
7b67c857 2720 ur = nlmsg_data(nlh);
97a64b45
MN		 2721 ur->proto = proto;
2722 memcpy(&ur->sel, sel, sizeof(ur->sel));
2723
2724 if (addr)
c0144bea 2725 NLA_PUT(skb, XFRMA_COADDR, sizeof(*addr), addr);
97a64b45 2726
9825069d 2727 return nlmsg_end(skb, nlh);
97a64b45 2728
c0144bea 2729nla_put_failure:
9825069d
TG		 2730 nlmsg_cancel(skb, nlh);
2731 return -EMSGSIZE;
97a64b45
MN		 2732}
2733
db983c11
AD		 2734static int xfrm_send_report(struct net *net, u8 proto,
2735 struct xfrm_selector *sel, xfrm_address_t *addr)
97a64b45
MN		 2736{
2737 struct sk_buff *skb;
97a64b45 2738
7deb2264 2739 skb = nlmsg_new(xfrm_report_msgsize(), GFP_ATOMIC);
97a64b45
MN		 2740 if (skb == NULL)
2741 return -ENOMEM;
2742
2743 if (build_report(skb, proto, sel, addr) < 0)
2744 BUG();
2745
a6483b79 2746 return nlmsg_multicast(net->xfrm.nlsk, skb, 0, XFRMNLGRP_REPORT, GFP_ATOMIC);
97a64b45
MN		 2747}
2748
3a2dfbe8
MW		 2749static inline size_t xfrm_mapping_msgsize(void)
2750{
2751 return NLMSG_ALIGN(sizeof(struct xfrm_user_mapping));
2752}
2753
2754static int build_mapping(struct sk_buff *skb, struct xfrm_state *x,
2755 xfrm_address_t *new_saddr, __be16 new_sport)
2756{
2757 struct xfrm_user_mapping *um;
2758 struct nlmsghdr *nlh;
2759
2760 nlh = nlmsg_put(skb, 0, 0, XFRM_MSG_MAPPING, sizeof(*um), 0);
2761 if (nlh == NULL)
2762 return -EMSGSIZE;
2763
2764 um = nlmsg_data(nlh);
2765
2766 memcpy(&um->id.daddr, &x->id.daddr, sizeof(um->id.daddr));
2767 um->id.spi = x->id.spi;
2768 um->id.family = x->props.family;
2769 um->id.proto = x->id.proto;
2770 memcpy(&um->new_saddr, new_saddr, sizeof(um->new_saddr));
2771 memcpy(&um->old_saddr, &x->props.saddr, sizeof(um->old_saddr));
2772 um->new_sport = new_sport;
2773 um->old_sport = x->encap->encap_sport;
2774 um->reqid = x->props.reqid;
2775
2776 return nlmsg_end(skb, nlh);
2777}
2778
2779static int xfrm_send_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr,
2780 __be16 sport)
2781{
a6483b79 2782 struct net *net = xs_net(x);
3a2dfbe8
MW		 2783 struct sk_buff *skb;
2784
2785 if (x->id.proto != IPPROTO_ESP)
2786 return -EINVAL;
2787
2788 if (!x->encap)
2789 return -EINVAL;
2790
2791 skb = nlmsg_new(xfrm_mapping_msgsize(), GFP_ATOMIC);
2792 if (skb == NULL)
2793 return -ENOMEM;
2794
2795 if (build_mapping(skb, x, ipaddr, sport) < 0)
2796 BUG();
2797
a6483b79 2798 return nlmsg_multicast(net->xfrm.nlsk, skb, 0, XFRMNLGRP_MAPPING, GFP_ATOMIC);
3a2dfbe8
MW		 2799}
2800
1da177e4
LT		 2801static struct xfrm_mgr netlink_mgr = {
2802 .id = "netlink",
2803 .notify = xfrm_send_state_notify,
2804 .acquire = xfrm_send_acquire,
2805 .compile_policy = xfrm_compile_policy,
2806 .notify_policy = xfrm_send_policy_notify,
97a64b45 2807 .report = xfrm_send_report,
5c79de6e 2808 .migrate = xfrm_send_migrate,
3a2dfbe8 2809 .new_mapping = xfrm_send_mapping,
1da177e4
LT		 2810};
2811
a6483b79 2812static int __net_init xfrm_user_net_init(struct net *net)
1da177e4 2813{
be33690d
PM		 2814 struct sock *nlsk;
2815
a6483b79 2816 nlsk = netlink_kernel_create(net, NETLINK_XFRM, XFRMNLGRP_MAX,
af65bdfc 2817 xfrm_netlink_rcv, NULL, THIS_MODULE);
be33690d 2818 if (nlsk == NULL)
1da177e4 2819 return -ENOMEM;
d79d792e 2820 net->xfrm.nlsk_stash = nlsk; /* Don't set to NULL */
a6483b79 2821 rcu_assign_pointer(net->xfrm.nlsk, nlsk);
1da177e4
LT		 2822 return 0;
2823}
2824
d79d792e 2825static void __net_exit xfrm_user_net_exit(struct list_head *net_exit_list)
1da177e4 2826{
d79d792e
EB		 2827 struct net *net;
2828 list_for_each_entry(net, net_exit_list, exit_list)
2829 rcu_assign_pointer(net->xfrm.nlsk, NULL);
2830 synchronize_net();
2831 list_for_each_entry(net, net_exit_list, exit_list)
2832 netlink_kernel_release(net->xfrm.nlsk_stash);
1da177e4
LT		 2833}
2834
a6483b79 2835static struct pernet_operations xfrm_user_net_ops = {
d79d792e
EB		 2836 .init = xfrm_user_net_init,
2837 .exit_batch = xfrm_user_net_exit,
a6483b79
AD		 2838};
2839
2840static int __init xfrm_user_init(void)
2841{
2842 int rv;
2843
2844 printk(KERN_INFO "Initializing XFRM netlink socket\n");
2845
2846 rv = register_pernet_subsys(&xfrm_user_net_ops);
2847 if (rv < 0)
2848 return rv;
2849 rv = xfrm_register_km(&netlink_mgr);
2850 if (rv < 0)
2851 unregister_pernet_subsys(&xfrm_user_net_ops);
2852 return rv;
2853}
2854
2855static void __exit xfrm_user_exit(void)
2856{
2857 xfrm_unregister_km(&netlink_mgr);
2858 unregister_pernet_subsys(&xfrm_user_net_ops);
2859}
2860
1da177e4
LT		 2861module_init(xfrm_user_init);
2862module_exit(xfrm_user_exit);
2863MODULE_LICENSE("GPL");
4fdb3bb7 2864MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK, NETLINK_XFRM);
f8cd5488 2865
Linux kernel - Deliverables
This page took 1.017942 seconds and 5 git commands to generate.