net/xfrm/xfrm_user.c

   1 /* xfrm_user.c: User interface to configure xfrm engine.
   2  *
   3  * Copyright (C) 2002 David S. Miller ([email protected])
   4  *
   5  * Changes:
   6  *      Mitsuru KANDA @USAGI
   7  *      Kazunori MIYAZAWA @USAGI
   8  *      Kunihiro Ishiguro <[email protected]>
   9  *              IPv6 support
  10  *
  11  */
  12
  13 #include <linux/crypto.h>
  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>
  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>
  28 #include <net/netlink.h>
  29 #include <net/ah.h>
  30 #include <asm/uaccess.h>
  31 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  32 #include <linux/in6.h>
  33 #endif
  34
  35 static inline int aead_len(struct xfrm_algo_aead *alg)
  36 {
  37         return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
  38 }
  39
  40 static int verify_one_alg(struct nlattr **attrs, enum xfrm_attr_type_t type)
  41 {
  42         struct nlattr *rt = attrs[type];
  43         struct xfrm_algo *algp;
  44
  45         if (!rt)
  46                 return 0;
  47
  48         algp = nla_data(rt);
  49         if (nla_len(rt) < xfrm_alg_len(algp))
  50                 return -EINVAL;
  51
  52         switch (type) {
  53         case XFRMA_ALG_AUTH:
  54         case XFRMA_ALG_CRYPT:
  55         case XFRMA_ALG_COMP:
  56                 break;
  57
  58         default:
  59                 return -EINVAL;
  60         }
  61
  62         algp->alg_name[CRYPTO_MAX_ALG_NAME - 1] = '\0';
  63         return 0;
  64 }
  65
  66 static 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
  82 static 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
  98 static void verify_one_addr(struct nlattr **attrs, enum xfrm_attr_type_t type,
  99                            xfrm_address_t **addrp)
 100 {
 101         struct nlattr *rt = attrs[type];
 102
 103         if (rt && addrp)
 104                 *addrp = nla_data(rt);
 105 }
 106
 107 static inline int verify_sec_ctx_len(struct nlattr **attrs)
 108 {
 109         struct nlattr *rt = attrs[XFRMA_SEC_CTX];
 110         struct xfrm_user_sec_ctx *uctx;
 111
 112         if (!rt)
 113                 return 0;
 114
 115         uctx = nla_data(rt);
 116         if (uctx->len != (sizeof(struct xfrm_user_sec_ctx) + uctx->ctx_len))
 117                 return -EINVAL;
 118
 119         return 0;
 120 }
 121
 122
 123 static int verify_newsa_info(struct xfrm_usersa_info *p,
 124                              struct nlattr **attrs)
 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;
 143         }
 144
 145         err = -EINVAL;
 146         switch (p->id.proto) {
 147         case IPPROTO_AH:
 148                 if ((!attrs[XFRMA_ALG_AUTH]     &&
 149                      !attrs[XFRMA_ALG_AUTH_TRUNC]) ||
 150                     attrs[XFRMA_ALG_AEAD]       ||
 151                     attrs[XFRMA_ALG_CRYPT]      ||
 152                     attrs[XFRMA_ALG_COMP]       ||
 153                     attrs[XFRMA_TFCPAD])
 154                         goto out;
 155                 break;
 156
 157         case IPPROTO_ESP:
 158                 if (attrs[XFRMA_ALG_COMP])
 159                         goto out;
 160                 if (!attrs[XFRMA_ALG_AUTH] &&
 161                     !attrs[XFRMA_ALG_AUTH_TRUNC] &&
 162                     !attrs[XFRMA_ALG_CRYPT] &&
 163                     !attrs[XFRMA_ALG_AEAD])
 164                         goto out;
 165                 if ((attrs[XFRMA_ALG_AUTH] ||
 166                      attrs[XFRMA_ALG_AUTH_TRUNC] ||
 167                      attrs[XFRMA_ALG_CRYPT]) &&
 168                     attrs[XFRMA_ALG_AEAD])
 169                         goto out;
 170                 if (attrs[XFRMA_TFCPAD] &&
 171                     p->mode != XFRM_MODE_TUNNEL)
 172                         goto out;
 173                 break;
 174
 175         case IPPROTO_COMP:
 176                 if (!attrs[XFRMA_ALG_COMP]      ||
 177                     attrs[XFRMA_ALG_AEAD]       ||
 178                     attrs[XFRMA_ALG_AUTH]       ||
 179                     attrs[XFRMA_ALG_AUTH_TRUNC] ||
 180                     attrs[XFRMA_ALG_CRYPT]      ||
 181                     attrs[XFRMA_TFCPAD])
 182                         goto out;
 183                 break;
 184
 185 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 186         case IPPROTO_DSTOPTS:
 187         case IPPROTO_ROUTING:
 188                 if (attrs[XFRMA_ALG_COMP]       ||
 189                     attrs[XFRMA_ALG_AUTH]       ||
 190                     attrs[XFRMA_ALG_AUTH_TRUNC] ||
 191                     attrs[XFRMA_ALG_AEAD]       ||
 192                     attrs[XFRMA_ALG_CRYPT]      ||
 193                     attrs[XFRMA_ENCAP]          ||
 194                     attrs[XFRMA_SEC_CTX]        ||
 195                     attrs[XFRMA_TFCPAD]         ||
 196                     !attrs[XFRMA_COADDR])
 197                         goto out;
 198                 break;
 199 #endif
 200
 201         default:
 202                 goto out;
 203         }
 204
 205         if ((err = verify_aead(attrs)))
 206                 goto out;
 207         if ((err = verify_auth_trunc(attrs)))
 208                 goto out;
 209         if ((err = verify_one_alg(attrs, XFRMA_ALG_AUTH)))
 210                 goto out;
 211         if ((err = verify_one_alg(attrs, XFRMA_ALG_CRYPT)))
 212                 goto out;
 213         if ((err = verify_one_alg(attrs, XFRMA_ALG_COMP)))
 214                 goto out;
 215         if ((err = verify_sec_ctx_len(attrs)))
 216                 goto out;
 217
 218         err = -EINVAL;
 219         switch (p->mode) {
 220         case XFRM_MODE_TRANSPORT:
 221         case XFRM_MODE_TUNNEL:
 222         case XFRM_MODE_ROUTEOPTIMIZATION:
 223         case XFRM_MODE_BEET:
 224                 break;
 225
 226         default:
 227                 goto out;
 228         }
 229
 230         err = 0;
 231
 232 out:
 233         return err;
 234 }
 235
 236 static int attach_one_algo(struct xfrm_algo **algpp, u8 *props,
 237                            struct xfrm_algo_desc *(*get_byname)(char *, int),
 238                            struct nlattr *rta)
 239 {
 240         struct xfrm_algo *p, *ualg;
 241         struct xfrm_algo_desc *algo;
 242
 243         if (!rta)
 244                 return 0;
 245
 246         ualg = nla_data(rta);
 247
 248         algo = get_byname(ualg->alg_name, 1);
 249         if (!algo)
 250                 return -ENOSYS;
 251         *props = algo->desc.sadb_alg_id;
 252
 253         p = kmemdup(ualg, xfrm_alg_len(ualg), GFP_KERNEL);
 254         if (!p)
 255                 return -ENOMEM;
 256
 257         strcpy(p->alg_name, algo->name);
 258         *algpp = p;
 259         return 0;
 260 }
 261
 262 static 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
 292 static 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;
 306         if ((ualg->alg_trunc_len / 8) > MAX_AH_AUTH_LEN ||
 307             ualg->alg_trunc_len > algo->uinfo.auth.icv_fullbits)
 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
 323 static 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
 348 static inline int xfrm_user_sec_ctx_size(struct xfrm_sec_ctx *xfrm_ctx)
 349 {
 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
 359 static 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;
 368         memcpy(&x->props.saddr, &p->saddr, sizeof(x->props.saddr));
 369         x->props.flags = p->flags;
 370
 371         if (!x->sel.family && !(p->flags & XFRM_STATE_AF_UNSPEC))
 372                 x->sel.family = p->family;
 373 }
 374
 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 */
 380 static void xfrm_update_ae_params(struct xfrm_state *x, struct nlattr **attrs)
 381 {
 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];
 386
 387         if (rp) {
 388                 struct xfrm_replay_state *replay;
 389                 replay = nla_data(rp);
 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;
 396                 ltime = nla_data(lt);
 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
 403         if (et)
 404                 x->replay_maxage = nla_get_u32(et);
 405
 406         if (rt)
 407                 x->replay_maxdiff = nla_get_u32(rt);
 408 }
 409
 410 static struct xfrm_state *xfrm_state_construct(struct net *net,
 411                                                struct xfrm_usersa_info *p,
 412                                                struct nlattr **attrs,
 413                                                int *errp)
 414 {
 415         struct xfrm_state *x = xfrm_state_alloc(net);
 416         int err = -ENOMEM;
 417
 418         if (!x)
 419                 goto error_no_put;
 420
 421         copy_from_user_state(x, p);
 422
 423         if ((err = attach_aead(&x->aead, &x->props.ealgo,
 424                                attrs[XFRMA_ALG_AEAD])))
 425                 goto error;
 426         if ((err = attach_auth_trunc(&x->aalg, &x->props.aalgo,
 427                                      attrs[XFRMA_ALG_AUTH_TRUNC])))
 428                 goto error;
 429         if (!x->props.aalgo) {
 430                 if ((err = attach_auth(&x->aalg, &x->props.aalgo,
 431                                        attrs[XFRMA_ALG_AUTH])))
 432                         goto error;
 433         }
 434         if ((err = attach_one_algo(&x->ealg, &x->props.ealgo,
 435                                    xfrm_ealg_get_byname,
 436                                    attrs[XFRMA_ALG_CRYPT])))
 437                 goto error;
 438         if ((err = attach_one_algo(&x->calg, &x->props.calgo,
 439                                    xfrm_calg_get_byname,
 440                                    attrs[XFRMA_ALG_COMP])))
 441                 goto error;
 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
 450         if (attrs[XFRMA_TFCPAD])
 451                 x->tfcpad = nla_get_u32(attrs[XFRMA_TFCPAD]);
 452
 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
 460         xfrm_mark_get(attrs, &x->mark);
 461
 462         err = xfrm_init_state(x);
 463         if (err)
 464                 goto error;
 465
 466         if (attrs[XFRMA_SEC_CTX] &&
 467             security_xfrm_state_alloc(x, nla_data(attrs[XFRMA_SEC_CTX])))
 468                 goto error;
 469
 470         x->km.seq = p->seq;
 471         x->replay_maxdiff = net->xfrm.sysctl_aevent_rseqth;
 472         /* sysctl_xfrm_aevent_etime is in 100ms units */
 473         x->replay_maxage = (net->xfrm.sysctl_aevent_etime*HZ)/XFRM_AE_ETH_M;
 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
 480         xfrm_update_ae_params(x, attrs);
 481
 482         return x;
 483
 484 error:
 485         x->km.state = XFRM_STATE_DEAD;
 486         xfrm_state_put(x);
 487 error_no_put:
 488         *errp = err;
 489         return NULL;
 490 }
 491
 492 static int xfrm_add_sa(struct sk_buff *skb, struct nlmsghdr *nlh,
 493                 struct nlattr **attrs)
 494 {
 495         struct net *net = sock_net(skb->sk);
 496         struct xfrm_usersa_info *p = nlmsg_data(nlh);
 497         struct xfrm_state *x;
 498         int err;
 499         struct km_event c;
 500         uid_t loginuid = NETLINK_CB(skb).loginuid;
 501         u32 sessionid = NETLINK_CB(skb).sessionid;
 502         u32 sid = NETLINK_CB(skb).sid;
 503
 504         err = verify_newsa_info(p, attrs);
 505         if (err)
 506                 return err;
 507
 508         x = xfrm_state_construct(net, p, attrs, &err);
 509         if (!x)
 510                 return err;
 511
 512         xfrm_state_hold(x);
 513         if (nlh->nlmsg_type == XFRM_MSG_NEWSA)
 514                 err = xfrm_state_add(x);
 515         else
 516                 err = xfrm_state_update(x);
 517
 518         xfrm_audit_state_add(x, err ? 0 : 1, loginuid, sessionid, sid);
 519
 520         if (err < 0) {
 521                 x->km.state = XFRM_STATE_DEAD;
 522                 __xfrm_state_put(x);
 523                 goto out;
 524         }
 525
 526         c.seq = nlh->nlmsg_seq;
 527         c.pid = nlh->nlmsg_pid;
 528         c.event = nlh->nlmsg_type;
 529
 530         km_state_notify(x, &c);
 531 out:
 532         xfrm_state_put(x);
 533         return err;
 534 }
 535
 536 static struct xfrm_state *xfrm_user_state_lookup(struct net *net,
 537                                                  struct xfrm_usersa_id *p,
 538                                                  struct nlattr **attrs,
 539                                                  int *errp)
 540 {
 541         struct xfrm_state *x = NULL;
 542         struct xfrm_mark m;
 543         int err;
 544         u32 mark = xfrm_mark_get(attrs, &m);
 545
 546         if (xfrm_id_proto_match(p->proto, IPSEC_PROTO_ANY)) {
 547                 err = -ESRCH;
 548                 x = xfrm_state_lookup(net, mark, &p->daddr, p->spi, p->proto, p->family);
 549         } else {
 550                 xfrm_address_t *saddr = NULL;
 551
 552                 verify_one_addr(attrs, XFRMA_SRCADDR, &saddr);
 553                 if (!saddr) {
 554                         err = -EINVAL;
 555                         goto out;
 556                 }
 557
 558                 err = -ESRCH;
 559                 x = xfrm_state_lookup_byaddr(net, mark,
 560                                              &p->daddr, saddr,
 561                                              p->proto, p->family);
 562         }
 563
 564  out:
 565         if (!x && errp)
 566                 *errp = err;
 567         return x;
 568 }
 569
 570 static int xfrm_del_sa(struct sk_buff *skb, struct nlmsghdr *nlh,
 571                 struct nlattr **attrs)
 572 {
 573         struct net *net = sock_net(skb->sk);
 574         struct xfrm_state *x;
 575         int err = -ESRCH;
 576         struct km_event c;
 577         struct xfrm_usersa_id *p = nlmsg_data(nlh);
 578         uid_t loginuid = NETLINK_CB(skb).loginuid;
 579         u32 sessionid = NETLINK_CB(skb).sessionid;
 580         u32 sid = NETLINK_CB(skb).sid;
 581
 582         x = xfrm_user_state_lookup(net, p, attrs, &err);
 583         if (x == NULL)
 584                 return err;
 585
 586         if ((err = security_xfrm_state_delete(x)) != 0)
 587                 goto out;
 588
 589         if (xfrm_state_kern(x)) {
 590                 err = -EPERM;
 591                 goto out;
 592         }
 593
 594         err = xfrm_state_delete(x);
 595
 596         if (err < 0)
 597                 goto out;
 598
 599         c.seq = nlh->nlmsg_seq;
 600         c.pid = nlh->nlmsg_pid;
 601         c.event = nlh->nlmsg_type;
 602         km_state_notify(x, &c);
 603
 604 out:
 605         xfrm_audit_state_delete(x, err ? 0 : 1, loginuid, sessionid, sid);
 606         xfrm_state_put(x);
 607         return err;
 608 }
 609
 610 static 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));
 617         memcpy(&p->saddr, &x->props.saddr, sizeof(p->saddr));
 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
 626 struct xfrm_dump_info {
 627         struct sk_buff *in_skb;
 628         struct sk_buff *out_skb;
 629         u32 nlmsg_seq;
 630         u16 nlmsg_flags;
 631 };
 632
 633 static int copy_sec_ctx(struct xfrm_sec_ctx *s, struct sk_buff *skb)
 634 {
 635         struct xfrm_user_sec_ctx *uctx;
 636         struct nlattr *attr;
 637         int ctx_size = sizeof(*uctx) + s->ctx_len;
 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
 654 static 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
 672 /* Don't change this without updating xfrm_sa_len! */
 673 static int copy_to_user_state_extra(struct xfrm_state *x,
 674                                     struct xfrm_usersa_info *p,
 675                                     struct sk_buff *skb)
 676 {
 677         copy_to_user_state(x, p);
 678
 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);
 684
 685         if (x->aead)
 686                 NLA_PUT(skb, XFRMA_ALG_AEAD, aead_len(x->aead), x->aead);
 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         }
 694         if (x->ealg)
 695                 NLA_PUT(skb, XFRMA_ALG_CRYPT, xfrm_alg_len(x->ealg), x->ealg);
 696         if (x->calg)
 697                 NLA_PUT(skb, XFRMA_ALG_COMP, sizeof(*(x->calg)), x->calg);
 698
 699         if (x->encap)
 700                 NLA_PUT(skb, XFRMA_ENCAP, sizeof(*x->encap), x->encap);
 701
 702         if (x->tfcpad)
 703                 NLA_PUT_U32(skb, XFRMA_TFCPAD, x->tfcpad);
 704
 705         if (xfrm_mark_put(skb, &x->mark))
 706                 goto nla_put_failure;
 707
 708         if (x->security && copy_sec_ctx(x->security, skb) < 0)
 709                 goto nla_put_failure;
 710
 711         return 0;
 712
 713 nla_put_failure:
 714         return -EMSGSIZE;
 715 }
 716
 717 static 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
 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
 737         nlmsg_end(skb, nlh);
 738         return 0;
 739
 740 nla_put_failure:
 741         nlmsg_cancel(skb, nlh);
 742         return err;
 743 }
 744
 745 static 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
 752 static int xfrm_dump_sa(struct sk_buff *skb, struct netlink_callback *cb)
 753 {
 754         struct net *net = sock_net(skb->sk);
 755         struct xfrm_state_walk *walk = (struct xfrm_state_walk *) &cb->args[1];
 756         struct xfrm_dump_info info;
 757
 758         BUILD_BUG_ON(sizeof(struct xfrm_state_walk) >
 759                      sizeof(cb->args) - sizeof(cb->args[0]));
 760
 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;
 765
 766         if (!cb->args[0]) {
 767                 cb->args[0] = 1;
 768                 xfrm_state_walk_init(walk, 0);
 769         }
 770
 771         (void) xfrm_state_walk(net, walk, dump_one_state, &info);
 772
 773         return skb->len;
 774 }
 775
 776 static 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
 782         skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
 783         if (!skb)
 784                 return ERR_PTR(-ENOMEM);
 785
 786         info.in_skb = in_skb;
 787         info.out_skb = skb;
 788         info.nlmsg_seq = seq;
 789         info.nlmsg_flags = 0;
 790
 791         if (dump_one_state(x, 0, &info)) {
 792                 kfree_skb(skb);
 793                 return NULL;
 794         }
 795
 796         return skb;
 797 }
 798
 799 static 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
 806 static int build_spdinfo(struct sk_buff *skb, struct net *net,
 807                          u32 pid, u32 seq, u32 flags)
 808 {
 809         struct xfrmk_spdinfo si;
 810         struct xfrmu_spdinfo spc;
 811         struct xfrmu_spdhinfo sph;
 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;
 821         xfrm_spd_getinfo(net, &si);
 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);
 833
 834         return nlmsg_end(skb, nlh);
 835
 836 nla_put_failure:
 837         nlmsg_cancel(skb, nlh);
 838         return -EMSGSIZE;
 839 }
 840
 841 static int xfrm_get_spdinfo(struct sk_buff *skb, struct nlmsghdr *nlh,
 842                 struct nlattr **attrs)
 843 {
 844         struct net *net = sock_net(skb->sk);
 845         struct sk_buff *r_skb;
 846         u32 *flags = nlmsg_data(nlh);
 847         u32 spid = NETLINK_CB(skb).pid;
 848         u32 seq = nlh->nlmsg_seq;
 849
 850         r_skb = nlmsg_new(xfrm_spdinfo_msgsize(), GFP_ATOMIC);
 851         if (r_skb == NULL)
 852                 return -ENOMEM;
 853
 854         if (build_spdinfo(r_skb, net, spid, seq, *flags) < 0)
 855                 BUG();
 856
 857         return nlmsg_unicast(net->xfrm.nlsk, r_skb, spid);
 858 }
 859
 860 static 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
 867 static int build_sadinfo(struct sk_buff *skb, struct net *net,
 868                          u32 pid, u32 seq, u32 flags)
 869 {
 870         struct xfrmk_sadinfo si;
 871         struct xfrmu_sadhinfo sh;
 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;
 881         xfrm_sad_getinfo(net, &si);
 882
 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);
 888
 889         return nlmsg_end(skb, nlh);
 890
 891 nla_put_failure:
 892         nlmsg_cancel(skb, nlh);
 893         return -EMSGSIZE;
 894 }
 895
 896 static int xfrm_get_sadinfo(struct sk_buff *skb, struct nlmsghdr *nlh,
 897                 struct nlattr **attrs)
 898 {
 899         struct net *net = sock_net(skb->sk);
 900         struct sk_buff *r_skb;
 901         u32 *flags = nlmsg_data(nlh);
 902         u32 spid = NETLINK_CB(skb).pid;
 903         u32 seq = nlh->nlmsg_seq;
 904
 905         r_skb = nlmsg_new(xfrm_sadinfo_msgsize(), GFP_ATOMIC);
 906         if (r_skb == NULL)
 907                 return -ENOMEM;
 908
 909         if (build_sadinfo(r_skb, net, spid, seq, *flags) < 0)
 910                 BUG();
 911
 912         return nlmsg_unicast(net->xfrm.nlsk, r_skb, spid);
 913 }
 914
 915 static int xfrm_get_sa(struct sk_buff *skb, struct nlmsghdr *nlh,
 916                 struct nlattr **attrs)
 917 {
 918         struct net *net = sock_net(skb->sk);
 919         struct xfrm_usersa_id *p = nlmsg_data(nlh);
 920         struct xfrm_state *x;
 921         struct sk_buff *resp_skb;
 922         int err = -ESRCH;
 923
 924         x = xfrm_user_state_lookup(net, p, attrs, &err);
 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 {
 932                 err = nlmsg_unicast(net->xfrm.nlsk, resp_skb, NETLINK_CB(skb).pid);
 933         }
 934         xfrm_state_put(x);
 935 out_noput:
 936         return err;
 937 }
 938
 939 static 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;
 954         }
 955
 956         if (p->min > p->max)
 957                 return -EINVAL;
 958
 959         return 0;
 960 }
 961
 962 static int xfrm_alloc_userspi(struct sk_buff *skb, struct nlmsghdr *nlh,
 963                 struct nlattr **attrs)
 964 {
 965         struct net *net = sock_net(skb->sk);
 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;
 972         u32 mark;
 973         struct xfrm_mark m;
 974
 975         p = nlmsg_data(nlh);
 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;
 984
 985         mark = xfrm_mark_get(attrs, &m);
 986         if (p->info.seq) {
 987                 x = xfrm_find_acq_byseq(net, mark, p->info.seq);
 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)
 995                 x = xfrm_find_acq(net, &m, p->info.mode, p->info.reqid,
 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
1003         err = xfrm_alloc_spi(x, p->min, p->max);
1004         if (err)
1005                 goto out;
1006
1007         resp_skb = xfrm_state_netlink(skb, x, nlh->nlmsg_seq);
1008         if (IS_ERR(resp_skb)) {
1009                 err = PTR_ERR(resp_skb);
1010                 goto out;
1011         }
1012
1013         err = nlmsg_unicast(net->xfrm.nlsk, resp_skb, NETLINK_CB(skb).pid);
1014
1015 out:
1016         xfrm_state_put(x);
1017 out_noput:
1018         return err;
1019 }
1020
1021 static int verify_policy_dir(u8 dir)
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;
1031         }
1032
1033         return 0;
1034 }
1035
1036 static int verify_policy_type(u8 type)
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;
1047         }
1048
1049         return 0;
1050 }
1051
1052 static 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;
1063         }
1064
1065         switch (p->action) {
1066         case XFRM_POLICY_ALLOW:
1067         case XFRM_POLICY_BLOCK:
1068                 break;
1069
1070         default:
1071                 return -EINVAL;
1072         }
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;
1087         }
1088
1089         return verify_policy_dir(p->dir);
1090 }
1091
1092 static int copy_from_user_sec_ctx(struct xfrm_policy *pol, struct nlattr **attrs)
1093 {
1094         struct nlattr *rt = attrs[XFRMA_SEC_CTX];
1095         struct xfrm_user_sec_ctx *uctx;
1096
1097         if (!rt)
1098                 return 0;
1099
1100         uctx = nla_data(rt);
1101         return security_xfrm_policy_alloc(&pol->security, uctx);
1102 }
1103
1104 static 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;
1123                 /* If all masks are ~0, then we allow all algorithms. */
1124                 t->allalgs = !~(t->aalgos & t->ealgos & t->calgos);
1125                 t->encap_family = ut->family;
1126         }
1127 }
1128
1129 static 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;
1156                 }
1157         }
1158
1159         return 0;
1160 }
1161
1162 static int copy_from_user_tmpl(struct xfrm_policy *pol, struct nlattr **attrs)
1163 {
1164         struct nlattr *rt = attrs[XFRMA_TMPL];
1165
1166         if (!rt) {
1167                 pol->xfrm_nr = 0;
1168         } else {
1169                 struct xfrm_user_tmpl *utmpl = nla_data(rt);
1170                 int nr = nla_len(rt) / sizeof(*utmpl);
1171                 int err;
1172
1173                 err = validate_tmpl(nr, utmpl, pol->family);
1174                 if (err)
1175                         return err;
1176
1177                 copy_templates(pol, utmpl, nr);
1178         }
1179         return 0;
1180 }
1181
1182 static int copy_from_user_policy_type(u8 *tp, struct nlattr **attrs)
1183 {
1184         struct nlattr *rt = attrs[XFRMA_POLICY_TYPE];
1185         struct xfrm_userpolicy_type *upt;
1186         u8 type = XFRM_POLICY_TYPE_MAIN;
1187         int err;
1188
1189         if (rt) {
1190                 upt = nla_data(rt);
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
1202 static 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
1214 static 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
1228 static struct xfrm_policy *xfrm_policy_construct(struct net *net, struct xfrm_userpolicy_info *p, struct nlattr **attrs, int *errp)
1229 {
1230         struct xfrm_policy *xp = xfrm_policy_alloc(net, GFP_KERNEL);
1231         int err;
1232
1233         if (!xp) {
1234                 *errp = -ENOMEM;
1235                 return NULL;
1236         }
1237
1238         copy_from_user_policy(xp, p);
1239
1240         err = copy_from_user_policy_type(&xp->type, attrs);
1241         if (err)
1242                 goto error;
1243
1244         if (!(err = copy_from_user_tmpl(xp, attrs)))
1245                 err = copy_from_user_sec_ctx(xp, attrs);
1246         if (err)
1247                 goto error;
1248
1249         xfrm_mark_get(attrs, &xp->mark);
1250
1251         return xp;
1252  error:
1253         *errp = err;
1254         xp->walk.dead = 1;
1255         xfrm_policy_destroy(xp);
1256         return NULL;
1257 }
1258
1259 static int xfrm_add_policy(struct sk_buff *skb, struct nlmsghdr *nlh,
1260                 struct nlattr **attrs)
1261 {
1262         struct net *net = sock_net(skb->sk);
1263         struct xfrm_userpolicy_info *p = nlmsg_data(nlh);
1264         struct xfrm_policy *xp;
1265         struct km_event c;
1266         int err;
1267         int excl;
1268         uid_t loginuid = NETLINK_CB(skb).loginuid;
1269         u32 sessionid = NETLINK_CB(skb).sessionid;
1270         u32 sid = NETLINK_CB(skb).sid;
1271
1272         err = verify_newpolicy_info(p);
1273         if (err)
1274                 return err;
1275         err = verify_sec_ctx_len(attrs);
1276         if (err)
1277                 return err;
1278
1279         xp = xfrm_policy_construct(net, p, attrs, &err);
1280         if (!xp)
1281                 return err;
1282
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 */
1287         excl = nlh->nlmsg_type == XFRM_MSG_NEWPOLICY;
1288         err = xfrm_policy_insert(p->dir, xp, excl);
1289         xfrm_audit_policy_add(xp, err ? 0 : 1, loginuid, sessionid, sid);
1290
1291         if (err) {
1292                 security_xfrm_policy_free(xp->security);
1293                 kfree(xp);
1294                 return err;
1295         }
1296
1297         c.event = nlh->nlmsg_type;
1298         c.seq = nlh->nlmsg_seq;
1299         c.pid = nlh->nlmsg_pid;
1300         km_policy_notify(xp, p->dir, &c);
1301
1302         xfrm_pol_put(xp);
1303
1304         return 0;
1305 }
1306
1307 static 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));
1320                 up->family = kp->encap_family;
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         }
1330
1331         return nla_put(skb, XFRMA_TMPL,
1332                        sizeof(struct xfrm_user_tmpl) * xp->xfrm_nr, vec);
1333 }
1334
1335 static 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);
1339         }
1340         return 0;
1341 }
1342
1343 static 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;
1349 }
1350 static 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 }
1358
1359 #ifdef CONFIG_XFRM_SUB_POLICY
1360 static int copy_to_user_policy_type(u8 type, struct sk_buff *skb)
1361 {
1362         struct xfrm_userpolicy_type upt = {
1363                 .type = type,
1364         };
1365
1366         return nla_put(skb, XFRMA_POLICY_TYPE, sizeof(upt), &upt);
1367 }
1368
1369 #else
1370 static inline int copy_to_user_policy_type(u8 type, struct sk_buff *skb)
1371 {
1372         return 0;
1373 }
1374 #endif
1375
1376 static 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;
1383
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;
1388
1389         p = nlmsg_data(nlh);
1390         copy_to_user_policy(xp, p, dir);
1391         if (copy_to_user_tmpl(xp, skb) < 0)
1392                 goto nlmsg_failure;
1393         if (copy_to_user_sec_ctx(xp, skb))
1394                 goto nlmsg_failure;
1395         if (copy_to_user_policy_type(xp->type, skb) < 0)
1396                 goto nlmsg_failure;
1397         if (xfrm_mark_put(skb, &xp->mark))
1398                 goto nla_put_failure;
1399
1400         nlmsg_end(skb, nlh);
1401         return 0;
1402
1403 nla_put_failure:
1404 nlmsg_failure:
1405         nlmsg_cancel(skb, nlh);
1406         return -EMSGSIZE;
1407 }
1408
1409 static 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
1417 static int xfrm_dump_policy(struct sk_buff *skb, struct netlink_callback *cb)
1418 {
1419         struct net *net = sock_net(skb->sk);
1420         struct xfrm_policy_walk *walk = (struct xfrm_policy_walk *) &cb->args[1];
1421         struct xfrm_dump_info info;
1422
1423         BUILD_BUG_ON(sizeof(struct xfrm_policy_walk) >
1424                      sizeof(cb->args) - sizeof(cb->args[0]));
1425
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;
1430
1431         if (!cb->args[0]) {
1432                 cb->args[0] = 1;
1433                 xfrm_policy_walk_init(walk, XFRM_POLICY_TYPE_ANY);
1434         }
1435
1436         (void) xfrm_policy_walk(net, walk, dump_one_policy, &info);
1437
1438         return skb->len;
1439 }
1440
1441 static 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
1448         skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1449         if (!skb)
1450                 return ERR_PTR(-ENOMEM);
1451
1452         info.in_skb = in_skb;
1453         info.out_skb = skb;
1454         info.nlmsg_seq = seq;
1455         info.nlmsg_flags = 0;
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
1465 static int xfrm_get_policy(struct sk_buff *skb, struct nlmsghdr *nlh,
1466                 struct nlattr **attrs)
1467 {
1468         struct net *net = sock_net(skb->sk);
1469         struct xfrm_policy *xp;
1470         struct xfrm_userpolicy_id *p;
1471         u8 type = XFRM_POLICY_TYPE_MAIN;
1472         int err;
1473         struct km_event c;
1474         int delete;
1475         struct xfrm_mark m;
1476         u32 mark = xfrm_mark_get(attrs, &m);
1477
1478         p = nlmsg_data(nlh);
1479         delete = nlh->nlmsg_type == XFRM_MSG_DELPOLICY;
1480
1481         err = copy_from_user_policy_type(&type, attrs);
1482         if (err)
1483                 return err;
1484
1485         err = verify_policy_dir(p->dir);
1486         if (err)
1487                 return err;
1488
1489         if (p->index)
1490                 xp = xfrm_policy_byid(net, mark, type, p->dir, p->index, delete, &err);
1491         else {
1492                 struct nlattr *rt = attrs[XFRMA_SEC_CTX];
1493                 struct xfrm_sec_ctx *ctx;
1494
1495                 err = verify_sec_ctx_len(attrs);
1496                 if (err)
1497                         return err;
1498
1499                 ctx = NULL;
1500                 if (rt) {
1501                         struct xfrm_user_sec_ctx *uctx = nla_data(rt);
1502
1503                         err = security_xfrm_policy_alloc(&ctx, uctx);
1504                         if (err)
1505                                 return err;
1506                 }
1507                 xp = xfrm_policy_bysel_ctx(net, mark, type, p->dir, &p->sel,
1508                                            ctx, delete, &err);
1509                 security_xfrm_policy_free(ctx);
1510         }
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 {
1521                         err = nlmsg_unicast(net->xfrm.nlsk, resp_skb,
1522                                             NETLINK_CB(skb).pid);
1523                 }
1524         } else {
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);
1531
1532                 if (err != 0)
1533                         goto out;
1534
1535                 c.data.byid = p->index;
1536                 c.event = nlh->nlmsg_type;
1537                 c.seq = nlh->nlmsg_seq;
1538                 c.pid = nlh->nlmsg_pid;
1539                 km_policy_notify(xp, p->dir, &c);
1540         }
1541
1542 out:
1543         xfrm_pol_put(xp);
1544         return err;
1545 }
1546
1547 static int xfrm_flush_sa(struct sk_buff *skb, struct nlmsghdr *nlh,
1548                 struct nlattr **attrs)
1549 {
1550         struct net *net = sock_net(skb->sk);
1551         struct km_event c;
1552         struct xfrm_usersa_flush *p = nlmsg_data(nlh);
1553         struct xfrm_audit audit_info;
1554         int err;
1555
1556         audit_info.loginuid = NETLINK_CB(skb).loginuid;
1557         audit_info.sessionid = NETLINK_CB(skb).sessionid;
1558         audit_info.secid = NETLINK_CB(skb).sid;
1559         err = xfrm_state_flush(net, p->proto, &audit_info);
1560         if (err) {
1561                 if (err == -ESRCH) /* empty table */
1562                         return 0;
1563                 return err;
1564         }
1565         c.data.proto = p->proto;
1566         c.event = nlh->nlmsg_type;
1567         c.seq = nlh->nlmsg_seq;
1568         c.pid = nlh->nlmsg_pid;
1569         c.net = net;
1570         km_state_notify(NULL, &c);
1571
1572         return 0;
1573 }
1574
1575 static 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))
1580                + nla_total_size(sizeof(struct xfrm_mark))
1581                + nla_total_size(4) /* XFRM_AE_RTHR */
1582                + nla_total_size(4); /* XFRM_AE_ETHR */
1583 }
1584
1585 static 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;
1589
1590         nlh = nlmsg_put(skb, c->pid, c->seq, XFRM_MSG_NEWAE, sizeof(*id), 0);
1591         if (nlh == NULL)
1592                 return -EMSGSIZE;
1593
1594         id = nlmsg_data(nlh);
1595         memcpy(&id->sa_id.daddr, &x->id.daddr,sizeof(x->id.daddr));
1596         id->sa_id.spi = x->id.spi;
1597         id->sa_id.family = x->props.family;
1598         id->sa_id.proto = x->id.proto;
1599         memcpy(&id->saddr, &x->props.saddr,sizeof(x->props.saddr));
1600         id->reqid = x->props.reqid;
1601         id->flags = c->data.aevent;
1602
1603         NLA_PUT(skb, XFRMA_REPLAY_VAL, sizeof(x->replay), &x->replay);
1604         NLA_PUT(skb, XFRMA_LTIME_VAL, sizeof(x->curlft), &x->curlft);
1605
1606         if (id->flags & XFRM_AE_RTHR)
1607                 NLA_PUT_U32(skb, XFRMA_REPLAY_THRESH, x->replay_maxdiff);
1608
1609         if (id->flags & XFRM_AE_ETHR)
1610                 NLA_PUT_U32(skb, XFRMA_ETIMER_THRESH,
1611                             x->replay_maxage * 10 / HZ);
1612
1613         if (xfrm_mark_put(skb, &x->mark))
1614                 goto nla_put_failure;
1615
1616         return nlmsg_end(skb, nlh);
1617
1618 nla_put_failure:
1619         nlmsg_cancel(skb, nlh);
1620         return -EMSGSIZE;
1621 }
1622
1623 static int xfrm_get_ae(struct sk_buff *skb, struct nlmsghdr *nlh,
1624                 struct nlattr **attrs)
1625 {
1626         struct net *net = sock_net(skb->sk);
1627         struct xfrm_state *x;
1628         struct sk_buff *r_skb;
1629         int err;
1630         struct km_event c;
1631         u32 mark;
1632         struct xfrm_mark m;
1633         struct xfrm_aevent_id *p = nlmsg_data(nlh);
1634         struct xfrm_usersa_id *id = &p->sa_id;
1635
1636         r_skb = nlmsg_new(xfrm_aevent_msgsize(), GFP_ATOMIC);
1637         if (r_skb == NULL)
1638                 return -ENOMEM;
1639
1640         mark = xfrm_mark_get(attrs, &m);
1641
1642         x = xfrm_state_lookup(net, mark, &id->daddr, id->spi, id->proto, id->family);
1643         if (x == NULL) {
1644                 kfree_skb(r_skb);
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();
1660         err = nlmsg_unicast(net->xfrm.nlsk, r_skb, NETLINK_CB(skb).pid);
1661         spin_unlock_bh(&x->lock);
1662         xfrm_state_put(x);
1663         return err;
1664 }
1665
1666 static int xfrm_new_ae(struct sk_buff *skb, struct nlmsghdr *nlh,
1667                 struct nlattr **attrs)
1668 {
1669         struct net *net = sock_net(skb->sk);
1670         struct xfrm_state *x;
1671         struct km_event c;
1672         int err = - EINVAL;
1673         u32 mark = 0;
1674         struct xfrm_mark m;
1675         struct xfrm_aevent_id *p = nlmsg_data(nlh);
1676         struct nlattr *rp = attrs[XFRMA_REPLAY_VAL];
1677         struct nlattr *lt = attrs[XFRMA_LTIME_VAL];
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
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);
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);
1696         xfrm_update_ae_params(x, attrs);
1697         spin_unlock_bh(&x->lock);
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;
1705 out:
1706         xfrm_state_put(x);
1707         return err;
1708 }
1709
1710 static int xfrm_flush_policy(struct sk_buff *skb, struct nlmsghdr *nlh,
1711                 struct nlattr **attrs)
1712 {
1713         struct net *net = sock_net(skb->sk);
1714         struct km_event c;
1715         u8 type = XFRM_POLICY_TYPE_MAIN;
1716         int err;
1717         struct xfrm_audit audit_info;
1718
1719         err = copy_from_user_policy_type(&type, attrs);
1720         if (err)
1721                 return err;
1722
1723         audit_info.loginuid = NETLINK_CB(skb).loginuid;
1724         audit_info.sessionid = NETLINK_CB(skb).sessionid;
1725         audit_info.secid = NETLINK_CB(skb).sid;
1726         err = xfrm_policy_flush(net, type, &audit_info);
1727         if (err) {
1728                 if (err == -ESRCH) /* empty table */
1729                         return 0;
1730                 return err;
1731         }
1732
1733         c.data.type = type;
1734         c.event = nlh->nlmsg_type;
1735         c.seq = nlh->nlmsg_seq;
1736         c.pid = nlh->nlmsg_pid;
1737         c.net = net;
1738         km_policy_notify(NULL, 0, &c);
1739         return 0;
1740 }
1741
1742 static int xfrm_add_pol_expire(struct sk_buff *skb, struct nlmsghdr *nlh,
1743                 struct nlattr **attrs)
1744 {
1745         struct net *net = sock_net(skb->sk);
1746         struct xfrm_policy *xp;
1747         struct xfrm_user_polexpire *up = nlmsg_data(nlh);
1748         struct xfrm_userpolicy_info *p = &up->pol;
1749         u8 type = XFRM_POLICY_TYPE_MAIN;
1750         int err = -ENOENT;
1751         struct xfrm_mark m;
1752         u32 mark = xfrm_mark_get(attrs, &m);
1753
1754         err = copy_from_user_policy_type(&type, attrs);
1755         if (err)
1756                 return err;
1757
1758         err = verify_policy_dir(p->dir);
1759         if (err)
1760                 return err;
1761
1762         if (p->index)
1763                 xp = xfrm_policy_byid(net, mark, type, p->dir, p->index, 0, &err);
1764         else {
1765                 struct nlattr *rt = attrs[XFRMA_SEC_CTX];
1766                 struct xfrm_sec_ctx *ctx;
1767
1768                 err = verify_sec_ctx_len(attrs);
1769                 if (err)
1770                         return err;
1771
1772                 ctx = NULL;
1773                 if (rt) {
1774                         struct xfrm_user_sec_ctx *uctx = nla_data(rt);
1775
1776                         err = security_xfrm_policy_alloc(&ctx, uctx);
1777                         if (err)
1778                                 return err;
1779                 }
1780                 xp = xfrm_policy_bysel_ctx(net, mark, type, p->dir,
1781                                            &p->sel, ctx, 0, &err);
1782                 security_xfrm_policy_free(ctx);
1783         }
1784         if (xp == NULL)
1785                 return -ENOENT;
1786
1787         if (unlikely(xp->walk.dead))
1788                 goto out;
1789
1790         err = 0;
1791         if (up->hard) {
1792                 uid_t loginuid = NETLINK_CB(skb).loginuid;
1793                 uid_t sessionid = NETLINK_CB(skb).sessionid;
1794                 u32 sid = NETLINK_CB(skb).sid;
1795                 xfrm_policy_delete(xp, p->dir);
1796                 xfrm_audit_policy_delete(xp, 1, loginuid, sessionid, sid);
1797
1798         } else {
1799                 // reset the timers here?
1800                 WARN(1, "Dont know what to do with soft policy expire\n");
1801         }
1802         km_policy_expired(xp, p->dir, up->hard, current->pid);
1803
1804 out:
1805         xfrm_pol_put(xp);
1806         return err;
1807 }
1808
1809 static int xfrm_add_sa_expire(struct sk_buff *skb, struct nlmsghdr *nlh,
1810                 struct nlattr **attrs)
1811 {
1812         struct net *net = sock_net(skb->sk);
1813         struct xfrm_state *x;
1814         int err;
1815         struct xfrm_user_expire *ue = nlmsg_data(nlh);
1816         struct xfrm_usersa_info *p = &ue->state;
1817         struct xfrm_mark m;
1818         u32 mark = xfrm_mark_get(attrs, &m);
1819
1820         x = xfrm_state_lookup(net, mark, &p->id.daddr, p->id.spi, p->id.proto, p->family);
1821
1822         err = -ENOENT;
1823         if (x == NULL)
1824                 return err;
1825
1826         spin_lock_bh(&x->lock);
1827         err = -EINVAL;
1828         if (x->km.state != XFRM_STATE_VALID)
1829                 goto out;
1830         km_state_expired(x, ue->hard, current->pid);
1831
1832         if (ue->hard) {
1833                 uid_t loginuid = NETLINK_CB(skb).loginuid;
1834                 uid_t sessionid = NETLINK_CB(skb).sessionid;
1835                 u32 sid = NETLINK_CB(skb).sid;
1836                 __xfrm_state_delete(x);
1837                 xfrm_audit_state_delete(x, 1, loginuid, sessionid, sid);
1838         }
1839         err = 0;
1840 out:
1841         spin_unlock_bh(&x->lock);
1842         xfrm_state_put(x);
1843         return err;
1844 }
1845
1846 static int xfrm_add_acquire(struct sk_buff *skb, struct nlmsghdr *nlh,
1847                 struct nlattr **attrs)
1848 {
1849         struct net *net = sock_net(skb->sk);
1850         struct xfrm_policy *xp;
1851         struct xfrm_user_tmpl *ut;
1852         int i;
1853         struct nlattr *rt = attrs[XFRMA_TMPL];
1854         struct xfrm_mark mark;
1855
1856         struct xfrm_user_acquire *ua = nlmsg_data(nlh);
1857         struct xfrm_state *x = xfrm_state_alloc(net);
1858         int err = -ENOMEM;
1859
1860         if (!x)
1861                 goto nomem;
1862
1863         xfrm_mark_get(attrs, &mark);
1864
1865         err = verify_newpolicy_info(&ua->policy);
1866         if (err)
1867                 goto bad_policy;
1868
1869         /*   build an XP */
1870         xp = xfrm_policy_construct(net, &ua->policy, attrs, &err);
1871         if (!xp)
1872                 goto free_state;
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));
1877         xp->mark.m = x->mark.m = mark.m;
1878         xp->mark.v = x->mark.v = mark.v;
1879         ut = nla_data(rt);
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;
1898
1899 bad_policy:
1900         WARN(1, "BAD policy passed\n");
1901 free_state:
1902         kfree(x);
1903 nomem:
1904         return err;
1905 }
1906
1907 #ifdef CONFIG_XFRM_MIGRATE
1908 static int copy_from_user_migrate(struct xfrm_migrate *ma,
1909                                   struct xfrm_kmaddress *k,
1910                                   struct nlattr **attrs, int *num)
1911 {
1912         struct nlattr *rt = attrs[XFRMA_MIGRATE];
1913         struct xfrm_user_migrate *um;
1914         int i, num_migrate;
1915
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
1926         um = nla_data(rt);
1927         num_migrate = nla_len(rt) / sizeof(*um);
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
1950 static int xfrm_do_migrate(struct sk_buff *skb, struct nlmsghdr *nlh,
1951                            struct nlattr **attrs)
1952 {
1953         struct xfrm_userpolicy_id *pi = nlmsg_data(nlh);
1954         struct xfrm_migrate m[XFRM_MAX_DEPTH];
1955         struct xfrm_kmaddress km, *kmp;
1956         u8 type;
1957         int err;
1958         int n = 0;
1959
1960         if (attrs[XFRMA_MIGRATE] == NULL)
1961                 return -EINVAL;
1962
1963         kmp = attrs[XFRMA_KMADDRESS] ? &km : NULL;
1964
1965         err = copy_from_user_policy_type(&type, attrs);
1966         if (err)
1967                 return err;
1968
1969         err = copy_from_user_migrate((struct xfrm_migrate *)m, kmp, attrs, &n);
1970         if (err)
1971                 return err;
1972
1973         if (!n)
1974                 return 0;
1975
1976         xfrm_migrate(&pi->sel, pi->dir, type, m, n, kmp);
1977
1978         return 0;
1979 }
1980 #else
1981 static int xfrm_do_migrate(struct sk_buff *skb, struct nlmsghdr *nlh,
1982                            struct nlattr **attrs)
1983 {
1984         return -ENOPROTOOPT;
1985 }
1986 #endif
1987
1988 #ifdef CONFIG_XFRM_MIGRATE
1989 static 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
2004         return nla_put(skb, XFRMA_MIGRATE, sizeof(um), &um);
2005 }
2006
2007 static 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));
2015         memcpy(&uk.remote, &k->remote, sizeof(uk.remote));
2016
2017         return nla_put(skb, XFRMA_KMADDRESS, sizeof(uk), &uk);
2018 }
2019
2020 static inline size_t xfrm_migrate_msgsize(int num_migrate, int with_kma)
2021 {
2022         return NLMSG_ALIGN(sizeof(struct xfrm_userpolicy_id))
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();
2026 }
2027
2028 static int build_migrate(struct sk_buff *skb, struct xfrm_migrate *m,
2029                          int num_migrate, struct xfrm_kmaddress *k,
2030                          struct xfrm_selector *sel, u8 dir, u8 type)
2031 {
2032         struct xfrm_migrate *mp;
2033         struct xfrm_userpolicy_id *pol_id;
2034         struct nlmsghdr *nlh;
2035         int i;
2036
2037         nlh = nlmsg_put(skb, 0, 0, XFRM_MSG_MIGRATE, sizeof(*pol_id), 0);
2038         if (nlh == NULL)
2039                 return -EMSGSIZE;
2040
2041         pol_id = nlmsg_data(nlh);
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
2047         if (k != NULL && (copy_to_user_kmaddress(k, skb) < 0))
2048                         goto nlmsg_failure;
2049
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
2058         return nlmsg_end(skb, nlh);
2059 nlmsg_failure:
2060         nlmsg_cancel(skb, nlh);
2061         return -EMSGSIZE;
2062 }
2063
2064 static int xfrm_send_migrate(struct xfrm_selector *sel, u8 dir, u8 type,
2065                              struct xfrm_migrate *m, int num_migrate,
2066                              struct xfrm_kmaddress *k)
2067 {
2068         struct net *net = &init_net;
2069         struct sk_buff *skb;
2070
2071         skb = nlmsg_new(xfrm_migrate_msgsize(num_migrate, !!k), GFP_ATOMIC);
2072         if (skb == NULL)
2073                 return -ENOMEM;
2074
2075         /* build migrate */
2076         if (build_migrate(skb, m, num_migrate, k, sel, dir, type) < 0)
2077                 BUG();
2078
2079         return nlmsg_multicast(net->xfrm.nlsk, skb, 0, XFRMNLGRP_MIGRATE, GFP_ATOMIC);
2080 }
2081 #else
2082 static int xfrm_send_migrate(struct xfrm_selector *sel, u8 dir, u8 type,
2083                              struct xfrm_migrate *m, int num_migrate,
2084                              struct xfrm_kmaddress *k)
2085 {
2086         return -ENOPROTOOPT;
2087 }
2088 #endif
2089
2090 #define XMSGSIZE(type) sizeof(struct type)
2091
2092 static const int xfrm_msg_min[XFRM_NR_MSGTYPES] = {
2093         [XFRM_MSG_NEWSA       - XFRM_MSG_BASE] = XMSGSIZE(xfrm_usersa_info),
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),
2100         [XFRM_MSG_ACQUIRE     - XFRM_MSG_BASE] = XMSGSIZE(xfrm_user_acquire),
2101         [XFRM_MSG_EXPIRE      - XFRM_MSG_BASE] = XMSGSIZE(xfrm_user_expire),
2102         [XFRM_MSG_UPDPOLICY   - XFRM_MSG_BASE] = XMSGSIZE(xfrm_userpolicy_info),
2103         [XFRM_MSG_UPDSA       - XFRM_MSG_BASE] = XMSGSIZE(xfrm_usersa_info),
2104         [XFRM_MSG_POLEXPIRE   - XFRM_MSG_BASE] = XMSGSIZE(xfrm_user_polexpire),
2105         [XFRM_MSG_FLUSHSA     - XFRM_MSG_BASE] = XMSGSIZE(xfrm_usersa_flush),
2106         [XFRM_MSG_FLUSHPOLICY - XFRM_MSG_BASE] = 0,
2107         [XFRM_MSG_NEWAE       - XFRM_MSG_BASE] = XMSGSIZE(xfrm_aevent_id),
2108         [XFRM_MSG_GETAE       - XFRM_MSG_BASE] = XMSGSIZE(xfrm_aevent_id),
2109         [XFRM_MSG_REPORT      - XFRM_MSG_BASE] = XMSGSIZE(xfrm_user_report),
2110         [XFRM_MSG_MIGRATE     - XFRM_MSG_BASE] = XMSGSIZE(xfrm_userpolicy_id),
2111         [XFRM_MSG_GETSADINFO  - XFRM_MSG_BASE] = sizeof(u32),
2112         [XFRM_MSG_GETSPDINFO  - XFRM_MSG_BASE] = sizeof(u32),
2113 };
2114
2115 #undef XMSGSIZE
2116
2117 static const struct nla_policy xfrma_policy[XFRMA_MAX+1] = {
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)},
2122         [XFRMA_ALG_AEAD]        = { .len = sizeof(struct xfrm_algo_aead) },
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) },
2137         [XFRMA_KMADDRESS]       = { .len = sizeof(struct xfrm_user_kmaddress) },
2138         [XFRMA_MARK]            = { .len = sizeof(struct xfrm_mark) },
2139         [XFRMA_TFCPAD]          = { .type = NLA_U32 },
2140 };
2141
2142 static struct xfrm_link {
2143         int (*doit)(struct sk_buff *, struct nlmsghdr *, struct nlattr **);
2144         int (*dump)(struct sk_buff *, struct netlink_callback *);
2145         int (*done)(struct netlink_callback *);
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,
2150                                                    .dump = xfrm_dump_sa,
2151                                                    .done = xfrm_dump_sa_done  },
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,
2155                                                    .dump = xfrm_dump_policy,
2156                                                    .done = xfrm_dump_policy_done },
2157         [XFRM_MSG_ALLOCSPI    - XFRM_MSG_BASE] = { .doit = xfrm_alloc_userspi },
2158         [XFRM_MSG_ACQUIRE     - XFRM_MSG_BASE] = { .doit = xfrm_add_acquire   },
2159         [XFRM_MSG_EXPIRE      - XFRM_MSG_BASE] = { .doit = xfrm_add_sa_expire },
2160         [XFRM_MSG_UPDPOLICY   - XFRM_MSG_BASE] = { .doit = xfrm_add_policy    },
2161         [XFRM_MSG_UPDSA       - XFRM_MSG_BASE] = { .doit = xfrm_add_sa        },
2162         [XFRM_MSG_POLEXPIRE   - XFRM_MSG_BASE] = { .doit = xfrm_add_pol_expire},
2163         [XFRM_MSG_FLUSHSA     - XFRM_MSG_BASE] = { .doit = xfrm_flush_sa      },
2164         [XFRM_MSG_FLUSHPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_flush_policy  },
2165         [XFRM_MSG_NEWAE       - XFRM_MSG_BASE] = { .doit = xfrm_new_ae  },
2166         [XFRM_MSG_GETAE       - XFRM_MSG_BASE] = { .doit = xfrm_get_ae  },
2167         [XFRM_MSG_MIGRATE     - XFRM_MSG_BASE] = { .doit = xfrm_do_migrate    },
2168         [XFRM_MSG_GETSADINFO  - XFRM_MSG_BASE] = { .doit = xfrm_get_sadinfo   },
2169         [XFRM_MSG_GETSPDINFO  - XFRM_MSG_BASE] = { .doit = xfrm_get_spdinfo   },
2170 };
2171
2172 static int xfrm_user_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
2173 {
2174         struct net *net = sock_net(skb->sk);
2175         struct nlattr *attrs[XFRMA_MAX+1];
2176         struct xfrm_link *link;
2177         int type, err;
2178
2179         type = nlh->nlmsg_type;
2180         if (type > XFRM_MSG_MAX)
2181                 return -EINVAL;
2182
2183         type -= XFRM_MSG_BASE;
2184         link = &xfrm_dispatch[type];
2185
2186         /* All operations require privileges, even GET */
2187         if (security_netlink_recv(skb, CAP_NET_ADMIN))
2188                 return -EPERM;
2189
2190         if ((type == (XFRM_MSG_GETSA - XFRM_MSG_BASE) ||
2191              type == (XFRM_MSG_GETPOLICY - XFRM_MSG_BASE)) &&
2192             (nlh->nlmsg_flags & NLM_F_DUMP)) {
2193                 if (link->dump == NULL)
2194                         return -EINVAL;
2195
2196                 return netlink_dump_start(net->xfrm.nlsk, skb, nlh, link->dump, link->done);
2197         }
2198
2199         err = nlmsg_parse(nlh, xfrm_msg_min[type], attrs, XFRMA_MAX,
2200                           xfrma_policy);
2201         if (err < 0)
2202                 return err;
2203
2204         if (link->doit == NULL)
2205                 return -EINVAL;
2206
2207         return link->doit(skb, nlh, attrs);
2208 }
2209
2210 static void xfrm_netlink_rcv(struct sk_buff *skb)
2211 {
2212         mutex_lock(&xfrm_cfg_mutex);
2213         netlink_rcv_skb(skb, &xfrm_user_rcv_msg);
2214         mutex_unlock(&xfrm_cfg_mutex);
2215 }
2216
2217 static inline size_t xfrm_expire_msgsize(void)
2218 {
2219         return NLMSG_ALIGN(sizeof(struct xfrm_user_expire))
2220                + nla_total_size(sizeof(struct xfrm_mark));
2221 }
2222
2223 static int build_expire(struct sk_buff *skb, struct xfrm_state *x, struct km_event *c)
2224 {
2225         struct xfrm_user_expire *ue;
2226         struct nlmsghdr *nlh;
2227
2228         nlh = nlmsg_put(skb, c->pid, 0, XFRM_MSG_EXPIRE, sizeof(*ue), 0);
2229         if (nlh == NULL)
2230                 return -EMSGSIZE;
2231
2232         ue = nlmsg_data(nlh);
2233         copy_to_user_state(x, &ue->state);
2234         ue->hard = (c->data.hard != 0) ? 1 : 0;
2235
2236         if (xfrm_mark_put(skb, &x->mark))
2237                 goto nla_put_failure;
2238
2239         return nlmsg_end(skb, nlh);
2240
2241 nla_put_failure:
2242         return -EMSGSIZE;
2243 }
2244
2245 static int xfrm_exp_state_notify(struct xfrm_state *x, struct km_event *c)
2246 {
2247         struct net *net = xs_net(x);
2248         struct sk_buff *skb;
2249
2250         skb = nlmsg_new(xfrm_expire_msgsize(), GFP_ATOMIC);
2251         if (skb == NULL)
2252                 return -ENOMEM;
2253
2254         if (build_expire(skb, x, c) < 0) {
2255                 kfree_skb(skb);
2256                 return -EMSGSIZE;
2257         }
2258
2259         return nlmsg_multicast(net->xfrm.nlsk, skb, 0, XFRMNLGRP_EXPIRE, GFP_ATOMIC);
2260 }
2261
2262 static int xfrm_aevent_state_notify(struct xfrm_state *x, struct km_event *c)
2263 {
2264         struct net *net = xs_net(x);
2265         struct sk_buff *skb;
2266
2267         skb = nlmsg_new(xfrm_aevent_msgsize(), GFP_ATOMIC);
2268         if (skb == NULL)
2269                 return -ENOMEM;
2270
2271         if (build_aevent(skb, x, c) < 0)
2272                 BUG();
2273
2274         return nlmsg_multicast(net->xfrm.nlsk, skb, 0, XFRMNLGRP_AEVENTS, GFP_ATOMIC);
2275 }
2276
2277 static int xfrm_notify_sa_flush(struct km_event *c)
2278 {
2279         struct net *net = c->net;
2280         struct xfrm_usersa_flush *p;
2281         struct nlmsghdr *nlh;
2282         struct sk_buff *skb;
2283         int len = NLMSG_ALIGN(sizeof(struct xfrm_usersa_flush));
2284
2285         skb = nlmsg_new(len, GFP_ATOMIC);
2286         if (skb == NULL)
2287                 return -ENOMEM;
2288
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         }
2294
2295         p = nlmsg_data(nlh);
2296         p->proto = c->data.proto;
2297
2298         nlmsg_end(skb, nlh);
2299
2300         return nlmsg_multicast(net->xfrm.nlsk, skb, 0, XFRMNLGRP_SA, GFP_ATOMIC);
2301 }
2302
2303 static inline size_t xfrm_sa_len(struct xfrm_state *x)
2304 {
2305         size_t l = 0;
2306         if (x->aead)
2307                 l += nla_total_size(aead_len(x->aead));
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         }
2313         if (x->ealg)
2314                 l += nla_total_size(xfrm_alg_len(x->ealg));
2315         if (x->calg)
2316                 l += nla_total_size(sizeof(*x->calg));
2317         if (x->encap)
2318                 l += nla_total_size(sizeof(*x->encap));
2319         if (x->tfcpad)
2320                 l += nla_total_size(sizeof(x->tfcpad));
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
2327         /* Must count x->lastused as it may become non-zero behind our back. */
2328         l += nla_total_size(sizeof(u64));
2329
2330         return l;
2331 }
2332
2333 static int xfrm_notify_sa(struct xfrm_state *x, struct km_event *c)
2334 {
2335         struct net *net = xs_net(x);
2336         struct xfrm_usersa_info *p;
2337         struct xfrm_usersa_id *id;
2338         struct nlmsghdr *nlh;
2339         struct sk_buff *skb;
2340         int len = xfrm_sa_len(x);
2341         int headlen;
2342
2343         headlen = sizeof(*p);
2344         if (c->event == XFRM_MSG_DELSA) {
2345                 len += nla_total_size(headlen);
2346                 headlen = sizeof(*id);
2347                 len += nla_total_size(sizeof(struct xfrm_mark));
2348         }
2349         len += NLMSG_ALIGN(headlen);
2350
2351         skb = nlmsg_new(len, GFP_ATOMIC);
2352         if (skb == NULL)
2353                 return -ENOMEM;
2354
2355         nlh = nlmsg_put(skb, c->pid, c->seq, c->event, headlen, 0);
2356         if (nlh == NULL)
2357                 goto nla_put_failure;
2358
2359         p = nlmsg_data(nlh);
2360         if (c->event == XFRM_MSG_DELSA) {
2361                 struct nlattr *attr;
2362
2363                 id = nlmsg_data(nlh);
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
2369                 attr = nla_reserve(skb, XFRMA_SA, sizeof(*p));
2370                 if (attr == NULL)
2371                         goto nla_put_failure;
2372
2373                 p = nla_data(attr);
2374         }
2375
2376         if (copy_to_user_state_extra(x, p, skb))
2377                 goto nla_put_failure;
2378
2379         nlmsg_end(skb, nlh);
2380
2381         return nlmsg_multicast(net->xfrm.nlsk, skb, 0, XFRMNLGRP_SA, GFP_ATOMIC);
2382
2383 nla_put_failure:
2384         /* Somebody screwed up with xfrm_sa_len! */
2385         WARN_ON(1);
2386         kfree_skb(skb);
2387         return -1;
2388 }
2389
2390 static int xfrm_send_state_notify(struct xfrm_state *x, struct km_event *c)
2391 {
2392
2393         switch (c->event) {
2394         case XFRM_MSG_EXPIRE:
2395                 return xfrm_exp_state_notify(x, c);
2396         case XFRM_MSG_NEWAE:
2397                 return xfrm_aevent_state_notify(x, c);
2398         case XFRM_MSG_DELSA:
2399         case XFRM_MSG_UPDSA:
2400         case XFRM_MSG_NEWSA:
2401                 return xfrm_notify_sa(x, c);
2402         case XFRM_MSG_FLUSHSA:
2403                 return xfrm_notify_sa_flush(c);
2404         default:
2405                 printk(KERN_NOTICE "xfrm_user: Unknown SA event %d\n",
2406                        c->event);
2407                 break;
2408         }
2409
2410         return 0;
2411
2412 }
2413
2414 static 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)
2419                + nla_total_size(sizeof(struct xfrm_mark))
2420                + nla_total_size(xfrm_user_sec_ctx_size(x->security))
2421                + userpolicy_type_attrsize();
2422 }
2423
2424 static 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;
2430         __u32 seq = xfrm_get_acqseq();
2431
2432         nlh = nlmsg_put(skb, 0, 0, XFRM_MSG_ACQUIRE, sizeof(*ua), 0);
2433         if (nlh == NULL)
2434                 return -EMSGSIZE;
2435
2436         ua = nlmsg_data(nlh);
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;
2448         if (copy_to_user_state_sec_ctx(x, skb))
2449                 goto nlmsg_failure;
2450         if (copy_to_user_policy_type(xp->type, skb) < 0)
2451                 goto nlmsg_failure;
2452         if (xfrm_mark_put(skb, &xp->mark))
2453                 goto nla_put_failure;
2454
2455         return nlmsg_end(skb, nlh);
2456
2457 nla_put_failure:
2458 nlmsg_failure:
2459         nlmsg_cancel(skb, nlh);
2460         return -EMSGSIZE;
2461 }
2462
2463 static int xfrm_send_acquire(struct xfrm_state *x, struct xfrm_tmpl *xt,
2464                              struct xfrm_policy *xp, int dir)
2465 {
2466         struct net *net = xs_net(x);
2467         struct sk_buff *skb;
2468
2469         skb = nlmsg_new(xfrm_acquire_msgsize(x, xp), GFP_ATOMIC);
2470         if (skb == NULL)
2471                 return -ENOMEM;
2472
2473         if (build_acquire(skb, x, xt, xp, dir) < 0)
2474                 BUG();
2475
2476         return nlmsg_multicast(net->xfrm.nlsk, skb, 0, XFRMNLGRP_ACQUIRE, GFP_ATOMIC);
2477 }
2478
2479 /* User gives us xfrm_user_policy_info followed by an array of 0
2480  * or more templates.
2481  */
2482 static struct xfrm_policy *xfrm_compile_policy(struct sock *sk, int opt,
2483                                                u8 *data, int len, int *dir)
2484 {
2485         struct net *net = sock_net(sk);
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
2491         switch (sk->sk_family) {
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));
2518         if (validate_tmpl(nr, ut, p->sel.family))
2519                 return NULL;
2520
2521         if (p->dir > XFRM_POLICY_OUT)
2522                 return NULL;
2523
2524         xp = xfrm_policy_alloc(net, GFP_ATOMIC);
2525         if (xp == NULL) {
2526                 *dir = -ENOBUFS;
2527                 return NULL;
2528         }
2529
2530         copy_from_user_policy(xp, p);
2531         xp->type = XFRM_POLICY_TYPE_MAIN;
2532         copy_templates(xp, ut, nr);
2533
2534         *dir = p->dir;
2535
2536         return xp;
2537 }
2538
2539 static 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))
2544                + nla_total_size(sizeof(struct xfrm_mark))
2545                + userpolicy_type_attrsize();
2546 }
2547
2548 static int build_polexpire(struct sk_buff *skb, struct xfrm_policy *xp,
2549                            int dir, struct km_event *c)
2550 {
2551         struct xfrm_user_polexpire *upe;
2552         struct nlmsghdr *nlh;
2553         int hard = c->data.hard;
2554
2555         nlh = nlmsg_put(skb, c->pid, 0, XFRM_MSG_POLEXPIRE, sizeof(*upe), 0);
2556         if (nlh == NULL)
2557                 return -EMSGSIZE;
2558
2559         upe = nlmsg_data(nlh);
2560         copy_to_user_policy(xp, &upe->pol, dir);
2561         if (copy_to_user_tmpl(xp, skb) < 0)
2562                 goto nlmsg_failure;
2563         if (copy_to_user_sec_ctx(xp, skb))
2564                 goto nlmsg_failure;
2565         if (copy_to_user_policy_type(xp->type, skb) < 0)
2566                 goto nlmsg_failure;
2567         if (xfrm_mark_put(skb, &xp->mark))
2568                 goto nla_put_failure;
2569         upe->hard = !!hard;
2570
2571         return nlmsg_end(skb, nlh);
2572
2573 nla_put_failure:
2574 nlmsg_failure:
2575         nlmsg_cancel(skb, nlh);
2576         return -EMSGSIZE;
2577 }
2578
2579 static int xfrm_exp_policy_notify(struct xfrm_policy *xp, int dir, struct km_event *c)
2580 {
2581         struct net *net = xp_net(xp);
2582         struct sk_buff *skb;
2583
2584         skb = nlmsg_new(xfrm_polexpire_msgsize(xp), GFP_ATOMIC);
2585         if (skb == NULL)
2586                 return -ENOMEM;
2587
2588         if (build_polexpire(skb, xp, dir, c) < 0)
2589                 BUG();
2590
2591         return nlmsg_multicast(net->xfrm.nlsk, skb, 0, XFRMNLGRP_EXPIRE, GFP_ATOMIC);
2592 }
2593
2594 static int xfrm_notify_policy(struct xfrm_policy *xp, int dir, struct km_event *c)
2595 {
2596         struct net *net = xp_net(xp);
2597         struct xfrm_userpolicy_info *p;
2598         struct xfrm_userpolicy_id *id;
2599         struct nlmsghdr *nlh;
2600         struct sk_buff *skb;
2601         int len = nla_total_size(sizeof(struct xfrm_user_tmpl) * xp->xfrm_nr);
2602         int headlen;
2603
2604         headlen = sizeof(*p);
2605         if (c->event == XFRM_MSG_DELPOLICY) {
2606                 len += nla_total_size(headlen);
2607                 headlen = sizeof(*id);
2608         }
2609         len += userpolicy_type_attrsize();
2610         len += nla_total_size(sizeof(struct xfrm_mark));
2611         len += NLMSG_ALIGN(headlen);
2612
2613         skb = nlmsg_new(len, GFP_ATOMIC);
2614         if (skb == NULL)
2615                 return -ENOMEM;
2616
2617         nlh = nlmsg_put(skb, c->pid, c->seq, c->event, headlen, 0);
2618         if (nlh == NULL)
2619                 goto nlmsg_failure;
2620
2621         p = nlmsg_data(nlh);
2622         if (c->event == XFRM_MSG_DELPOLICY) {
2623                 struct nlattr *attr;
2624
2625                 id = nlmsg_data(nlh);
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
2633                 attr = nla_reserve(skb, XFRMA_POLICY, sizeof(*p));
2634                 if (attr == NULL)
2635                         goto nlmsg_failure;
2636
2637                 p = nla_data(attr);
2638         }
2639
2640         copy_to_user_policy(xp, p, dir);
2641         if (copy_to_user_tmpl(xp, skb) < 0)
2642                 goto nlmsg_failure;
2643         if (copy_to_user_policy_type(xp->type, skb) < 0)
2644                 goto nlmsg_failure;
2645
2646         if (xfrm_mark_put(skb, &xp->mark))
2647                 goto nla_put_failure;
2648
2649         nlmsg_end(skb, nlh);
2650
2651         return nlmsg_multicast(net->xfrm.nlsk, skb, 0, XFRMNLGRP_POLICY, GFP_ATOMIC);
2652
2653 nla_put_failure:
2654 nlmsg_failure:
2655         kfree_skb(skb);
2656         return -1;
2657 }
2658
2659 static int xfrm_notify_policy_flush(struct km_event *c)
2660 {
2661         struct net *net = c->net;
2662         struct nlmsghdr *nlh;
2663         struct sk_buff *skb;
2664
2665         skb = nlmsg_new(userpolicy_type_attrsize(), GFP_ATOMIC);
2666         if (skb == NULL)
2667                 return -ENOMEM;
2668
2669         nlh = nlmsg_put(skb, c->pid, c->seq, XFRM_MSG_FLUSHPOLICY, 0, 0);
2670         if (nlh == NULL)
2671                 goto nlmsg_failure;
2672         if (copy_to_user_policy_type(c->data.type, skb) < 0)
2673                 goto nlmsg_failure;
2674
2675         nlmsg_end(skb, nlh);
2676
2677         return nlmsg_multicast(net->xfrm.nlsk, skb, 0, XFRMNLGRP_POLICY, GFP_ATOMIC);
2678
2679 nlmsg_failure:
2680         kfree_skb(skb);
2681         return -1;
2682 }
2683
2684 static int xfrm_send_policy_notify(struct xfrm_policy *xp, int dir, struct km_event *c)
2685 {
2686
2687         switch (c->event) {
2688         case XFRM_MSG_NEWPOLICY:
2689         case XFRM_MSG_UPDPOLICY:
2690         case XFRM_MSG_DELPOLICY:
2691                 return xfrm_notify_policy(xp, dir, c);
2692         case XFRM_MSG_FLUSHPOLICY:
2693                 return xfrm_notify_policy_flush(c);
2694         case XFRM_MSG_POLEXPIRE:
2695                 return xfrm_exp_policy_notify(xp, dir, c);
2696         default:
2697                 printk(KERN_NOTICE "xfrm_user: Unknown Policy event %d\n",
2698                        c->event);
2699         }
2700
2701         return 0;
2702
2703 }
2704
2705 static inline size_t xfrm_report_msgsize(void)
2706 {
2707         return NLMSG_ALIGN(sizeof(struct xfrm_user_report));
2708 }
2709
2710 static 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;
2715
2716         nlh = nlmsg_put(skb, 0, 0, XFRM_MSG_REPORT, sizeof(*ur), 0);
2717         if (nlh == NULL)
2718                 return -EMSGSIZE;
2719
2720         ur = nlmsg_data(nlh);
2721         ur->proto = proto;
2722         memcpy(&ur->sel, sel, sizeof(ur->sel));
2723
2724         if (addr)
2725                 NLA_PUT(skb, XFRMA_COADDR, sizeof(*addr), addr);
2726
2727         return nlmsg_end(skb, nlh);
2728
2729 nla_put_failure:
2730         nlmsg_cancel(skb, nlh);
2731         return -EMSGSIZE;
2732 }
2733
2734 static int xfrm_send_report(struct net *net, u8 proto,
2735                             struct xfrm_selector *sel, xfrm_address_t *addr)
2736 {
2737         struct sk_buff *skb;
2738
2739         skb = nlmsg_new(xfrm_report_msgsize(), GFP_ATOMIC);
2740         if (skb == NULL)
2741                 return -ENOMEM;
2742
2743         if (build_report(skb, proto, sel, addr) < 0)
2744                 BUG();
2745
2746         return nlmsg_multicast(net->xfrm.nlsk, skb, 0, XFRMNLGRP_REPORT, GFP_ATOMIC);
2747 }
2748
2749 static inline size_t xfrm_mapping_msgsize(void)
2750 {
2751         return NLMSG_ALIGN(sizeof(struct xfrm_user_mapping));
2752 }
2753
2754 static 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
2779 static int xfrm_send_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr,
2780                              __be16 sport)
2781 {
2782         struct net *net = xs_net(x);
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
2798         return nlmsg_multicast(net->xfrm.nlsk, skb, 0, XFRMNLGRP_MAPPING, GFP_ATOMIC);
2799 }
2800
2801 static 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,
2807         .report         = xfrm_send_report,
2808         .migrate        = xfrm_send_migrate,
2809         .new_mapping    = xfrm_send_mapping,
2810 };
2811
2812 static int __net_init xfrm_user_net_init(struct net *net)
2813 {
2814         struct sock *nlsk;
2815
2816         nlsk = netlink_kernel_create(net, NETLINK_XFRM, XFRMNLGRP_MAX,
2817                                      xfrm_netlink_rcv, NULL, THIS_MODULE);
2818         if (nlsk == NULL)
2819                 return -ENOMEM;
2820         net->xfrm.nlsk_stash = nlsk; /* Don't set to NULL */
2821         rcu_assign_pointer(net->xfrm.nlsk, nlsk);
2822         return 0;
2823 }
2824
2825 static void __net_exit xfrm_user_net_exit(struct list_head *net_exit_list)
2826 {
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);
2833 }
2834
2835 static struct pernet_operations xfrm_user_net_ops = {
2836         .init       = xfrm_user_net_init,
2837         .exit_batch = xfrm_user_net_exit,
2838 };
2839
2840 static 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
2855 static void __exit xfrm_user_exit(void)
2856 {
2857         xfrm_unregister_km(&netlink_mgr);
2858         unregister_pernet_subsys(&xfrm_user_net_ops);
2859 }
2860
2861 module_init(xfrm_user_init);
2862 module_exit(xfrm_user_exit);
2863 MODULE_LICENSE("GPL");
2864 MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK, NETLINK_XFRM);
2865