// SPDX-License-Identifier: GPL-2.0-only

  #include <linux/module.h>
  #include <linux/errno.h>
  #include <linux/socket.h>
  #include <linux/skbuff.h>
  #include <linux/ip.h>
  #include <linux/udp.h>

  #include <linux/icmpv6.h>

  #include <linux/types.h>
  #include <linux/kernel.h>
  #include <net/fou.h>
  #include <net/ip.h>
  #include <net/ip6_tunnel.h>
  #include <net/ip6_checksum.h>
  #include <net/protocol.h>
  #include <net/udp.h>
  #include <net/udp_tunnel.h>

  #if IS_ENABLED(CONFIG_IPV6_FOU_TUNNEL)

  static void fou6_build_udp(struct sk_buff *skb, struct ip_tunnel_encap *e,
  			   struct flowi6 *fl6, u8 *protocol, __be16 sport)
  {
  	struct udphdr *uh;
  
  	skb_push(skb, sizeof(struct udphdr));
  	skb_reset_transport_header(skb);
  
  	uh = udp_hdr(skb);
  
  	uh->dest = e->dport;
  	uh->source = sport;
  	uh->len = htons(skb->len);
  	udp6_set_csum(!(e->flags & TUNNEL_ENCAP_FLAG_CSUM6), skb,
  		      &fl6->saddr, &fl6->daddr, skb->len);
  
  	*protocol = IPPROTO_UDP;
  }

  static int fou6_build_header(struct sk_buff *skb, struct ip_tunnel_encap *e,
  			     u8 *protocol, struct flowi6 *fl6)

  {
  	__be16 sport;
  	int err;
  	int type = e->flags & TUNNEL_ENCAP_FLAG_CSUM6 ?
  		SKB_GSO_UDP_TUNNEL_CSUM : SKB_GSO_UDP_TUNNEL;
  
  	err = __fou_build_header(skb, e, protocol, &sport, type);
  	if (err)
  		return err;
  
  	fou6_build_udp(skb, e, fl6, protocol, sport);
  
  	return 0;
  }

  static int gue6_build_header(struct sk_buff *skb, struct ip_tunnel_encap *e,
  			     u8 *protocol, struct flowi6 *fl6)

  {
  	__be16 sport;
  	int err;
  	int type = e->flags & TUNNEL_ENCAP_FLAG_CSUM6 ?
  		SKB_GSO_UDP_TUNNEL_CSUM : SKB_GSO_UDP_TUNNEL;
  
  	err = __gue_build_header(skb, e, protocol, &sport, type);
  	if (err)
  		return err;
  
  	fou6_build_udp(skb, e, fl6, protocol, sport);
  
  	return 0;
  }

  static int gue6_err_proto_handler(int proto, struct sk_buff *skb,
  				  struct inet6_skb_parm *opt,

  				  u8 type, u8 code, int offset, __be32 info)

  {
  	const struct inet6_protocol *ipprot;
  
  	ipprot = rcu_dereference(inet6_protos[proto]);
  	if (ipprot && ipprot->err_handler) {
  		if (!ipprot->err_handler(skb, opt, type, code, offset, info))
  			return 0;
  	}
  
  	return -ENOENT;
  }
  
  static int gue6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
  		    u8 type, u8 code, int offset, __be32 info)
  {
  	int transport_offset = skb_transport_offset(skb);
  	struct guehdr *guehdr;

  	size_t len, optlen;

  	int ret;

  	len = sizeof(struct udphdr) + sizeof(struct guehdr);

  	if (!pskb_may_pull(skb, transport_offset + len))

  		return -EINVAL;
  
  	guehdr = (struct guehdr *)&udp_hdr(skb)[1];
  
  	switch (guehdr->version) {
  	case 0: /* Full GUE header present */
  		break;
  	case 1: {
  		/* Direct encasulation of IPv4 or IPv6 */
  		skb_set_transport_header(skb, -(int)sizeof(struct icmp6hdr));
  
  		switch (((struct iphdr *)guehdr)->version) {
  		case 4:
  			ret = gue6_err_proto_handler(IPPROTO_IPIP, skb, opt,
  						     type, code, offset, info);
  			goto out;
  		case 6:
  			ret = gue6_err_proto_handler(IPPROTO_IPV6, skb, opt,
  						     type, code, offset, info);
  			goto out;
  		default:
  			ret = -EOPNOTSUPP;
  			goto out;
  		}
  	}
  	default: /* Undefined version */
  		return -EOPNOTSUPP;
  	}
  
  	if (guehdr->control)
  		return -ENOENT;
  
  	optlen = guehdr->hlen << 2;

  	if (!pskb_may_pull(skb, transport_offset + len + optlen))

  		return -EINVAL;
  
  	guehdr = (struct guehdr *)&udp_hdr(skb)[1];

  	if (validate_gue_flags(guehdr, optlen))
  		return -EINVAL;

  	/* Handling exceptions for direct UDP encapsulation in GUE would lead to
  	 * recursion. Besides, this kind of encapsulation can't even be
  	 * configured currently. Discard this.
  	 */
  	if (guehdr->proto_ctype == IPPROTO_UDP ||
  	    guehdr->proto_ctype == IPPROTO_UDPLITE)
  		return -EOPNOTSUPP;

  	skb_set_transport_header(skb, -(int)sizeof(struct icmp6hdr));
  	ret = gue6_err_proto_handler(guehdr->proto_ctype, skb,
  				     opt, type, code, offset, info);
  
  out:
  	skb_set_transport_header(skb, transport_offset);
  	return ret;
  }

  static const struct ip6_tnl_encap_ops fou_ip6tun_ops = {
  	.encap_hlen = fou_encap_hlen,
  	.build_header = fou6_build_header,

  	.err_handler = gue6_err,

  };
  
  static const struct ip6_tnl_encap_ops gue_ip6tun_ops = {
  	.encap_hlen = gue_encap_hlen,
  	.build_header = gue6_build_header,

  	.err_handler = gue6_err,

  };
  
  static int ip6_tnl_encap_add_fou_ops(void)
  {
  	int ret;
  
  	ret = ip6_tnl_encap_add_ops(&fou_ip6tun_ops, TUNNEL_ENCAP_FOU);
  	if (ret < 0) {
  		pr_err("can't add fou6 ops
  ");
  		return ret;
  	}
  
  	ret = ip6_tnl_encap_add_ops(&gue_ip6tun_ops, TUNNEL_ENCAP_GUE);
  	if (ret < 0) {
  		pr_err("can't add gue6 ops
  ");
  		ip6_tnl_encap_del_ops(&fou_ip6tun_ops, TUNNEL_ENCAP_FOU);
  		return ret;
  	}
  
  	return 0;
  }
  
  static void ip6_tnl_encap_del_fou_ops(void)
  {
  	ip6_tnl_encap_del_ops(&fou_ip6tun_ops, TUNNEL_ENCAP_FOU);
  	ip6_tnl_encap_del_ops(&gue_ip6tun_ops, TUNNEL_ENCAP_GUE);
  }
  
  #else
  
  static int ip6_tnl_encap_add_fou_ops(void)
  {
  	return 0;
  }
  
  static void ip6_tnl_encap_del_fou_ops(void)
  {
  }
  
  #endif
  
  static int __init fou6_init(void)
  {
  	int ret;
  
  	ret = ip6_tnl_encap_add_fou_ops();
  
  	return ret;
  }
  
  static void __exit fou6_fini(void)
  {
  	ip6_tnl_encap_del_fou_ops();
  }
  
  module_init(fou6_init);
  module_exit(fou6_fini);
  MODULE_AUTHOR("Tom Herbert <therbert@google.com>");
  MODULE_LICENSE("GPL");

  MODULE_DESCRIPTION("Foo over UDP (IPv6)");