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