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/module.h>
  14 #include <linux/kernel.h>
  15 #include <linux/types.h>
  16 #include <linux/slab.h>
  17 #include <linux/socket.h>
  18 #include <linux/string.h>
  19 #include <linux/net.h>
  20 #include <linux/skbuff.h>
  21 #include <linux/netlink.h>
  22 #include <linux/rtnetlink.h>
  23 #include <linux/pfkeyv2.h>
  24 #include <linux/ipsec.h>
  25 #include <linux/init.h>
  26 #include <linux/security.h>
  27 #include <net/sock.h>
  28 #include <net/xfrm.h>
  29 #include <asm/uaccess.h>
  30
  31 static struct sock *xfrm_nl;
  32
  33 static int verify_one_alg(struct rtattr **xfrma, enum xfrm_attr_type_t type)
  34 {
  35         struct rtattr *rt = xfrma[type - 1];
  36         struct xfrm_algo *algp;
  37
  38         if (!rt)
  39                 return 0;
  40
  41         if ((rt->rta_len - sizeof(*rt)) < sizeof(*algp))
  42                 return -EINVAL;
  43
  44         algp = RTA_DATA(rt);
  45         switch (type) {
  46         case XFRMA_ALG_AUTH:
  47                 if (!algp->alg_key_len &&
  48                     strcmp(algp->alg_name, "digest_null") != 0)
  49                         return -EINVAL;
  50                 break;
  51
  52         case XFRMA_ALG_CRYPT:
  53                 if (!algp->alg_key_len &&
  54                     strcmp(algp->alg_name, "cipher_null") != 0)
  55                         return -EINVAL;
  56                 break;
  57
  58         case XFRMA_ALG_COMP:
  59                 /* Zero length keys are legal.  */
  60                 break;
  61
  62         default:
  63                 return -EINVAL;
  64         };
  65
  66         algp->alg_name[CRYPTO_MAX_ALG_NAME - 1] = '\0';
  67         return 0;
  68 }
  69
  70 static int verify_encap_tmpl(struct rtattr **xfrma)
  71 {
  72         struct rtattr *rt = xfrma[XFRMA_ENCAP - 1];
  73         struct xfrm_encap_tmpl *encap;
  74
  75         if (!rt)
  76                 return 0;
  77
  78         if ((rt->rta_len - sizeof(*rt)) < sizeof(*encap))
  79                 return -EINVAL;
  80
  81         return 0;
  82 }
  83
  84 static int verify_newsa_info(struct xfrm_usersa_info *p,
  85                              struct rtattr **xfrma)
  86 {
  87         int err;
  88
  89         err = -EINVAL;
  90         switch (p->family) {
  91         case AF_INET:
  92                 break;
  93
  94         case AF_INET6:
  95 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  96                 break;
  97 #else
  98                 err = -EAFNOSUPPORT;
  99                 goto out;
 100 #endif
 101
 102         default:
 103                 goto out;
 104         };
 105
 106         err = -EINVAL;
 107         switch (p->id.proto) {
 108         case IPPROTO_AH:
 109                 if (!xfrma[XFRMA_ALG_AUTH-1]    ||
 110                     xfrma[XFRMA_ALG_CRYPT-1]    ||
 111                     xfrma[XFRMA_ALG_COMP-1])
 112                         goto out;
 113                 break;
 114
 115         case IPPROTO_ESP:
 116                 if ((!xfrma[XFRMA_ALG_AUTH-1] &&
 117                      !xfrma[XFRMA_ALG_CRYPT-1]) ||
 118                     xfrma[XFRMA_ALG_COMP-1])
 119                         goto out;
 120                 break;
 121
 122         case IPPROTO_COMP:
 123                 if (!xfrma[XFRMA_ALG_COMP-1]    ||
 124                     xfrma[XFRMA_ALG_AUTH-1]     ||
 125                     xfrma[XFRMA_ALG_CRYPT-1])
 126                         goto out;
 127                 break;
 128
 129         default:
 130                 goto out;
 131         };
 132
 133         if ((err = verify_one_alg(xfrma, XFRMA_ALG_AUTH)))
 134                 goto out;
 135         if ((err = verify_one_alg(xfrma, XFRMA_ALG_CRYPT)))
 136                 goto out;
 137         if ((err = verify_one_alg(xfrma, XFRMA_ALG_COMP)))
 138                 goto out;
 139         if ((err = verify_encap_tmpl(xfrma)))
 140                 goto out;
 141
 142         err = -EINVAL;
 143         switch (p->mode) {
 144         case 0:
 145         case 1:
 146                 break;
 147
 148         default:
 149                 goto out;
 150         };
 151
 152         err = 0;
 153
 154 out:
 155         return err;
 156 }
 157
 158 static int attach_one_algo(struct xfrm_algo **algpp, u8 *props,
 159                            struct xfrm_algo_desc *(*get_byname)(char *),
 160                            struct rtattr *u_arg)
 161 {
 162         struct rtattr *rta = u_arg;
 163         struct xfrm_algo *p, *ualg;
 164         struct xfrm_algo_desc *algo;
 165
 166         if (!rta)
 167                 return 0;
 168
 169         ualg = RTA_DATA(rta);
 170
 171         algo = get_byname(ualg->alg_name);
 172         if (!algo)
 173                 return -ENOSYS;
 174         *props = algo->desc.sadb_alg_id;
 175
 176         p = kmalloc(sizeof(*ualg) + ualg->alg_key_len, GFP_KERNEL);
 177         if (!p)
 178                 return -ENOMEM;
 179
 180         memcpy(p, ualg, sizeof(*ualg) + ualg->alg_key_len);
 181         *algpp = p;
 182         return 0;
 183 }
 184
 185 static int attach_encap_tmpl(struct xfrm_encap_tmpl **encapp, struct rtattr *u_arg)
 186 {
 187         struct rtattr *rta = u_arg;
 188         struct xfrm_encap_tmpl *p, *uencap;
 189
 190         if (!rta)
 191                 return 0;
 192
 193         uencap = RTA_DATA(rta);
 194         p = kmalloc(sizeof(*p), GFP_KERNEL);
 195         if (!p)
 196                 return -ENOMEM;
 197
 198         memcpy(p, uencap, sizeof(*p));
 199         *encapp = p;
 200         return 0;
 201 }
 202
 203 static void copy_from_user_state(struct xfrm_state *x, struct xfrm_usersa_info *p)
 204 {
 205         memcpy(&x->id, &p->id, sizeof(x->id));
 206         memcpy(&x->sel, &p->sel, sizeof(x->sel));
 207         memcpy(&x->lft, &p->lft, sizeof(x->lft));
 208         x->props.mode = p->mode;
 209         x->props.replay_window = p->replay_window;
 210         x->props.reqid = p->reqid;
 211         x->props.family = p->family;
 212         x->props.saddr = p->saddr;
 213         x->props.flags = p->flags;
 214 }
 215
 216 static struct xfrm_state *xfrm_state_construct(struct xfrm_usersa_info *p,
 217                                                struct rtattr **xfrma,
 218                                                int *errp)
 219 {
 220         struct xfrm_state *x = xfrm_state_alloc();
 221         int err = -ENOMEM;
 222
 223         if (!x)
 224                 goto error_no_put;
 225
 226         copy_from_user_state(x, p);
 227
 228         if ((err = attach_one_algo(&x->aalg, &x->props.aalgo,
 229                                    xfrm_aalg_get_byname,
 230                                    xfrma[XFRMA_ALG_AUTH-1])))
 231                 goto error;
 232         if ((err = attach_one_algo(&x->ealg, &x->props.ealgo,
 233                                    xfrm_ealg_get_byname,
 234                                    xfrma[XFRMA_ALG_CRYPT-1])))
 235                 goto error;
 236         if ((err = attach_one_algo(&x->calg, &x->props.calgo,
 237                                    xfrm_calg_get_byname,
 238                                    xfrma[XFRMA_ALG_COMP-1])))
 239                 goto error;
 240         if ((err = attach_encap_tmpl(&x->encap, xfrma[XFRMA_ENCAP-1])))
 241                 goto error;
 242
 243         err = -ENOENT;
 244         x->type = xfrm_get_type(x->id.proto, x->props.family);
 245         if (x->type == NULL)
 246                 goto error;
 247
 248         err = x->type->init_state(x, NULL);
 249         if (err)
 250                 goto error;
 251
 252         x->curlft.add_time = (unsigned long) xtime.tv_sec;
 253         x->km.state = XFRM_STATE_VALID;
 254         x->km.seq = p->seq;
 255
 256         return x;
 257
 258 error:
 259         x->km.state = XFRM_STATE_DEAD;
 260         xfrm_state_put(x);
 261 error_no_put:
 262         *errp = err;
 263         return NULL;
 264 }
 265
 266 static int xfrm_add_sa(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfrma)
 267 {
 268         struct xfrm_usersa_info *p = NLMSG_DATA(nlh);
 269         struct xfrm_state *x;
 270         int err;
 271
 272         err = verify_newsa_info(p, (struct rtattr **) xfrma);
 273         if (err)
 274                 return err;
 275
 276         xfrm_probe_algs();
 277
 278         x = xfrm_state_construct(p, (struct rtattr **) xfrma, &err);
 279         if (!x)
 280                 return err;
 281
 282         if (nlh->nlmsg_type == XFRM_MSG_NEWSA)
 283                 err = xfrm_state_add(x);
 284         else
 285                 err = xfrm_state_update(x);
 286
 287         if (err < 0) {
 288                 x->km.state = XFRM_STATE_DEAD;
 289                 xfrm_state_put(x);
 290         }
 291
 292         return err;
 293 }
 294
 295 static int xfrm_del_sa(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfrma)
 296 {
 297         struct xfrm_state *x;
 298         struct xfrm_usersa_id *p = NLMSG_DATA(nlh);
 299
 300         x = xfrm_state_lookup(&p->daddr, p->spi, p->proto, p->family);
 301         if (x == NULL)
 302                 return -ESRCH;
 303
 304         if (xfrm_state_kern(x)) {
 305                 xfrm_state_put(x);
 306                 return -EPERM;
 307         }
 308
 309         xfrm_state_delete(x);
 310         xfrm_state_put(x);
 311
 312         return 0;
 313 }
 314
 315 static void copy_to_user_state(struct xfrm_state *x, struct xfrm_usersa_info *p)
 316 {
 317         memcpy(&p->id, &x->id, sizeof(p->id));
 318         memcpy(&p->sel, &x->sel, sizeof(p->sel));
 319         memcpy(&p->lft, &x->lft, sizeof(p->lft));
 320         memcpy(&p->curlft, &x->curlft, sizeof(p->curlft));
 321         memcpy(&p->stats, &x->stats, sizeof(p->stats));
 322         p->saddr = x->props.saddr;
 323         p->mode = x->props.mode;
 324         p->replay_window = x->props.replay_window;
 325         p->reqid = x->props.reqid;
 326         p->family = x->props.family;
 327         p->flags = x->props.flags;
 328         p->seq = x->km.seq;
 329 }
 330
 331 struct xfrm_dump_info {
 332         struct sk_buff *in_skb;
 333         struct sk_buff *out_skb;
 334         u32 nlmsg_seq;
 335         int start_idx;
 336         int this_idx;
 337 };
 338
 339 static int dump_one_state(struct xfrm_state *x, int count, void *ptr)
 340 {
 341         struct xfrm_dump_info *sp = ptr;
 342         struct sk_buff *in_skb = sp->in_skb;
 343         struct sk_buff *skb = sp->out_skb;
 344         struct xfrm_usersa_info *p;
 345         struct nlmsghdr *nlh;
 346         unsigned char *b = skb->tail;
 347
 348         if (sp->this_idx < sp->start_idx)
 349                 goto out;
 350
 351         nlh = NLMSG_PUT(skb, NETLINK_CB(in_skb).pid,
 352                         sp->nlmsg_seq,
 353                         XFRM_MSG_NEWSA, sizeof(*p));
 354         nlh->nlmsg_flags = 0;
 355
 356         p = NLMSG_DATA(nlh);
 357         copy_to_user_state(x, p);
 358
 359         if (x->aalg)
 360                 RTA_PUT(skb, XFRMA_ALG_AUTH,
 361                         sizeof(*(x->aalg))+(x->aalg->alg_key_len+7)/8, x->aalg);
 362         if (x->ealg)
 363                 RTA_PUT(skb, XFRMA_ALG_CRYPT,
 364                         sizeof(*(x->ealg))+(x->ealg->alg_key_len+7)/8, x->ealg);
 365         if (x->calg)
 366                 RTA_PUT(skb, XFRMA_ALG_COMP, sizeof(*(x->calg)), x->calg);
 367
 368         if (x->encap)
 369                 RTA_PUT(skb, XFRMA_ENCAP, sizeof(*x->encap), x->encap);
 370
 371         nlh->nlmsg_len = skb->tail - b;
 372 out:
 373         sp->this_idx++;
 374         return 0;
 375
 376 nlmsg_failure:
 377 rtattr_failure:
 378         skb_trim(skb, b - skb->data);
 379         return -1;
 380 }
 381
 382 static int xfrm_dump_sa(struct sk_buff *skb, struct netlink_callback *cb)
 383 {
 384         struct xfrm_dump_info info;
 385
 386         info.in_skb = cb->skb;
 387         info.out_skb = skb;
 388         info.nlmsg_seq = cb->nlh->nlmsg_seq;
 389         info.this_idx = 0;
 390         info.start_idx = cb->args[0];
 391         (void) xfrm_state_walk(IPSEC_PROTO_ANY, dump_one_state, &info);
 392         cb->args[0] = info.this_idx;
 393
 394         return skb->len;
 395 }
 396
 397 static struct sk_buff *xfrm_state_netlink(struct sk_buff *in_skb,
 398                                           struct xfrm_state *x, u32 seq)
 399 {
 400         struct xfrm_dump_info info;
 401         struct sk_buff *skb;
 402
 403         skb = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);
 404         if (!skb)
 405                 return ERR_PTR(-ENOMEM);
 406
 407         NETLINK_CB(skb).dst_pid = NETLINK_CB(in_skb).pid;
 408         info.in_skb = in_skb;
 409         info.out_skb = skb;
 410         info.nlmsg_seq = seq;
 411         info.this_idx = info.start_idx = 0;
 412
 413         if (dump_one_state(x, 0, &info)) {
 414                 kfree_skb(skb);
 415                 return NULL;
 416         }
 417
 418         return skb;
 419 }
 420
 421 static int xfrm_get_sa(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfrma)
 422 {
 423         struct xfrm_usersa_id *p = NLMSG_DATA(nlh);
 424         struct xfrm_state *x;
 425         struct sk_buff *resp_skb;
 426         int err;
 427
 428         x = xfrm_state_lookup(&p->daddr, p->spi, p->proto, p->family);
 429         err = -ESRCH;
 430         if (x == NULL)
 431                 goto out_noput;
 432
 433         resp_skb = xfrm_state_netlink(skb, x, nlh->nlmsg_seq);
 434         if (IS_ERR(resp_skb)) {
 435                 err = PTR_ERR(resp_skb);
 436         } else {
 437                 err = netlink_unicast(xfrm_nl, resp_skb,
 438                                       NETLINK_CB(skb).pid, MSG_DONTWAIT);
 439         }
 440         xfrm_state_put(x);
 441 out_noput:
 442         return err;
 443 }
 444
 445 static int verify_userspi_info(struct xfrm_userspi_info *p)
 446 {
 447         switch (p->info.id.proto) {
 448         case IPPROTO_AH:
 449         case IPPROTO_ESP:
 450                 break;
 451
 452         case IPPROTO_COMP:
 453                 /* IPCOMP spi is 16-bits. */
 454                 if (p->max >= 0x10000)
 455                         return -EINVAL;
 456                 break;
 457
 458         default:
 459                 return -EINVAL;
 460         };
 461
 462         if (p->min > p->max)
 463                 return -EINVAL;
 464
 465         return 0;
 466 }
 467
 468 static int xfrm_alloc_userspi(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfrma)
 469 {
 470         struct xfrm_state *x;
 471         struct xfrm_userspi_info *p;
 472         struct sk_buff *resp_skb;
 473         xfrm_address_t *daddr;
 474         int family;
 475         int err;
 476
 477         p = NLMSG_DATA(nlh);
 478         err = verify_userspi_info(p);
 479         if (err)
 480                 goto out_noput;
 481
 482         family = p->info.family;
 483         daddr = &p->info.id.daddr;
 484
 485         x = NULL;
 486         if (p->info.seq) {
 487                 x = xfrm_find_acq_byseq(p->info.seq);
 488                 if (x && xfrm_addr_cmp(&x->id.daddr, daddr, family)) {
 489                         xfrm_state_put(x);
 490                         x = NULL;
 491                 }
 492         }
 493
 494         if (!x)
 495                 x = xfrm_find_acq(p->info.mode, p->info.reqid,
 496                                   p->info.id.proto, daddr,
 497                                   &p->info.saddr, 1,
 498                                   family);
 499         err = -ENOENT;
 500         if (x == NULL)
 501                 goto out_noput;
 502
 503         resp_skb = ERR_PTR(-ENOENT);
 504
 505         spin_lock_bh(&x->lock);
 506         if (x->km.state != XFRM_STATE_DEAD) {
 507                 xfrm_alloc_spi(x, htonl(p->min), htonl(p->max));
 508                 if (x->id.spi)
 509                         resp_skb = xfrm_state_netlink(skb, x, nlh->nlmsg_seq);
 510         }
 511         spin_unlock_bh(&x->lock);
 512
 513         if (IS_ERR(resp_skb)) {
 514                 err = PTR_ERR(resp_skb);
 515                 goto out;
 516         }
 517
 518         err = netlink_unicast(xfrm_nl, resp_skb,
 519                               NETLINK_CB(skb).pid, MSG_DONTWAIT);
 520
 521 out:
 522         xfrm_state_put(x);
 523 out_noput:
 524         return err;
 525 }
 526
 527 static int verify_policy_dir(__u8 dir)
 528 {
 529         switch (dir) {
 530         case XFRM_POLICY_IN:
 531         case XFRM_POLICY_OUT:
 532         case XFRM_POLICY_FWD:
 533                 break;
 534
 535         default:
 536                 return -EINVAL;
 537         };
 538
 539         return 0;
 540 }
 541
 542 static int verify_newpolicy_info(struct xfrm_userpolicy_info *p)
 543 {
 544         switch (p->share) {
 545         case XFRM_SHARE_ANY:
 546         case XFRM_SHARE_SESSION:
 547         case XFRM_SHARE_USER:
 548         case XFRM_SHARE_UNIQUE:
 549                 break;
 550
 551         default:
 552                 return -EINVAL;
 553         };
 554
 555         switch (p->action) {
 556         case XFRM_POLICY_ALLOW:
 557         case XFRM_POLICY_BLOCK:
 558                 break;
 559
 560         default:
 561                 return -EINVAL;
 562         };
 563
 564         switch (p->sel.family) {
 565         case AF_INET:
 566                 break;
 567
 568         case AF_INET6:
 569 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 570                 break;
 571 #else
 572                 return  -EAFNOSUPPORT;
 573 #endif
 574
 575         default:
 576                 return -EINVAL;
 577         };
 578
 579         return verify_policy_dir(p->dir);
 580 }
 581
 582 static void copy_templates(struct xfrm_policy *xp, struct xfrm_user_tmpl *ut,
 583                            int nr)
 584 {
 585         int i;
 586
 587         xp->xfrm_nr = nr;
 588         for (i = 0; i < nr; i++, ut++) {
 589                 struct xfrm_tmpl *t = &xp->xfrm_vec[i];
 590
 591                 memcpy(&t->id, &ut->id, sizeof(struct xfrm_id));
 592                 memcpy(&t->saddr, &ut->saddr,
 593                        sizeof(xfrm_address_t));
 594                 t->reqid = ut->reqid;
 595                 t->mode = ut->mode;
 596                 t->share = ut->share;
 597                 t->optional = ut->optional;
 598                 t->aalgos = ut->aalgos;
 599                 t->ealgos = ut->ealgos;
 600                 t->calgos = ut->calgos;
 601         }
 602 }
 603
 604 static int copy_from_user_tmpl(struct xfrm_policy *pol, struct rtattr **xfrma)
 605 {
 606         struct rtattr *rt = xfrma[XFRMA_TMPL-1];
 607         struct xfrm_user_tmpl *utmpl;
 608         int nr;
 609
 610         if (!rt) {
 611                 pol->xfrm_nr = 0;
 612         } else {
 613                 nr = (rt->rta_len - sizeof(*rt)) / sizeof(*utmpl);
 614
 615                 if (nr > XFRM_MAX_DEPTH)
 616                         return -EINVAL;
 617
 618                 copy_templates(pol, RTA_DATA(rt), nr);
 619         }
 620         return 0;
 621 }
 622
 623 static void copy_from_user_policy(struct xfrm_policy *xp, struct xfrm_userpolicy_info *p)
 624 {
 625         xp->priority = p->priority;
 626         xp->index = p->index;
 627         memcpy(&xp->selector, &p->sel, sizeof(xp->selector));
 628         memcpy(&xp->lft, &p->lft, sizeof(xp->lft));
 629         xp->action = p->action;
 630         xp->flags = p->flags;
 631         xp->family = p->sel.family;
 632         /* XXX xp->share = p->share; */
 633 }
 634
 635 static void copy_to_user_policy(struct xfrm_policy *xp, struct xfrm_userpolicy_info *p, int dir)
 636 {
 637         memcpy(&p->sel, &xp->selector, sizeof(p->sel));
 638         memcpy(&p->lft, &xp->lft, sizeof(p->lft));
 639         memcpy(&p->curlft, &xp->curlft, sizeof(p->curlft));
 640         p->priority = xp->priority;
 641         p->index = xp->index;
 642         p->sel.family = xp->family;
 643         p->dir = dir;
 644         p->action = xp->action;
 645         p->flags = xp->flags;
 646         p->share = XFRM_SHARE_ANY; /* XXX xp->share */
 647 }
 648
 649 static struct xfrm_policy *xfrm_policy_construct(struct xfrm_userpolicy_info *p, struct rtattr **xfrma, int *errp)
 650 {
 651         struct xfrm_policy *xp = xfrm_policy_alloc(GFP_KERNEL);
 652         int err;
 653
 654         if (!xp) {
 655                 *errp = -ENOMEM;
 656                 return NULL;
 657         }
 658
 659         copy_from_user_policy(xp, p);
 660         err = copy_from_user_tmpl(xp, xfrma);
 661         if (err) {
 662                 *errp = err;
 663                 kfree(xp);
 664                 xp = NULL;
 665         }
 666
 667         return xp;
 668 }
 669
 670 static int xfrm_add_policy(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfrma)
 671 {
 672         struct xfrm_userpolicy_info *p = NLMSG_DATA(nlh);
 673         struct xfrm_policy *xp;
 674         int err;
 675         int excl;
 676
 677         err = verify_newpolicy_info(p);
 678         if (err)
 679                 return err;
 680
 681         xp = xfrm_policy_construct(p, (struct rtattr **) xfrma, &err);
 682         if (!xp)
 683                 return err;
 684
 685         excl = nlh->nlmsg_type == XFRM_MSG_NEWPOLICY;
 686         err = xfrm_policy_insert(p->dir, xp, excl);
 687         if (err) {
 688                 kfree(xp);
 689                 return err;
 690         }
 691
 692         xfrm_pol_put(xp);
 693
 694         return 0;
 695 }
 696
 697 static int copy_to_user_tmpl(struct xfrm_policy *xp, struct sk_buff *skb)
 698 {
 699         struct xfrm_user_tmpl vec[XFRM_MAX_DEPTH];
 700         int i;
 701
 702         if (xp->xfrm_nr == 0)
 703                 return 0;
 704
 705         for (i = 0; i < xp->xfrm_nr; i++) {
 706                 struct xfrm_user_tmpl *up = &vec[i];
 707                 struct xfrm_tmpl *kp = &xp->xfrm_vec[i];
 708
 709                 memcpy(&up->id, &kp->id, sizeof(up->id));
 710                 up->family = xp->family;
 711                 memcpy(&up->saddr, &kp->saddr, sizeof(up->saddr));
 712                 up->reqid = kp->reqid;
 713                 up->mode = kp->mode;
 714                 up->share = kp->share;
 715                 up->optional = kp->optional;
 716                 up->aalgos = kp->aalgos;
 717                 up->ealgos = kp->ealgos;
 718                 up->calgos = kp->calgos;
 719         }
 720         RTA_PUT(skb, XFRMA_TMPL,
 721                 (sizeof(struct xfrm_user_tmpl) * xp->xfrm_nr),
 722                 vec);
 723
 724         return 0;
 725
 726 rtattr_failure:
 727         return -1;
 728 }
 729
 730 static int dump_one_policy(struct xfrm_policy *xp, int dir, int count, void *ptr)
 731 {
 732         struct xfrm_dump_info *sp = ptr;
 733         struct xfrm_userpolicy_info *p;
 734         struct sk_buff *in_skb = sp->in_skb;
 735         struct sk_buff *skb = sp->out_skb;
 736         struct nlmsghdr *nlh;
 737         unsigned char *b = skb->tail;
 738
 739         if (sp->this_idx < sp->start_idx)
 740                 goto out;
 741
 742         nlh = NLMSG_PUT(skb, NETLINK_CB(in_skb).pid,
 743                         sp->nlmsg_seq,
 744                         XFRM_MSG_NEWPOLICY, sizeof(*p));
 745         p = NLMSG_DATA(nlh);
 746         nlh->nlmsg_flags = 0;
 747
 748         copy_to_user_policy(xp, p, dir);
 749         if (copy_to_user_tmpl(xp, skb) < 0)
 750                 goto nlmsg_failure;
 751
 752         nlh->nlmsg_len = skb->tail - b;
 753 out:
 754         sp->this_idx++;
 755         return 0;
 756
 757 nlmsg_failure:
 758         skb_trim(skb, b - skb->data);
 759         return -1;
 760 }
 761
 762 static int xfrm_dump_policy(struct sk_buff *skb, struct netlink_callback *cb)
 763 {
 764         struct xfrm_dump_info info;
 765
 766         info.in_skb = cb->skb;
 767         info.out_skb = skb;
 768         info.nlmsg_seq = cb->nlh->nlmsg_seq;
 769         info.this_idx = 0;
 770         info.start_idx = cb->args[0];
 771         (void) xfrm_policy_walk(dump_one_policy, &info);
 772         cb->args[0] = info.this_idx;
 773
 774         return skb->len;
 775 }
 776
 777 static struct sk_buff *xfrm_policy_netlink(struct sk_buff *in_skb,
 778                                           struct xfrm_policy *xp,
 779                                           int dir, u32 seq)
 780 {
 781         struct xfrm_dump_info info;
 782         struct sk_buff *skb;
 783
 784         skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
 785         if (!skb)
 786                 return ERR_PTR(-ENOMEM);
 787
 788         NETLINK_CB(skb).dst_pid = NETLINK_CB(in_skb).pid;
 789         info.in_skb = in_skb;
 790         info.out_skb = skb;
 791         info.nlmsg_seq = seq;
 792         info.this_idx = info.start_idx = 0;
 793
 794         if (dump_one_policy(xp, dir, 0, &info) < 0) {
 795                 kfree_skb(skb);
 796                 return NULL;
 797         }
 798
 799         return skb;
 800 }
 801
 802 static int xfrm_get_policy(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfrma)
 803 {
 804         struct xfrm_policy *xp;
 805         struct xfrm_userpolicy_id *p;
 806         int err;
 807         int delete;
 808
 809         p = NLMSG_DATA(nlh);
 810         delete = nlh->nlmsg_type == XFRM_MSG_DELPOLICY;
 811
 812         err = verify_policy_dir(p->dir);
 813         if (err)
 814                 return err;
 815
 816         if (p->index)
 817                 xp = xfrm_policy_byid(p->dir, p->index, delete);
 818         else
 819                 xp = xfrm_policy_bysel(p->dir, &p->sel, delete);
 820         if (xp == NULL)
 821                 return -ENOENT;
 822
 823         if (!delete) {
 824                 struct sk_buff *resp_skb;
 825
 826                 resp_skb = xfrm_policy_netlink(skb, xp, p->dir, nlh->nlmsg_seq);
 827                 if (IS_ERR(resp_skb)) {
 828                         err = PTR_ERR(resp_skb);
 829                 } else {
 830                         err = netlink_unicast(xfrm_nl, resp_skb,
 831                                               NETLINK_CB(skb).pid,
 832                                               MSG_DONTWAIT);
 833                 }
 834         }
 835
 836         xfrm_pol_put(xp);
 837
 838         return err;
 839 }
 840
 841 static int xfrm_flush_sa(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfrma)
 842 {
 843         struct xfrm_usersa_flush *p = NLMSG_DATA(nlh);
 844
 845         xfrm_state_flush(p->proto);
 846         return 0;
 847 }
 848
 849 static int xfrm_flush_policy(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfrma)
 850 {
 851         xfrm_policy_flush();
 852         return 0;
 853 }
 854
 855 static const int xfrm_msg_min[(XFRM_MSG_MAX + 1 - XFRM_MSG_BASE)] = {
 856         NLMSG_LENGTH(sizeof(struct xfrm_usersa_info)),  /* NEW SA */
 857         NLMSG_LENGTH(sizeof(struct xfrm_usersa_id)),    /* DEL SA */
 858         NLMSG_LENGTH(sizeof(struct xfrm_usersa_id)),    /* GET SA */
 859         NLMSG_LENGTH(sizeof(struct xfrm_userpolicy_info)),/* NEW POLICY */
 860         NLMSG_LENGTH(sizeof(struct xfrm_userpolicy_id)),  /* DEL POLICY */
 861         NLMSG_LENGTH(sizeof(struct xfrm_userpolicy_id)),  /* GET POLICY */
 862         NLMSG_LENGTH(sizeof(struct xfrm_userspi_info)), /* ALLOC SPI */
 863         NLMSG_LENGTH(sizeof(struct xfrm_user_acquire)), /* ACQUIRE */
 864         NLMSG_LENGTH(sizeof(struct xfrm_user_expire)),  /* EXPIRE */
 865         NLMSG_LENGTH(sizeof(struct xfrm_userpolicy_info)),/* UPD POLICY */
 866         NLMSG_LENGTH(sizeof(struct xfrm_usersa_info)),  /* UPD SA */
 867         NLMSG_LENGTH(sizeof(struct xfrm_user_polexpire)), /* POLEXPIRE */
 868         NLMSG_LENGTH(sizeof(struct xfrm_usersa_flush)), /* FLUSH SA */
 869         NLMSG_LENGTH(0),                                /* FLUSH POLICY */
 870 };
 871
 872 static struct xfrm_link {
 873         int (*doit)(struct sk_buff *, struct nlmsghdr *, void **);
 874         int (*dump)(struct sk_buff *, struct netlink_callback *);
 875 } xfrm_dispatch[] = {
 876         {       .doit   =       xfrm_add_sa,            },
 877         {       .doit   =       xfrm_del_sa,            },
 878         {
 879                 .doit   =       xfrm_get_sa,
 880                 .dump   =       xfrm_dump_sa,
 881         },
 882         {       .doit   =       xfrm_add_policy         },
 883         {       .doit   =       xfrm_get_policy         },
 884         {
 885                 .doit   =       xfrm_get_policy,
 886                 .dump   =       xfrm_dump_policy,
 887         },
 888         {       .doit   =       xfrm_alloc_userspi      },
 889         {},
 890         {},
 891         {       .doit   =       xfrm_add_policy         },
 892         {       .doit   =       xfrm_add_sa,            },
 893         {},
 894         {       .doit   =       xfrm_flush_sa           },
 895         {       .doit   =       xfrm_flush_policy       },
 896 };
 897
 898 static int xfrm_done(struct netlink_callback *cb)
 899 {
 900         return 0;
 901 }
 902
 903 static int xfrm_user_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, int *errp)
 904 {
 905         struct rtattr *xfrma[XFRMA_MAX];
 906         struct xfrm_link *link;
 907         int type, min_len;
 908
 909         if (!(nlh->nlmsg_flags & NLM_F_REQUEST))
 910                 return 0;
 911
 912         type = nlh->nlmsg_type;
 913
 914         /* A control message: ignore them */
 915         if (type < XFRM_MSG_BASE)
 916                 return 0;
 917
 918         /* Unknown message: reply with EINVAL */
 919         if (type > XFRM_MSG_MAX)
 920                 goto err_einval;
 921
 922         type -= XFRM_MSG_BASE;
 923         link = &xfrm_dispatch[type];
 924
 925         /* All operations require privileges, even GET */
 926         if (security_netlink_recv(skb)) {
 927                 *errp = -EPERM;
 928                 return -1;
 929         }
 930
 931         if ((type == 2 || type == 5) && (nlh->nlmsg_flags & NLM_F_DUMP)) {
 932                 u32 rlen;
 933
 934                 if (link->dump == NULL)
 935                         goto err_einval;
 936
 937                 if ((*errp = netlink_dump_start(xfrm_nl, skb, nlh,
 938                                                 link->dump,
 939                                                 xfrm_done)) != 0) {
 940                         return -1;
 941                 }
 942                 rlen = NLMSG_ALIGN(nlh->nlmsg_len);
 943                 if (rlen > skb->len)
 944                         rlen = skb->len;
 945                 skb_pull(skb, rlen);
 946                 return -1;
 947         }
 948
 949         memset(xfrma, 0, sizeof(xfrma));
 950
 951         if (nlh->nlmsg_len < (min_len = xfrm_msg_min[type]))
 952                 goto err_einval;
 953
 954         if (nlh->nlmsg_len > min_len) {
 955                 int attrlen = nlh->nlmsg_len - NLMSG_ALIGN(min_len);
 956                 struct rtattr *attr = (void *) nlh + NLMSG_ALIGN(min_len);
 957
 958                 while (RTA_OK(attr, attrlen)) {
 959                         unsigned short flavor = attr->rta_type;
 960                         if (flavor) {
 961                                 if (flavor > XFRMA_MAX)
 962                                         goto err_einval;
 963                                 xfrma[flavor - 1] = attr;
 964                         }
 965                         attr = RTA_NEXT(attr, attrlen);
 966                 }
 967         }
 968
 969         if (link->doit == NULL)
 970                 goto err_einval;
 971         *errp = link->doit(skb, nlh, (void **) &xfrma);
 972
 973         return *errp;
 974
 975 err_einval:
 976         *errp = -EINVAL;
 977         return -1;
 978 }
 979
 980 static int xfrm_user_rcv_skb(struct sk_buff *skb)
 981 {
 982         int err;
 983         struct nlmsghdr *nlh;
 984
 985         while (skb->len >= NLMSG_SPACE(0)) {
 986                 u32 rlen;
 987
 988                 nlh = (struct nlmsghdr *) skb->data;
 989                 if (nlh->nlmsg_len < sizeof(*nlh) ||
 990                     skb->len < nlh->nlmsg_len)
 991                         return 0;
 992                 rlen = NLMSG_ALIGN(nlh->nlmsg_len);
 993                 if (rlen > skb->len)
 994                         rlen = skb->len;
 995                 if (xfrm_user_rcv_msg(skb, nlh, &err) < 0) {
 996                         if (err == 0)
 997                                 return -1;
 998                         netlink_ack(skb, nlh, err);
 999                 } else if (nlh->nlmsg_flags & NLM_F_ACK)
1000                         netlink_ack(skb, nlh, 0);
1001                 skb_pull(skb, rlen);
1002         }
1003
1004         return 0;
1005 }
1006
1007 static void xfrm_netlink_rcv(struct sock *sk, int len)
1008 {
1009         do {
1010                 struct sk_buff *skb;
1011
1012                 down(&xfrm_cfg_sem);
1013
1014                 while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
1015                         if (xfrm_user_rcv_skb(skb)) {
1016                                 if (skb->len)
1017                                         skb_queue_head(&sk->sk_receive_queue,
1018                                                        skb);
1019                                 else
1020                                         kfree_skb(skb);
1021                                 break;
1022                         }
1023                         kfree_skb(skb);
1024                 }
1025
1026                 up(&xfrm_cfg_sem);
1027
1028         } while (xfrm_nl && xfrm_nl->sk_receive_queue.qlen);
1029 }
1030
1031 static int build_expire(struct sk_buff *skb, struct xfrm_state *x, int hard)
1032 {
1033         struct xfrm_user_expire *ue;
1034         struct nlmsghdr *nlh;
1035         unsigned char *b = skb->tail;
1036
1037         nlh = NLMSG_PUT(skb, 0, 0, XFRM_MSG_EXPIRE,
1038                         sizeof(*ue));
1039         ue = NLMSG_DATA(nlh);
1040         nlh->nlmsg_flags = 0;
1041
1042         copy_to_user_state(x, &ue->state);
1043         ue->hard = (hard != 0) ? 1 : 0;
1044
1045         nlh->nlmsg_len = skb->tail - b;
1046         return skb->len;
1047
1048 nlmsg_failure:
1049         skb_trim(skb, b - skb->data);
1050         return -1;
1051 }
1052
1053 static int xfrm_send_state_notify(struct xfrm_state *x, int hard)
1054 {
1055         struct sk_buff *skb;
1056
1057         skb = alloc_skb(sizeof(struct xfrm_user_expire) + 16, GFP_ATOMIC);
1058         if (skb == NULL)
1059                 return -ENOMEM;
1060
1061         if (build_expire(skb, x, hard) < 0)
1062                 BUG();
1063
1064         NETLINK_CB(skb).dst_groups = XFRMGRP_EXPIRE;
1065
1066         return netlink_broadcast(xfrm_nl, skb, 0, XFRMGRP_EXPIRE, GFP_ATOMIC);
1067 }
1068
1069 static int build_acquire(struct sk_buff *skb, struct xfrm_state *x,
1070                          struct xfrm_tmpl *xt, struct xfrm_policy *xp,
1071                          int dir)
1072 {
1073         struct xfrm_user_acquire *ua;
1074         struct nlmsghdr *nlh;
1075         unsigned char *b = skb->tail;
1076         __u32 seq = xfrm_get_acqseq();
1077
1078         nlh = NLMSG_PUT(skb, 0, 0, XFRM_MSG_ACQUIRE,
1079                         sizeof(*ua));
1080         ua = NLMSG_DATA(nlh);
1081         nlh->nlmsg_flags = 0;
1082
1083         memcpy(&ua->id, &x->id, sizeof(ua->id));
1084         memcpy(&ua->saddr, &x->props.saddr, sizeof(ua->saddr));
1085         memcpy(&ua->sel, &x->sel, sizeof(ua->sel));
1086         copy_to_user_policy(xp, &ua->policy, dir);
1087         ua->aalgos = xt->aalgos;
1088         ua->ealgos = xt->ealgos;
1089         ua->calgos = xt->calgos;
1090         ua->seq = x->km.seq = seq;
1091
1092         if (copy_to_user_tmpl(xp, skb) < 0)
1093                 goto nlmsg_failure;
1094
1095         nlh->nlmsg_len = skb->tail - b;
1096         return skb->len;
1097
1098 nlmsg_failure:
1099         skb_trim(skb, b - skb->data);
1100         return -1;
1101 }
1102
1103 static int xfrm_send_acquire(struct xfrm_state *x, struct xfrm_tmpl *xt,
1104                              struct xfrm_policy *xp, int dir)
1105 {
1106         struct sk_buff *skb;
1107         size_t len;
1108
1109         len = RTA_SPACE(sizeof(struct xfrm_user_tmpl) * xp->xfrm_nr);
1110         len += NLMSG_SPACE(sizeof(struct xfrm_user_acquire));
1111         skb = alloc_skb(len, GFP_ATOMIC);
1112         if (skb == NULL)
1113                 return -ENOMEM;
1114
1115         if (build_acquire(skb, x, xt, xp, dir) < 0)
1116                 BUG();
1117
1118         NETLINK_CB(skb).dst_groups = XFRMGRP_ACQUIRE;
1119
1120         return netlink_broadcast(xfrm_nl, skb, 0, XFRMGRP_ACQUIRE, GFP_ATOMIC);
1121 }
1122
1123 /* User gives us xfrm_user_policy_info followed by an array of 0
1124  * or more templates.
1125  */
1126 struct xfrm_policy *xfrm_compile_policy(u16 family, int opt,
1127                                         u8 *data, int len, int *dir)
1128 {
1129         struct xfrm_userpolicy_info *p = (struct xfrm_userpolicy_info *)data;
1130         struct xfrm_user_tmpl *ut = (struct xfrm_user_tmpl *) (p + 1);
1131         struct xfrm_policy *xp;
1132         int nr;
1133
1134         switch (family) {
1135         case AF_INET:
1136                 if (opt != IP_XFRM_POLICY) {
1137                         *dir = -EOPNOTSUPP;
1138                         return NULL;
1139                 }
1140                 break;
1141 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
1142         case AF_INET6:
1143                 if (opt != IPV6_XFRM_POLICY) {
1144                         *dir = -EOPNOTSUPP;
1145                         return NULL;
1146                 }
1147                 break;
1148 #endif
1149         default:
1150                 *dir = -EINVAL;
1151                 return NULL;
1152         }
1153
1154         *dir = -EINVAL;
1155
1156         if (len < sizeof(*p) ||
1157             verify_newpolicy_info(p))
1158                 return NULL;
1159
1160         nr = ((len - sizeof(*p)) / sizeof(*ut));
1161         if (nr > XFRM_MAX_DEPTH)
1162                 return NULL;
1163
1164         xp = xfrm_policy_alloc(GFP_KERNEL);
1165         if (xp == NULL) {
1166                 *dir = -ENOBUFS;
1167                 return NULL;
1168         }
1169
1170         copy_from_user_policy(xp, p);
1171         copy_templates(xp, ut, nr);
1172
1173         *dir = p->dir;
1174
1175         return xp;
1176 }
1177
1178 static int build_polexpire(struct sk_buff *skb, struct xfrm_policy *xp,
1179                            int dir, int hard)
1180 {
1181         struct xfrm_user_polexpire *upe;
1182         struct nlmsghdr *nlh;
1183         unsigned char *b = skb->tail;
1184
1185         nlh = NLMSG_PUT(skb, 0, 0, XFRM_MSG_POLEXPIRE, sizeof(*upe));
1186         upe = NLMSG_DATA(nlh);
1187         nlh->nlmsg_flags = 0;
1188
1189         copy_to_user_policy(xp, &upe->pol, dir);
1190         if (copy_to_user_tmpl(xp, skb) < 0)
1191                 goto nlmsg_failure;
1192         upe->hard = !!hard;
1193
1194         nlh->nlmsg_len = skb->tail - b;
1195         return skb->len;
1196
1197 nlmsg_failure:
1198         skb_trim(skb, b - skb->data);
1199         return -1;
1200 }
1201
1202 static int xfrm_send_policy_notify(struct xfrm_policy *xp, int dir, int hard)
1203 {
1204         struct sk_buff *skb;
1205         size_t len;
1206
1207         len = RTA_SPACE(sizeof(struct xfrm_user_tmpl) * xp->xfrm_nr);
1208         len += NLMSG_SPACE(sizeof(struct xfrm_user_polexpire));
1209         skb = alloc_skb(len, GFP_ATOMIC);
1210         if (skb == NULL)
1211                 return -ENOMEM;
1212
1213         if (build_polexpire(skb, xp, dir, hard) < 0)
1214                 BUG();
1215
1216         NETLINK_CB(skb).dst_groups = XFRMGRP_EXPIRE;
1217
1218         return netlink_broadcast(xfrm_nl, skb, 0, XFRMGRP_EXPIRE, GFP_ATOMIC);
1219 }
1220
1221 static struct xfrm_mgr netlink_mgr = {
1222         .id             = "netlink",
1223         .notify         = xfrm_send_state_notify,
1224         .acquire        = xfrm_send_acquire,
1225         .compile_policy = xfrm_compile_policy,
1226         .notify_policy  = xfrm_send_policy_notify,
1227 };
1228
1229 static int __init xfrm_user_init(void)
1230 {
1231         printk(KERN_INFO "Initializing IPsec netlink socket\n");
1232
1233         xfrm_nl = netlink_kernel_create(NETLINK_XFRM, xfrm_netlink_rcv);
1234         if (xfrm_nl == NULL)
1235                 panic("xfrm_user_init: cannot initialize xfrm_nl\n");
1236
1237
1238         xfrm_register_km(&netlink_mgr);
1239
1240         return 0;
1241 }
1242
1243 static void __exit xfrm_user_exit(void)
1244 {
1245         xfrm_unregister_km(&netlink_mgr);
1246         sock_release(xfrm_nl->sk_socket);
1247 }
1248
1249 module_init(xfrm_user_init);
1250 module_exit(xfrm_user_exit);
1251 MODULE_LICENSE("GPL");