net/xfrm/xfrm_user.c

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