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