net/ipv4/fou.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 #include <linux/module.h>
   3 #include <linux/errno.h>
   4 #include <linux/socket.h>
   5 #include <linux/skbuff.h>
   6 #include <linux/ip.h>
   7 #include <linux/icmp.h>
   8 #include <linux/udp.h>
   9 #include <linux/types.h>
  10 #include <linux/kernel.h>
  11 #include <net/genetlink.h>
  12 #include <net/gro.h>
  13 #include <net/gue.h>
  14 #include <net/fou.h>
  15 #include <net/ip.h>
  16 #include <net/protocol.h>
  17 #include <net/udp.h>
  18 #include <net/udp_tunnel.h>
  19 #include <net/xfrm.h>
  20 #include <uapi/linux/fou.h>
  21 #include <uapi/linux/genetlink.h>
  22
  23 struct fou {
  24         struct socket *sock;
  25         u8 protocol;
  26         u8 flags;
  27         __be16 port;
  28         u8 family;
  29         u16 type;
  30         struct list_head list;
  31         struct rcu_head rcu;
  32 };
  33
  34 #define FOU_F_REMCSUM_NOPARTIAL BIT(0)
  35
  36 struct fou_cfg {
  37         u16 type;
  38         u8 protocol;
  39         u8 flags;
  40         struct udp_port_cfg udp_config;
  41 };
  42
  43 static unsigned int fou_net_id;
  44
  45 struct fou_net {
  46         struct list_head fou_list;
  47         struct mutex fou_lock;
  48 };
  49
  50 static inline struct fou *fou_from_sock(struct sock *sk)
  51 {
  52         return sk->sk_user_data;
  53 }
  54
  55 static int fou_recv_pull(struct sk_buff *skb, struct fou *fou, size_t len)
  56 {
  57         /* Remove 'len' bytes from the packet (UDP header and
  58          * FOU header if present).
  59          */
  60         if (fou->family == AF_INET)
  61                 ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(skb)->tot_len) - len);
  62         else
  63                 ipv6_hdr(skb)->payload_len =
  64                     htons(ntohs(ipv6_hdr(skb)->payload_len) - len);
  65
  66         __skb_pull(skb, len);
  67         skb_postpull_rcsum(skb, udp_hdr(skb), len);
  68         skb_reset_transport_header(skb);
  69         return iptunnel_pull_offloads(skb);
  70 }
  71
  72 static int fou_udp_recv(struct sock *sk, struct sk_buff *skb)
  73 {
  74         struct fou *fou = fou_from_sock(sk);
  75
  76         if (!fou)
  77                 return 1;
  78
  79         if (fou_recv_pull(skb, fou, sizeof(struct udphdr)))
  80                 goto drop;
  81
  82         return -fou->protocol;
  83
  84 drop:
  85         kfree_skb(skb);
  86         return 0;
  87 }
  88
  89 static struct guehdr *gue_remcsum(struct sk_buff *skb, struct guehdr *guehdr,
  90                                   void *data, size_t hdrlen, u8 ipproto,
  91                                   bool nopartial)
  92 {
  93         __be16 *pd = data;
  94         size_t start = ntohs(pd[0]);
  95         size_t offset = ntohs(pd[1]);
  96         size_t plen = sizeof(struct udphdr) + hdrlen +
  97             max_t(size_t, offset + sizeof(u16), start);
  98
  99         if (skb->remcsum_offload)
 100                 return guehdr;
 101
 102         if (!pskb_may_pull(skb, plen))
 103                 return NULL;
 104         guehdr = (struct guehdr *)&udp_hdr(skb)[1];
 105
 106         skb_remcsum_process(skb, (void *)guehdr + hdrlen,
 107                             start, offset, nopartial);
 108
 109         return guehdr;
 110 }
 111
 112 static int gue_control_message(struct sk_buff *skb, struct guehdr *guehdr)
 113 {
 114         /* No support yet */
 115         kfree_skb(skb);
 116         return 0;
 117 }
 118
 119 static int gue_udp_recv(struct sock *sk, struct sk_buff *skb)
 120 {
 121         struct fou *fou = fou_from_sock(sk);
 122         size_t len, optlen, hdrlen;
 123         struct guehdr *guehdr;
 124         void *data;
 125         u16 doffset = 0;
 126         u8 proto_ctype;
 127
 128         if (!fou)
 129                 return 1;
 130
 131         len = sizeof(struct udphdr) + sizeof(struct guehdr);
 132         if (!pskb_may_pull(skb, len))
 133                 goto drop;
 134
 135         guehdr = (struct guehdr *)&udp_hdr(skb)[1];
 136
 137         switch (guehdr->version) {
 138         case 0: /* Full GUE header present */
 139                 break;
 140
 141         case 1: {
 142                 /* Direct encapsulation of IPv4 or IPv6 */
 143
 144                 int prot;
 145
 146                 switch (((struct iphdr *)guehdr)->version) {
 147                 case 4:
 148                         prot = IPPROTO_IPIP;
 149                         break;
 150                 case 6:
 151                         prot = IPPROTO_IPV6;
 152                         break;
 153                 default:
 154                         goto drop;
 155                 }
 156
 157                 if (fou_recv_pull(skb, fou, sizeof(struct udphdr)))
 158                         goto drop;
 159
 160                 return -prot;
 161         }
 162
 163         default: /* Undefined version */
 164                 goto drop;
 165         }
 166
 167         optlen = guehdr->hlen << 2;
 168         len += optlen;
 169
 170         if (!pskb_may_pull(skb, len))
 171                 goto drop;
 172
 173         /* guehdr may change after pull */
 174         guehdr = (struct guehdr *)&udp_hdr(skb)[1];
 175
 176         if (validate_gue_flags(guehdr, optlen))
 177                 goto drop;
 178
 179         hdrlen = sizeof(struct guehdr) + optlen;
 180
 181         if (fou->family == AF_INET)
 182                 ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(skb)->tot_len) - len);
 183         else
 184                 ipv6_hdr(skb)->payload_len =
 185                     htons(ntohs(ipv6_hdr(skb)->payload_len) - len);
 186
 187         /* Pull csum through the guehdr now . This can be used if
 188          * there is a remote checksum offload.
 189          */
 190         skb_postpull_rcsum(skb, udp_hdr(skb), len);
 191
 192         data = &guehdr[1];
 193
 194         if (guehdr->flags & GUE_FLAG_PRIV) {
 195                 __be32 flags = *(__be32 *)(data + doffset);
 196
 197                 doffset += GUE_LEN_PRIV;
 198
 199                 if (flags & GUE_PFLAG_REMCSUM) {
 200                         guehdr = gue_remcsum(skb, guehdr, data + doffset,
 201                                              hdrlen, guehdr->proto_ctype,
 202                                              !!(fou->flags &
 203                                                 FOU_F_REMCSUM_NOPARTIAL));
 204                         if (!guehdr)
 205                                 goto drop;
 206
 207                         data = &guehdr[1];
 208
 209                         doffset += GUE_PLEN_REMCSUM;
 210                 }
 211         }
 212
 213         if (unlikely(guehdr->control))
 214                 return gue_control_message(skb, guehdr);
 215
 216         proto_ctype = guehdr->proto_ctype;
 217         __skb_pull(skb, sizeof(struct udphdr) + hdrlen);
 218         skb_reset_transport_header(skb);
 219
 220         if (iptunnel_pull_offloads(skb))
 221                 goto drop;
 222
 223         return -proto_ctype;
 224
 225 drop:
 226         kfree_skb(skb);
 227         return 0;
 228 }
 229
 230 static struct sk_buff *fou_gro_receive(struct sock *sk,
 231                                        struct list_head *head,
 232                                        struct sk_buff *skb)
 233 {
 234         const struct net_offload __rcu **offloads;
 235         u8 proto = fou_from_sock(sk)->protocol;
 236         const struct net_offload *ops;
 237         struct sk_buff *pp = NULL;
 238
 239         /* We can clear the encap_mark for FOU as we are essentially doing
 240          * one of two possible things.  We are either adding an L4 tunnel
 241          * header to the outer L3 tunnel header, or we are simply
 242          * treating the GRE tunnel header as though it is a UDP protocol
 243          * specific header such as VXLAN or GENEVE.
 244          */
 245         NAPI_GRO_CB(skb)->encap_mark = 0;
 246
 247         /* Flag this frame as already having an outer encap header */
 248         NAPI_GRO_CB(skb)->is_fou = 1;
 249
 250         rcu_read_lock();
 251         offloads = NAPI_GRO_CB(skb)->is_ipv6 ? inet6_offloads : inet_offloads;
 252         ops = rcu_dereference(offloads[proto]);
 253         if (!ops || !ops->callbacks.gro_receive)
 254                 goto out_unlock;
 255
 256         pp = call_gro_receive(ops->callbacks.gro_receive, head, skb);
 257
 258 out_unlock:
 259         rcu_read_unlock();
 260
 261         return pp;
 262 }
 263
 264 static int fou_gro_complete(struct sock *sk, struct sk_buff *skb,
 265                             int nhoff)
 266 {
 267         const struct net_offload __rcu **offloads;
 268         u8 proto = fou_from_sock(sk)->protocol;
 269         const struct net_offload *ops;
 270         int err = -ENOSYS;
 271
 272         rcu_read_lock();
 273         offloads = NAPI_GRO_CB(skb)->is_ipv6 ? inet6_offloads : inet_offloads;
 274         ops = rcu_dereference(offloads[proto]);
 275         if (WARN_ON(!ops || !ops->callbacks.gro_complete))
 276                 goto out_unlock;
 277
 278         err = ops->callbacks.gro_complete(skb, nhoff);
 279
 280         skb_set_inner_mac_header(skb, nhoff);
 281
 282 out_unlock:
 283         rcu_read_unlock();
 284
 285         return err;
 286 }
 287
 288 static struct guehdr *gue_gro_remcsum(struct sk_buff *skb, unsigned int off,
 289                                       struct guehdr *guehdr, void *data,
 290                                       size_t hdrlen, struct gro_remcsum *grc,
 291                                       bool nopartial)
 292 {
 293         __be16 *pd = data;
 294         size_t start = ntohs(pd[0]);
 295         size_t offset = ntohs(pd[1]);
 296
 297         if (skb->remcsum_offload)
 298                 return guehdr;
 299
 300         if (!NAPI_GRO_CB(skb)->csum_valid)
 301                 return NULL;
 302
 303         guehdr = skb_gro_remcsum_process(skb, (void *)guehdr, off, hdrlen,
 304                                          start, offset, grc, nopartial);
 305
 306         skb->remcsum_offload = 1;
 307
 308         return guehdr;
 309 }
 310
 311 static struct sk_buff *gue_gro_receive(struct sock *sk,
 312                                        struct list_head *head,
 313                                        struct sk_buff *skb)
 314 {
 315         const struct net_offload __rcu **offloads;
 316         const struct net_offload *ops;
 317         struct sk_buff *pp = NULL;
 318         struct sk_buff *p;
 319         struct guehdr *guehdr;
 320         size_t len, optlen, hdrlen, off;
 321         void *data;
 322         u16 doffset = 0;
 323         int flush = 1;
 324         struct fou *fou = fou_from_sock(sk);
 325         struct gro_remcsum grc;
 326         u8 proto;
 327
 328         skb_gro_remcsum_init(&grc);
 329
 330         off = skb_gro_offset(skb);
 331         len = off + sizeof(*guehdr);
 332
 333         guehdr = skb_gro_header_fast(skb, off);
 334         if (skb_gro_header_hard(skb, len)) {
 335                 guehdr = skb_gro_header_slow(skb, len, off);
 336                 if (unlikely(!guehdr))
 337                         goto out;
 338         }
 339
 340         switch (guehdr->version) {
 341         case 0:
 342                 break;
 343         case 1:
 344                 switch (((struct iphdr *)guehdr)->version) {
 345                 case 4:
 346                         proto = IPPROTO_IPIP;
 347                         break;
 348                 case 6:
 349                         proto = IPPROTO_IPV6;
 350                         break;
 351                 default:
 352                         goto out;
 353                 }
 354                 goto next_proto;
 355         default:
 356                 goto out;
 357         }
 358
 359         optlen = guehdr->hlen << 2;
 360         len += optlen;
 361
 362         if (skb_gro_header_hard(skb, len)) {
 363                 guehdr = skb_gro_header_slow(skb, len, off);
 364                 if (unlikely(!guehdr))
 365                         goto out;
 366         }
 367
 368         if (unlikely(guehdr->control) || guehdr->version != 0 ||
 369             validate_gue_flags(guehdr, optlen))
 370                 goto out;
 371
 372         hdrlen = sizeof(*guehdr) + optlen;
 373
 374         /* Adjust NAPI_GRO_CB(skb)->csum to account for guehdr,
 375          * this is needed if there is a remote checkcsum offload.
 376          */
 377         skb_gro_postpull_rcsum(skb, guehdr, hdrlen);
 378
 379         data = &guehdr[1];
 380
 381         if (guehdr->flags & GUE_FLAG_PRIV) {
 382                 __be32 flags = *(__be32 *)(data + doffset);
 383
 384                 doffset += GUE_LEN_PRIV;
 385
 386                 if (flags & GUE_PFLAG_REMCSUM) {
 387                         guehdr = gue_gro_remcsum(skb, off, guehdr,
 388                                                  data + doffset, hdrlen, &grc,
 389                                                  !!(fou->flags &
 390                                                     FOU_F_REMCSUM_NOPARTIAL));
 391
 392                         if (!guehdr)
 393                                 goto out;
 394
 395                         data = &guehdr[1];
 396
 397                         doffset += GUE_PLEN_REMCSUM;
 398                 }
 399         }
 400
 401         skb_gro_pull(skb, hdrlen);
 402
 403         list_for_each_entry(p, head, list) {
 404                 const struct guehdr *guehdr2;
 405
 406                 if (!NAPI_GRO_CB(p)->same_flow)
 407                         continue;
 408
 409                 guehdr2 = (struct guehdr *)(p->data + off);
 410
 411                 /* Compare base GUE header to be equal (covers
 412                  * hlen, version, proto_ctype, and flags.
 413                  */
 414                 if (guehdr->word != guehdr2->word) {
 415                         NAPI_GRO_CB(p)->same_flow = 0;
 416                         continue;
 417                 }
 418
 419                 /* Compare optional fields are the same. */
 420                 if (guehdr->hlen && memcmp(&guehdr[1], &guehdr2[1],
 421                                            guehdr->hlen << 2)) {
 422                         NAPI_GRO_CB(p)->same_flow = 0;
 423                         continue;
 424                 }
 425         }
 426
 427         proto = guehdr->proto_ctype;
 428
 429 next_proto:
 430
 431         /* We can clear the encap_mark for GUE as we are essentially doing
 432          * one of two possible things.  We are either adding an L4 tunnel
 433          * header to the outer L3 tunnel header, or we are simply
 434          * treating the GRE tunnel header as though it is a UDP protocol
 435          * specific header such as VXLAN or GENEVE.
 436          */
 437         NAPI_GRO_CB(skb)->encap_mark = 0;
 438
 439         /* Flag this frame as already having an outer encap header */
 440         NAPI_GRO_CB(skb)->is_fou = 1;
 441
 442         rcu_read_lock();
 443         offloads = NAPI_GRO_CB(skb)->is_ipv6 ? inet6_offloads : inet_offloads;
 444         ops = rcu_dereference(offloads[proto]);
 445         if (WARN_ON_ONCE(!ops || !ops->callbacks.gro_receive))
 446                 goto out_unlock;
 447
 448         pp = call_gro_receive(ops->callbacks.gro_receive, head, skb);
 449         flush = 0;
 450
 451 out_unlock:
 452         rcu_read_unlock();
 453 out:
 454         skb_gro_flush_final_remcsum(skb, pp, flush, &grc);
 455
 456         return pp;
 457 }
 458
 459 static int gue_gro_complete(struct sock *sk, struct sk_buff *skb, int nhoff)
 460 {
 461         struct guehdr *guehdr = (struct guehdr *)(skb->data + nhoff);
 462         const struct net_offload __rcu **offloads;
 463         const struct net_offload *ops;
 464         unsigned int guehlen = 0;
 465         u8 proto;
 466         int err = -ENOENT;
 467
 468         switch (guehdr->version) {
 469         case 0:
 470                 proto = guehdr->proto_ctype;
 471                 guehlen = sizeof(*guehdr) + (guehdr->hlen << 2);
 472                 break;
 473         case 1:
 474                 switch (((struct iphdr *)guehdr)->version) {
 475                 case 4:
 476                         proto = IPPROTO_IPIP;
 477                         break;
 478                 case 6:
 479                         proto = IPPROTO_IPV6;
 480                         break;
 481                 default:
 482                         return err;
 483                 }
 484                 break;
 485         default:
 486                 return err;
 487         }
 488
 489         rcu_read_lock();
 490         offloads = NAPI_GRO_CB(skb)->is_ipv6 ? inet6_offloads : inet_offloads;
 491         ops = rcu_dereference(offloads[proto]);
 492         if (WARN_ON(!ops || !ops->callbacks.gro_complete))
 493                 goto out_unlock;
 494
 495         err = ops->callbacks.gro_complete(skb, nhoff + guehlen);
 496
 497         skb_set_inner_mac_header(skb, nhoff + guehlen);
 498
 499 out_unlock:
 500         rcu_read_unlock();
 501         return err;
 502 }
 503
 504 static bool fou_cfg_cmp(struct fou *fou, struct fou_cfg *cfg)
 505 {
 506         struct sock *sk = fou->sock->sk;
 507         struct udp_port_cfg *udp_cfg = &cfg->udp_config;
 508
 509         if (fou->family != udp_cfg->family ||
 510             fou->port != udp_cfg->local_udp_port ||
 511             sk->sk_dport != udp_cfg->peer_udp_port ||
 512             sk->sk_bound_dev_if != udp_cfg->bind_ifindex)
 513                 return false;
 514
 515         if (fou->family == AF_INET) {
 516                 if (sk->sk_rcv_saddr != udp_cfg->local_ip.s_addr ||
 517                     sk->sk_daddr != udp_cfg->peer_ip.s_addr)
 518                         return false;
 519                 else
 520                         return true;
 521 #if IS_ENABLED(CONFIG_IPV6)
 522         } else {
 523                 if (ipv6_addr_cmp(&sk->sk_v6_rcv_saddr, &udp_cfg->local_ip6) ||
 524                     ipv6_addr_cmp(&sk->sk_v6_daddr, &udp_cfg->peer_ip6))
 525                         return false;
 526                 else
 527                         return true;
 528 #endif
 529         }
 530
 531         return false;
 532 }
 533
 534 static int fou_add_to_port_list(struct net *net, struct fou *fou,
 535                                 struct fou_cfg *cfg)
 536 {
 537         struct fou_net *fn = net_generic(net, fou_net_id);
 538         struct fou *fout;
 539
 540         mutex_lock(&fn->fou_lock);
 541         list_for_each_entry(fout, &fn->fou_list, list) {
 542                 if (fou_cfg_cmp(fout, cfg)) {
 543                         mutex_unlock(&fn->fou_lock);
 544                         return -EALREADY;
 545                 }
 546         }
 547
 548         list_add(&fou->list, &fn->fou_list);
 549         mutex_unlock(&fn->fou_lock);
 550
 551         return 0;
 552 }
 553
 554 static void fou_release(struct fou *fou)
 555 {
 556         struct socket *sock = fou->sock;
 557
 558         list_del(&fou->list);
 559         udp_tunnel_sock_release(sock);
 560
 561         kfree_rcu(fou, rcu);
 562 }
 563
 564 static int fou_create(struct net *net, struct fou_cfg *cfg,
 565                       struct socket **sockp)
 566 {
 567         struct socket *sock = NULL;
 568         struct fou *fou = NULL;
 569         struct sock *sk;
 570         struct udp_tunnel_sock_cfg tunnel_cfg;
 571         int err;
 572
 573         /* Open UDP socket */
 574         err = udp_sock_create(net, &cfg->udp_config, &sock);
 575         if (err < 0)
 576                 goto error;
 577
 578         /* Allocate FOU port structure */
 579         fou = kzalloc(sizeof(*fou), GFP_KERNEL);
 580         if (!fou) {
 581                 err = -ENOMEM;
 582                 goto error;
 583         }
 584
 585         sk = sock->sk;
 586
 587         fou->port = cfg->udp_config.local_udp_port;
 588         fou->family = cfg->udp_config.family;
 589         fou->flags = cfg->flags;
 590         fou->type = cfg->type;
 591         fou->sock = sock;
 592
 593         memset(&tunnel_cfg, 0, sizeof(tunnel_cfg));
 594         tunnel_cfg.encap_type = 1;
 595         tunnel_cfg.sk_user_data = fou;
 596         tunnel_cfg.encap_destroy = NULL;
 597
 598         /* Initial for fou type */
 599         switch (cfg->type) {
 600         case FOU_ENCAP_DIRECT:
 601                 tunnel_cfg.encap_rcv = fou_udp_recv;
 602                 tunnel_cfg.gro_receive = fou_gro_receive;
 603                 tunnel_cfg.gro_complete = fou_gro_complete;
 604                 fou->protocol = cfg->protocol;
 605                 break;
 606         case FOU_ENCAP_GUE:
 607                 tunnel_cfg.encap_rcv = gue_udp_recv;
 608                 tunnel_cfg.gro_receive = gue_gro_receive;
 609                 tunnel_cfg.gro_complete = gue_gro_complete;
 610                 break;
 611         default:
 612                 err = -EINVAL;
 613                 goto error;
 614         }
 615
 616         setup_udp_tunnel_sock(net, sock, &tunnel_cfg);
 617
 618         sk->sk_allocation = GFP_ATOMIC;
 619
 620         err = fou_add_to_port_list(net, fou, cfg);
 621         if (err)
 622                 goto error;
 623
 624         if (sockp)
 625                 *sockp = sock;
 626
 627         return 0;
 628
 629 error:
 630         kfree(fou);
 631         if (sock)
 632                 udp_tunnel_sock_release(sock);
 633
 634         return err;
 635 }
 636
 637 static int fou_destroy(struct net *net, struct fou_cfg *cfg)
 638 {
 639         struct fou_net *fn = net_generic(net, fou_net_id);
 640         int err = -EINVAL;
 641         struct fou *fou;
 642
 643         mutex_lock(&fn->fou_lock);
 644         list_for_each_entry(fou, &fn->fou_list, list) {
 645                 if (fou_cfg_cmp(fou, cfg)) {
 646                         fou_release(fou);
 647                         err = 0;
 648                         break;
 649                 }
 650         }
 651         mutex_unlock(&fn->fou_lock);
 652
 653         return err;
 654 }
 655
 656 static struct genl_family fou_nl_family;
 657
 658 static const struct nla_policy fou_nl_policy[FOU_ATTR_MAX + 1] = {
 659         [FOU_ATTR_PORT]                 = { .type = NLA_U16, },
 660         [FOU_ATTR_AF]                   = { .type = NLA_U8, },
 661         [FOU_ATTR_IPPROTO]              = { .type = NLA_U8, },
 662         [FOU_ATTR_TYPE]                 = { .type = NLA_U8, },
 663         [FOU_ATTR_REMCSUM_NOPARTIAL]    = { .type = NLA_FLAG, },
 664         [FOU_ATTR_LOCAL_V4]             = { .type = NLA_U32, },
 665         [FOU_ATTR_PEER_V4]              = { .type = NLA_U32, },
 666         [FOU_ATTR_LOCAL_V6]             = { .len = sizeof(struct in6_addr), },
 667         [FOU_ATTR_PEER_V6]              = { .len = sizeof(struct in6_addr), },
 668         [FOU_ATTR_PEER_PORT]            = { .type = NLA_U16, },
 669         [FOU_ATTR_IFINDEX]              = { .type = NLA_S32, },
 670 };
 671
 672 static int parse_nl_config(struct genl_info *info,
 673                            struct fou_cfg *cfg)
 674 {
 675         bool has_local = false, has_peer = false;
 676         struct nlattr *attr;
 677         int ifindex;
 678         __be16 port;
 679
 680         memset(cfg, 0, sizeof(*cfg));
 681
 682         cfg->udp_config.family = AF_INET;
 683
 684         if (info->attrs[FOU_ATTR_AF]) {
 685                 u8 family = nla_get_u8(info->attrs[FOU_ATTR_AF]);
 686
 687                 switch (family) {
 688                 case AF_INET:
 689                         break;
 690                 case AF_INET6:
 691                         cfg->udp_config.ipv6_v6only = 1;
 692                         break;
 693                 default:
 694                         return -EAFNOSUPPORT;
 695                 }
 696
 697                 cfg->udp_config.family = family;
 698         }
 699
 700         if (info->attrs[FOU_ATTR_PORT]) {
 701                 port = nla_get_be16(info->attrs[FOU_ATTR_PORT]);
 702                 cfg->udp_config.local_udp_port = port;
 703         }
 704
 705         if (info->attrs[FOU_ATTR_IPPROTO])
 706                 cfg->protocol = nla_get_u8(info->attrs[FOU_ATTR_IPPROTO]);
 707
 708         if (info->attrs[FOU_ATTR_TYPE])
 709                 cfg->type = nla_get_u8(info->attrs[FOU_ATTR_TYPE]);
 710
 711         if (info->attrs[FOU_ATTR_REMCSUM_NOPARTIAL])
 712                 cfg->flags |= FOU_F_REMCSUM_NOPARTIAL;
 713
 714         if (cfg->udp_config.family == AF_INET) {
 715                 if (info->attrs[FOU_ATTR_LOCAL_V4]) {
 716                         attr = info->attrs[FOU_ATTR_LOCAL_V4];
 717                         cfg->udp_config.local_ip.s_addr = nla_get_in_addr(attr);
 718                         has_local = true;
 719                 }
 720
 721                 if (info->attrs[FOU_ATTR_PEER_V4]) {
 722                         attr = info->attrs[FOU_ATTR_PEER_V4];
 723                         cfg->udp_config.peer_ip.s_addr = nla_get_in_addr(attr);
 724                         has_peer = true;
 725                 }
 726 #if IS_ENABLED(CONFIG_IPV6)
 727         } else {
 728                 if (info->attrs[FOU_ATTR_LOCAL_V6]) {
 729                         attr = info->attrs[FOU_ATTR_LOCAL_V6];
 730                         cfg->udp_config.local_ip6 = nla_get_in6_addr(attr);
 731                         has_local = true;
 732                 }
 733
 734                 if (info->attrs[FOU_ATTR_PEER_V6]) {
 735                         attr = info->attrs[FOU_ATTR_PEER_V6];
 736                         cfg->udp_config.peer_ip6 = nla_get_in6_addr(attr);
 737                         has_peer = true;
 738                 }
 739 #endif
 740         }
 741
 742         if (has_peer) {
 743                 if (info->attrs[FOU_ATTR_PEER_PORT]) {
 744                         port = nla_get_be16(info->attrs[FOU_ATTR_PEER_PORT]);
 745                         cfg->udp_config.peer_udp_port = port;
 746                 } else {
 747                         return -EINVAL;
 748                 }
 749         }
 750
 751         if (info->attrs[FOU_ATTR_IFINDEX]) {
 752                 if (!has_local)
 753                         return -EINVAL;
 754
 755                 ifindex = nla_get_s32(info->attrs[FOU_ATTR_IFINDEX]);
 756
 757                 cfg->udp_config.bind_ifindex = ifindex;
 758         }
 759
 760         return 0;
 761 }
 762
 763 static int fou_nl_cmd_add_port(struct sk_buff *skb, struct genl_info *info)
 764 {
 765         struct net *net = genl_info_net(info);
 766         struct fou_cfg cfg;
 767         int err;
 768
 769         err = parse_nl_config(info, &cfg);
 770         if (err)
 771                 return err;
 772
 773         return fou_create(net, &cfg, NULL);
 774 }
 775
 776 static int fou_nl_cmd_rm_port(struct sk_buff *skb, struct genl_info *info)
 777 {
 778         struct net *net = genl_info_net(info);
 779         struct fou_cfg cfg;
 780         int err;
 781
 782         err = parse_nl_config(info, &cfg);
 783         if (err)
 784                 return err;
 785
 786         return fou_destroy(net, &cfg);
 787 }
 788
 789 static int fou_fill_info(struct fou *fou, struct sk_buff *msg)
 790 {
 791         struct sock *sk = fou->sock->sk;
 792
 793         if (nla_put_u8(msg, FOU_ATTR_AF, fou->sock->sk->sk_family) ||
 794             nla_put_be16(msg, FOU_ATTR_PORT, fou->port) ||
 795             nla_put_be16(msg, FOU_ATTR_PEER_PORT, sk->sk_dport) ||
 796             nla_put_u8(msg, FOU_ATTR_IPPROTO, fou->protocol) ||
 797             nla_put_u8(msg, FOU_ATTR_TYPE, fou->type) ||
 798             nla_put_s32(msg, FOU_ATTR_IFINDEX, sk->sk_bound_dev_if))
 799                 return -1;
 800
 801         if (fou->flags & FOU_F_REMCSUM_NOPARTIAL)
 802                 if (nla_put_flag(msg, FOU_ATTR_REMCSUM_NOPARTIAL))
 803                         return -1;
 804
 805         if (fou->sock->sk->sk_family == AF_INET) {
 806                 if (nla_put_in_addr(msg, FOU_ATTR_LOCAL_V4, sk->sk_rcv_saddr))
 807                         return -1;
 808
 809                 if (nla_put_in_addr(msg, FOU_ATTR_PEER_V4, sk->sk_daddr))
 810                         return -1;
 811 #if IS_ENABLED(CONFIG_IPV6)
 812         } else {
 813                 if (nla_put_in6_addr(msg, FOU_ATTR_LOCAL_V6,
 814                                      &sk->sk_v6_rcv_saddr))
 815                         return -1;
 816
 817                 if (nla_put_in6_addr(msg, FOU_ATTR_PEER_V6, &sk->sk_v6_daddr))
 818                         return -1;
 819 #endif
 820         }
 821
 822         return 0;
 823 }
 824
 825 static int fou_dump_info(struct fou *fou, u32 portid, u32 seq,
 826                          u32 flags, struct sk_buff *skb, u8 cmd)
 827 {
 828         void *hdr;
 829
 830         hdr = genlmsg_put(skb, portid, seq, &fou_nl_family, flags, cmd);
 831         if (!hdr)
 832                 return -ENOMEM;
 833
 834         if (fou_fill_info(fou, skb) < 0)
 835                 goto nla_put_failure;
 836
 837         genlmsg_end(skb, hdr);
 838         return 0;
 839
 840 nla_put_failure:
 841         genlmsg_cancel(skb, hdr);
 842         return -EMSGSIZE;
 843 }
 844
 845 static int fou_nl_cmd_get_port(struct sk_buff *skb, struct genl_info *info)
 846 {
 847         struct net *net = genl_info_net(info);
 848         struct fou_net *fn = net_generic(net, fou_net_id);
 849         struct sk_buff *msg;
 850         struct fou_cfg cfg;
 851         struct fou *fout;
 852         __be16 port;
 853         u8 family;
 854         int ret;
 855
 856         ret = parse_nl_config(info, &cfg);
 857         if (ret)
 858                 return ret;
 859         port = cfg.udp_config.local_udp_port;
 860         if (port == 0)
 861                 return -EINVAL;
 862
 863         family = cfg.udp_config.family;
 864         if (family != AF_INET && family != AF_INET6)
 865                 return -EINVAL;
 866
 867         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 868         if (!msg)
 869                 return -ENOMEM;
 870
 871         ret = -ESRCH;
 872         mutex_lock(&fn->fou_lock);
 873         list_for_each_entry(fout, &fn->fou_list, list) {
 874                 if (fou_cfg_cmp(fout, &cfg)) {
 875                         ret = fou_dump_info(fout, info->snd_portid,
 876                                             info->snd_seq, 0, msg,
 877                                             info->genlhdr->cmd);
 878                         break;
 879                 }
 880         }
 881         mutex_unlock(&fn->fou_lock);
 882         if (ret < 0)
 883                 goto out_free;
 884
 885         return genlmsg_reply(msg, info);
 886
 887 out_free:
 888         nlmsg_free(msg);
 889         return ret;
 890 }
 891
 892 static int fou_nl_dump(struct sk_buff *skb, struct netlink_callback *cb)
 893 {
 894         struct net *net = sock_net(skb->sk);
 895         struct fou_net *fn = net_generic(net, fou_net_id);
 896         struct fou *fout;
 897         int idx = 0, ret;
 898
 899         mutex_lock(&fn->fou_lock);
 900         list_for_each_entry(fout, &fn->fou_list, list) {
 901                 if (idx++ < cb->args[0])
 902                         continue;
 903                 ret = fou_dump_info(fout, NETLINK_CB(cb->skb).portid,
 904                                     cb->nlh->nlmsg_seq, NLM_F_MULTI,
 905                                     skb, FOU_CMD_GET);
 906                 if (ret)
 907                         break;
 908         }
 909         mutex_unlock(&fn->fou_lock);
 910
 911         cb->args[0] = idx;
 912         return skb->len;
 913 }
 914
 915 static const struct genl_small_ops fou_nl_ops[] = {
 916         {
 917                 .cmd = FOU_CMD_ADD,
 918                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
 919                 .doit = fou_nl_cmd_add_port,
 920                 .flags = GENL_ADMIN_PERM,
 921         },
 922         {
 923                 .cmd = FOU_CMD_DEL,
 924                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
 925                 .doit = fou_nl_cmd_rm_port,
 926                 .flags = GENL_ADMIN_PERM,
 927         },
 928         {
 929                 .cmd = FOU_CMD_GET,
 930                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
 931                 .doit = fou_nl_cmd_get_port,
 932                 .dumpit = fou_nl_dump,
 933         },
 934 };
 935
 936 static struct genl_family fou_nl_family __ro_after_init = {
 937         .hdrsize        = 0,
 938         .name           = FOU_GENL_NAME,
 939         .version        = FOU_GENL_VERSION,
 940         .maxattr        = FOU_ATTR_MAX,
 941         .policy = fou_nl_policy,
 942         .netnsok        = true,
 943         .module         = THIS_MODULE,
 944         .small_ops      = fou_nl_ops,
 945         .n_small_ops    = ARRAY_SIZE(fou_nl_ops),
 946 };
 947
 948 size_t fou_encap_hlen(struct ip_tunnel_encap *e)
 949 {
 950         return sizeof(struct udphdr);
 951 }
 952 EXPORT_SYMBOL(fou_encap_hlen);
 953
 954 size_t gue_encap_hlen(struct ip_tunnel_encap *e)
 955 {
 956         size_t len;
 957         bool need_priv = false;
 958
 959         len = sizeof(struct udphdr) + sizeof(struct guehdr);
 960
 961         if (e->flags & TUNNEL_ENCAP_FLAG_REMCSUM) {
 962                 len += GUE_PLEN_REMCSUM;
 963                 need_priv = true;
 964         }
 965
 966         len += need_priv ? GUE_LEN_PRIV : 0;
 967
 968         return len;
 969 }
 970 EXPORT_SYMBOL(gue_encap_hlen);
 971
 972 int __fou_build_header(struct sk_buff *skb, struct ip_tunnel_encap *e,
 973                        u8 *protocol, __be16 *sport, int type)
 974 {
 975         int err;
 976
 977         err = iptunnel_handle_offloads(skb, type);
 978         if (err)
 979                 return err;
 980
 981         *sport = e->sport ? : udp_flow_src_port(dev_net(skb->dev),
 982                                                 skb, 0, 0, false);
 983
 984         return 0;
 985 }
 986 EXPORT_SYMBOL(__fou_build_header);
 987
 988 int __gue_build_header(struct sk_buff *skb, struct ip_tunnel_encap *e,
 989                        u8 *protocol, __be16 *sport, int type)
 990 {
 991         struct guehdr *guehdr;
 992         size_t hdrlen, optlen = 0;
 993         void *data;
 994         bool need_priv = false;
 995         int err;
 996
 997         if ((e->flags & TUNNEL_ENCAP_FLAG_REMCSUM) &&
 998             skb->ip_summed == CHECKSUM_PARTIAL) {
 999                 optlen += GUE_PLEN_REMCSUM;
1000                 type |= SKB_GSO_TUNNEL_REMCSUM;
1001                 need_priv = true;
1002         }
1003
1004         optlen += need_priv ? GUE_LEN_PRIV : 0;
1005
1006         err = iptunnel_handle_offloads(skb, type);
1007         if (err)
1008                 return err;
1009
1010         /* Get source port (based on flow hash) before skb_push */
1011         *sport = e->sport ? : udp_flow_src_port(dev_net(skb->dev),
1012                                                 skb, 0, 0, false);
1013
1014         hdrlen = sizeof(struct guehdr) + optlen;
1015
1016         skb_push(skb, hdrlen);
1017
1018         guehdr = (struct guehdr *)skb->data;
1019
1020         guehdr->control = 0;
1021         guehdr->version = 0;
1022         guehdr->hlen = optlen >> 2;
1023         guehdr->flags = 0;
1024         guehdr->proto_ctype = *protocol;
1025
1026         data = &guehdr[1];
1027
1028         if (need_priv) {
1029                 __be32 *flags = data;
1030
1031                 guehdr->flags |= GUE_FLAG_PRIV;
1032                 *flags = 0;
1033                 data += GUE_LEN_PRIV;
1034
1035                 if (type & SKB_GSO_TUNNEL_REMCSUM) {
1036                         u16 csum_start = skb_checksum_start_offset(skb);
1037                         __be16 *pd = data;
1038
1039                         if (csum_start < hdrlen)
1040                                 return -EINVAL;
1041
1042                         csum_start -= hdrlen;
1043                         pd[0] = htons(csum_start);
1044                         pd[1] = htons(csum_start + skb->csum_offset);
1045
1046                         if (!skb_is_gso(skb)) {
1047                                 skb->ip_summed = CHECKSUM_NONE;
1048                                 skb->encapsulation = 0;
1049                         }
1050
1051                         *flags |= GUE_PFLAG_REMCSUM;
1052                         data += GUE_PLEN_REMCSUM;
1053                 }
1054
1055         }
1056
1057         return 0;
1058 }
1059 EXPORT_SYMBOL(__gue_build_header);
1060
1061 #ifdef CONFIG_NET_FOU_IP_TUNNELS
1062
1063 static void fou_build_udp(struct sk_buff *skb, struct ip_tunnel_encap *e,
1064                           struct flowi4 *fl4, u8 *protocol, __be16 sport)
1065 {
1066         struct udphdr *uh;
1067
1068         skb_push(skb, sizeof(struct udphdr));
1069         skb_reset_transport_header(skb);
1070
1071         uh = udp_hdr(skb);
1072
1073         uh->dest = e->dport;
1074         uh->source = sport;
1075         uh->len = htons(skb->len);
1076         udp_set_csum(!(e->flags & TUNNEL_ENCAP_FLAG_CSUM), skb,
1077                      fl4->saddr, fl4->daddr, skb->len);
1078
1079         *protocol = IPPROTO_UDP;
1080 }
1081
1082 static int fou_build_header(struct sk_buff *skb, struct ip_tunnel_encap *e,
1083                             u8 *protocol, struct flowi4 *fl4)
1084 {
1085         int type = e->flags & TUNNEL_ENCAP_FLAG_CSUM ? SKB_GSO_UDP_TUNNEL_CSUM :
1086                                                        SKB_GSO_UDP_TUNNEL;
1087         __be16 sport;
1088         int err;
1089
1090         err = __fou_build_header(skb, e, protocol, &sport, type);
1091         if (err)
1092                 return err;
1093
1094         fou_build_udp(skb, e, fl4, protocol, sport);
1095
1096         return 0;
1097 }
1098
1099 static int gue_build_header(struct sk_buff *skb, struct ip_tunnel_encap *e,
1100                             u8 *protocol, struct flowi4 *fl4)
1101 {
1102         int type = e->flags & TUNNEL_ENCAP_FLAG_CSUM ? SKB_GSO_UDP_TUNNEL_CSUM :
1103                                                        SKB_GSO_UDP_TUNNEL;
1104         __be16 sport;
1105         int err;
1106
1107         err = __gue_build_header(skb, e, protocol, &sport, type);
1108         if (err)
1109                 return err;
1110
1111         fou_build_udp(skb, e, fl4, protocol, sport);
1112
1113         return 0;
1114 }
1115
1116 static int gue_err_proto_handler(int proto, struct sk_buff *skb, u32 info)
1117 {
1118         const struct net_protocol *ipprot = rcu_dereference(inet_protos[proto]);
1119
1120         if (ipprot && ipprot->err_handler) {
1121                 if (!ipprot->err_handler(skb, info))
1122                         return 0;
1123         }
1124
1125         return -ENOENT;
1126 }
1127
1128 static int gue_err(struct sk_buff *skb, u32 info)
1129 {
1130         int transport_offset = skb_transport_offset(skb);
1131         struct guehdr *guehdr;
1132         size_t len, optlen;
1133         int ret;
1134
1135         len = sizeof(struct udphdr) + sizeof(struct guehdr);
1136         if (!pskb_may_pull(skb, transport_offset + len))
1137                 return -EINVAL;
1138
1139         guehdr = (struct guehdr *)&udp_hdr(skb)[1];
1140
1141         switch (guehdr->version) {
1142         case 0: /* Full GUE header present */
1143                 break;
1144         case 1: {
1145                 /* Direct encapsulation of IPv4 or IPv6 */
1146                 skb_set_transport_header(skb, -(int)sizeof(struct icmphdr));
1147
1148                 switch (((struct iphdr *)guehdr)->version) {
1149                 case 4:
1150                         ret = gue_err_proto_handler(IPPROTO_IPIP, skb, info);
1151                         goto out;
1152 #if IS_ENABLED(CONFIG_IPV6)
1153                 case 6:
1154                         ret = gue_err_proto_handler(IPPROTO_IPV6, skb, info);
1155                         goto out;
1156 #endif
1157                 default:
1158                         ret = -EOPNOTSUPP;
1159                         goto out;
1160                 }
1161         }
1162         default: /* Undefined version */
1163                 return -EOPNOTSUPP;
1164         }
1165
1166         if (guehdr->control)
1167                 return -ENOENT;
1168
1169         optlen = guehdr->hlen << 2;
1170
1171         if (!pskb_may_pull(skb, transport_offset + len + optlen))
1172                 return -EINVAL;
1173
1174         guehdr = (struct guehdr *)&udp_hdr(skb)[1];
1175         if (validate_gue_flags(guehdr, optlen))
1176                 return -EINVAL;
1177
1178         /* Handling exceptions for direct UDP encapsulation in GUE would lead to
1179          * recursion. Besides, this kind of encapsulation can't even be
1180          * configured currently. Discard this.
1181          */
1182         if (guehdr->proto_ctype == IPPROTO_UDP ||
1183             guehdr->proto_ctype == IPPROTO_UDPLITE)
1184                 return -EOPNOTSUPP;
1185
1186         skb_set_transport_header(skb, -(int)sizeof(struct icmphdr));
1187         ret = gue_err_proto_handler(guehdr->proto_ctype, skb, info);
1188
1189 out:
1190         skb_set_transport_header(skb, transport_offset);
1191         return ret;
1192 }
1193
1194
1195 static const struct ip_tunnel_encap_ops fou_iptun_ops = {
1196         .encap_hlen = fou_encap_hlen,
1197         .build_header = fou_build_header,
1198         .err_handler = gue_err,
1199 };
1200
1201 static const struct ip_tunnel_encap_ops gue_iptun_ops = {
1202         .encap_hlen = gue_encap_hlen,
1203         .build_header = gue_build_header,
1204         .err_handler = gue_err,
1205 };
1206
1207 static int ip_tunnel_encap_add_fou_ops(void)
1208 {
1209         int ret;
1210
1211         ret = ip_tunnel_encap_add_ops(&fou_iptun_ops, TUNNEL_ENCAP_FOU);
1212         if (ret < 0) {
1213                 pr_err("can't add fou ops\n");
1214                 return ret;
1215         }
1216
1217         ret = ip_tunnel_encap_add_ops(&gue_iptun_ops, TUNNEL_ENCAP_GUE);
1218         if (ret < 0) {
1219                 pr_err("can't add gue ops\n");
1220                 ip_tunnel_encap_del_ops(&fou_iptun_ops, TUNNEL_ENCAP_FOU);
1221                 return ret;
1222         }
1223
1224         return 0;
1225 }
1226
1227 static void ip_tunnel_encap_del_fou_ops(void)
1228 {
1229         ip_tunnel_encap_del_ops(&fou_iptun_ops, TUNNEL_ENCAP_FOU);
1230         ip_tunnel_encap_del_ops(&gue_iptun_ops, TUNNEL_ENCAP_GUE);
1231 }
1232
1233 #else
1234
1235 static int ip_tunnel_encap_add_fou_ops(void)
1236 {
1237         return 0;
1238 }
1239
1240 static void ip_tunnel_encap_del_fou_ops(void)
1241 {
1242 }
1243
1244 #endif
1245
1246 static __net_init int fou_init_net(struct net *net)
1247 {
1248         struct fou_net *fn = net_generic(net, fou_net_id);
1249
1250         INIT_LIST_HEAD(&fn->fou_list);
1251         mutex_init(&fn->fou_lock);
1252         return 0;
1253 }
1254
1255 static __net_exit void fou_exit_net(struct net *net)
1256 {
1257         struct fou_net *fn = net_generic(net, fou_net_id);
1258         struct fou *fou, *next;
1259
1260         /* Close all the FOU sockets */
1261         mutex_lock(&fn->fou_lock);
1262         list_for_each_entry_safe(fou, next, &fn->fou_list, list)
1263                 fou_release(fou);
1264         mutex_unlock(&fn->fou_lock);
1265 }
1266
1267 static struct pernet_operations fou_net_ops = {
1268         .init = fou_init_net,
1269         .exit = fou_exit_net,
1270         .id   = &fou_net_id,
1271         .size = sizeof(struct fou_net),
1272 };
1273
1274 static int __init fou_init(void)
1275 {
1276         int ret;
1277
1278         ret = register_pernet_device(&fou_net_ops);
1279         if (ret)
1280                 goto exit;
1281
1282         ret = genl_register_family(&fou_nl_family);
1283         if (ret < 0)
1284                 goto unregister;
1285
1286         ret = ip_tunnel_encap_add_fou_ops();
1287         if (ret == 0)
1288                 return 0;
1289
1290         genl_unregister_family(&fou_nl_family);
1291 unregister:
1292         unregister_pernet_device(&fou_net_ops);
1293 exit:
1294         return ret;
1295 }
1296
1297 static void __exit fou_fini(void)
1298 {
1299         ip_tunnel_encap_del_fou_ops();
1300         genl_unregister_family(&fou_nl_family);
1301         unregister_pernet_device(&fou_net_ops);
1302 }
1303
1304 module_init(fou_init);
1305 module_exit(fou_fini);
1306 MODULE_AUTHOR("Tom Herbert <[email protected]>");
1307 MODULE_LICENSE("GPL");
1308 MODULE_DESCRIPTION("Foo over UDP");