Merge git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net

[platform/kernel/linux-starfive.git] / net / xfrm / xfrm_output.c

diff --git a/net/xfrm/xfrm_output.c b/net/xfrm/xfrm_output.c
index ac907b9..229544b 100644 (file)
--- a/net/xfrm/xfrm_output.c
+++ b/net/xfrm/xfrm_output.c
@@ -77,6 +77,83 @@ static int xfrm4_transport_output(struct xfrm_state *x, struct sk_buff *skb)
        return 0;
 }
 
+#if IS_ENABLED(CONFIG_IPV6_MIP6)
+static int mip6_rthdr_offset(struct sk_buff *skb, u8 **nexthdr, int type)
+{
+       const unsigned char *nh = skb_network_header(skb);
+       unsigned int offset = sizeof(struct ipv6hdr);
+       unsigned int packet_len;
+       int found_rhdr = 0;
+
+       packet_len = skb_tail_pointer(skb) - nh;
+       *nexthdr = &ipv6_hdr(skb)->nexthdr;
+
+       while (offset <= packet_len) {
+               struct ipv6_opt_hdr *exthdr;
+
+               switch (**nexthdr) {
+               case NEXTHDR_HOP:
+                       break;
+               case NEXTHDR_ROUTING:
+                       if (type == IPPROTO_ROUTING && offset + 3 <= packet_len) {
+                               struct ipv6_rt_hdr *rt;
+
+                               rt = (struct ipv6_rt_hdr *)(nh + offset);
+                               if (rt->type != 0)
+                                       return offset;
+                       }
+                       found_rhdr = 1;
+                       break;
+               case NEXTHDR_DEST:
+                       /* HAO MUST NOT appear more than once.
+                        * XXX: It is better to try to find by the end of
+                        * XXX: packet if HAO exists.
+                        */
+                       if (ipv6_find_tlv(skb, offset, IPV6_TLV_HAO) >= 0) {
+                               net_dbg_ratelimited("mip6: hao exists already, override\n");
+                               return offset;
+                       }
+
+                       if (found_rhdr)
+                               return offset;
+
+                       break;
+               default:
+                       return offset;
+               }
+
+               if (offset + sizeof(struct ipv6_opt_hdr) > packet_len)
+                       return -EINVAL;
+
+               exthdr = (struct ipv6_opt_hdr *)(skb_network_header(skb) +
+                                                offset);
+               offset += ipv6_optlen(exthdr);
+               if (offset > IPV6_MAXPLEN)
+                       return -EINVAL;
+               *nexthdr = &exthdr->nexthdr;
+       }
+
+       return -EINVAL;
+}
+#endif
+
+#if IS_ENABLED(CONFIG_IPV6)
+static int xfrm6_hdr_offset(struct xfrm_state *x, struct sk_buff *skb, u8 **prevhdr)
+{
+       switch (x->type->proto) {
+#if IS_ENABLED(CONFIG_IPV6_MIP6)
+       case IPPROTO_DSTOPTS:
+       case IPPROTO_ROUTING:
+               return mip6_rthdr_offset(skb, prevhdr, x->type->proto);
+#endif
+       default:
+               break;
+       }
+
+       return ip6_find_1stfragopt(skb, prevhdr);
+}
+#endif
+
 /* Add encapsulation header.
  *
  * The IP header and mutable extension headers will be moved forward to make
@@ -92,7 +169,7 @@ static int xfrm6_transport_output(struct xfrm_state *x, struct sk_buff *skb)
        iph = ipv6_hdr(skb);
        skb_set_inner_transport_header(skb, skb_transport_offset(skb));
 
-       hdr_len = x->type->hdr_offset(x, skb, &prevhdr);
+       hdr_len = xfrm6_hdr_offset(x, skb, &prevhdr);
        if (hdr_len < 0)
                return hdr_len;
        skb_set_mac_header(skb,
@@ -122,7 +199,7 @@ static int xfrm6_ro_output(struct xfrm_state *x, struct sk_buff *skb)
 
        iph = ipv6_hdr(skb);
 
-       hdr_len = x->type->hdr_offset(x, skb, &prevhdr);
+       hdr_len = xfrm6_hdr_offset(x, skb, &prevhdr);
        if (hdr_len < 0)
                return hdr_len;
        skb_set_mac_header(skb,
@@ -448,7 +525,7 @@ static int xfrm_output_one(struct sk_buff *skb, int err)
                        goto error;
                }
 
-               err = x->repl->overflow(x, skb);
+               err = xfrm_replay_overflow(x, skb);
                if (err) {
                        XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTSTATESEQERROR);
                        goto error;
@@ -565,6 +642,42 @@ static int xfrm_output_gso(struct net *net, struct sock *sk, struct sk_buff *skb
        return 0;
 }
 
+/* For partial checksum offload, the outer header checksum is calculated
+ * by software and the inner header checksum is calculated by hardware.
+ * This requires hardware to know the inner packet type to calculate
+ * the inner header checksum. Save inner ip protocol here to avoid
+ * traversing the packet in the vendor's xmit code.
+ * If the encap type is IPIP, just save skb->inner_ipproto. Otherwise,
+ * get the ip protocol from the IP header.
+ */
+static void xfrm_get_inner_ipproto(struct sk_buff *skb)
+{
+       struct xfrm_offload *xo = xfrm_offload(skb);
+       const struct ethhdr *eth;
+
+       if (!xo)
+               return;
+
+       if (skb->inner_protocol_type == ENCAP_TYPE_IPPROTO) {
+               xo->inner_ipproto = skb->inner_ipproto;
+               return;
+       }
+
+       if (skb->inner_protocol_type != ENCAP_TYPE_ETHER)
+               return;
+
+       eth = (struct ethhdr *)skb_inner_mac_header(skb);
+
+       switch (ntohs(eth->h_proto)) {
+       case ETH_P_IPV6:
+               xo->inner_ipproto = inner_ipv6_hdr(skb)->nexthdr;
+               break;
+       case ETH_P_IP:
+               xo->inner_ipproto = inner_ip_hdr(skb)->protocol;
+               break;
+       }
+}
+
 int xfrm_output(struct sock *sk, struct sk_buff *skb)
 {
        struct net *net = dev_net(skb_dst(skb)->dev);
@@ -594,12 +707,15 @@ int xfrm_output(struct sock *sk, struct sk_buff *skb)
                        kfree_skb(skb);
                        return -ENOMEM;
                }
-               skb->encapsulation = 1;
 
                sp->olen++;
                sp->xvec[sp->len++] = x;
                xfrm_state_hold(x);
 
+               if (skb->encapsulation)
+                       xfrm_get_inner_ipproto(skb);
+               skb->encapsulation = 1;
+
                if (skb_is_gso(skb)) {
                        if (skb->inner_protocol)
                                return xfrm_output_gso(net, sk, skb);