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