net/ipv4/fou.c

   1 #include <linux/module.h>
   2 #include <linux/errno.h>
   3 #include <linux/socket.h>
   4 #include <linux/skbuff.h>
   5 #include <linux/ip.h>
   6 #include <linux/udp.h>
   7 #include <linux/types.h>
   8 #include <linux/kernel.h>
   9 #include <net/genetlink.h>
  10 #include <net/gue.h>
  11 #include <net/ip.h>
  12 #include <net/protocol.h>
  13 #include <net/udp.h>
  14 #include <net/udp_tunnel.h>
  15 #include <net/xfrm.h>
  16 #include <uapi/linux/fou.h>
  17 #include <uapi/linux/genetlink.h>
  18
  19 struct fou {
  20         struct socket *sock;
  21         u8 protocol;
  22         u8 flags;
  23         __be16 port;
  24         u16 type;
  25         struct list_head list;
  26         struct rcu_head rcu;
  27 };
  28
  29 #define FOU_F_REMCSUM_NOPARTIAL BIT(0)
  30
  31 struct fou_cfg {
  32         u16 type;
  33         u8 protocol;
  34         u8 flags;
  35         struct udp_port_cfg udp_config;
  36 };
  37
  38 static unsigned int fou_net_id;
  39
  40 struct fou_net {
  41         struct list_head fou_list;
  42         struct mutex fou_lock;
  43 };
  44
  45 static inline struct fou *fou_from_sock(struct sock *sk)
  46 {
  47         return sk->sk_user_data;
  48 }
  49
  50 static int fou_recv_pull(struct sk_buff *skb, size_t len)
  51 {
  52         struct iphdr *iph = ip_hdr(skb);
  53
  54         /* Remove 'len' bytes from the packet (UDP header and
  55          * FOU header if present).
  56          */
  57         iph->tot_len = htons(ntohs(iph->tot_len) - len);
  58         __skb_pull(skb, len);
  59         skb_postpull_rcsum(skb, udp_hdr(skb), len);
  60         skb_reset_transport_header(skb);
  61         return iptunnel_pull_offloads(skb);
  62 }
  63
  64 static int fou_udp_recv(struct sock *sk, struct sk_buff *skb)
  65 {
  66         struct fou *fou = fou_from_sock(sk);
  67
  68         if (!fou)
  69                 return 1;
  70
  71         if (fou_recv_pull(skb, sizeof(struct udphdr)))
  72                 goto drop;
  73
  74         return -fou->protocol;
  75
  76 drop:
  77         kfree_skb(skb);
  78         return 0;
  79 }
  80
  81 static struct guehdr *gue_remcsum(struct sk_buff *skb, struct guehdr *guehdr,
  82                                   void *data, size_t hdrlen, u8 ipproto,
  83                                   bool nopartial)
  84 {
  85         __be16 *pd = data;
  86         size_t start = ntohs(pd[0]);
  87         size_t offset = ntohs(pd[1]);
  88         size_t plen = sizeof(struct udphdr) + hdrlen +
  89             max_t(size_t, offset + sizeof(u16), start);
  90
  91         if (skb->remcsum_offload)
  92                 return guehdr;
  93
  94         if (!pskb_may_pull(skb, plen))
  95                 return NULL;
  96         guehdr = (struct guehdr *)&udp_hdr(skb)[1];
  97
  98         skb_remcsum_process(skb, (void *)guehdr + hdrlen,
  99                             start, offset, nopartial);
 100
 101         return guehdr;
 102 }
 103
 104 static int gue_control_message(struct sk_buff *skb, struct guehdr *guehdr)
 105 {
 106         /* No support yet */
 107         kfree_skb(skb);
 108         return 0;
 109 }
 110
 111 static int gue_udp_recv(struct sock *sk, struct sk_buff *skb)
 112 {
 113         struct fou *fou = fou_from_sock(sk);
 114         size_t len, optlen, hdrlen;
 115         struct guehdr *guehdr;
 116         void *data;
 117         u16 doffset = 0;
 118
 119         if (!fou)
 120                 return 1;
 121
 122         len = sizeof(struct udphdr) + sizeof(struct guehdr);
 123         if (!pskb_may_pull(skb, len))
 124                 goto drop;
 125
 126         guehdr = (struct guehdr *)&udp_hdr(skb)[1];
 127
 128         optlen = guehdr->hlen << 2;
 129         len += optlen;
 130
 131         if (!pskb_may_pull(skb, len))
 132                 goto drop;
 133
 134         /* guehdr may change after pull */
 135         guehdr = (struct guehdr *)&udp_hdr(skb)[1];
 136
 137         hdrlen = sizeof(struct guehdr) + optlen;
 138
 139         if (guehdr->version != 0 || validate_gue_flags(guehdr, optlen))
 140                 goto drop;
 141
 142         hdrlen = sizeof(struct guehdr) + optlen;
 143
 144         ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(skb)->tot_len) - len);
 145
 146         /* Pull csum through the guehdr now . This can be used if
 147          * there is a remote checksum offload.
 148          */
 149         skb_postpull_rcsum(skb, udp_hdr(skb), len);
 150
 151         data = &guehdr[1];
 152
 153         if (guehdr->flags & GUE_FLAG_PRIV) {
 154                 __be32 flags = *(__be32 *)(data + doffset);
 155
 156                 doffset += GUE_LEN_PRIV;
 157
 158                 if (flags & GUE_PFLAG_REMCSUM) {
 159                         guehdr = gue_remcsum(skb, guehdr, data + doffset,
 160                                              hdrlen, guehdr->proto_ctype,
 161                                              !!(fou->flags &
 162                                                 FOU_F_REMCSUM_NOPARTIAL));
 163                         if (!guehdr)
 164                                 goto drop;
 165
 166                         data = &guehdr[1];
 167
 168                         doffset += GUE_PLEN_REMCSUM;
 169                 }
 170         }
 171
 172         if (unlikely(guehdr->control))
 173                 return gue_control_message(skb, guehdr);
 174
 175         __skb_pull(skb, sizeof(struct udphdr) + hdrlen);
 176         skb_reset_transport_header(skb);
 177
 178         if (iptunnel_pull_offloads(skb))
 179                 goto drop;
 180
 181         return -guehdr->proto_ctype;
 182
 183 drop:
 184         kfree_skb(skb);
 185         return 0;
 186 }
 187
 188 static struct sk_buff **fou_gro_receive(struct sock *sk,
 189                                         struct sk_buff **head,
 190                                         struct sk_buff *skb)
 191 {
 192         const struct net_offload *ops;
 193         struct sk_buff **pp = NULL;
 194         u8 proto = fou_from_sock(sk)->protocol;
 195         const struct net_offload **offloads;
 196
 197         /* We can clear the encap_mark for FOU as we are essentially doing
 198          * one of two possible things.  We are either adding an L4 tunnel
 199          * header to the outer L3 tunnel header, or we are are simply
 200          * treating the GRE tunnel header as though it is a UDP protocol
 201          * specific header such as VXLAN or GENEVE.
 202          */
 203         NAPI_GRO_CB(skb)->encap_mark = 0;
 204
 205         /* Flag this frame as already having an outer encap header */
 206         NAPI_GRO_CB(skb)->is_fou = 1;
 207
 208         rcu_read_lock();
 209         offloads = NAPI_GRO_CB(skb)->is_ipv6 ? inet6_offloads : inet_offloads;
 210         ops = rcu_dereference(offloads[proto]);
 211         if (!ops || !ops->callbacks.gro_receive)
 212                 goto out_unlock;
 213
 214         pp = ops->callbacks.gro_receive(head, skb);
 215
 216 out_unlock:
 217         rcu_read_unlock();
 218
 219         return pp;
 220 }
 221
 222 static int fou_gro_complete(struct sock *sk, struct sk_buff *skb,
 223                             int nhoff)
 224 {
 225         const struct net_offload *ops;
 226         u8 proto = fou_from_sock(sk)->protocol;
 227         int err = -ENOSYS;
 228         const struct net_offload **offloads;
 229
 230         rcu_read_lock();
 231         offloads = NAPI_GRO_CB(skb)->is_ipv6 ? inet6_offloads : inet_offloads;
 232         ops = rcu_dereference(offloads[proto]);
 233         if (WARN_ON(!ops || !ops->callbacks.gro_complete))
 234                 goto out_unlock;
 235
 236         err = ops->callbacks.gro_complete(skb, nhoff);
 237
 238         skb_set_inner_mac_header(skb, nhoff);
 239
 240 out_unlock:
 241         rcu_read_unlock();
 242
 243         return err;
 244 }
 245
 246 static struct guehdr *gue_gro_remcsum(struct sk_buff *skb, unsigned int off,
 247                                       struct guehdr *guehdr, void *data,
 248                                       size_t hdrlen, struct gro_remcsum *grc,
 249                                       bool nopartial)
 250 {
 251         __be16 *pd = data;
 252         size_t start = ntohs(pd[0]);
 253         size_t offset = ntohs(pd[1]);
 254
 255         if (skb->remcsum_offload)
 256                 return guehdr;
 257
 258         if (!NAPI_GRO_CB(skb)->csum_valid)
 259                 return NULL;
 260
 261         guehdr = skb_gro_remcsum_process(skb, (void *)guehdr, off, hdrlen,
 262                                          start, offset, grc, nopartial);
 263
 264         skb->remcsum_offload = 1;
 265
 266         return guehdr;
 267 }
 268
 269 static struct sk_buff **gue_gro_receive(struct sock *sk,
 270                                         struct sk_buff **head,
 271                                         struct sk_buff *skb)
 272 {
 273         const struct net_offload **offloads;
 274         const struct net_offload *ops;
 275         struct sk_buff **pp = NULL;
 276         struct sk_buff *p;
 277         struct guehdr *guehdr;
 278         size_t len, optlen, hdrlen, off;
 279         void *data;
 280         u16 doffset = 0;
 281         int flush = 1;
 282         struct fou *fou = fou_from_sock(sk);
 283         struct gro_remcsum grc;
 284
 285         skb_gro_remcsum_init(&grc);
 286
 287         off = skb_gro_offset(skb);
 288         len = off + sizeof(*guehdr);
 289
 290         guehdr = skb_gro_header_fast(skb, off);
 291         if (skb_gro_header_hard(skb, len)) {
 292                 guehdr = skb_gro_header_slow(skb, len, off);
 293                 if (unlikely(!guehdr))
 294                         goto out;
 295         }
 296
 297         optlen = guehdr->hlen << 2;
 298         len += optlen;
 299
 300         if (skb_gro_header_hard(skb, len)) {
 301                 guehdr = skb_gro_header_slow(skb, len, off);
 302                 if (unlikely(!guehdr))
 303                         goto out;
 304         }
 305
 306         if (unlikely(guehdr->control) || guehdr->version != 0 ||
 307             validate_gue_flags(guehdr, optlen))
 308                 goto out;
 309
 310         hdrlen = sizeof(*guehdr) + optlen;
 311
 312         /* Adjust NAPI_GRO_CB(skb)->csum to account for guehdr,
 313          * this is needed if there is a remote checkcsum offload.
 314          */
 315         skb_gro_postpull_rcsum(skb, guehdr, hdrlen);
 316
 317         data = &guehdr[1];
 318
 319         if (guehdr->flags & GUE_FLAG_PRIV) {
 320                 __be32 flags = *(__be32 *)(data + doffset);
 321
 322                 doffset += GUE_LEN_PRIV;
 323
 324                 if (flags & GUE_PFLAG_REMCSUM) {
 325                         guehdr = gue_gro_remcsum(skb, off, guehdr,
 326                                                  data + doffset, hdrlen, &grc,
 327                                                  !!(fou->flags &
 328                                                     FOU_F_REMCSUM_NOPARTIAL));
 329
 330                         if (!guehdr)
 331                                 goto out;
 332
 333                         data = &guehdr[1];
 334
 335                         doffset += GUE_PLEN_REMCSUM;
 336                 }
 337         }
 338
 339         skb_gro_pull(skb, hdrlen);
 340
 341         for (p = *head; p; p = p->next) {
 342                 const struct guehdr *guehdr2;
 343
 344                 if (!NAPI_GRO_CB(p)->same_flow)
 345                         continue;
 346
 347                 guehdr2 = (struct guehdr *)(p->data + off);
 348
 349                 /* Compare base GUE header to be equal (covers
 350                  * hlen, version, proto_ctype, and flags.
 351                  */
 352                 if (guehdr->word != guehdr2->word) {
 353                         NAPI_GRO_CB(p)->same_flow = 0;
 354                         continue;
 355                 }
 356
 357                 /* Compare optional fields are the same. */
 358                 if (guehdr->hlen && memcmp(&guehdr[1], &guehdr2[1],
 359                                            guehdr->hlen << 2)) {
 360                         NAPI_GRO_CB(p)->same_flow = 0;
 361                         continue;
 362                 }
 363         }
 364
 365         /* We can clear the encap_mark for GUE as we are essentially doing
 366          * one of two possible things.  We are either adding an L4 tunnel
 367          * header to the outer L3 tunnel header, or we are are simply
 368          * treating the GRE tunnel header as though it is a UDP protocol
 369          * specific header such as VXLAN or GENEVE.
 370          */
 371         NAPI_GRO_CB(skb)->encap_mark = 0;
 372
 373         /* Flag this frame as already having an outer encap header */
 374         NAPI_GRO_CB(skb)->is_fou = 1;
 375
 376         rcu_read_lock();
 377         offloads = NAPI_GRO_CB(skb)->is_ipv6 ? inet6_offloads : inet_offloads;
 378         ops = rcu_dereference(offloads[guehdr->proto_ctype]);
 379         if (WARN_ON_ONCE(!ops || !ops->callbacks.gro_receive))
 380                 goto out_unlock;
 381
 382         pp = ops->callbacks.gro_receive(head, skb);
 383         flush = 0;
 384
 385 out_unlock:
 386         rcu_read_unlock();
 387 out:
 388         NAPI_GRO_CB(skb)->flush |= flush;
 389         skb_gro_remcsum_cleanup(skb, &grc);
 390
 391         return pp;
 392 }
 393
 394 static int gue_gro_complete(struct sock *sk, struct sk_buff *skb, int nhoff)
 395 {
 396         const struct net_offload **offloads;
 397         struct guehdr *guehdr = (struct guehdr *)(skb->data + nhoff);
 398         const struct net_offload *ops;
 399         unsigned int guehlen;
 400         u8 proto;
 401         int err = -ENOENT;
 402
 403         proto = guehdr->proto_ctype;
 404
 405         guehlen = sizeof(*guehdr) + (guehdr->hlen << 2);
 406
 407         rcu_read_lock();
 408         offloads = NAPI_GRO_CB(skb)->is_ipv6 ? inet6_offloads : inet_offloads;
 409         ops = rcu_dereference(offloads[proto]);
 410         if (WARN_ON(!ops || !ops->callbacks.gro_complete))
 411                 goto out_unlock;
 412
 413         err = ops->callbacks.gro_complete(skb, nhoff + guehlen);
 414
 415         skb_set_inner_mac_header(skb, nhoff + guehlen);
 416
 417 out_unlock:
 418         rcu_read_unlock();
 419         return err;
 420 }
 421
 422 static int fou_add_to_port_list(struct net *net, struct fou *fou)
 423 {
 424         struct fou_net *fn = net_generic(net, fou_net_id);
 425         struct fou *fout;
 426
 427         mutex_lock(&fn->fou_lock);
 428         list_for_each_entry(fout, &fn->fou_list, list) {
 429                 if (fou->port == fout->port) {
 430                         mutex_unlock(&fn->fou_lock);
 431                         return -EALREADY;
 432                 }
 433         }
 434
 435         list_add(&fou->list, &fn->fou_list);
 436         mutex_unlock(&fn->fou_lock);
 437
 438         return 0;
 439 }
 440
 441 static void fou_release(struct fou *fou)
 442 {
 443         struct socket *sock = fou->sock;
 444
 445         list_del(&fou->list);
 446         udp_tunnel_sock_release(sock);
 447
 448         kfree_rcu(fou, rcu);
 449 }
 450
 451 static int fou_encap_init(struct sock *sk, struct fou *fou, struct fou_cfg *cfg)
 452 {
 453         udp_sk(sk)->encap_rcv = fou_udp_recv;
 454         udp_sk(sk)->gro_receive = fou_gro_receive;
 455         udp_sk(sk)->gro_complete = fou_gro_complete;
 456         fou_from_sock(sk)->protocol = cfg->protocol;
 457
 458         return 0;
 459 }
 460
 461 static int gue_encap_init(struct sock *sk, struct fou *fou, struct fou_cfg *cfg)
 462 {
 463         udp_sk(sk)->encap_rcv = gue_udp_recv;
 464         udp_sk(sk)->gro_receive = gue_gro_receive;
 465         udp_sk(sk)->gro_complete = gue_gro_complete;
 466
 467         return 0;
 468 }
 469
 470 static int fou_create(struct net *net, struct fou_cfg *cfg,
 471                       struct socket **sockp)
 472 {
 473         struct socket *sock = NULL;
 474         struct fou *fou = NULL;
 475         struct sock *sk;
 476         int err;
 477
 478         /* Open UDP socket */
 479         err = udp_sock_create(net, &cfg->udp_config, &sock);
 480         if (err < 0)
 481                 goto error;
 482
 483         /* Allocate FOU port structure */
 484         fou = kzalloc(sizeof(*fou), GFP_KERNEL);
 485         if (!fou) {
 486                 err = -ENOMEM;
 487                 goto error;
 488         }
 489
 490         sk = sock->sk;
 491
 492         fou->flags = cfg->flags;
 493         fou->port = cfg->udp_config.local_udp_port;
 494
 495         /* Initial for fou type */
 496         switch (cfg->type) {
 497         case FOU_ENCAP_DIRECT:
 498                 err = fou_encap_init(sk, fou, cfg);
 499                 if (err)
 500                         goto error;
 501                 break;
 502         case FOU_ENCAP_GUE:
 503                 err = gue_encap_init(sk, fou, cfg);
 504                 if (err)
 505                         goto error;
 506                 break;
 507         default:
 508                 err = -EINVAL;
 509                 goto error;
 510         }
 511
 512         fou->type = cfg->type;
 513
 514         udp_sk(sk)->encap_type = 1;
 515         udp_encap_enable();
 516
 517         sk->sk_user_data = fou;
 518         fou->sock = sock;
 519
 520         inet_inc_convert_csum(sk);
 521
 522         sk->sk_allocation = GFP_ATOMIC;
 523
 524         err = fou_add_to_port_list(net, fou);
 525         if (err)
 526                 goto error;
 527
 528         if (sockp)
 529                 *sockp = sock;
 530
 531         return 0;
 532
 533 error:
 534         kfree(fou);
 535         if (sock)
 536                 udp_tunnel_sock_release(sock);
 537
 538         return err;
 539 }
 540
 541 static int fou_destroy(struct net *net, struct fou_cfg *cfg)
 542 {
 543         struct fou_net *fn = net_generic(net, fou_net_id);
 544         __be16 port = cfg->udp_config.local_udp_port;
 545         int err = -EINVAL;
 546         struct fou *fou;
 547
 548         mutex_lock(&fn->fou_lock);
 549         list_for_each_entry(fou, &fn->fou_list, list) {
 550                 if (fou->port == port) {
 551                         fou_release(fou);
 552                         err = 0;
 553                         break;
 554                 }
 555         }
 556         mutex_unlock(&fn->fou_lock);
 557
 558         return err;
 559 }
 560
 561 static struct genl_family fou_nl_family = {
 562         .id             = GENL_ID_GENERATE,
 563         .hdrsize        = 0,
 564         .name           = FOU_GENL_NAME,
 565         .version        = FOU_GENL_VERSION,
 566         .maxattr        = FOU_ATTR_MAX,
 567         .netnsok        = true,
 568 };
 569
 570 static struct nla_policy fou_nl_policy[FOU_ATTR_MAX + 1] = {
 571         [FOU_ATTR_PORT] = { .type = NLA_U16, },
 572         [FOU_ATTR_AF] = { .type = NLA_U8, },
 573         [FOU_ATTR_IPPROTO] = { .type = NLA_U8, },
 574         [FOU_ATTR_TYPE] = { .type = NLA_U8, },
 575         [FOU_ATTR_REMCSUM_NOPARTIAL] = { .type = NLA_FLAG, },
 576 };
 577
 578 static int parse_nl_config(struct genl_info *info,
 579                            struct fou_cfg *cfg)
 580 {
 581         memset(cfg, 0, sizeof(*cfg));
 582
 583         cfg->udp_config.family = AF_INET;
 584
 585         if (info->attrs[FOU_ATTR_AF]) {
 586                 u8 family = nla_get_u8(info->attrs[FOU_ATTR_AF]);
 587
 588                 if (family != AF_INET)
 589                         return -EINVAL;
 590
 591                 cfg->udp_config.family = family;
 592         }
 593
 594         if (info->attrs[FOU_ATTR_PORT]) {
 595                 __be16 port = nla_get_be16(info->attrs[FOU_ATTR_PORT]);
 596
 597                 cfg->udp_config.local_udp_port = port;
 598         }
 599
 600         if (info->attrs[FOU_ATTR_IPPROTO])
 601                 cfg->protocol = nla_get_u8(info->attrs[FOU_ATTR_IPPROTO]);
 602
 603         if (info->attrs[FOU_ATTR_TYPE])
 604                 cfg->type = nla_get_u8(info->attrs[FOU_ATTR_TYPE]);
 605
 606         if (info->attrs[FOU_ATTR_REMCSUM_NOPARTIAL])
 607                 cfg->flags |= FOU_F_REMCSUM_NOPARTIAL;
 608
 609         return 0;
 610 }
 611
 612 static int fou_nl_cmd_add_port(struct sk_buff *skb, struct genl_info *info)
 613 {
 614         struct net *net = genl_info_net(info);
 615         struct fou_cfg cfg;
 616         int err;
 617
 618         err = parse_nl_config(info, &cfg);
 619         if (err)
 620                 return err;
 621
 622         return fou_create(net, &cfg, NULL);
 623 }
 624
 625 static int fou_nl_cmd_rm_port(struct sk_buff *skb, struct genl_info *info)
 626 {
 627         struct net *net = genl_info_net(info);
 628         struct fou_cfg cfg;
 629         int err;
 630
 631         err = parse_nl_config(info, &cfg);
 632         if (err)
 633                 return err;
 634
 635         return fou_destroy(net, &cfg);
 636 }
 637
 638 static int fou_fill_info(struct fou *fou, struct sk_buff *msg)
 639 {
 640         if (nla_put_u8(msg, FOU_ATTR_AF, fou->sock->sk->sk_family) ||
 641             nla_put_be16(msg, FOU_ATTR_PORT, fou->port) ||
 642             nla_put_u8(msg, FOU_ATTR_IPPROTO, fou->protocol) ||
 643             nla_put_u8(msg, FOU_ATTR_TYPE, fou->type))
 644                 return -1;
 645
 646         if (fou->flags & FOU_F_REMCSUM_NOPARTIAL)
 647                 if (nla_put_flag(msg, FOU_ATTR_REMCSUM_NOPARTIAL))
 648                         return -1;
 649         return 0;
 650 }
 651
 652 static int fou_dump_info(struct fou *fou, u32 portid, u32 seq,
 653                          u32 flags, struct sk_buff *skb, u8 cmd)
 654 {
 655         void *hdr;
 656
 657         hdr = genlmsg_put(skb, portid, seq, &fou_nl_family, flags, cmd);
 658         if (!hdr)
 659                 return -ENOMEM;
 660
 661         if (fou_fill_info(fou, skb) < 0)
 662                 goto nla_put_failure;
 663
 664         genlmsg_end(skb, hdr);
 665         return 0;
 666
 667 nla_put_failure:
 668         genlmsg_cancel(skb, hdr);
 669         return -EMSGSIZE;
 670 }
 671
 672 static int fou_nl_cmd_get_port(struct sk_buff *skb, struct genl_info *info)
 673 {
 674         struct net *net = genl_info_net(info);
 675         struct fou_net *fn = net_generic(net, fou_net_id);
 676         struct sk_buff *msg;
 677         struct fou_cfg cfg;
 678         struct fou *fout;
 679         __be16 port;
 680         int ret;
 681
 682         ret = parse_nl_config(info, &cfg);
 683         if (ret)
 684                 return ret;
 685         port = cfg.udp_config.local_udp_port;
 686         if (port == 0)
 687                 return -EINVAL;
 688
 689         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 690         if (!msg)
 691                 return -ENOMEM;
 692
 693         ret = -ESRCH;
 694         mutex_lock(&fn->fou_lock);
 695         list_for_each_entry(fout, &fn->fou_list, list) {
 696                 if (port == fout->port) {
 697                         ret = fou_dump_info(fout, info->snd_portid,
 698                                             info->snd_seq, 0, msg,
 699                                             info->genlhdr->cmd);
 700                         break;
 701                 }
 702         }
 703         mutex_unlock(&fn->fou_lock);
 704         if (ret < 0)
 705                 goto out_free;
 706
 707         return genlmsg_reply(msg, info);
 708
 709 out_free:
 710         nlmsg_free(msg);
 711         return ret;
 712 }
 713
 714 static int fou_nl_dump(struct sk_buff *skb, struct netlink_callback *cb)
 715 {
 716         struct net *net = sock_net(skb->sk);
 717         struct fou_net *fn = net_generic(net, fou_net_id);
 718         struct fou *fout;
 719         int idx = 0, ret;
 720
 721         mutex_lock(&fn->fou_lock);
 722         list_for_each_entry(fout, &fn->fou_list, list) {
 723                 if (idx++ < cb->args[0])
 724                         continue;
 725                 ret = fou_dump_info(fout, NETLINK_CB(cb->skb).portid,
 726                                     cb->nlh->nlmsg_seq, NLM_F_MULTI,
 727                                     skb, FOU_CMD_GET);
 728                 if (ret)
 729                         break;
 730         }
 731         mutex_unlock(&fn->fou_lock);
 732
 733         cb->args[0] = idx;
 734         return skb->len;
 735 }
 736
 737 static const struct genl_ops fou_nl_ops[] = {
 738         {
 739                 .cmd = FOU_CMD_ADD,
 740                 .doit = fou_nl_cmd_add_port,
 741                 .policy = fou_nl_policy,
 742                 .flags = GENL_ADMIN_PERM,
 743         },
 744         {
 745                 .cmd = FOU_CMD_DEL,
 746                 .doit = fou_nl_cmd_rm_port,
 747                 .policy = fou_nl_policy,
 748                 .flags = GENL_ADMIN_PERM,
 749         },
 750         {
 751                 .cmd = FOU_CMD_GET,
 752                 .doit = fou_nl_cmd_get_port,
 753                 .dumpit = fou_nl_dump,
 754                 .policy = fou_nl_policy,
 755         },
 756 };
 757
 758 size_t fou_encap_hlen(struct ip_tunnel_encap *e)
 759 {
 760         return sizeof(struct udphdr);
 761 }
 762 EXPORT_SYMBOL(fou_encap_hlen);
 763
 764 size_t gue_encap_hlen(struct ip_tunnel_encap *e)
 765 {
 766         size_t len;
 767         bool need_priv = false;
 768
 769         len = sizeof(struct udphdr) + sizeof(struct guehdr);
 770
 771         if (e->flags & TUNNEL_ENCAP_FLAG_REMCSUM) {
 772                 len += GUE_PLEN_REMCSUM;
 773                 need_priv = true;
 774         }
 775
 776         len += need_priv ? GUE_LEN_PRIV : 0;
 777
 778         return len;
 779 }
 780 EXPORT_SYMBOL(gue_encap_hlen);
 781
 782 static void fou_build_udp(struct sk_buff *skb, struct ip_tunnel_encap *e,
 783                           struct flowi4 *fl4, u8 *protocol, __be16 sport)
 784 {
 785         struct udphdr *uh;
 786
 787         skb_push(skb, sizeof(struct udphdr));
 788         skb_reset_transport_header(skb);
 789
 790         uh = udp_hdr(skb);
 791
 792         uh->dest = e->dport;
 793         uh->source = sport;
 794         uh->len = htons(skb->len);
 795         udp_set_csum(!(e->flags & TUNNEL_ENCAP_FLAG_CSUM), skb,
 796                      fl4->saddr, fl4->daddr, skb->len);
 797
 798         *protocol = IPPROTO_UDP;
 799 }
 800
 801 int fou_build_header(struct sk_buff *skb, struct ip_tunnel_encap *e,
 802                      u8 *protocol, struct flowi4 *fl4)
 803 {
 804         int type = e->flags & TUNNEL_ENCAP_FLAG_CSUM ? SKB_GSO_UDP_TUNNEL_CSUM :
 805                                                        SKB_GSO_UDP_TUNNEL;
 806         __be16 sport;
 807         int err;
 808
 809         err = iptunnel_handle_offloads(skb, type);
 810         if (err)
 811                 return err;
 812
 813         sport = e->sport ? : udp_flow_src_port(dev_net(skb->dev),
 814                                                skb, 0, 0, false);
 815         fou_build_udp(skb, e, fl4, protocol, sport);
 816
 817         return 0;
 818 }
 819 EXPORT_SYMBOL(fou_build_header);
 820
 821 int gue_build_header(struct sk_buff *skb, struct ip_tunnel_encap *e,
 822                      u8 *protocol, struct flowi4 *fl4)
 823 {
 824         int type = e->flags & TUNNEL_ENCAP_FLAG_CSUM ? SKB_GSO_UDP_TUNNEL_CSUM :
 825                                                        SKB_GSO_UDP_TUNNEL;
 826         struct guehdr *guehdr;
 827         size_t hdrlen, optlen = 0;
 828         __be16 sport;
 829         void *data;
 830         bool need_priv = false;
 831         int err;
 832
 833         if ((e->flags & TUNNEL_ENCAP_FLAG_REMCSUM) &&
 834             skb->ip_summed == CHECKSUM_PARTIAL) {
 835                 optlen += GUE_PLEN_REMCSUM;
 836                 type |= SKB_GSO_TUNNEL_REMCSUM;
 837                 need_priv = true;
 838         }
 839
 840         optlen += need_priv ? GUE_LEN_PRIV : 0;
 841
 842         err = iptunnel_handle_offloads(skb, type);
 843         if (err)
 844                 return err;
 845
 846         /* Get source port (based on flow hash) before skb_push */
 847         sport = e->sport ? : udp_flow_src_port(dev_net(skb->dev),
 848                                                skb, 0, 0, false);
 849
 850         hdrlen = sizeof(struct guehdr) + optlen;
 851
 852         skb_push(skb, hdrlen);
 853
 854         guehdr = (struct guehdr *)skb->data;
 855
 856         guehdr->control = 0;
 857         guehdr->version = 0;
 858         guehdr->hlen = optlen >> 2;
 859         guehdr->flags = 0;
 860         guehdr->proto_ctype = *protocol;
 861
 862         data = &guehdr[1];
 863
 864         if (need_priv) {
 865                 __be32 *flags = data;
 866
 867                 guehdr->flags |= GUE_FLAG_PRIV;
 868                 *flags = 0;
 869                 data += GUE_LEN_PRIV;
 870
 871                 if (type & SKB_GSO_TUNNEL_REMCSUM) {
 872                         u16 csum_start = skb_checksum_start_offset(skb);
 873                         __be16 *pd = data;
 874
 875                         if (csum_start < hdrlen)
 876                                 return -EINVAL;
 877
 878                         csum_start -= hdrlen;
 879                         pd[0] = htons(csum_start);
 880                         pd[1] = htons(csum_start + skb->csum_offset);
 881
 882                         if (!skb_is_gso(skb)) {
 883                                 skb->ip_summed = CHECKSUM_NONE;
 884                                 skb->encapsulation = 0;
 885                         }
 886
 887                         *flags |= GUE_PFLAG_REMCSUM;
 888                         data += GUE_PLEN_REMCSUM;
 889                 }
 890
 891         }
 892
 893         fou_build_udp(skb, e, fl4, protocol, sport);
 894
 895         return 0;
 896 }
 897 EXPORT_SYMBOL(gue_build_header);
 898
 899 #ifdef CONFIG_NET_FOU_IP_TUNNELS
 900
 901 static const struct ip_tunnel_encap_ops fou_iptun_ops = {
 902         .encap_hlen = fou_encap_hlen,
 903         .build_header = fou_build_header,
 904 };
 905
 906 static const struct ip_tunnel_encap_ops gue_iptun_ops = {
 907         .encap_hlen = gue_encap_hlen,
 908         .build_header = gue_build_header,
 909 };
 910
 911 static int ip_tunnel_encap_add_fou_ops(void)
 912 {
 913         int ret;
 914
 915         ret = ip_tunnel_encap_add_ops(&fou_iptun_ops, TUNNEL_ENCAP_FOU);
 916         if (ret < 0) {
 917                 pr_err("can't add fou ops\n");
 918                 return ret;
 919         }
 920
 921         ret = ip_tunnel_encap_add_ops(&gue_iptun_ops, TUNNEL_ENCAP_GUE);
 922         if (ret < 0) {
 923                 pr_err("can't add gue ops\n");
 924                 ip_tunnel_encap_del_ops(&fou_iptun_ops, TUNNEL_ENCAP_FOU);
 925                 return ret;
 926         }
 927
 928         return 0;
 929 }
 930
 931 static void ip_tunnel_encap_del_fou_ops(void)
 932 {
 933         ip_tunnel_encap_del_ops(&fou_iptun_ops, TUNNEL_ENCAP_FOU);
 934         ip_tunnel_encap_del_ops(&gue_iptun_ops, TUNNEL_ENCAP_GUE);
 935 }
 936
 937 #else
 938
 939 static int ip_tunnel_encap_add_fou_ops(void)
 940 {
 941         return 0;
 942 }
 943
 944 static void ip_tunnel_encap_del_fou_ops(void)
 945 {
 946 }
 947
 948 #endif
 949
 950 static __net_init int fou_init_net(struct net *net)
 951 {
 952         struct fou_net *fn = net_generic(net, fou_net_id);
 953
 954         INIT_LIST_HEAD(&fn->fou_list);
 955         mutex_init(&fn->fou_lock);
 956         return 0;
 957 }
 958
 959 static __net_exit void fou_exit_net(struct net *net)
 960 {
 961         struct fou_net *fn = net_generic(net, fou_net_id);
 962         struct fou *fou, *next;
 963
 964         /* Close all the FOU sockets */
 965         mutex_lock(&fn->fou_lock);
 966         list_for_each_entry_safe(fou, next, &fn->fou_list, list)
 967                 fou_release(fou);
 968         mutex_unlock(&fn->fou_lock);
 969 }
 970
 971 static struct pernet_operations fou_net_ops = {
 972         .init = fou_init_net,
 973         .exit = fou_exit_net,
 974         .id   = &fou_net_id,
 975         .size = sizeof(struct fou_net),
 976 };
 977
 978 static int __init fou_init(void)
 979 {
 980         int ret;
 981
 982         ret = register_pernet_device(&fou_net_ops);
 983         if (ret)
 984                 goto exit;
 985
 986         ret = genl_register_family_with_ops(&fou_nl_family,
 987                                             fou_nl_ops);
 988         if (ret < 0)
 989                 goto unregister;
 990
 991         ret = ip_tunnel_encap_add_fou_ops();
 992         if (ret == 0)
 993                 return 0;
 994
 995         genl_unregister_family(&fou_nl_family);
 996 unregister:
 997         unregister_pernet_device(&fou_net_ops);
 998 exit:
 999         return ret;
1000 }
1001
1002 static void __exit fou_fini(void)
1003 {
1004         ip_tunnel_encap_del_fou_ops();
1005         genl_unregister_family(&fou_nl_family);
1006         unregister_pernet_device(&fou_net_ops);
1007 }
1008
1009 module_init(fou_init);
1010 module_exit(fou_fini);
1011 MODULE_AUTHOR("Tom Herbert <therbert@google.com>");
1012 MODULE_LICENSE("GPL");