11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * IPv6 output functions 31da177e4SLinus Torvalds * Linux INET6 implementation 41da177e4SLinus Torvalds * 51da177e4SLinus Torvalds * Authors: 61da177e4SLinus Torvalds * Pedro Roque <roque@di.fc.ul.pt> 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * Based on linux/net/ipv4/ip_output.c 91da177e4SLinus Torvalds * 101da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or 111da177e4SLinus Torvalds * modify it under the terms of the GNU General Public License 121da177e4SLinus Torvalds * as published by the Free Software Foundation; either version 131da177e4SLinus Torvalds * 2 of the License, or (at your option) any later version. 141da177e4SLinus Torvalds * 151da177e4SLinus Torvalds * Changes: 161da177e4SLinus Torvalds * A.N.Kuznetsov : airthmetics in fragmentation. 171da177e4SLinus Torvalds * extension headers are implemented. 181da177e4SLinus Torvalds * route changes now work. 191da177e4SLinus Torvalds * ip6_forward does not confuse sniffers. 201da177e4SLinus Torvalds * etc. 211da177e4SLinus Torvalds * 221da177e4SLinus Torvalds * H. von Brand : Added missing #include <linux/string.h> 231da177e4SLinus Torvalds * Imran Patel : frag id should be in NBO 241da177e4SLinus Torvalds * Kazunori MIYAZAWA @USAGI 251da177e4SLinus Torvalds * : add ip6_append_data and related functions 261da177e4SLinus Torvalds * for datagram xmit 271da177e4SLinus Torvalds */ 281da177e4SLinus Torvalds 291da177e4SLinus Torvalds #include <linux/errno.h> 30ef76bc23SHerbert Xu #include <linux/kernel.h> 311da177e4SLinus Torvalds #include <linux/string.h> 321da177e4SLinus Torvalds #include <linux/socket.h> 331da177e4SLinus Torvalds #include <linux/net.h> 341da177e4SLinus Torvalds #include <linux/netdevice.h> 351da177e4SLinus Torvalds #include <linux/if_arp.h> 361da177e4SLinus Torvalds #include <linux/in6.h> 371da177e4SLinus Torvalds #include <linux/tcp.h> 381da177e4SLinus Torvalds #include <linux/route.h> 39b59f45d0SHerbert Xu #include <linux/module.h> 405a0e3ad6STejun Heo #include <linux/slab.h> 411da177e4SLinus Torvalds 421da177e4SLinus Torvalds #include <linux/netfilter.h> 431da177e4SLinus Torvalds #include <linux/netfilter_ipv6.h> 441da177e4SLinus Torvalds 451da177e4SLinus Torvalds #include <net/sock.h> 461da177e4SLinus Torvalds #include <net/snmp.h> 471da177e4SLinus Torvalds 481da177e4SLinus Torvalds #include <net/ipv6.h> 491da177e4SLinus Torvalds #include <net/ndisc.h> 501da177e4SLinus Torvalds #include <net/protocol.h> 511da177e4SLinus Torvalds #include <net/ip6_route.h> 521da177e4SLinus Torvalds #include <net/addrconf.h> 531da177e4SLinus Torvalds #include <net/rawv6.h> 541da177e4SLinus Torvalds #include <net/icmp.h> 551da177e4SLinus Torvalds #include <net/xfrm.h> 561da177e4SLinus Torvalds #include <net/checksum.h> 577bc570c8SYOSHIFUJI Hideaki #include <linux/mroute6.h> 581da177e4SLinus Torvalds 59ef76bc23SHerbert Xu int __ip6_local_out(struct sk_buff *skb) 60ef76bc23SHerbert Xu { 61ef76bc23SHerbert Xu int len; 62ef76bc23SHerbert Xu 63ef76bc23SHerbert Xu len = skb->len - sizeof(struct ipv6hdr); 64ef76bc23SHerbert Xu if (len > IPV6_MAXPLEN) 65ef76bc23SHerbert Xu len = 0; 66ef76bc23SHerbert Xu ipv6_hdr(skb)->payload_len = htons(len); 67ef76bc23SHerbert Xu 68b2e0b385SJan Engelhardt return nf_hook(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL, 69b2e0b385SJan Engelhardt skb_dst(skb)->dev, dst_output); 70ef76bc23SHerbert Xu } 71ef76bc23SHerbert Xu 72ef76bc23SHerbert Xu int ip6_local_out(struct sk_buff *skb) 73ef76bc23SHerbert Xu { 74ef76bc23SHerbert Xu int err; 75ef76bc23SHerbert Xu 76ef76bc23SHerbert Xu err = __ip6_local_out(skb); 77ef76bc23SHerbert Xu if (likely(err == 1)) 78ef76bc23SHerbert Xu err = dst_output(skb); 79ef76bc23SHerbert Xu 80ef76bc23SHerbert Xu return err; 81ef76bc23SHerbert Xu } 82ef76bc23SHerbert Xu EXPORT_SYMBOL_GPL(ip6_local_out); 83ef76bc23SHerbert Xu 849e508490SJan Engelhardt static int ip6_finish_output2(struct sk_buff *skb) 851da177e4SLinus Torvalds { 86adf30907SEric Dumazet struct dst_entry *dst = skb_dst(skb); 871da177e4SLinus Torvalds struct net_device *dev = dst->dev; 88f6b72b62SDavid S. Miller struct neighbour *neigh; 896fd6ce20SYOSHIFUJI Hideaki / 吉藤英明 struct in6_addr *nexthop; 906fd6ce20SYOSHIFUJI Hideaki / 吉藤英明 int ret; 911da177e4SLinus Torvalds 921da177e4SLinus Torvalds skb->protocol = htons(ETH_P_IPV6); 931da177e4SLinus Torvalds skb->dev = dev; 941da177e4SLinus Torvalds 950660e03fSArnaldo Carvalho de Melo if (ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr)) { 96adf30907SEric Dumazet struct inet6_dev *idev = ip6_dst_idev(skb_dst(skb)); 971da177e4SLinus Torvalds 987ad6848cSOctavian Purdila if (!(dev->flags & IFF_LOOPBACK) && sk_mc_loop(skb->sk) && 99d1db275dSPatrick McHardy ((mroute6_socket(dev_net(dev), skb) && 100bd91b8bfSBenjamin Thery !(IP6CB(skb)->flags & IP6SKB_FORWARDED)) || 1010660e03fSArnaldo Carvalho de Melo ipv6_chk_mcast_addr(dev, &ipv6_hdr(skb)->daddr, 1027bc570c8SYOSHIFUJI Hideaki &ipv6_hdr(skb)->saddr))) { 1031da177e4SLinus Torvalds struct sk_buff *newskb = skb_clone(skb, GFP_ATOMIC); 1041da177e4SLinus Torvalds 1051da177e4SLinus Torvalds /* Do not check for IFF_ALLMULTI; multicast routing 1061da177e4SLinus Torvalds is not supported in any case. 1071da177e4SLinus Torvalds */ 1081da177e4SLinus Torvalds if (newskb) 109b2e0b385SJan Engelhardt NF_HOOK(NFPROTO_IPV6, NF_INET_POST_ROUTING, 110b2e0b385SJan Engelhardt newskb, NULL, newskb->dev, 11195603e22SMichel Machado dev_loopback_xmit); 1121da177e4SLinus Torvalds 1130660e03fSArnaldo Carvalho de Melo if (ipv6_hdr(skb)->hop_limit == 0) { 1143bd653c8SDenis V. Lunev IP6_INC_STATS(dev_net(dev), idev, 1153bd653c8SDenis V. Lunev IPSTATS_MIB_OUTDISCARDS); 1161da177e4SLinus Torvalds kfree_skb(skb); 1171da177e4SLinus Torvalds return 0; 1181da177e4SLinus Torvalds } 1191da177e4SLinus Torvalds } 1201da177e4SLinus Torvalds 121edf391ffSNeil Horman IP6_UPD_PO_STATS(dev_net(dev), idev, IPSTATS_MIB_OUTMCAST, 122edf391ffSNeil Horman skb->len); 123dd408515SHannes Frederic Sowa 124dd408515SHannes Frederic Sowa if (IPV6_ADDR_MC_SCOPE(&ipv6_hdr(skb)->daddr) <= 125dd408515SHannes Frederic Sowa IPV6_ADDR_SCOPE_NODELOCAL && 126dd408515SHannes Frederic Sowa !(dev->flags & IFF_LOOPBACK)) { 127dd408515SHannes Frederic Sowa kfree_skb(skb); 128dd408515SHannes Frederic Sowa return 0; 129dd408515SHannes Frederic Sowa } 1301da177e4SLinus Torvalds } 1311da177e4SLinus Torvalds 1326fd6ce20SYOSHIFUJI Hideaki / 吉藤英明 rcu_read_lock_bh(); 1336fd6ce20SYOSHIFUJI Hideaki / 吉藤英明 nexthop = rt6_nexthop((struct rt6_info *)dst, &ipv6_hdr(skb)->daddr); 1346fd6ce20SYOSHIFUJI Hideaki / 吉藤英明 neigh = __ipv6_neigh_lookup_noref(dst->dev, nexthop); 1356fd6ce20SYOSHIFUJI Hideaki / 吉藤英明 if (unlikely(!neigh)) 1366fd6ce20SYOSHIFUJI Hideaki / 吉藤英明 neigh = __neigh_create(&nd_tbl, nexthop, dst->dev, false); 1376fd6ce20SYOSHIFUJI Hideaki / 吉藤英明 if (!IS_ERR(neigh)) { 1386fd6ce20SYOSHIFUJI Hideaki / 吉藤英明 ret = dst_neigh_output(dst, neigh, skb); 1396fd6ce20SYOSHIFUJI Hideaki / 吉藤英明 rcu_read_unlock_bh(); 1406fd6ce20SYOSHIFUJI Hideaki / 吉藤英明 return ret; 1416fd6ce20SYOSHIFUJI Hideaki / 吉藤英明 } 1426fd6ce20SYOSHIFUJI Hideaki / 吉藤英明 rcu_read_unlock_bh(); 14305e3aa09SDavid S. Miller 1449e508490SJan Engelhardt IP6_INC_STATS_BH(dev_net(dst->dev), 1459e508490SJan Engelhardt ip6_dst_idev(dst), IPSTATS_MIB_OUTNOROUTES); 1469e508490SJan Engelhardt kfree_skb(skb); 1479e508490SJan Engelhardt return -EINVAL; 1481da177e4SLinus Torvalds } 1491da177e4SLinus Torvalds 1509e508490SJan Engelhardt static int ip6_finish_output(struct sk_buff *skb) 1519e508490SJan Engelhardt { 1529e508490SJan Engelhardt if ((skb->len > ip6_skb_dst_mtu(skb) && !skb_is_gso(skb)) || 1539e508490SJan Engelhardt dst_allfrag(skb_dst(skb))) 1549e508490SJan Engelhardt return ip6_fragment(skb, ip6_finish_output2); 1559e508490SJan Engelhardt else 1569e508490SJan Engelhardt return ip6_finish_output2(skb); 1579e508490SJan Engelhardt } 1589e508490SJan Engelhardt 1591da177e4SLinus Torvalds int ip6_output(struct sk_buff *skb) 1601da177e4SLinus Torvalds { 1619e508490SJan Engelhardt struct net_device *dev = skb_dst(skb)->dev; 162adf30907SEric Dumazet struct inet6_dev *idev = ip6_dst_idev(skb_dst(skb)); 163778d80beSYOSHIFUJI Hideaki if (unlikely(idev->cnf.disable_ipv6)) { 1649e508490SJan Engelhardt IP6_INC_STATS(dev_net(dev), idev, 1653bd653c8SDenis V. Lunev IPSTATS_MIB_OUTDISCARDS); 166778d80beSYOSHIFUJI Hideaki kfree_skb(skb); 167778d80beSYOSHIFUJI Hideaki return 0; 168778d80beSYOSHIFUJI Hideaki } 169778d80beSYOSHIFUJI Hideaki 1709c6eb28aSJan Engelhardt return NF_HOOK_COND(NFPROTO_IPV6, NF_INET_POST_ROUTING, skb, NULL, dev, 1719c6eb28aSJan Engelhardt ip6_finish_output, 1729c6eb28aSJan Engelhardt !(IP6CB(skb)->flags & IP6SKB_REROUTED)); 1731da177e4SLinus Torvalds } 1741da177e4SLinus Torvalds 1751da177e4SLinus Torvalds /* 176b5d43998SShan Wei * xmit an sk_buff (used by TCP, SCTP and DCCP) 1771da177e4SLinus Torvalds */ 1781da177e4SLinus Torvalds 1794c9483b2SDavid S. Miller int ip6_xmit(struct sock *sk, struct sk_buff *skb, struct flowi6 *fl6, 180b903d324SEric Dumazet struct ipv6_txoptions *opt, int tclass) 1811da177e4SLinus Torvalds { 1823bd653c8SDenis V. Lunev struct net *net = sock_net(sk); 183b30bd282SPatrick McHardy struct ipv6_pinfo *np = inet6_sk(sk); 1844c9483b2SDavid S. Miller struct in6_addr *first_hop = &fl6->daddr; 185adf30907SEric Dumazet struct dst_entry *dst = skb_dst(skb); 1861da177e4SLinus Torvalds struct ipv6hdr *hdr; 1874c9483b2SDavid S. Miller u8 proto = fl6->flowi6_proto; 1881da177e4SLinus Torvalds int seg_len = skb->len; 189e651f03aSGerrit Renker int hlimit = -1; 1901da177e4SLinus Torvalds u32 mtu; 1911da177e4SLinus Torvalds 1921da177e4SLinus Torvalds if (opt) { 193c2636b4dSChuck Lever unsigned int head_room; 1941da177e4SLinus Torvalds 1951da177e4SLinus Torvalds /* First: exthdrs may take lots of space (~8K for now) 1961da177e4SLinus Torvalds MAX_HEADER is not enough. 1971da177e4SLinus Torvalds */ 1981da177e4SLinus Torvalds head_room = opt->opt_nflen + opt->opt_flen; 1991da177e4SLinus Torvalds seg_len += head_room; 2001da177e4SLinus Torvalds head_room += sizeof(struct ipv6hdr) + LL_RESERVED_SPACE(dst->dev); 2011da177e4SLinus Torvalds 2021da177e4SLinus Torvalds if (skb_headroom(skb) < head_room) { 2031da177e4SLinus Torvalds struct sk_buff *skb2 = skb_realloc_headroom(skb, head_room); 204a11d206dSYOSHIFUJI Hideaki if (skb2 == NULL) { 205adf30907SEric Dumazet IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), 206a11d206dSYOSHIFUJI Hideaki IPSTATS_MIB_OUTDISCARDS); 2071da177e4SLinus Torvalds kfree_skb(skb); 2081da177e4SLinus Torvalds return -ENOBUFS; 2091da177e4SLinus Torvalds } 210808db80aSEric Dumazet consume_skb(skb); 211a11d206dSYOSHIFUJI Hideaki skb = skb2; 2121da177e4SLinus Torvalds skb_set_owner_w(skb, sk); 2131da177e4SLinus Torvalds } 2141da177e4SLinus Torvalds if (opt->opt_flen) 2151da177e4SLinus Torvalds ipv6_push_frag_opts(skb, opt, &proto); 2161da177e4SLinus Torvalds if (opt->opt_nflen) 2171da177e4SLinus Torvalds ipv6_push_nfrag_opts(skb, opt, &proto, &first_hop); 2181da177e4SLinus Torvalds } 2191da177e4SLinus Torvalds 220e2d1bca7SArnaldo Carvalho de Melo skb_push(skb, sizeof(struct ipv6hdr)); 221e2d1bca7SArnaldo Carvalho de Melo skb_reset_network_header(skb); 2220660e03fSArnaldo Carvalho de Melo hdr = ipv6_hdr(skb); 2231da177e4SLinus Torvalds 2241da177e4SLinus Torvalds /* 2251da177e4SLinus Torvalds * Fill in the IPv6 header 2261da177e4SLinus Torvalds */ 227b903d324SEric Dumazet if (np) 2281da177e4SLinus Torvalds hlimit = np->hop_limit; 2291da177e4SLinus Torvalds if (hlimit < 0) 2306b75d090SYOSHIFUJI Hideaki hlimit = ip6_dst_hoplimit(dst); 2311da177e4SLinus Torvalds 2323e4e4c1fSYOSHIFUJI Hideaki / 吉藤英明 ip6_flow_hdr(hdr, tclass, fl6->flowlabel); 23341a1f8eaSYOSHIFUJI Hideaki 2341da177e4SLinus Torvalds hdr->payload_len = htons(seg_len); 2351da177e4SLinus Torvalds hdr->nexthdr = proto; 2361da177e4SLinus Torvalds hdr->hop_limit = hlimit; 2371da177e4SLinus Torvalds 2384e3fd7a0SAlexey Dobriyan hdr->saddr = fl6->saddr; 2394e3fd7a0SAlexey Dobriyan hdr->daddr = *first_hop; 2401da177e4SLinus Torvalds 241a2c2064fSPatrick McHardy skb->priority = sk->sk_priority; 2424a19ec58SLaszlo Attila Toth skb->mark = sk->sk_mark; 243a2c2064fSPatrick McHardy 2441da177e4SLinus Torvalds mtu = dst_mtu(dst); 245283d07acSWei Yongjun if ((skb->len <= mtu) || skb->local_df || skb_is_gso(skb)) { 246adf30907SEric Dumazet IP6_UPD_PO_STATS(net, ip6_dst_idev(skb_dst(skb)), 247edf391ffSNeil Horman IPSTATS_MIB_OUT, skb->len); 248b2e0b385SJan Engelhardt return NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL, 249b2e0b385SJan Engelhardt dst->dev, dst_output); 2501da177e4SLinus Torvalds } 2511da177e4SLinus Torvalds 2521da177e4SLinus Torvalds skb->dev = dst->dev; 253f4e53e29SSteffen Klassert ipv6_local_error(sk, EMSGSIZE, fl6, mtu); 254adf30907SEric Dumazet IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_FRAGFAILS); 2551da177e4SLinus Torvalds kfree_skb(skb); 2561da177e4SLinus Torvalds return -EMSGSIZE; 2571da177e4SLinus Torvalds } 2581da177e4SLinus Torvalds 2597159039aSYOSHIFUJI Hideaki EXPORT_SYMBOL(ip6_xmit); 2607159039aSYOSHIFUJI Hideaki 2611da177e4SLinus Torvalds static int ip6_call_ra_chain(struct sk_buff *skb, int sel) 2621da177e4SLinus Torvalds { 2631da177e4SLinus Torvalds struct ip6_ra_chain *ra; 2641da177e4SLinus Torvalds struct sock *last = NULL; 2651da177e4SLinus Torvalds 2661da177e4SLinus Torvalds read_lock(&ip6_ra_lock); 2671da177e4SLinus Torvalds for (ra = ip6_ra_chain; ra; ra = ra->next) { 2681da177e4SLinus Torvalds struct sock *sk = ra->sk; 2690bd1b59bSAndrew McDonald if (sk && ra->sel == sel && 2700bd1b59bSAndrew McDonald (!sk->sk_bound_dev_if || 2710bd1b59bSAndrew McDonald sk->sk_bound_dev_if == skb->dev->ifindex)) { 2721da177e4SLinus Torvalds if (last) { 2731da177e4SLinus Torvalds struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC); 2741da177e4SLinus Torvalds if (skb2) 2751da177e4SLinus Torvalds rawv6_rcv(last, skb2); 2761da177e4SLinus Torvalds } 2771da177e4SLinus Torvalds last = sk; 2781da177e4SLinus Torvalds } 2791da177e4SLinus Torvalds } 2801da177e4SLinus Torvalds 2811da177e4SLinus Torvalds if (last) { 2821da177e4SLinus Torvalds rawv6_rcv(last, skb); 2831da177e4SLinus Torvalds read_unlock(&ip6_ra_lock); 2841da177e4SLinus Torvalds return 1; 2851da177e4SLinus Torvalds } 2861da177e4SLinus Torvalds read_unlock(&ip6_ra_lock); 2871da177e4SLinus Torvalds return 0; 2881da177e4SLinus Torvalds } 2891da177e4SLinus Torvalds 290e21e0b5fSVille Nuorvala static int ip6_forward_proxy_check(struct sk_buff *skb) 291e21e0b5fSVille Nuorvala { 2920660e03fSArnaldo Carvalho de Melo struct ipv6hdr *hdr = ipv6_hdr(skb); 293e21e0b5fSVille Nuorvala u8 nexthdr = hdr->nexthdr; 29475f2811cSJesse Gross __be16 frag_off; 295e21e0b5fSVille Nuorvala int offset; 296e21e0b5fSVille Nuorvala 297e21e0b5fSVille Nuorvala if (ipv6_ext_hdr(nexthdr)) { 29875f2811cSJesse Gross offset = ipv6_skip_exthdr(skb, sizeof(*hdr), &nexthdr, &frag_off); 299e21e0b5fSVille Nuorvala if (offset < 0) 300e21e0b5fSVille Nuorvala return 0; 301e21e0b5fSVille Nuorvala } else 302e21e0b5fSVille Nuorvala offset = sizeof(struct ipv6hdr); 303e21e0b5fSVille Nuorvala 304e21e0b5fSVille Nuorvala if (nexthdr == IPPROTO_ICMPV6) { 305e21e0b5fSVille Nuorvala struct icmp6hdr *icmp6; 306e21e0b5fSVille Nuorvala 307d56f90a7SArnaldo Carvalho de Melo if (!pskb_may_pull(skb, (skb_network_header(skb) + 308d56f90a7SArnaldo Carvalho de Melo offset + 1 - skb->data))) 309e21e0b5fSVille Nuorvala return 0; 310e21e0b5fSVille Nuorvala 311d56f90a7SArnaldo Carvalho de Melo icmp6 = (struct icmp6hdr *)(skb_network_header(skb) + offset); 312e21e0b5fSVille Nuorvala 313e21e0b5fSVille Nuorvala switch (icmp6->icmp6_type) { 314e21e0b5fSVille Nuorvala case NDISC_ROUTER_SOLICITATION: 315e21e0b5fSVille Nuorvala case NDISC_ROUTER_ADVERTISEMENT: 316e21e0b5fSVille Nuorvala case NDISC_NEIGHBOUR_SOLICITATION: 317e21e0b5fSVille Nuorvala case NDISC_NEIGHBOUR_ADVERTISEMENT: 318e21e0b5fSVille Nuorvala case NDISC_REDIRECT: 319e21e0b5fSVille Nuorvala /* For reaction involving unicast neighbor discovery 320e21e0b5fSVille Nuorvala * message destined to the proxied address, pass it to 321e21e0b5fSVille Nuorvala * input function. 322e21e0b5fSVille Nuorvala */ 323e21e0b5fSVille Nuorvala return 1; 324e21e0b5fSVille Nuorvala default: 325e21e0b5fSVille Nuorvala break; 326e21e0b5fSVille Nuorvala } 327e21e0b5fSVille Nuorvala } 328e21e0b5fSVille Nuorvala 32974553b09SVille Nuorvala /* 33074553b09SVille Nuorvala * The proxying router can't forward traffic sent to a link-local 33174553b09SVille Nuorvala * address, so signal the sender and discard the packet. This 33274553b09SVille Nuorvala * behavior is clarified by the MIPv6 specification. 33374553b09SVille Nuorvala */ 33474553b09SVille Nuorvala if (ipv6_addr_type(&hdr->daddr) & IPV6_ADDR_LINKLOCAL) { 33574553b09SVille Nuorvala dst_link_failure(skb); 33674553b09SVille Nuorvala return -1; 33774553b09SVille Nuorvala } 33874553b09SVille Nuorvala 339e21e0b5fSVille Nuorvala return 0; 340e21e0b5fSVille Nuorvala } 341e21e0b5fSVille Nuorvala 3421da177e4SLinus Torvalds static inline int ip6_forward_finish(struct sk_buff *skb) 3431da177e4SLinus Torvalds { 3441da177e4SLinus Torvalds return dst_output(skb); 3451da177e4SLinus Torvalds } 3461da177e4SLinus Torvalds 3471da177e4SLinus Torvalds int ip6_forward(struct sk_buff *skb) 3481da177e4SLinus Torvalds { 349adf30907SEric Dumazet struct dst_entry *dst = skb_dst(skb); 3500660e03fSArnaldo Carvalho de Melo struct ipv6hdr *hdr = ipv6_hdr(skb); 3511da177e4SLinus Torvalds struct inet6_skb_parm *opt = IP6CB(skb); 352c346dca1SYOSHIFUJI Hideaki struct net *net = dev_net(dst->dev); 35314f3ad6fSUlrich Weber u32 mtu; 3541da177e4SLinus Torvalds 35553b7997fSYOSHIFUJI Hideaki if (net->ipv6.devconf_all->forwarding == 0) 3561da177e4SLinus Torvalds goto error; 3571da177e4SLinus Torvalds 3584497b076SBen Hutchings if (skb_warn_if_lro(skb)) 3594497b076SBen Hutchings goto drop; 3604497b076SBen Hutchings 3611da177e4SLinus Torvalds if (!xfrm6_policy_check(NULL, XFRM_POLICY_FWD, skb)) { 3623bd653c8SDenis V. Lunev IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_INDISCARDS); 3631da177e4SLinus Torvalds goto drop; 3641da177e4SLinus Torvalds } 3651da177e4SLinus Torvalds 36672b43d08SAlexey Kuznetsov if (skb->pkt_type != PACKET_HOST) 36772b43d08SAlexey Kuznetsov goto drop; 36872b43d08SAlexey Kuznetsov 36935fc92a9SHerbert Xu skb_forward_csum(skb); 3701da177e4SLinus Torvalds 3711da177e4SLinus Torvalds /* 3721da177e4SLinus Torvalds * We DO NOT make any processing on 3731da177e4SLinus Torvalds * RA packets, pushing them to user level AS IS 3741da177e4SLinus Torvalds * without ane WARRANTY that application will be able 3751da177e4SLinus Torvalds * to interpret them. The reason is that we 3761da177e4SLinus Torvalds * cannot make anything clever here. 3771da177e4SLinus Torvalds * 3781da177e4SLinus Torvalds * We are not end-node, so that if packet contains 3791da177e4SLinus Torvalds * AH/ESP, we cannot make anything. 3801da177e4SLinus Torvalds * Defragmentation also would be mistake, RA packets 3811da177e4SLinus Torvalds * cannot be fragmented, because there is no warranty 3821da177e4SLinus Torvalds * that different fragments will go along one path. --ANK 3831da177e4SLinus Torvalds */ 3841da177e4SLinus Torvalds if (opt->ra) { 385d56f90a7SArnaldo Carvalho de Melo u8 *ptr = skb_network_header(skb) + opt->ra; 3861da177e4SLinus Torvalds if (ip6_call_ra_chain(skb, (ptr[2]<<8) + ptr[3])) 3871da177e4SLinus Torvalds return 0; 3881da177e4SLinus Torvalds } 3891da177e4SLinus Torvalds 3901da177e4SLinus Torvalds /* 3911da177e4SLinus Torvalds * check and decrement ttl 3921da177e4SLinus Torvalds */ 3931da177e4SLinus Torvalds if (hdr->hop_limit <= 1) { 3941da177e4SLinus Torvalds /* Force OUTPUT device used as source address */ 3951da177e4SLinus Torvalds skb->dev = dst->dev; 3963ffe533cSAlexey Dobriyan icmpv6_send(skb, ICMPV6_TIME_EXCEED, ICMPV6_EXC_HOPLIMIT, 0); 397483a47d2SDenis V. Lunev IP6_INC_STATS_BH(net, 398483a47d2SDenis V. Lunev ip6_dst_idev(dst), IPSTATS_MIB_INHDRERRORS); 3991da177e4SLinus Torvalds 4001da177e4SLinus Torvalds kfree_skb(skb); 4011da177e4SLinus Torvalds return -ETIMEDOUT; 4021da177e4SLinus Torvalds } 4031da177e4SLinus Torvalds 404fbea49e1SYOSHIFUJI Hideaki /* XXX: idev->cnf.proxy_ndp? */ 40553b7997fSYOSHIFUJI Hideaki if (net->ipv6.devconf_all->proxy_ndp && 4068a3edd80SDaniel Lezcano pneigh_lookup(&nd_tbl, net, &hdr->daddr, skb->dev, 0)) { 40774553b09SVille Nuorvala int proxied = ip6_forward_proxy_check(skb); 40874553b09SVille Nuorvala if (proxied > 0) 409e21e0b5fSVille Nuorvala return ip6_input(skb); 41074553b09SVille Nuorvala else if (proxied < 0) { 4113bd653c8SDenis V. Lunev IP6_INC_STATS(net, ip6_dst_idev(dst), 4123bd653c8SDenis V. Lunev IPSTATS_MIB_INDISCARDS); 41374553b09SVille Nuorvala goto drop; 41474553b09SVille Nuorvala } 415e21e0b5fSVille Nuorvala } 416e21e0b5fSVille Nuorvala 4171da177e4SLinus Torvalds if (!xfrm6_route_forward(skb)) { 4183bd653c8SDenis V. Lunev IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_INDISCARDS); 4191da177e4SLinus Torvalds goto drop; 4201da177e4SLinus Torvalds } 421adf30907SEric Dumazet dst = skb_dst(skb); 4221da177e4SLinus Torvalds 4231da177e4SLinus Torvalds /* IPv6 specs say nothing about it, but it is clear that we cannot 4241da177e4SLinus Torvalds send redirects to source routed frames. 4251e5dc146SMasahide NAKAMURA We don't send redirects to frames decapsulated from IPsec. 4261da177e4SLinus Torvalds */ 427c45a3dfbSDavid S. Miller if (skb->dev == dst->dev && opt->srcrt == 0 && !skb_sec_path(skb)) { 4281da177e4SLinus Torvalds struct in6_addr *target = NULL; 429fbfe95a4SDavid S. Miller struct inet_peer *peer; 4301da177e4SLinus Torvalds struct rt6_info *rt; 4311da177e4SLinus Torvalds 4321da177e4SLinus Torvalds /* 4331da177e4SLinus Torvalds * incoming and outgoing devices are the same 4341da177e4SLinus Torvalds * send a redirect. 4351da177e4SLinus Torvalds */ 4361da177e4SLinus Torvalds 4371da177e4SLinus Torvalds rt = (struct rt6_info *) dst; 438c45a3dfbSDavid S. Miller if (rt->rt6i_flags & RTF_GATEWAY) 439c45a3dfbSDavid S. Miller target = &rt->rt6i_gateway; 4401da177e4SLinus Torvalds else 4411da177e4SLinus Torvalds target = &hdr->daddr; 4421da177e4SLinus Torvalds 4431d861aa4SDavid S. Miller peer = inet_getpeer_v6(net->ipv6.peers, &rt->rt6i_dst.addr, 1); 44492d86829SDavid S. Miller 4451da177e4SLinus Torvalds /* Limit redirects both by destination (here) 4461da177e4SLinus Torvalds and by source (inside ndisc_send_redirect) 4471da177e4SLinus Torvalds */ 448fbfe95a4SDavid S. Miller if (inet_peer_xrlim_allow(peer, 1*HZ)) 4494991969aSDavid S. Miller ndisc_send_redirect(skb, target); 4501d861aa4SDavid S. Miller if (peer) 4511d861aa4SDavid S. Miller inet_putpeer(peer); 4525bb1ab09SDavid L Stevens } else { 4535bb1ab09SDavid L Stevens int addrtype = ipv6_addr_type(&hdr->saddr); 4545bb1ab09SDavid L Stevens 4551da177e4SLinus Torvalds /* This check is security critical. */ 456f81b2e7dSYOSHIFUJI Hideaki if (addrtype == IPV6_ADDR_ANY || 457f81b2e7dSYOSHIFUJI Hideaki addrtype & (IPV6_ADDR_MULTICAST | IPV6_ADDR_LOOPBACK)) 4581da177e4SLinus Torvalds goto error; 4595bb1ab09SDavid L Stevens if (addrtype & IPV6_ADDR_LINKLOCAL) { 4605bb1ab09SDavid L Stevens icmpv6_send(skb, ICMPV6_DEST_UNREACH, 4613ffe533cSAlexey Dobriyan ICMPV6_NOT_NEIGHBOUR, 0); 4625bb1ab09SDavid L Stevens goto error; 4635bb1ab09SDavid L Stevens } 4641da177e4SLinus Torvalds } 4651da177e4SLinus Torvalds 46614f3ad6fSUlrich Weber mtu = dst_mtu(dst); 46714f3ad6fSUlrich Weber if (mtu < IPV6_MIN_MTU) 46814f3ad6fSUlrich Weber mtu = IPV6_MIN_MTU; 46914f3ad6fSUlrich Weber 4704cdd3408SPatrick McHardy if ((!skb->local_df && skb->len > mtu && !skb_is_gso(skb)) || 4714cdd3408SPatrick McHardy (IP6CB(skb)->frag_max_size && IP6CB(skb)->frag_max_size > mtu)) { 4721da177e4SLinus Torvalds /* Again, force OUTPUT device used as source address */ 4731da177e4SLinus Torvalds skb->dev = dst->dev; 47414f3ad6fSUlrich Weber icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu); 475483a47d2SDenis V. Lunev IP6_INC_STATS_BH(net, 476483a47d2SDenis V. Lunev ip6_dst_idev(dst), IPSTATS_MIB_INTOOBIGERRORS); 477483a47d2SDenis V. Lunev IP6_INC_STATS_BH(net, 478483a47d2SDenis V. Lunev ip6_dst_idev(dst), IPSTATS_MIB_FRAGFAILS); 4791da177e4SLinus Torvalds kfree_skb(skb); 4801da177e4SLinus Torvalds return -EMSGSIZE; 4811da177e4SLinus Torvalds } 4821da177e4SLinus Torvalds 4831da177e4SLinus Torvalds if (skb_cow(skb, dst->dev->hard_header_len)) { 4843bd653c8SDenis V. Lunev IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTDISCARDS); 4851da177e4SLinus Torvalds goto drop; 4861da177e4SLinus Torvalds } 4871da177e4SLinus Torvalds 4880660e03fSArnaldo Carvalho de Melo hdr = ipv6_hdr(skb); 4891da177e4SLinus Torvalds 4901da177e4SLinus Torvalds /* Mangling hops number delayed to point after skb COW */ 4911da177e4SLinus Torvalds 4921da177e4SLinus Torvalds hdr->hop_limit--; 4931da177e4SLinus Torvalds 494483a47d2SDenis V. Lunev IP6_INC_STATS_BH(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTFORWDATAGRAMS); 4952d8dbb04SVincent Bernat IP6_ADD_STATS_BH(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTOCTETS, skb->len); 496b2e0b385SJan Engelhardt return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD, skb, skb->dev, dst->dev, 4976e23ae2aSPatrick McHardy ip6_forward_finish); 4981da177e4SLinus Torvalds 4991da177e4SLinus Torvalds error: 500483a47d2SDenis V. Lunev IP6_INC_STATS_BH(net, ip6_dst_idev(dst), IPSTATS_MIB_INADDRERRORS); 5011da177e4SLinus Torvalds drop: 5021da177e4SLinus Torvalds kfree_skb(skb); 5031da177e4SLinus Torvalds return -EINVAL; 5041da177e4SLinus Torvalds } 5051da177e4SLinus Torvalds 5061da177e4SLinus Torvalds static void ip6_copy_metadata(struct sk_buff *to, struct sk_buff *from) 5071da177e4SLinus Torvalds { 5081da177e4SLinus Torvalds to->pkt_type = from->pkt_type; 5091da177e4SLinus Torvalds to->priority = from->priority; 5101da177e4SLinus Torvalds to->protocol = from->protocol; 511adf30907SEric Dumazet skb_dst_drop(to); 512adf30907SEric Dumazet skb_dst_set(to, dst_clone(skb_dst(from))); 5131da177e4SLinus Torvalds to->dev = from->dev; 51482e91ffeSThomas Graf to->mark = from->mark; 5151da177e4SLinus Torvalds 5161da177e4SLinus Torvalds #ifdef CONFIG_NET_SCHED 5171da177e4SLinus Torvalds to->tc_index = from->tc_index; 5181da177e4SLinus Torvalds #endif 519e7ac05f3SYasuyuki Kozakai nf_copy(to, from); 52007a93626SAmerigo Wang #if IS_ENABLED(CONFIG_NETFILTER_XT_TARGET_TRACE) 521ba9dda3aSJozsef Kadlecsik to->nf_trace = from->nf_trace; 522ba9dda3aSJozsef Kadlecsik #endif 523984bc16cSJames Morris skb_copy_secmark(to, from); 5241da177e4SLinus Torvalds } 5251da177e4SLinus Torvalds 526ad0081e4SDavid Stevens int ip6_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *)) 5271da177e4SLinus Torvalds { 5281da177e4SLinus Torvalds struct sk_buff *frag; 529adf30907SEric Dumazet struct rt6_info *rt = (struct rt6_info*)skb_dst(skb); 530d91675f9SYOSHIFUJI Hideaki struct ipv6_pinfo *np = skb->sk ? inet6_sk(skb->sk) : NULL; 5311da177e4SLinus Torvalds struct ipv6hdr *tmp_hdr; 5321da177e4SLinus Torvalds struct frag_hdr *fh; 5331da177e4SLinus Torvalds unsigned int mtu, hlen, left, len; 534a7ae1992SHerbert Xu int hroom, troom; 535ae08e1f0SAl Viro __be32 frag_id = 0; 5361da177e4SLinus Torvalds int ptr, offset = 0, err=0; 5371da177e4SLinus Torvalds u8 *prevhdr, nexthdr = 0; 538adf30907SEric Dumazet struct net *net = dev_net(skb_dst(skb)->dev); 5391da177e4SLinus Torvalds 5401da177e4SLinus Torvalds hlen = ip6_find_1stfragopt(skb, &prevhdr); 5411da177e4SLinus Torvalds nexthdr = *prevhdr; 5421da177e4SLinus Torvalds 543628a5c56SJohn Heffner mtu = ip6_skb_dst_mtu(skb); 544b881ef76SJohn Heffner 545b881ef76SJohn Heffner /* We must not fragment if the socket is set to force MTU discovery 54614f3ad6fSUlrich Weber * or if the skb it not generated by a local socket. 547b881ef76SJohn Heffner */ 5484cdd3408SPatrick McHardy if (unlikely(!skb->local_df && skb->len > mtu) || 5494cdd3408SPatrick McHardy (IP6CB(skb)->frag_max_size && 5504cdd3408SPatrick McHardy IP6CB(skb)->frag_max_size > mtu)) { 551a34a101eSEric Dumazet if (skb->sk && dst_allfrag(skb_dst(skb))) 552a34a101eSEric Dumazet sk_nocaps_add(skb->sk, NETIF_F_GSO_MASK); 553a34a101eSEric Dumazet 554adf30907SEric Dumazet skb->dev = skb_dst(skb)->dev; 5553ffe533cSAlexey Dobriyan icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu); 556adf30907SEric Dumazet IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), 5573bd653c8SDenis V. Lunev IPSTATS_MIB_FRAGFAILS); 558b881ef76SJohn Heffner kfree_skb(skb); 559b881ef76SJohn Heffner return -EMSGSIZE; 560b881ef76SJohn Heffner } 561b881ef76SJohn Heffner 562d91675f9SYOSHIFUJI Hideaki if (np && np->frag_size < mtu) { 563d91675f9SYOSHIFUJI Hideaki if (np->frag_size) 564d91675f9SYOSHIFUJI Hideaki mtu = np->frag_size; 565d91675f9SYOSHIFUJI Hideaki } 566d91675f9SYOSHIFUJI Hideaki mtu -= hlen + sizeof(struct frag_hdr); 5671da177e4SLinus Torvalds 56821dc3301SDavid S. Miller if (skb_has_frag_list(skb)) { 5691da177e4SLinus Torvalds int first_len = skb_pagelen(skb); 5703d13008eSEric Dumazet struct sk_buff *frag2; 5711da177e4SLinus Torvalds 5721da177e4SLinus Torvalds if (first_len - hlen > mtu || 5731da177e4SLinus Torvalds ((first_len - hlen) & 7) || 5741da177e4SLinus Torvalds skb_cloned(skb)) 5751da177e4SLinus Torvalds goto slow_path; 5761da177e4SLinus Torvalds 5774d9092bbSDavid S. Miller skb_walk_frags(skb, frag) { 5781da177e4SLinus Torvalds /* Correct geometry. */ 5791da177e4SLinus Torvalds if (frag->len > mtu || 5801da177e4SLinus Torvalds ((frag->len & 7) && frag->next) || 5811da177e4SLinus Torvalds skb_headroom(frag) < hlen) 5823d13008eSEric Dumazet goto slow_path_clean; 5831da177e4SLinus Torvalds 5841da177e4SLinus Torvalds /* Partially cloned skb? */ 5851da177e4SLinus Torvalds if (skb_shared(frag)) 5863d13008eSEric Dumazet goto slow_path_clean; 5872fdba6b0SHerbert Xu 5882fdba6b0SHerbert Xu BUG_ON(frag->sk); 5892fdba6b0SHerbert Xu if (skb->sk) { 5902fdba6b0SHerbert Xu frag->sk = skb->sk; 5912fdba6b0SHerbert Xu frag->destructor = sock_wfree; 5922fdba6b0SHerbert Xu } 5933d13008eSEric Dumazet skb->truesize -= frag->truesize; 5941da177e4SLinus Torvalds } 5951da177e4SLinus Torvalds 5961da177e4SLinus Torvalds err = 0; 5971da177e4SLinus Torvalds offset = 0; 5981da177e4SLinus Torvalds frag = skb_shinfo(skb)->frag_list; 5994d9092bbSDavid S. Miller skb_frag_list_init(skb); 6001da177e4SLinus Torvalds /* BUILD HEADER */ 6011da177e4SLinus Torvalds 6029a217a1cSYOSHIFUJI Hideaki *prevhdr = NEXTHDR_FRAGMENT; 603d56f90a7SArnaldo Carvalho de Melo tmp_hdr = kmemdup(skb_network_header(skb), hlen, GFP_ATOMIC); 6041da177e4SLinus Torvalds if (!tmp_hdr) { 605adf30907SEric Dumazet IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), 6063bd653c8SDenis V. Lunev IPSTATS_MIB_FRAGFAILS); 6071da177e4SLinus Torvalds return -ENOMEM; 6081da177e4SLinus Torvalds } 6091da177e4SLinus Torvalds 6101da177e4SLinus Torvalds __skb_pull(skb, hlen); 6111da177e4SLinus Torvalds fh = (struct frag_hdr*)__skb_push(skb, sizeof(struct frag_hdr)); 612e2d1bca7SArnaldo Carvalho de Melo __skb_push(skb, hlen); 613e2d1bca7SArnaldo Carvalho de Melo skb_reset_network_header(skb); 614d56f90a7SArnaldo Carvalho de Melo memcpy(skb_network_header(skb), tmp_hdr, hlen); 6151da177e4SLinus Torvalds 61687c48fa3SEric Dumazet ipv6_select_ident(fh, rt); 6171da177e4SLinus Torvalds fh->nexthdr = nexthdr; 6181da177e4SLinus Torvalds fh->reserved = 0; 6191da177e4SLinus Torvalds fh->frag_off = htons(IP6_MF); 6201da177e4SLinus Torvalds frag_id = fh->identification; 6211da177e4SLinus Torvalds 6221da177e4SLinus Torvalds first_len = skb_pagelen(skb); 6231da177e4SLinus Torvalds skb->data_len = first_len - skb_headlen(skb); 6241da177e4SLinus Torvalds skb->len = first_len; 6250660e03fSArnaldo Carvalho de Melo ipv6_hdr(skb)->payload_len = htons(first_len - 6260660e03fSArnaldo Carvalho de Melo sizeof(struct ipv6hdr)); 6271da177e4SLinus Torvalds 628d8d1f30bSChangli Gao dst_hold(&rt->dst); 6291da177e4SLinus Torvalds 6301da177e4SLinus Torvalds for (;;) { 6311da177e4SLinus Torvalds /* Prepare header of the next frame, 6321da177e4SLinus Torvalds * before previous one went down. */ 6331da177e4SLinus Torvalds if (frag) { 6341da177e4SLinus Torvalds frag->ip_summed = CHECKSUM_NONE; 635badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(frag); 6361da177e4SLinus Torvalds fh = (struct frag_hdr*)__skb_push(frag, sizeof(struct frag_hdr)); 637e2d1bca7SArnaldo Carvalho de Melo __skb_push(frag, hlen); 638e2d1bca7SArnaldo Carvalho de Melo skb_reset_network_header(frag); 639d56f90a7SArnaldo Carvalho de Melo memcpy(skb_network_header(frag), tmp_hdr, 640d56f90a7SArnaldo Carvalho de Melo hlen); 6411da177e4SLinus Torvalds offset += skb->len - hlen - sizeof(struct frag_hdr); 6421da177e4SLinus Torvalds fh->nexthdr = nexthdr; 6431da177e4SLinus Torvalds fh->reserved = 0; 6441da177e4SLinus Torvalds fh->frag_off = htons(offset); 6451da177e4SLinus Torvalds if (frag->next != NULL) 6461da177e4SLinus Torvalds fh->frag_off |= htons(IP6_MF); 6471da177e4SLinus Torvalds fh->identification = frag_id; 6480660e03fSArnaldo Carvalho de Melo ipv6_hdr(frag)->payload_len = 6490660e03fSArnaldo Carvalho de Melo htons(frag->len - 6500660e03fSArnaldo Carvalho de Melo sizeof(struct ipv6hdr)); 6511da177e4SLinus Torvalds ip6_copy_metadata(frag, skb); 6521da177e4SLinus Torvalds } 6531da177e4SLinus Torvalds 6541da177e4SLinus Torvalds err = output(skb); 655dafee490SWei Dong if(!err) 656d8d1f30bSChangli Gao IP6_INC_STATS(net, ip6_dst_idev(&rt->dst), 6573bd653c8SDenis V. Lunev IPSTATS_MIB_FRAGCREATES); 658dafee490SWei Dong 6591da177e4SLinus Torvalds if (err || !frag) 6601da177e4SLinus Torvalds break; 6611da177e4SLinus Torvalds 6621da177e4SLinus Torvalds skb = frag; 6631da177e4SLinus Torvalds frag = skb->next; 6641da177e4SLinus Torvalds skb->next = NULL; 6651da177e4SLinus Torvalds } 6661da177e4SLinus Torvalds 6671da177e4SLinus Torvalds kfree(tmp_hdr); 6681da177e4SLinus Torvalds 6691da177e4SLinus Torvalds if (err == 0) { 670d8d1f30bSChangli Gao IP6_INC_STATS(net, ip6_dst_idev(&rt->dst), 6713bd653c8SDenis V. Lunev IPSTATS_MIB_FRAGOKS); 67294e187c0SAmerigo Wang ip6_rt_put(rt); 6731da177e4SLinus Torvalds return 0; 6741da177e4SLinus Torvalds } 6751da177e4SLinus Torvalds 6761da177e4SLinus Torvalds while (frag) { 6771da177e4SLinus Torvalds skb = frag->next; 6781da177e4SLinus Torvalds kfree_skb(frag); 6791da177e4SLinus Torvalds frag = skb; 6801da177e4SLinus Torvalds } 6811da177e4SLinus Torvalds 682d8d1f30bSChangli Gao IP6_INC_STATS(net, ip6_dst_idev(&rt->dst), 6833bd653c8SDenis V. Lunev IPSTATS_MIB_FRAGFAILS); 68494e187c0SAmerigo Wang ip6_rt_put(rt); 6851da177e4SLinus Torvalds return err; 6863d13008eSEric Dumazet 6873d13008eSEric Dumazet slow_path_clean: 6883d13008eSEric Dumazet skb_walk_frags(skb, frag2) { 6893d13008eSEric Dumazet if (frag2 == frag) 6903d13008eSEric Dumazet break; 6913d13008eSEric Dumazet frag2->sk = NULL; 6923d13008eSEric Dumazet frag2->destructor = NULL; 6933d13008eSEric Dumazet skb->truesize += frag2->truesize; 6943d13008eSEric Dumazet } 6951da177e4SLinus Torvalds } 6961da177e4SLinus Torvalds 6971da177e4SLinus Torvalds slow_path: 69872e843bbSEric Dumazet if ((skb->ip_summed == CHECKSUM_PARTIAL) && 69972e843bbSEric Dumazet skb_checksum_help(skb)) 70072e843bbSEric Dumazet goto fail; 70172e843bbSEric Dumazet 7021da177e4SLinus Torvalds left = skb->len - hlen; /* Space per frame */ 7031da177e4SLinus Torvalds ptr = hlen; /* Where to start from */ 7041da177e4SLinus Torvalds 7051da177e4SLinus Torvalds /* 7061da177e4SLinus Torvalds * Fragment the datagram. 7071da177e4SLinus Torvalds */ 7081da177e4SLinus Torvalds 7091da177e4SLinus Torvalds *prevhdr = NEXTHDR_FRAGMENT; 710a7ae1992SHerbert Xu hroom = LL_RESERVED_SPACE(rt->dst.dev); 711a7ae1992SHerbert Xu troom = rt->dst.dev->needed_tailroom; 7121da177e4SLinus Torvalds 7131da177e4SLinus Torvalds /* 7141da177e4SLinus Torvalds * Keep copying data until we run out. 7151da177e4SLinus Torvalds */ 7161da177e4SLinus Torvalds while(left > 0) { 7171da177e4SLinus Torvalds len = left; 7181da177e4SLinus Torvalds /* IF: it doesn't fit, use 'mtu' - the data space left */ 7191da177e4SLinus Torvalds if (len > mtu) 7201da177e4SLinus Torvalds len = mtu; 7211da177e4SLinus Torvalds /* IF: we are not sending up to and including the packet end 7221da177e4SLinus Torvalds then align the next start on an eight byte boundary */ 7231da177e4SLinus Torvalds if (len < left) { 7241da177e4SLinus Torvalds len &= ~7; 7251da177e4SLinus Torvalds } 7261da177e4SLinus Torvalds /* 7271da177e4SLinus Torvalds * Allocate buffer. 7281da177e4SLinus Torvalds */ 7291da177e4SLinus Torvalds 730a7ae1992SHerbert Xu if ((frag = alloc_skb(len + hlen + sizeof(struct frag_hdr) + 731a7ae1992SHerbert Xu hroom + troom, GFP_ATOMIC)) == NULL) { 73264ce2073SPatrick McHardy NETDEBUG(KERN_INFO "IPv6: frag: no memory for new fragment!\n"); 733adf30907SEric Dumazet IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), 734a11d206dSYOSHIFUJI Hideaki IPSTATS_MIB_FRAGFAILS); 7351da177e4SLinus Torvalds err = -ENOMEM; 7361da177e4SLinus Torvalds goto fail; 7371da177e4SLinus Torvalds } 7381da177e4SLinus Torvalds 7391da177e4SLinus Torvalds /* 7401da177e4SLinus Torvalds * Set up data on packet 7411da177e4SLinus Torvalds */ 7421da177e4SLinus Torvalds 7431da177e4SLinus Torvalds ip6_copy_metadata(frag, skb); 744a7ae1992SHerbert Xu skb_reserve(frag, hroom); 7451da177e4SLinus Torvalds skb_put(frag, len + hlen + sizeof(struct frag_hdr)); 746c1d2bbe1SArnaldo Carvalho de Melo skb_reset_network_header(frag); 747badff6d0SArnaldo Carvalho de Melo fh = (struct frag_hdr *)(skb_network_header(frag) + hlen); 748b0e380b1SArnaldo Carvalho de Melo frag->transport_header = (frag->network_header + hlen + 749b0e380b1SArnaldo Carvalho de Melo sizeof(struct frag_hdr)); 7501da177e4SLinus Torvalds 7511da177e4SLinus Torvalds /* 7521da177e4SLinus Torvalds * Charge the memory for the fragment to any owner 7531da177e4SLinus Torvalds * it might possess 7541da177e4SLinus Torvalds */ 7551da177e4SLinus Torvalds if (skb->sk) 7561da177e4SLinus Torvalds skb_set_owner_w(frag, skb->sk); 7571da177e4SLinus Torvalds 7581da177e4SLinus Torvalds /* 7591da177e4SLinus Torvalds * Copy the packet header into the new buffer. 7601da177e4SLinus Torvalds */ 761d626f62bSArnaldo Carvalho de Melo skb_copy_from_linear_data(skb, skb_network_header(frag), hlen); 7621da177e4SLinus Torvalds 7631da177e4SLinus Torvalds /* 7641da177e4SLinus Torvalds * Build fragment header. 7651da177e4SLinus Torvalds */ 7661da177e4SLinus Torvalds fh->nexthdr = nexthdr; 7671da177e4SLinus Torvalds fh->reserved = 0; 768f36d6ab1SYan Zheng if (!frag_id) { 76987c48fa3SEric Dumazet ipv6_select_ident(fh, rt); 7701da177e4SLinus Torvalds frag_id = fh->identification; 7711da177e4SLinus Torvalds } else 7721da177e4SLinus Torvalds fh->identification = frag_id; 7731da177e4SLinus Torvalds 7741da177e4SLinus Torvalds /* 7751da177e4SLinus Torvalds * Copy a block of the IP datagram. 7761da177e4SLinus Torvalds */ 7778984e41dSWei Yongjun if (skb_copy_bits(skb, ptr, skb_transport_header(frag), len)) 7781da177e4SLinus Torvalds BUG(); 7791da177e4SLinus Torvalds left -= len; 7801da177e4SLinus Torvalds 7811da177e4SLinus Torvalds fh->frag_off = htons(offset); 7821da177e4SLinus Torvalds if (left > 0) 7831da177e4SLinus Torvalds fh->frag_off |= htons(IP6_MF); 7840660e03fSArnaldo Carvalho de Melo ipv6_hdr(frag)->payload_len = htons(frag->len - 7850660e03fSArnaldo Carvalho de Melo sizeof(struct ipv6hdr)); 7861da177e4SLinus Torvalds 7871da177e4SLinus Torvalds ptr += len; 7881da177e4SLinus Torvalds offset += len; 7891da177e4SLinus Torvalds 7901da177e4SLinus Torvalds /* 7911da177e4SLinus Torvalds * Put this fragment into the sending queue. 7921da177e4SLinus Torvalds */ 7931da177e4SLinus Torvalds err = output(frag); 7941da177e4SLinus Torvalds if (err) 7951da177e4SLinus Torvalds goto fail; 796dafee490SWei Dong 797adf30907SEric Dumazet IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), 7983bd653c8SDenis V. Lunev IPSTATS_MIB_FRAGCREATES); 7991da177e4SLinus Torvalds } 800adf30907SEric Dumazet IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), 801a11d206dSYOSHIFUJI Hideaki IPSTATS_MIB_FRAGOKS); 802808db80aSEric Dumazet consume_skb(skb); 8031da177e4SLinus Torvalds return err; 8041da177e4SLinus Torvalds 8051da177e4SLinus Torvalds fail: 806adf30907SEric Dumazet IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), 807a11d206dSYOSHIFUJI Hideaki IPSTATS_MIB_FRAGFAILS); 8081da177e4SLinus Torvalds kfree_skb(skb); 8091da177e4SLinus Torvalds return err; 8101da177e4SLinus Torvalds } 8111da177e4SLinus Torvalds 812b71d1d42SEric Dumazet static inline int ip6_rt_check(const struct rt6key *rt_key, 813b71d1d42SEric Dumazet const struct in6_addr *fl_addr, 814b71d1d42SEric Dumazet const struct in6_addr *addr_cache) 815cf6b1982SYOSHIFUJI Hideaki { 816a02cec21SEric Dumazet return (rt_key->plen != 128 || !ipv6_addr_equal(fl_addr, &rt_key->addr)) && 817a02cec21SEric Dumazet (addr_cache == NULL || !ipv6_addr_equal(fl_addr, addr_cache)); 818cf6b1982SYOSHIFUJI Hideaki } 819cf6b1982SYOSHIFUJI Hideaki 820497c615aSHerbert Xu static struct dst_entry *ip6_sk_dst_check(struct sock *sk, 821497c615aSHerbert Xu struct dst_entry *dst, 822b71d1d42SEric Dumazet const struct flowi6 *fl6) 8231da177e4SLinus Torvalds { 8241da177e4SLinus Torvalds struct ipv6_pinfo *np = inet6_sk(sk); 825497c615aSHerbert Xu struct rt6_info *rt = (struct rt6_info *)dst; 8261da177e4SLinus Torvalds 827497c615aSHerbert Xu if (!dst) 828497c615aSHerbert Xu goto out; 8291da177e4SLinus Torvalds 8301da177e4SLinus Torvalds /* Yes, checking route validity in not connected 831d76e60a5SDavid S. Miller * case is not very simple. Take into account, 832d76e60a5SDavid S. Miller * that we do not support routing by source, TOS, 833d76e60a5SDavid S. Miller * and MSG_DONTROUTE --ANK (980726) 834d76e60a5SDavid S. Miller * 835cf6b1982SYOSHIFUJI Hideaki * 1. ip6_rt_check(): If route was host route, 836cf6b1982SYOSHIFUJI Hideaki * check that cached destination is current. 837d76e60a5SDavid S. Miller * If it is network route, we still may 838d76e60a5SDavid S. Miller * check its validity using saved pointer 839d76e60a5SDavid S. Miller * to the last used address: daddr_cache. 840d76e60a5SDavid S. Miller * We do not want to save whole address now, 841d76e60a5SDavid S. Miller * (because main consumer of this service 842d76e60a5SDavid S. Miller * is tcp, which has not this problem), 843d76e60a5SDavid S. Miller * so that the last trick works only on connected 844d76e60a5SDavid S. Miller * sockets. 845d76e60a5SDavid S. Miller * 2. oif also should be the same. 8461da177e4SLinus Torvalds */ 8474c9483b2SDavid S. Miller if (ip6_rt_check(&rt->rt6i_dst, &fl6->daddr, np->daddr_cache) || 8488e1ef0a9SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_SUBTREES 8494c9483b2SDavid S. Miller ip6_rt_check(&rt->rt6i_src, &fl6->saddr, np->saddr_cache) || 8508e1ef0a9SYOSHIFUJI Hideaki #endif 8514c9483b2SDavid S. Miller (fl6->flowi6_oif && fl6->flowi6_oif != dst->dev->ifindex)) { 852497c615aSHerbert Xu dst_release(dst); 853497c615aSHerbert Xu dst = NULL; 8541da177e4SLinus Torvalds } 855497c615aSHerbert Xu 856497c615aSHerbert Xu out: 857497c615aSHerbert Xu return dst; 8581da177e4SLinus Torvalds } 859497c615aSHerbert Xu 860497c615aSHerbert Xu static int ip6_dst_lookup_tail(struct sock *sk, 8614c9483b2SDavid S. Miller struct dst_entry **dst, struct flowi6 *fl6) 862497c615aSHerbert Xu { 8633b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(sk); 86469cce1d1SDavid S. Miller #ifdef CONFIG_IPV6_OPTIMISTIC_DAD 86569cce1d1SDavid S. Miller struct neighbour *n; 86697cac082SDavid S. Miller struct rt6_info *rt; 86769cce1d1SDavid S. Miller #endif 86869cce1d1SDavid S. Miller int err; 8691da177e4SLinus Torvalds 8701da177e4SLinus Torvalds if (*dst == NULL) 8714c9483b2SDavid S. Miller *dst = ip6_route_output(net, sk, fl6); 8721da177e4SLinus Torvalds 8731da177e4SLinus Torvalds if ((err = (*dst)->error)) 8741da177e4SLinus Torvalds goto out_err_release; 8751da177e4SLinus Torvalds 8764c9483b2SDavid S. Miller if (ipv6_addr_any(&fl6->saddr)) { 877c3968a85SDaniel Walter struct rt6_info *rt = (struct rt6_info *) *dst; 878c3968a85SDaniel Walter err = ip6_route_get_saddr(net, rt, &fl6->daddr, 8797cbca67cSYOSHIFUJI Hideaki sk ? inet6_sk(sk)->srcprefs : 0, 8804c9483b2SDavid S. Miller &fl6->saddr); 88144456d37SOlaf Hering if (err) 8821da177e4SLinus Torvalds goto out_err_release; 8831da177e4SLinus Torvalds } 8841da177e4SLinus Torvalds 88595c385b4SNeil Horman #ifdef CONFIG_IPV6_OPTIMISTIC_DAD 88695c385b4SNeil Horman /* 88795c385b4SNeil Horman * Here if the dst entry we've looked up 88895c385b4SNeil Horman * has a neighbour entry that is in the INCOMPLETE 88995c385b4SNeil Horman * state and the src address from the flow is 89095c385b4SNeil Horman * marked as OPTIMISTIC, we release the found 89195c385b4SNeil Horman * dst entry and replace it instead with the 89295c385b4SNeil Horman * dst entry of the nexthop router 89395c385b4SNeil Horman */ 894c56bf6feSEric Dumazet rt = (struct rt6_info *) *dst; 895707be1ffSYOSHIFUJI Hideaki / 吉藤英明 rcu_read_lock_bh(); 896707be1ffSYOSHIFUJI Hideaki / 吉藤英明 n = __ipv6_neigh_lookup_noref(rt->dst.dev, rt6_nexthop(rt, &fl6->daddr)); 897707be1ffSYOSHIFUJI Hideaki / 吉藤英明 err = n && !(n->nud_state & NUD_VALID) ? -EINVAL : 0; 898707be1ffSYOSHIFUJI Hideaki / 吉藤英明 rcu_read_unlock_bh(); 899707be1ffSYOSHIFUJI Hideaki / 吉藤英明 900707be1ffSYOSHIFUJI Hideaki / 吉藤英明 if (err) { 90195c385b4SNeil Horman struct inet6_ifaddr *ifp; 9024c9483b2SDavid S. Miller struct flowi6 fl_gw6; 90395c385b4SNeil Horman int redirect; 90495c385b4SNeil Horman 9054c9483b2SDavid S. Miller ifp = ipv6_get_ifaddr(net, &fl6->saddr, 9061cab3da6SDaniel Lezcano (*dst)->dev, 1); 90795c385b4SNeil Horman 90895c385b4SNeil Horman redirect = (ifp && ifp->flags & IFA_F_OPTIMISTIC); 90995c385b4SNeil Horman if (ifp) 91095c385b4SNeil Horman in6_ifa_put(ifp); 91195c385b4SNeil Horman 91295c385b4SNeil Horman if (redirect) { 91395c385b4SNeil Horman /* 91495c385b4SNeil Horman * We need to get the dst entry for the 91595c385b4SNeil Horman * default router instead 91695c385b4SNeil Horman */ 91795c385b4SNeil Horman dst_release(*dst); 9184c9483b2SDavid S. Miller memcpy(&fl_gw6, fl6, sizeof(struct flowi6)); 9194c9483b2SDavid S. Miller memset(&fl_gw6.daddr, 0, sizeof(struct in6_addr)); 9204c9483b2SDavid S. Miller *dst = ip6_route_output(net, sk, &fl_gw6); 92195c385b4SNeil Horman if ((err = (*dst)->error)) 92295c385b4SNeil Horman goto out_err_release; 92395c385b4SNeil Horman } 92495c385b4SNeil Horman } 92595c385b4SNeil Horman #endif 92695c385b4SNeil Horman 9271da177e4SLinus Torvalds return 0; 9281da177e4SLinus Torvalds 9291da177e4SLinus Torvalds out_err_release: 930ca46f9c8SMitsuru Chinen if (err == -ENETUNREACH) 931483a47d2SDenis V. Lunev IP6_INC_STATS_BH(net, NULL, IPSTATS_MIB_OUTNOROUTES); 9321da177e4SLinus Torvalds dst_release(*dst); 9331da177e4SLinus Torvalds *dst = NULL; 9341da177e4SLinus Torvalds return err; 9351da177e4SLinus Torvalds } 93634a0b3cdSAdrian Bunk 937497c615aSHerbert Xu /** 938497c615aSHerbert Xu * ip6_dst_lookup - perform route lookup on flow 939497c615aSHerbert Xu * @sk: socket which provides route info 940497c615aSHerbert Xu * @dst: pointer to dst_entry * for result 9414c9483b2SDavid S. Miller * @fl6: flow to lookup 942497c615aSHerbert Xu * 943497c615aSHerbert Xu * This function performs a route lookup on the given flow. 944497c615aSHerbert Xu * 945497c615aSHerbert Xu * It returns zero on success, or a standard errno code on error. 946497c615aSHerbert Xu */ 9474c9483b2SDavid S. Miller int ip6_dst_lookup(struct sock *sk, struct dst_entry **dst, struct flowi6 *fl6) 948497c615aSHerbert Xu { 949497c615aSHerbert Xu *dst = NULL; 9504c9483b2SDavid S. Miller return ip6_dst_lookup_tail(sk, dst, fl6); 951497c615aSHerbert Xu } 9523cf3dc6cSArnaldo Carvalho de Melo EXPORT_SYMBOL_GPL(ip6_dst_lookup); 9533cf3dc6cSArnaldo Carvalho de Melo 954497c615aSHerbert Xu /** 95568d0c6d3SDavid S. Miller * ip6_dst_lookup_flow - perform route lookup on flow with ipsec 95668d0c6d3SDavid S. Miller * @sk: socket which provides route info 9574c9483b2SDavid S. Miller * @fl6: flow to lookup 95868d0c6d3SDavid S. Miller * @final_dst: final destination address for ipsec lookup 959a1414715SDavid S. Miller * @can_sleep: we are in a sleepable context 96068d0c6d3SDavid S. Miller * 96168d0c6d3SDavid S. Miller * This function performs a route lookup on the given flow. 96268d0c6d3SDavid S. Miller * 96368d0c6d3SDavid S. Miller * It returns a valid dst pointer on success, or a pointer encoded 96468d0c6d3SDavid S. Miller * error code. 96568d0c6d3SDavid S. Miller */ 9664c9483b2SDavid S. Miller struct dst_entry *ip6_dst_lookup_flow(struct sock *sk, struct flowi6 *fl6, 96768d0c6d3SDavid S. Miller const struct in6_addr *final_dst, 968a1414715SDavid S. Miller bool can_sleep) 96968d0c6d3SDavid S. Miller { 97068d0c6d3SDavid S. Miller struct dst_entry *dst = NULL; 97168d0c6d3SDavid S. Miller int err; 97268d0c6d3SDavid S. Miller 9734c9483b2SDavid S. Miller err = ip6_dst_lookup_tail(sk, &dst, fl6); 97468d0c6d3SDavid S. Miller if (err) 97568d0c6d3SDavid S. Miller return ERR_PTR(err); 97668d0c6d3SDavid S. Miller if (final_dst) 9774e3fd7a0SAlexey Dobriyan fl6->daddr = *final_dst; 9782774c131SDavid S. Miller if (can_sleep) 9794c9483b2SDavid S. Miller fl6->flowi6_flags |= FLOWI_FLAG_CAN_SLEEP; 9802774c131SDavid S. Miller 9814c9483b2SDavid S. Miller return xfrm_lookup(sock_net(sk), dst, flowi6_to_flowi(fl6), sk, 0); 98268d0c6d3SDavid S. Miller } 98368d0c6d3SDavid S. Miller EXPORT_SYMBOL_GPL(ip6_dst_lookup_flow); 98468d0c6d3SDavid S. Miller 98568d0c6d3SDavid S. Miller /** 98668d0c6d3SDavid S. Miller * ip6_sk_dst_lookup_flow - perform socket cached route lookup on flow 98768d0c6d3SDavid S. Miller * @sk: socket which provides the dst cache and route info 9884c9483b2SDavid S. Miller * @fl6: flow to lookup 98968d0c6d3SDavid S. Miller * @final_dst: final destination address for ipsec lookup 990a1414715SDavid S. Miller * @can_sleep: we are in a sleepable context 991497c615aSHerbert Xu * 992497c615aSHerbert Xu * This function performs a route lookup on the given flow with the 993497c615aSHerbert Xu * possibility of using the cached route in the socket if it is valid. 994497c615aSHerbert Xu * It will take the socket dst lock when operating on the dst cache. 995497c615aSHerbert Xu * As a result, this function can only be used in process context. 996497c615aSHerbert Xu * 99768d0c6d3SDavid S. Miller * It returns a valid dst pointer on success, or a pointer encoded 99868d0c6d3SDavid S. Miller * error code. 999497c615aSHerbert Xu */ 10004c9483b2SDavid S. Miller struct dst_entry *ip6_sk_dst_lookup_flow(struct sock *sk, struct flowi6 *fl6, 100168d0c6d3SDavid S. Miller const struct in6_addr *final_dst, 1002a1414715SDavid S. Miller bool can_sleep) 1003497c615aSHerbert Xu { 100468d0c6d3SDavid S. Miller struct dst_entry *dst = sk_dst_check(sk, inet6_sk(sk)->dst_cookie); 100568d0c6d3SDavid S. Miller int err; 1006497c615aSHerbert Xu 10074c9483b2SDavid S. Miller dst = ip6_sk_dst_check(sk, dst, fl6); 100868d0c6d3SDavid S. Miller 10094c9483b2SDavid S. Miller err = ip6_dst_lookup_tail(sk, &dst, fl6); 101068d0c6d3SDavid S. Miller if (err) 101168d0c6d3SDavid S. Miller return ERR_PTR(err); 101268d0c6d3SDavid S. Miller if (final_dst) 10134e3fd7a0SAlexey Dobriyan fl6->daddr = *final_dst; 10142774c131SDavid S. Miller if (can_sleep) 10154c9483b2SDavid S. Miller fl6->flowi6_flags |= FLOWI_FLAG_CAN_SLEEP; 10162774c131SDavid S. Miller 10174c9483b2SDavid S. Miller return xfrm_lookup(sock_net(sk), dst, flowi6_to_flowi(fl6), sk, 0); 101868d0c6d3SDavid S. Miller } 101968d0c6d3SDavid S. Miller EXPORT_SYMBOL_GPL(ip6_sk_dst_lookup_flow); 1020497c615aSHerbert Xu 102134a0b3cdSAdrian Bunk static inline int ip6_ufo_append_data(struct sock *sk, 1022e89e9cf5SAnanda Raju int getfrag(void *from, char *to, int offset, int len, 1023e89e9cf5SAnanda Raju int odd, struct sk_buff *skb), 1024e89e9cf5SAnanda Raju void *from, int length, int hh_len, int fragheaderlen, 102587c48fa3SEric Dumazet int transhdrlen, int mtu,unsigned int flags, 102687c48fa3SEric Dumazet struct rt6_info *rt) 1027e89e9cf5SAnanda Raju 1028e89e9cf5SAnanda Raju { 1029e89e9cf5SAnanda Raju struct sk_buff *skb; 1030e89e9cf5SAnanda Raju int err; 1031e89e9cf5SAnanda Raju 1032e89e9cf5SAnanda Raju /* There is support for UDP large send offload by network 1033e89e9cf5SAnanda Raju * device, so create one single skb packet containing complete 1034e89e9cf5SAnanda Raju * udp datagram 1035e89e9cf5SAnanda Raju */ 1036e89e9cf5SAnanda Raju if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL) { 1037e89e9cf5SAnanda Raju skb = sock_alloc_send_skb(sk, 1038e89e9cf5SAnanda Raju hh_len + fragheaderlen + transhdrlen + 20, 1039e89e9cf5SAnanda Raju (flags & MSG_DONTWAIT), &err); 1040e89e9cf5SAnanda Raju if (skb == NULL) 1041504744e4SZheng Yan return err; 1042e89e9cf5SAnanda Raju 1043e89e9cf5SAnanda Raju /* reserve space for Hardware header */ 1044e89e9cf5SAnanda Raju skb_reserve(skb, hh_len); 1045e89e9cf5SAnanda Raju 1046e89e9cf5SAnanda Raju /* create space for UDP/IP header */ 1047e89e9cf5SAnanda Raju skb_put(skb,fragheaderlen + transhdrlen); 1048e89e9cf5SAnanda Raju 1049e89e9cf5SAnanda Raju /* initialize network header pointer */ 1050c1d2bbe1SArnaldo Carvalho de Melo skb_reset_network_header(skb); 1051e89e9cf5SAnanda Raju 1052e89e9cf5SAnanda Raju /* initialize protocol header pointer */ 1053b0e380b1SArnaldo Carvalho de Melo skb->transport_header = skb->network_header + fragheaderlen; 1054e89e9cf5SAnanda Raju 105584fa7933SPatrick McHardy skb->ip_summed = CHECKSUM_PARTIAL; 1056e89e9cf5SAnanda Raju skb->csum = 0; 1057e89e9cf5SAnanda Raju } 1058e89e9cf5SAnanda Raju 1059e89e9cf5SAnanda Raju err = skb_append_datato_frags(sk,skb, getfrag, from, 1060e89e9cf5SAnanda Raju (length - transhdrlen)); 1061e89e9cf5SAnanda Raju if (!err) { 1062e89e9cf5SAnanda Raju struct frag_hdr fhdr; 1063e89e9cf5SAnanda Raju 1064c31d5326SSridhar Samudrala /* Specify the length of each IPv6 datagram fragment. 1065c31d5326SSridhar Samudrala * It has to be a multiple of 8. 1066c31d5326SSridhar Samudrala */ 1067c31d5326SSridhar Samudrala skb_shinfo(skb)->gso_size = (mtu - fragheaderlen - 1068c31d5326SSridhar Samudrala sizeof(struct frag_hdr)) & ~7; 1069f83ef8c0SHerbert Xu skb_shinfo(skb)->gso_type = SKB_GSO_UDP; 107087c48fa3SEric Dumazet ipv6_select_ident(&fhdr, rt); 1071e89e9cf5SAnanda Raju skb_shinfo(skb)->ip6_frag_id = fhdr.identification; 1072e89e9cf5SAnanda Raju __skb_queue_tail(&sk->sk_write_queue, skb); 1073e89e9cf5SAnanda Raju 1074e89e9cf5SAnanda Raju return 0; 1075e89e9cf5SAnanda Raju } 1076e89e9cf5SAnanda Raju /* There is not enough support do UPD LSO, 1077e89e9cf5SAnanda Raju * so follow normal path 1078e89e9cf5SAnanda Raju */ 1079e89e9cf5SAnanda Raju kfree_skb(skb); 1080e89e9cf5SAnanda Raju 1081e89e9cf5SAnanda Raju return err; 1082e89e9cf5SAnanda Raju } 10831da177e4SLinus Torvalds 10840178b695SHerbert Xu static inline struct ipv6_opt_hdr *ip6_opt_dup(struct ipv6_opt_hdr *src, 10850178b695SHerbert Xu gfp_t gfp) 10860178b695SHerbert Xu { 10870178b695SHerbert Xu return src ? kmemdup(src, (src->hdrlen + 1) * 8, gfp) : NULL; 10880178b695SHerbert Xu } 10890178b695SHerbert Xu 10900178b695SHerbert Xu static inline struct ipv6_rt_hdr *ip6_rthdr_dup(struct ipv6_rt_hdr *src, 10910178b695SHerbert Xu gfp_t gfp) 10920178b695SHerbert Xu { 10930178b695SHerbert Xu return src ? kmemdup(src, (src->hdrlen + 1) * 8, gfp) : NULL; 10940178b695SHerbert Xu } 10950178b695SHerbert Xu 10960c183379SGao feng static void ip6_append_data_mtu(int *mtu, 10970c183379SGao feng int *maxfraglen, 10980c183379SGao feng unsigned int fragheaderlen, 10990c183379SGao feng struct sk_buff *skb, 11000c183379SGao feng struct rt6_info *rt) 11010c183379SGao feng { 11020c183379SGao feng if (!(rt->dst.flags & DST_XFRM_TUNNEL)) { 11030c183379SGao feng if (skb == NULL) { 11040c183379SGao feng /* first fragment, reserve header_len */ 11050c183379SGao feng *mtu = *mtu - rt->dst.header_len; 11060c183379SGao feng 11070c183379SGao feng } else { 11080c183379SGao feng /* 11090c183379SGao feng * this fragment is not first, the headers 11100c183379SGao feng * space is regarded as data space. 11110c183379SGao feng */ 11120c183379SGao feng *mtu = dst_mtu(rt->dst.path); 11130c183379SGao feng } 11140c183379SGao feng *maxfraglen = ((*mtu - fragheaderlen) & ~7) 11150c183379SGao feng + fragheaderlen - sizeof(struct frag_hdr); 11160c183379SGao feng } 11170c183379SGao feng } 11180c183379SGao feng 111941a1f8eaSYOSHIFUJI Hideaki int ip6_append_data(struct sock *sk, int getfrag(void *from, char *to, 112041a1f8eaSYOSHIFUJI Hideaki int offset, int len, int odd, struct sk_buff *skb), 11211da177e4SLinus Torvalds void *from, int length, int transhdrlen, 11224c9483b2SDavid S. Miller int hlimit, int tclass, struct ipv6_txoptions *opt, struct flowi6 *fl6, 112313b52cd4SBrian Haley struct rt6_info *rt, unsigned int flags, int dontfrag) 11241da177e4SLinus Torvalds { 11251da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sk); 11261da177e4SLinus Torvalds struct ipv6_pinfo *np = inet6_sk(sk); 1127bdc712b4SDavid S. Miller struct inet_cork *cork; 11280c183379SGao feng struct sk_buff *skb, *skb_prev = NULL; 11291da177e4SLinus Torvalds unsigned int maxfraglen, fragheaderlen; 11301da177e4SLinus Torvalds int exthdrlen; 1131299b0767SSteffen Klassert int dst_exthdrlen; 11321da177e4SLinus Torvalds int hh_len; 11331da177e4SLinus Torvalds int mtu; 11341da177e4SLinus Torvalds int copy; 11351da177e4SLinus Torvalds int err; 11361da177e4SLinus Torvalds int offset = 0; 1137a693e698SAnders Berggren __u8 tx_flags = 0; 11381da177e4SLinus Torvalds 11391da177e4SLinus Torvalds if (flags&MSG_PROBE) 11401da177e4SLinus Torvalds return 0; 1141bdc712b4SDavid S. Miller cork = &inet->cork.base; 11421da177e4SLinus Torvalds if (skb_queue_empty(&sk->sk_write_queue)) { 11431da177e4SLinus Torvalds /* 11441da177e4SLinus Torvalds * setup for corking 11451da177e4SLinus Torvalds */ 11461da177e4SLinus Torvalds if (opt) { 11470178b695SHerbert Xu if (WARN_ON(np->cork.opt)) 11480178b695SHerbert Xu return -EINVAL; 11490178b695SHerbert Xu 11500178b695SHerbert Xu np->cork.opt = kmalloc(opt->tot_len, sk->sk_allocation); 11511da177e4SLinus Torvalds if (unlikely(np->cork.opt == NULL)) 11521da177e4SLinus Torvalds return -ENOBUFS; 11530178b695SHerbert Xu 11540178b695SHerbert Xu np->cork.opt->tot_len = opt->tot_len; 11550178b695SHerbert Xu np->cork.opt->opt_flen = opt->opt_flen; 11560178b695SHerbert Xu np->cork.opt->opt_nflen = opt->opt_nflen; 11570178b695SHerbert Xu 11580178b695SHerbert Xu np->cork.opt->dst0opt = ip6_opt_dup(opt->dst0opt, 11590178b695SHerbert Xu sk->sk_allocation); 11600178b695SHerbert Xu if (opt->dst0opt && !np->cork.opt->dst0opt) 11610178b695SHerbert Xu return -ENOBUFS; 11620178b695SHerbert Xu 11630178b695SHerbert Xu np->cork.opt->dst1opt = ip6_opt_dup(opt->dst1opt, 11640178b695SHerbert Xu sk->sk_allocation); 11650178b695SHerbert Xu if (opt->dst1opt && !np->cork.opt->dst1opt) 11660178b695SHerbert Xu return -ENOBUFS; 11670178b695SHerbert Xu 11680178b695SHerbert Xu np->cork.opt->hopopt = ip6_opt_dup(opt->hopopt, 11690178b695SHerbert Xu sk->sk_allocation); 11700178b695SHerbert Xu if (opt->hopopt && !np->cork.opt->hopopt) 11710178b695SHerbert Xu return -ENOBUFS; 11720178b695SHerbert Xu 11730178b695SHerbert Xu np->cork.opt->srcrt = ip6_rthdr_dup(opt->srcrt, 11740178b695SHerbert Xu sk->sk_allocation); 11750178b695SHerbert Xu if (opt->srcrt && !np->cork.opt->srcrt) 11760178b695SHerbert Xu return -ENOBUFS; 11770178b695SHerbert Xu 11781da177e4SLinus Torvalds /* need source address above miyazawa*/ 11791da177e4SLinus Torvalds } 1180d8d1f30bSChangli Gao dst_hold(&rt->dst); 1181bdc712b4SDavid S. Miller cork->dst = &rt->dst; 11824c9483b2SDavid S. Miller inet->cork.fl.u.ip6 = *fl6; 11831da177e4SLinus Torvalds np->cork.hop_limit = hlimit; 118441a1f8eaSYOSHIFUJI Hideaki np->cork.tclass = tclass; 11850c183379SGao feng if (rt->dst.flags & DST_XFRM_TUNNEL) 1186628a5c56SJohn Heffner mtu = np->pmtudisc == IPV6_PMTUDISC_PROBE ? 1187299b0767SSteffen Klassert rt->dst.dev->mtu : dst_mtu(&rt->dst); 11880c183379SGao feng else 11890c183379SGao feng mtu = np->pmtudisc == IPV6_PMTUDISC_PROBE ? 11900c183379SGao feng rt->dst.dev->mtu : dst_mtu(rt->dst.path); 1191c7503609SDave Jones if (np->frag_size < mtu) { 1192d91675f9SYOSHIFUJI Hideaki if (np->frag_size) 1193d91675f9SYOSHIFUJI Hideaki mtu = np->frag_size; 1194d91675f9SYOSHIFUJI Hideaki } 1195bdc712b4SDavid S. Miller cork->fragsize = mtu; 1196d8d1f30bSChangli Gao if (dst_allfrag(rt->dst.path)) 1197bdc712b4SDavid S. Miller cork->flags |= IPCORK_ALLFRAG; 1198bdc712b4SDavid S. Miller cork->length = 0; 11997efdba5bSRomain KUNTZ exthdrlen = (opt ? opt->opt_flen : 0); 12001da177e4SLinus Torvalds length += exthdrlen; 12011da177e4SLinus Torvalds transhdrlen += exthdrlen; 12027efdba5bSRomain KUNTZ dst_exthdrlen = rt->dst.header_len - rt->rt6i_nfheader_len; 12031da177e4SLinus Torvalds } else { 1204bdc712b4SDavid S. Miller rt = (struct rt6_info *)cork->dst; 12054c9483b2SDavid S. Miller fl6 = &inet->cork.fl.u.ip6; 12061da177e4SLinus Torvalds opt = np->cork.opt; 12071da177e4SLinus Torvalds transhdrlen = 0; 12081da177e4SLinus Torvalds exthdrlen = 0; 1209299b0767SSteffen Klassert dst_exthdrlen = 0; 1210bdc712b4SDavid S. Miller mtu = cork->fragsize; 12111da177e4SLinus Torvalds } 12121da177e4SLinus Torvalds 1213d8d1f30bSChangli Gao hh_len = LL_RESERVED_SPACE(rt->dst.dev); 12141da177e4SLinus Torvalds 1215a1b05140SMasahide NAKAMURA fragheaderlen = sizeof(struct ipv6hdr) + rt->rt6i_nfheader_len + 1216b4ce9277SHerbert Xu (opt ? opt->opt_nflen : 0); 12171da177e4SLinus Torvalds maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen - sizeof(struct frag_hdr); 12181da177e4SLinus Torvalds 12191da177e4SLinus Torvalds if (mtu <= sizeof(struct ipv6hdr) + IPV6_MAXPLEN) { 1220bdc712b4SDavid S. Miller if (cork->length + length > sizeof(struct ipv6hdr) + IPV6_MAXPLEN - fragheaderlen) { 12214c9483b2SDavid S. Miller ipv6_local_error(sk, EMSGSIZE, fl6, mtu-exthdrlen); 12221da177e4SLinus Torvalds return -EMSGSIZE; 12231da177e4SLinus Torvalds } 12241da177e4SLinus Torvalds } 12251da177e4SLinus Torvalds 1226a693e698SAnders Berggren /* For UDP, check if TX timestamp is enabled */ 1227*bf84a010SDaniel Borkmann if (sk->sk_type == SOCK_DGRAM) 1228*bf84a010SDaniel Borkmann sock_tx_timestamp(sk, &tx_flags); 1229a693e698SAnders Berggren 12301da177e4SLinus Torvalds /* 12311da177e4SLinus Torvalds * Let's try using as much space as possible. 12321da177e4SLinus Torvalds * Use MTU if total length of the message fits into the MTU. 12331da177e4SLinus Torvalds * Otherwise, we need to reserve fragment header and 12341da177e4SLinus Torvalds * fragment alignment (= 8-15 octects, in total). 12351da177e4SLinus Torvalds * 12361da177e4SLinus Torvalds * Note that we may need to "move" the data from the tail of 12371da177e4SLinus Torvalds * of the buffer to the new fragment when we split 12381da177e4SLinus Torvalds * the message. 12391da177e4SLinus Torvalds * 12401da177e4SLinus Torvalds * FIXME: It may be fragmented into multiple chunks 12411da177e4SLinus Torvalds * at once if non-fragmentable extension headers 12421da177e4SLinus Torvalds * are too large. 12431da177e4SLinus Torvalds * --yoshfuji 12441da177e4SLinus Torvalds */ 12451da177e4SLinus Torvalds 1246bdc712b4SDavid S. Miller cork->length += length; 12474b340ae2SBrian Haley if (length > mtu) { 12484b340ae2SBrian Haley int proto = sk->sk_protocol; 12494b340ae2SBrian Haley if (dontfrag && (proto == IPPROTO_UDP || proto == IPPROTO_RAW)){ 12504c9483b2SDavid S. Miller ipv6_local_rxpmtu(sk, fl6, mtu-exthdrlen); 12514b340ae2SBrian Haley return -EMSGSIZE; 12524b340ae2SBrian Haley } 12534b340ae2SBrian Haley 12544b340ae2SBrian Haley if (proto == IPPROTO_UDP && 1255d8d1f30bSChangli Gao (rt->dst.dev->features & NETIF_F_UFO)) { 1256e89e9cf5SAnanda Raju 12574b340ae2SBrian Haley err = ip6_ufo_append_data(sk, getfrag, from, length, 12584b340ae2SBrian Haley hh_len, fragheaderlen, 125987c48fa3SEric Dumazet transhdrlen, mtu, flags, rt); 1260baa829d8SPatrick McHardy if (err) 1261e89e9cf5SAnanda Raju goto error; 1262e89e9cf5SAnanda Raju return 0; 1263e89e9cf5SAnanda Raju } 12644b340ae2SBrian Haley } 12651da177e4SLinus Torvalds 12661da177e4SLinus Torvalds if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL) 12671da177e4SLinus Torvalds goto alloc_new_skb; 12681da177e4SLinus Torvalds 12691da177e4SLinus Torvalds while (length > 0) { 12701da177e4SLinus Torvalds /* Check if the remaining data fits into current packet. */ 1271bdc712b4SDavid S. Miller copy = (cork->length <= mtu && !(cork->flags & IPCORK_ALLFRAG) ? mtu : maxfraglen) - skb->len; 12721da177e4SLinus Torvalds if (copy < length) 12731da177e4SLinus Torvalds copy = maxfraglen - skb->len; 12741da177e4SLinus Torvalds 12751da177e4SLinus Torvalds if (copy <= 0) { 12761da177e4SLinus Torvalds char *data; 12771da177e4SLinus Torvalds unsigned int datalen; 12781da177e4SLinus Torvalds unsigned int fraglen; 12791da177e4SLinus Torvalds unsigned int fraggap; 12801da177e4SLinus Torvalds unsigned int alloclen; 12811da177e4SLinus Torvalds alloc_new_skb: 12821da177e4SLinus Torvalds /* There's no room in the current skb */ 12830c183379SGao feng if (skb) 12840c183379SGao feng fraggap = skb->len - maxfraglen; 12851da177e4SLinus Torvalds else 12861da177e4SLinus Torvalds fraggap = 0; 12870c183379SGao feng /* update mtu and maxfraglen if necessary */ 12880c183379SGao feng if (skb == NULL || skb_prev == NULL) 12890c183379SGao feng ip6_append_data_mtu(&mtu, &maxfraglen, 12900c183379SGao feng fragheaderlen, skb, rt); 12910c183379SGao feng 12920c183379SGao feng skb_prev = skb; 12931da177e4SLinus Torvalds 12941da177e4SLinus Torvalds /* 12951da177e4SLinus Torvalds * If remaining data exceeds the mtu, 12961da177e4SLinus Torvalds * we know we need more fragment(s). 12971da177e4SLinus Torvalds */ 12981da177e4SLinus Torvalds datalen = length + fraggap; 12991da177e4SLinus Torvalds 13000c183379SGao feng if (datalen > (cork->length <= mtu && !(cork->flags & IPCORK_ALLFRAG) ? mtu : maxfraglen) - fragheaderlen) 13010c183379SGao feng datalen = maxfraglen - fragheaderlen - rt->dst.trailer_len; 13021da177e4SLinus Torvalds if ((flags & MSG_MORE) && 1303d8d1f30bSChangli Gao !(rt->dst.dev->features&NETIF_F_SG)) 13041da177e4SLinus Torvalds alloclen = mtu; 13051da177e4SLinus Torvalds else 13061da177e4SLinus Torvalds alloclen = datalen + fragheaderlen; 13071da177e4SLinus Torvalds 1308299b0767SSteffen Klassert alloclen += dst_exthdrlen; 1309299b0767SSteffen Klassert 13100c183379SGao feng if (datalen != length + fraggap) { 13111da177e4SLinus Torvalds /* 13120c183379SGao feng * this is not the last fragment, the trailer 13130c183379SGao feng * space is regarded as data space. 13141da177e4SLinus Torvalds */ 13150c183379SGao feng datalen += rt->dst.trailer_len; 13160c183379SGao feng } 13170c183379SGao feng 1318d8d1f30bSChangli Gao alloclen += rt->dst.trailer_len; 13190c183379SGao feng fraglen = datalen + fragheaderlen; 13201da177e4SLinus Torvalds 13211da177e4SLinus Torvalds /* 13221da177e4SLinus Torvalds * We just reserve space for fragment header. 13231da177e4SLinus Torvalds * Note: this may be overallocation if the message 13241da177e4SLinus Torvalds * (without MSG_MORE) fits into the MTU. 13251da177e4SLinus Torvalds */ 13261da177e4SLinus Torvalds alloclen += sizeof(struct frag_hdr); 13271da177e4SLinus Torvalds 13281da177e4SLinus Torvalds if (transhdrlen) { 13291da177e4SLinus Torvalds skb = sock_alloc_send_skb(sk, 13301da177e4SLinus Torvalds alloclen + hh_len, 13311da177e4SLinus Torvalds (flags & MSG_DONTWAIT), &err); 13321da177e4SLinus Torvalds } else { 13331da177e4SLinus Torvalds skb = NULL; 13341da177e4SLinus Torvalds if (atomic_read(&sk->sk_wmem_alloc) <= 13351da177e4SLinus Torvalds 2 * sk->sk_sndbuf) 13361da177e4SLinus Torvalds skb = sock_wmalloc(sk, 13371da177e4SLinus Torvalds alloclen + hh_len, 1, 13381da177e4SLinus Torvalds sk->sk_allocation); 13391da177e4SLinus Torvalds if (unlikely(skb == NULL)) 13401da177e4SLinus Torvalds err = -ENOBUFS; 1341a693e698SAnders Berggren else { 1342a693e698SAnders Berggren /* Only the initial fragment 1343a693e698SAnders Berggren * is time stamped. 1344a693e698SAnders Berggren */ 1345a693e698SAnders Berggren tx_flags = 0; 1346a693e698SAnders Berggren } 13471da177e4SLinus Torvalds } 13481da177e4SLinus Torvalds if (skb == NULL) 13491da177e4SLinus Torvalds goto error; 13501da177e4SLinus Torvalds /* 13511da177e4SLinus Torvalds * Fill in the control structures 13521da177e4SLinus Torvalds */ 1353d7f7c0acSEric Dumazet skb->ip_summed = CHECKSUM_NONE; 13541da177e4SLinus Torvalds skb->csum = 0; 13551f85851eSGao feng /* reserve for fragmentation and ipsec header */ 13561f85851eSGao feng skb_reserve(skb, hh_len + sizeof(struct frag_hdr) + 13571f85851eSGao feng dst_exthdrlen); 13581da177e4SLinus Torvalds 1359a693e698SAnders Berggren if (sk->sk_type == SOCK_DGRAM) 1360a693e698SAnders Berggren skb_shinfo(skb)->tx_flags = tx_flags; 1361a693e698SAnders Berggren 13621da177e4SLinus Torvalds /* 13631da177e4SLinus Torvalds * Find where to start putting bytes 13641da177e4SLinus Torvalds */ 13651f85851eSGao feng data = skb_put(skb, fraglen); 13661f85851eSGao feng skb_set_network_header(skb, exthdrlen); 13671f85851eSGao feng data += fragheaderlen; 1368b0e380b1SArnaldo Carvalho de Melo skb->transport_header = (skb->network_header + 1369b0e380b1SArnaldo Carvalho de Melo fragheaderlen); 13701da177e4SLinus Torvalds if (fraggap) { 13711da177e4SLinus Torvalds skb->csum = skb_copy_and_csum_bits( 13721da177e4SLinus Torvalds skb_prev, maxfraglen, 13731da177e4SLinus Torvalds data + transhdrlen, fraggap, 0); 13741da177e4SLinus Torvalds skb_prev->csum = csum_sub(skb_prev->csum, 13751da177e4SLinus Torvalds skb->csum); 13761da177e4SLinus Torvalds data += fraggap; 1377e9fa4f7bSHerbert Xu pskb_trim_unique(skb_prev, maxfraglen); 13781da177e4SLinus Torvalds } 13791da177e4SLinus Torvalds copy = datalen - transhdrlen - fraggap; 1380299b0767SSteffen Klassert 13811da177e4SLinus Torvalds if (copy < 0) { 13821da177e4SLinus Torvalds err = -EINVAL; 13831da177e4SLinus Torvalds kfree_skb(skb); 13841da177e4SLinus Torvalds goto error; 13851da177e4SLinus Torvalds } else if (copy > 0 && getfrag(from, data + transhdrlen, offset, copy, fraggap, skb) < 0) { 13861da177e4SLinus Torvalds err = -EFAULT; 13871da177e4SLinus Torvalds kfree_skb(skb); 13881da177e4SLinus Torvalds goto error; 13891da177e4SLinus Torvalds } 13901da177e4SLinus Torvalds 13911da177e4SLinus Torvalds offset += copy; 13921da177e4SLinus Torvalds length -= datalen - fraggap; 13931da177e4SLinus Torvalds transhdrlen = 0; 13941da177e4SLinus Torvalds exthdrlen = 0; 1395299b0767SSteffen Klassert dst_exthdrlen = 0; 13961da177e4SLinus Torvalds 13971da177e4SLinus Torvalds /* 13981da177e4SLinus Torvalds * Put the packet on the pending queue 13991da177e4SLinus Torvalds */ 14001da177e4SLinus Torvalds __skb_queue_tail(&sk->sk_write_queue, skb); 14011da177e4SLinus Torvalds continue; 14021da177e4SLinus Torvalds } 14031da177e4SLinus Torvalds 14041da177e4SLinus Torvalds if (copy > length) 14051da177e4SLinus Torvalds copy = length; 14061da177e4SLinus Torvalds 1407d8d1f30bSChangli Gao if (!(rt->dst.dev->features&NETIF_F_SG)) { 14081da177e4SLinus Torvalds unsigned int off; 14091da177e4SLinus Torvalds 14101da177e4SLinus Torvalds off = skb->len; 14111da177e4SLinus Torvalds if (getfrag(from, skb_put(skb, copy), 14121da177e4SLinus Torvalds offset, copy, off, skb) < 0) { 14131da177e4SLinus Torvalds __skb_trim(skb, off); 14141da177e4SLinus Torvalds err = -EFAULT; 14151da177e4SLinus Torvalds goto error; 14161da177e4SLinus Torvalds } 14171da177e4SLinus Torvalds } else { 14181da177e4SLinus Torvalds int i = skb_shinfo(skb)->nr_frags; 14195640f768SEric Dumazet struct page_frag *pfrag = sk_page_frag(sk); 14201da177e4SLinus Torvalds 14211da177e4SLinus Torvalds err = -ENOMEM; 14225640f768SEric Dumazet if (!sk_page_frag_refill(sk, pfrag)) 14231da177e4SLinus Torvalds goto error; 14241da177e4SLinus Torvalds 14255640f768SEric Dumazet if (!skb_can_coalesce(skb, i, pfrag->page, 14265640f768SEric Dumazet pfrag->offset)) { 14271da177e4SLinus Torvalds err = -EMSGSIZE; 14285640f768SEric Dumazet if (i == MAX_SKB_FRAGS) 14291da177e4SLinus Torvalds goto error; 14305640f768SEric Dumazet 14315640f768SEric Dumazet __skb_fill_page_desc(skb, i, pfrag->page, 14325640f768SEric Dumazet pfrag->offset, 0); 14335640f768SEric Dumazet skb_shinfo(skb)->nr_frags = ++i; 14345640f768SEric Dumazet get_page(pfrag->page); 14351da177e4SLinus Torvalds } 14365640f768SEric Dumazet copy = min_t(int, copy, pfrag->size - pfrag->offset); 14379e903e08SEric Dumazet if (getfrag(from, 14385640f768SEric Dumazet page_address(pfrag->page) + pfrag->offset, 14395640f768SEric Dumazet offset, copy, skb->len, skb) < 0) 14405640f768SEric Dumazet goto error_efault; 14415640f768SEric Dumazet 14425640f768SEric Dumazet pfrag->offset += copy; 14435640f768SEric Dumazet skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy); 14441da177e4SLinus Torvalds skb->len += copy; 14451da177e4SLinus Torvalds skb->data_len += copy; 1446f945fa7aSHerbert Xu skb->truesize += copy; 1447f945fa7aSHerbert Xu atomic_add(copy, &sk->sk_wmem_alloc); 14481da177e4SLinus Torvalds } 14491da177e4SLinus Torvalds offset += copy; 14501da177e4SLinus Torvalds length -= copy; 14511da177e4SLinus Torvalds } 14525640f768SEric Dumazet 14531da177e4SLinus Torvalds return 0; 14545640f768SEric Dumazet 14555640f768SEric Dumazet error_efault: 14565640f768SEric Dumazet err = -EFAULT; 14571da177e4SLinus Torvalds error: 1458bdc712b4SDavid S. Miller cork->length -= length; 14593bd653c8SDenis V. Lunev IP6_INC_STATS(sock_net(sk), rt->rt6i_idev, IPSTATS_MIB_OUTDISCARDS); 14601da177e4SLinus Torvalds return err; 14611da177e4SLinus Torvalds } 1462a495f836SChris Elston EXPORT_SYMBOL_GPL(ip6_append_data); 14631da177e4SLinus Torvalds 1464bf138862SPavel Emelyanov static void ip6_cork_release(struct inet_sock *inet, struct ipv6_pinfo *np) 1465bf138862SPavel Emelyanov { 14660178b695SHerbert Xu if (np->cork.opt) { 14670178b695SHerbert Xu kfree(np->cork.opt->dst0opt); 14680178b695SHerbert Xu kfree(np->cork.opt->dst1opt); 14690178b695SHerbert Xu kfree(np->cork.opt->hopopt); 14700178b695SHerbert Xu kfree(np->cork.opt->srcrt); 1471bf138862SPavel Emelyanov kfree(np->cork.opt); 1472bf138862SPavel Emelyanov np->cork.opt = NULL; 14730178b695SHerbert Xu } 14740178b695SHerbert Xu 1475bdc712b4SDavid S. Miller if (inet->cork.base.dst) { 1476bdc712b4SDavid S. Miller dst_release(inet->cork.base.dst); 1477bdc712b4SDavid S. Miller inet->cork.base.dst = NULL; 1478bdc712b4SDavid S. Miller inet->cork.base.flags &= ~IPCORK_ALLFRAG; 1479bf138862SPavel Emelyanov } 1480bf138862SPavel Emelyanov memset(&inet->cork.fl, 0, sizeof(inet->cork.fl)); 1481bf138862SPavel Emelyanov } 1482bf138862SPavel Emelyanov 14831da177e4SLinus Torvalds int ip6_push_pending_frames(struct sock *sk) 14841da177e4SLinus Torvalds { 14851da177e4SLinus Torvalds struct sk_buff *skb, *tmp_skb; 14861da177e4SLinus Torvalds struct sk_buff **tail_skb; 14871da177e4SLinus Torvalds struct in6_addr final_dst_buf, *final_dst = &final_dst_buf; 14881da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sk); 14891da177e4SLinus Torvalds struct ipv6_pinfo *np = inet6_sk(sk); 14903bd653c8SDenis V. Lunev struct net *net = sock_net(sk); 14911da177e4SLinus Torvalds struct ipv6hdr *hdr; 14921da177e4SLinus Torvalds struct ipv6_txoptions *opt = np->cork.opt; 1493bdc712b4SDavid S. Miller struct rt6_info *rt = (struct rt6_info *)inet->cork.base.dst; 14944c9483b2SDavid S. Miller struct flowi6 *fl6 = &inet->cork.fl.u.ip6; 14954c9483b2SDavid S. Miller unsigned char proto = fl6->flowi6_proto; 14961da177e4SLinus Torvalds int err = 0; 14971da177e4SLinus Torvalds 14981da177e4SLinus Torvalds if ((skb = __skb_dequeue(&sk->sk_write_queue)) == NULL) 14991da177e4SLinus Torvalds goto out; 15001da177e4SLinus Torvalds tail_skb = &(skb_shinfo(skb)->frag_list); 15011da177e4SLinus Torvalds 15021da177e4SLinus Torvalds /* move skb->data to ip header from ext header */ 1503d56f90a7SArnaldo Carvalho de Melo if (skb->data < skb_network_header(skb)) 1504bbe735e4SArnaldo Carvalho de Melo __skb_pull(skb, skb_network_offset(skb)); 15051da177e4SLinus Torvalds while ((tmp_skb = __skb_dequeue(&sk->sk_write_queue)) != NULL) { 1506cfe1fc77SArnaldo Carvalho de Melo __skb_pull(tmp_skb, skb_network_header_len(skb)); 15071da177e4SLinus Torvalds *tail_skb = tmp_skb; 15081da177e4SLinus Torvalds tail_skb = &(tmp_skb->next); 15091da177e4SLinus Torvalds skb->len += tmp_skb->len; 15101da177e4SLinus Torvalds skb->data_len += tmp_skb->len; 15111da177e4SLinus Torvalds skb->truesize += tmp_skb->truesize; 15121da177e4SLinus Torvalds tmp_skb->destructor = NULL; 15131da177e4SLinus Torvalds tmp_skb->sk = NULL; 15141da177e4SLinus Torvalds } 15151da177e4SLinus Torvalds 151628a89453SHerbert Xu /* Allow local fragmentation. */ 1517b5c15fc0SHerbert Xu if (np->pmtudisc < IPV6_PMTUDISC_DO) 151828a89453SHerbert Xu skb->local_df = 1; 151928a89453SHerbert Xu 15204e3fd7a0SAlexey Dobriyan *final_dst = fl6->daddr; 1521cfe1fc77SArnaldo Carvalho de Melo __skb_pull(skb, skb_network_header_len(skb)); 15221da177e4SLinus Torvalds if (opt && opt->opt_flen) 15231da177e4SLinus Torvalds ipv6_push_frag_opts(skb, opt, &proto); 15241da177e4SLinus Torvalds if (opt && opt->opt_nflen) 15251da177e4SLinus Torvalds ipv6_push_nfrag_opts(skb, opt, &proto, &final_dst); 15261da177e4SLinus Torvalds 1527e2d1bca7SArnaldo Carvalho de Melo skb_push(skb, sizeof(struct ipv6hdr)); 1528e2d1bca7SArnaldo Carvalho de Melo skb_reset_network_header(skb); 15290660e03fSArnaldo Carvalho de Melo hdr = ipv6_hdr(skb); 15301da177e4SLinus Torvalds 15313e4e4c1fSYOSHIFUJI Hideaki / 吉藤英明 ip6_flow_hdr(hdr, np->cork.tclass, fl6->flowlabel); 15321da177e4SLinus Torvalds hdr->hop_limit = np->cork.hop_limit; 15331da177e4SLinus Torvalds hdr->nexthdr = proto; 15344e3fd7a0SAlexey Dobriyan hdr->saddr = fl6->saddr; 15354e3fd7a0SAlexey Dobriyan hdr->daddr = *final_dst; 15361da177e4SLinus Torvalds 1537a2c2064fSPatrick McHardy skb->priority = sk->sk_priority; 15384a19ec58SLaszlo Attila Toth skb->mark = sk->sk_mark; 1539a2c2064fSPatrick McHardy 1540d8d1f30bSChangli Gao skb_dst_set(skb, dst_clone(&rt->dst)); 1541edf391ffSNeil Horman IP6_UPD_PO_STATS(net, rt->rt6i_idev, IPSTATS_MIB_OUT, skb->len); 154214878f75SDavid L Stevens if (proto == IPPROTO_ICMPV6) { 1543adf30907SEric Dumazet struct inet6_dev *idev = ip6_dst_idev(skb_dst(skb)); 154414878f75SDavid L Stevens 15455a57d4c7SDenis V. Lunev ICMP6MSGOUT_INC_STATS_BH(net, idev, icmp6_hdr(skb)->icmp6_type); 1546e41b5368SDenis V. Lunev ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTMSGS); 154714878f75SDavid L Stevens } 154814878f75SDavid L Stevens 1549ef76bc23SHerbert Xu err = ip6_local_out(skb); 15501da177e4SLinus Torvalds if (err) { 15511da177e4SLinus Torvalds if (err > 0) 15526ce9e7b5SEric Dumazet err = net_xmit_errno(err); 15531da177e4SLinus Torvalds if (err) 15541da177e4SLinus Torvalds goto error; 15551da177e4SLinus Torvalds } 15561da177e4SLinus Torvalds 15571da177e4SLinus Torvalds out: 1558bf138862SPavel Emelyanov ip6_cork_release(inet, np); 15591da177e4SLinus Torvalds return err; 15601da177e4SLinus Torvalds error: 156106254914SEric Dumazet IP6_INC_STATS(net, rt->rt6i_idev, IPSTATS_MIB_OUTDISCARDS); 15621da177e4SLinus Torvalds goto out; 15631da177e4SLinus Torvalds } 1564a495f836SChris Elston EXPORT_SYMBOL_GPL(ip6_push_pending_frames); 15651da177e4SLinus Torvalds 15661da177e4SLinus Torvalds void ip6_flush_pending_frames(struct sock *sk) 15671da177e4SLinus Torvalds { 15681da177e4SLinus Torvalds struct sk_buff *skb; 15691da177e4SLinus Torvalds 15701da177e4SLinus Torvalds while ((skb = __skb_dequeue_tail(&sk->sk_write_queue)) != NULL) { 1571adf30907SEric Dumazet if (skb_dst(skb)) 1572adf30907SEric Dumazet IP6_INC_STATS(sock_net(sk), ip6_dst_idev(skb_dst(skb)), 1573a11d206dSYOSHIFUJI Hideaki IPSTATS_MIB_OUTDISCARDS); 15741da177e4SLinus Torvalds kfree_skb(skb); 15751da177e4SLinus Torvalds } 15761da177e4SLinus Torvalds 1577bf138862SPavel Emelyanov ip6_cork_release(inet_sk(sk), inet6_sk(sk)); 15781da177e4SLinus Torvalds } 1579a495f836SChris Elston EXPORT_SYMBOL_GPL(ip6_flush_pending_frames); 1580