2 * IPv6 output functions
3 * Linux INET6 implementation
6 * Pedro Roque <roque@di.fc.ul.pt>
8 * Based on linux/net/ipv4/ip_output.c
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
16 * A.N.Kuznetsov : airthmetics in fragmentation.
17 * extension headers are implemented.
18 * route changes now work.
19 * ip6_forward does not confuse sniffers.
22 * H. von Brand : Added missing #include <linux/string.h>
23 * Imran Patel : frag id should be in NBO
24 * Kazunori MIYAZAWA @USAGI
25 * : add ip6_append_data and related functions
29 #include <linux/errno.h>
30 #include <linux/kernel.h>
31 #include <linux/string.h>
32 #include <linux/socket.h>
33 #include <linux/net.h>
34 #include <linux/netdevice.h>
35 #include <linux/if_arp.h>
36 #include <linux/in6.h>
37 #include <linux/tcp.h>
38 #include <linux/route.h>
39 #include <linux/module.h>
40 #include <linux/slab.h>
42 #include <linux/netfilter.h>
43 #include <linux/netfilter_ipv6.h>
49 #include <net/ndisc.h>
50 #include <net/protocol.h>
51 #include <net/ip6_route.h>
52 #include <net/addrconf.h>
53 #include <net/rawv6.h>
56 #include <net/checksum.h>
57 #include <linux/mroute6.h>
59 static int ip6_finish_output2(struct sock *sk, struct sk_buff *skb)
61 struct dst_entry *dst = skb_dst(skb);
62 struct net_device *dev = dst->dev;
63 struct net *net = dev_net(dev);
64 struct neighbour *neigh;
65 struct in6_addr *nexthop;
68 skb->protocol = htons(ETH_P_IPV6);
71 if (ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr)) {
72 struct inet6_dev *idev = ip6_dst_idev(skb_dst(skb));
74 if (!(dev->flags & IFF_LOOPBACK) && sk_mc_loop(sk) &&
75 ((mroute6_socket(net, skb) &&
76 !(IP6CB(skb)->flags & IP6SKB_FORWARDED)) ||
77 ipv6_chk_mcast_addr(dev, &ipv6_hdr(skb)->daddr,
78 &ipv6_hdr(skb)->saddr))) {
79 struct sk_buff *newskb = skb_clone(skb, GFP_ATOMIC);
81 /* Do not check for IFF_ALLMULTI; multicast routing
82 is not supported in any case.
85 NF_HOOK(NFPROTO_IPV6, NF_INET_POST_ROUTING,
86 net, sk, newskb, NULL, newskb->dev,
89 if (ipv6_hdr(skb)->hop_limit == 0) {
90 IP6_INC_STATS(net, idev,
91 IPSTATS_MIB_OUTDISCARDS);
97 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUTMCAST, skb->len);
99 if (IPV6_ADDR_MC_SCOPE(&ipv6_hdr(skb)->daddr) <=
100 IPV6_ADDR_SCOPE_NODELOCAL &&
101 !(dev->flags & IFF_LOOPBACK)) {
108 nexthop = rt6_nexthop((struct rt6_info *)dst, &ipv6_hdr(skb)->daddr);
109 neigh = __ipv6_neigh_lookup_noref(dst->dev, nexthop);
110 if (unlikely(!neigh))
111 neigh = __neigh_create(&nd_tbl, nexthop, dst->dev, false);
112 if (!IS_ERR(neigh)) {
113 ret = dst_neigh_output(dst, neigh, skb);
114 rcu_read_unlock_bh();
117 rcu_read_unlock_bh();
119 IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTNOROUTES);
124 static int ip6_finish_output(struct net *net, struct sock *sk, struct sk_buff *skb)
126 if ((skb->len > ip6_skb_dst_mtu(skb) && !skb_is_gso(skb)) ||
127 dst_allfrag(skb_dst(skb)) ||
128 (IP6CB(skb)->frag_max_size && skb->len > IP6CB(skb)->frag_max_size))
129 return ip6_fragment(sk, skb, ip6_finish_output2);
131 return ip6_finish_output2(sk, skb);
134 int ip6_output(struct sock *sk, struct sk_buff *skb)
136 struct net_device *dev = skb_dst(skb)->dev;
137 struct inet6_dev *idev = ip6_dst_idev(skb_dst(skb));
138 struct net *net = dev_net(dev);
140 if (unlikely(idev->cnf.disable_ipv6)) {
141 IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTDISCARDS);
146 return NF_HOOK_COND(NFPROTO_IPV6, NF_INET_POST_ROUTING,
147 net, sk, skb, NULL, dev,
149 !(IP6CB(skb)->flags & IP6SKB_REROUTED));
153 * xmit an sk_buff (used by TCP, SCTP and DCCP)
156 int ip6_xmit(struct sock *sk, struct sk_buff *skb, struct flowi6 *fl6,
157 struct ipv6_txoptions *opt, int tclass)
159 struct net *net = sock_net(sk);
160 struct ipv6_pinfo *np = inet6_sk(sk);
161 struct in6_addr *first_hop = &fl6->daddr;
162 struct dst_entry *dst = skb_dst(skb);
164 u8 proto = fl6->flowi6_proto;
165 int seg_len = skb->len;
170 unsigned int head_room;
172 /* First: exthdrs may take lots of space (~8K for now)
173 MAX_HEADER is not enough.
175 head_room = opt->opt_nflen + opt->opt_flen;
176 seg_len += head_room;
177 head_room += sizeof(struct ipv6hdr) + LL_RESERVED_SPACE(dst->dev);
179 if (skb_headroom(skb) < head_room) {
180 struct sk_buff *skb2 = skb_realloc_headroom(skb, head_room);
182 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
183 IPSTATS_MIB_OUTDISCARDS);
189 skb_set_owner_w(skb, sk);
192 ipv6_push_frag_opts(skb, opt, &proto);
194 ipv6_push_nfrag_opts(skb, opt, &proto, &first_hop);
197 skb_push(skb, sizeof(struct ipv6hdr));
198 skb_reset_network_header(skb);
202 * Fill in the IPv6 header
205 hlimit = np->hop_limit;
207 hlimit = ip6_dst_hoplimit(dst);
209 ip6_flow_hdr(hdr, tclass, ip6_make_flowlabel(net, skb, fl6->flowlabel,
210 np->autoflowlabel, fl6));
212 hdr->payload_len = htons(seg_len);
213 hdr->nexthdr = proto;
214 hdr->hop_limit = hlimit;
216 hdr->saddr = fl6->saddr;
217 hdr->daddr = *first_hop;
219 skb->protocol = htons(ETH_P_IPV6);
220 skb->priority = sk->sk_priority;
221 skb->mark = sk->sk_mark;
224 if ((skb->len <= mtu) || skb->ignore_df || skb_is_gso(skb)) {
225 IP6_UPD_PO_STATS(net, ip6_dst_idev(skb_dst(skb)),
226 IPSTATS_MIB_OUT, skb->len);
227 return NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT,
228 net, sk, skb, NULL, dst->dev,
233 ipv6_local_error(sk, EMSGSIZE, fl6, mtu);
234 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_FRAGFAILS);
238 EXPORT_SYMBOL(ip6_xmit);
240 static int ip6_call_ra_chain(struct sk_buff *skb, int sel)
242 struct ip6_ra_chain *ra;
243 struct sock *last = NULL;
245 read_lock(&ip6_ra_lock);
246 for (ra = ip6_ra_chain; ra; ra = ra->next) {
247 struct sock *sk = ra->sk;
248 if (sk && ra->sel == sel &&
249 (!sk->sk_bound_dev_if ||
250 sk->sk_bound_dev_if == skb->dev->ifindex)) {
252 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
254 rawv6_rcv(last, skb2);
261 rawv6_rcv(last, skb);
262 read_unlock(&ip6_ra_lock);
265 read_unlock(&ip6_ra_lock);
269 static int ip6_forward_proxy_check(struct sk_buff *skb)
271 struct ipv6hdr *hdr = ipv6_hdr(skb);
272 u8 nexthdr = hdr->nexthdr;
276 if (ipv6_ext_hdr(nexthdr)) {
277 offset = ipv6_skip_exthdr(skb, sizeof(*hdr), &nexthdr, &frag_off);
281 offset = sizeof(struct ipv6hdr);
283 if (nexthdr == IPPROTO_ICMPV6) {
284 struct icmp6hdr *icmp6;
286 if (!pskb_may_pull(skb, (skb_network_header(skb) +
287 offset + 1 - skb->data)))
290 icmp6 = (struct icmp6hdr *)(skb_network_header(skb) + offset);
292 switch (icmp6->icmp6_type) {
293 case NDISC_ROUTER_SOLICITATION:
294 case NDISC_ROUTER_ADVERTISEMENT:
295 case NDISC_NEIGHBOUR_SOLICITATION:
296 case NDISC_NEIGHBOUR_ADVERTISEMENT:
298 /* For reaction involving unicast neighbor discovery
299 * message destined to the proxied address, pass it to
309 * The proxying router can't forward traffic sent to a link-local
310 * address, so signal the sender and discard the packet. This
311 * behavior is clarified by the MIPv6 specification.
313 if (ipv6_addr_type(&hdr->daddr) & IPV6_ADDR_LINKLOCAL) {
314 dst_link_failure(skb);
321 static inline int ip6_forward_finish(struct net *net, struct sock *sk,
324 skb_sender_cpu_clear(skb);
325 return dst_output(sk, skb);
328 static unsigned int ip6_dst_mtu_forward(const struct dst_entry *dst)
331 struct inet6_dev *idev;
333 if (dst_metric_locked(dst, RTAX_MTU)) {
334 mtu = dst_metric_raw(dst, RTAX_MTU);
341 idev = __in6_dev_get(dst->dev);
343 mtu = idev->cnf.mtu6;
349 static bool ip6_pkt_too_big(const struct sk_buff *skb, unsigned int mtu)
354 /* ipv6 conntrack defrag sets max_frag_size + ignore_df */
355 if (IP6CB(skb)->frag_max_size && IP6CB(skb)->frag_max_size > mtu)
361 if (skb_is_gso(skb) && skb_gso_network_seglen(skb) <= mtu)
367 int ip6_forward(struct sk_buff *skb)
369 struct dst_entry *dst = skb_dst(skb);
370 struct ipv6hdr *hdr = ipv6_hdr(skb);
371 struct inet6_skb_parm *opt = IP6CB(skb);
372 struct net *net = dev_net(dst->dev);
375 if (net->ipv6.devconf_all->forwarding == 0)
378 if (skb->pkt_type != PACKET_HOST)
381 if (skb_warn_if_lro(skb))
384 if (!xfrm6_policy_check(NULL, XFRM_POLICY_FWD, skb)) {
385 IP6_INC_STATS_BH(net, ip6_dst_idev(dst),
386 IPSTATS_MIB_INDISCARDS);
390 skb_forward_csum(skb);
393 * We DO NOT make any processing on
394 * RA packets, pushing them to user level AS IS
395 * without ane WARRANTY that application will be able
396 * to interpret them. The reason is that we
397 * cannot make anything clever here.
399 * We are not end-node, so that if packet contains
400 * AH/ESP, we cannot make anything.
401 * Defragmentation also would be mistake, RA packets
402 * cannot be fragmented, because there is no warranty
403 * that different fragments will go along one path. --ANK
405 if (unlikely(opt->flags & IP6SKB_ROUTERALERT)) {
406 if (ip6_call_ra_chain(skb, ntohs(opt->ra)))
411 * check and decrement ttl
413 if (hdr->hop_limit <= 1) {
414 /* Force OUTPUT device used as source address */
416 icmpv6_send(skb, ICMPV6_TIME_EXCEED, ICMPV6_EXC_HOPLIMIT, 0);
417 IP6_INC_STATS_BH(net, ip6_dst_idev(dst),
418 IPSTATS_MIB_INHDRERRORS);
424 /* XXX: idev->cnf.proxy_ndp? */
425 if (net->ipv6.devconf_all->proxy_ndp &&
426 pneigh_lookup(&nd_tbl, net, &hdr->daddr, skb->dev, 0)) {
427 int proxied = ip6_forward_proxy_check(skb);
429 return ip6_input(skb);
430 else if (proxied < 0) {
431 IP6_INC_STATS_BH(net, ip6_dst_idev(dst),
432 IPSTATS_MIB_INDISCARDS);
437 if (!xfrm6_route_forward(skb)) {
438 IP6_INC_STATS_BH(net, ip6_dst_idev(dst),
439 IPSTATS_MIB_INDISCARDS);
444 /* IPv6 specs say nothing about it, but it is clear that we cannot
445 send redirects to source routed frames.
446 We don't send redirects to frames decapsulated from IPsec.
448 if (skb->dev == dst->dev && opt->srcrt == 0 && !skb_sec_path(skb)) {
449 struct in6_addr *target = NULL;
450 struct inet_peer *peer;
454 * incoming and outgoing devices are the same
458 rt = (struct rt6_info *) dst;
459 if (rt->rt6i_flags & RTF_GATEWAY)
460 target = &rt->rt6i_gateway;
462 target = &hdr->daddr;
464 peer = inet_getpeer_v6(net->ipv6.peers, &hdr->daddr, 1);
466 /* Limit redirects both by destination (here)
467 and by source (inside ndisc_send_redirect)
469 if (inet_peer_xrlim_allow(peer, 1*HZ))
470 ndisc_send_redirect(skb, target);
474 int addrtype = ipv6_addr_type(&hdr->saddr);
476 /* This check is security critical. */
477 if (addrtype == IPV6_ADDR_ANY ||
478 addrtype & (IPV6_ADDR_MULTICAST | IPV6_ADDR_LOOPBACK))
480 if (addrtype & IPV6_ADDR_LINKLOCAL) {
481 icmpv6_send(skb, ICMPV6_DEST_UNREACH,
482 ICMPV6_NOT_NEIGHBOUR, 0);
487 mtu = ip6_dst_mtu_forward(dst);
488 if (mtu < IPV6_MIN_MTU)
491 if (ip6_pkt_too_big(skb, mtu)) {
492 /* Again, force OUTPUT device used as source address */
494 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
495 IP6_INC_STATS_BH(net, ip6_dst_idev(dst),
496 IPSTATS_MIB_INTOOBIGERRORS);
497 IP6_INC_STATS_BH(net, ip6_dst_idev(dst),
498 IPSTATS_MIB_FRAGFAILS);
503 if (skb_cow(skb, dst->dev->hard_header_len)) {
504 IP6_INC_STATS_BH(net, ip6_dst_idev(dst),
505 IPSTATS_MIB_OUTDISCARDS);
511 /* Mangling hops number delayed to point after skb COW */
515 IP6_INC_STATS_BH(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTFORWDATAGRAMS);
516 IP6_ADD_STATS_BH(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTOCTETS, skb->len);
517 return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD,
518 net, NULL, skb, skb->dev, dst->dev,
522 IP6_INC_STATS_BH(net, ip6_dst_idev(dst), IPSTATS_MIB_INADDRERRORS);
528 static void ip6_copy_metadata(struct sk_buff *to, struct sk_buff *from)
530 to->pkt_type = from->pkt_type;
531 to->priority = from->priority;
532 to->protocol = from->protocol;
534 skb_dst_set(to, dst_clone(skb_dst(from)));
536 to->mark = from->mark;
538 #ifdef CONFIG_NET_SCHED
539 to->tc_index = from->tc_index;
542 skb_copy_secmark(to, from);
545 int ip6_fragment(struct sock *sk, struct sk_buff *skb,
546 int (*output)(struct sock *, struct sk_buff *))
548 struct sk_buff *frag;
549 struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
550 struct ipv6_pinfo *np = skb->sk && !dev_recursion_level() ?
551 inet6_sk(skb->sk) : NULL;
552 struct ipv6hdr *tmp_hdr;
554 unsigned int mtu, hlen, left, len;
557 int ptr, offset = 0, err = 0;
558 u8 *prevhdr, nexthdr = 0;
559 struct net *net = dev_net(skb_dst(skb)->dev);
561 hlen = ip6_find_1stfragopt(skb, &prevhdr);
564 mtu = ip6_skb_dst_mtu(skb);
566 /* We must not fragment if the socket is set to force MTU discovery
567 * or if the skb it not generated by a local socket.
569 if (unlikely(!skb->ignore_df && skb->len > mtu))
572 if (IP6CB(skb)->frag_max_size) {
573 if (IP6CB(skb)->frag_max_size > mtu)
576 /* don't send fragments larger than what we received */
577 mtu = IP6CB(skb)->frag_max_size;
578 if (mtu < IPV6_MIN_MTU)
582 if (np && np->frag_size < mtu) {
586 mtu -= hlen + sizeof(struct frag_hdr);
588 frag_id = ipv6_select_ident(net, &ipv6_hdr(skb)->daddr,
589 &ipv6_hdr(skb)->saddr);
591 if (skb_has_frag_list(skb)) {
592 int first_len = skb_pagelen(skb);
593 struct sk_buff *frag2;
595 if (first_len - hlen > mtu ||
596 ((first_len - hlen) & 7) ||
600 skb_walk_frags(skb, frag) {
601 /* Correct geometry. */
602 if (frag->len > mtu ||
603 ((frag->len & 7) && frag->next) ||
604 skb_headroom(frag) < hlen)
605 goto slow_path_clean;
607 /* Partially cloned skb? */
608 if (skb_shared(frag))
609 goto slow_path_clean;
614 frag->destructor = sock_wfree;
616 skb->truesize -= frag->truesize;
621 frag = skb_shinfo(skb)->frag_list;
622 skb_frag_list_init(skb);
625 *prevhdr = NEXTHDR_FRAGMENT;
626 tmp_hdr = kmemdup(skb_network_header(skb), hlen, GFP_ATOMIC);
628 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
629 IPSTATS_MIB_FRAGFAILS);
633 __skb_pull(skb, hlen);
634 fh = (struct frag_hdr *)__skb_push(skb, sizeof(struct frag_hdr));
635 __skb_push(skb, hlen);
636 skb_reset_network_header(skb);
637 memcpy(skb_network_header(skb), tmp_hdr, hlen);
639 fh->nexthdr = nexthdr;
641 fh->frag_off = htons(IP6_MF);
642 fh->identification = frag_id;
644 first_len = skb_pagelen(skb);
645 skb->data_len = first_len - skb_headlen(skb);
646 skb->len = first_len;
647 ipv6_hdr(skb)->payload_len = htons(first_len -
648 sizeof(struct ipv6hdr));
653 /* Prepare header of the next frame,
654 * before previous one went down. */
656 frag->ip_summed = CHECKSUM_NONE;
657 skb_reset_transport_header(frag);
658 fh = (struct frag_hdr *)__skb_push(frag, sizeof(struct frag_hdr));
659 __skb_push(frag, hlen);
660 skb_reset_network_header(frag);
661 memcpy(skb_network_header(frag), tmp_hdr,
663 offset += skb->len - hlen - sizeof(struct frag_hdr);
664 fh->nexthdr = nexthdr;
666 fh->frag_off = htons(offset);
668 fh->frag_off |= htons(IP6_MF);
669 fh->identification = frag_id;
670 ipv6_hdr(frag)->payload_len =
672 sizeof(struct ipv6hdr));
673 ip6_copy_metadata(frag, skb);
676 err = output(sk, skb);
678 IP6_INC_STATS(net, ip6_dst_idev(&rt->dst),
679 IPSTATS_MIB_FRAGCREATES);
692 IP6_INC_STATS(net, ip6_dst_idev(&rt->dst),
693 IPSTATS_MIB_FRAGOKS);
698 kfree_skb_list(frag);
700 IP6_INC_STATS(net, ip6_dst_idev(&rt->dst),
701 IPSTATS_MIB_FRAGFAILS);
706 skb_walk_frags(skb, frag2) {
710 frag2->destructor = NULL;
711 skb->truesize += frag2->truesize;
716 if ((skb->ip_summed == CHECKSUM_PARTIAL) &&
717 skb_checksum_help(skb))
720 left = skb->len - hlen; /* Space per frame */
721 ptr = hlen; /* Where to start from */
724 * Fragment the datagram.
727 *prevhdr = NEXTHDR_FRAGMENT;
728 hroom = LL_RESERVED_SPACE(rt->dst.dev);
729 troom = rt->dst.dev->needed_tailroom;
732 * Keep copying data until we run out.
736 /* IF: it doesn't fit, use 'mtu' - the data space left */
739 /* IF: we are not sending up to and including the packet end
740 then align the next start on an eight byte boundary */
745 /* Allocate buffer */
746 frag = alloc_skb(len + hlen + sizeof(struct frag_hdr) +
747 hroom + troom, GFP_ATOMIC);
749 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
750 IPSTATS_MIB_FRAGFAILS);
756 * Set up data on packet
759 ip6_copy_metadata(frag, skb);
760 skb_reserve(frag, hroom);
761 skb_put(frag, len + hlen + sizeof(struct frag_hdr));
762 skb_reset_network_header(frag);
763 fh = (struct frag_hdr *)(skb_network_header(frag) + hlen);
764 frag->transport_header = (frag->network_header + hlen +
765 sizeof(struct frag_hdr));
768 * Charge the memory for the fragment to any owner
772 skb_set_owner_w(frag, skb->sk);
775 * Copy the packet header into the new buffer.
777 skb_copy_from_linear_data(skb, skb_network_header(frag), hlen);
780 * Build fragment header.
782 fh->nexthdr = nexthdr;
784 fh->identification = frag_id;
787 * Copy a block of the IP datagram.
789 BUG_ON(skb_copy_bits(skb, ptr, skb_transport_header(frag),
793 fh->frag_off = htons(offset);
795 fh->frag_off |= htons(IP6_MF);
796 ipv6_hdr(frag)->payload_len = htons(frag->len -
797 sizeof(struct ipv6hdr));
803 * Put this fragment into the sending queue.
805 err = output(sk, frag);
809 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
810 IPSTATS_MIB_FRAGCREATES);
812 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
813 IPSTATS_MIB_FRAGOKS);
818 if (skb->sk && dst_allfrag(skb_dst(skb)))
819 sk_nocaps_add(skb->sk, NETIF_F_GSO_MASK);
821 skb->dev = skb_dst(skb)->dev;
822 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
826 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
827 IPSTATS_MIB_FRAGFAILS);
832 static inline int ip6_rt_check(const struct rt6key *rt_key,
833 const struct in6_addr *fl_addr,
834 const struct in6_addr *addr_cache)
836 return (rt_key->plen != 128 || !ipv6_addr_equal(fl_addr, &rt_key->addr)) &&
837 (!addr_cache || !ipv6_addr_equal(fl_addr, addr_cache));
840 static struct dst_entry *ip6_sk_dst_check(struct sock *sk,
841 struct dst_entry *dst,
842 const struct flowi6 *fl6)
844 struct ipv6_pinfo *np = inet6_sk(sk);
850 if (dst->ops->family != AF_INET6) {
855 rt = (struct rt6_info *)dst;
856 /* Yes, checking route validity in not connected
857 * case is not very simple. Take into account,
858 * that we do not support routing by source, TOS,
859 * and MSG_DONTROUTE --ANK (980726)
861 * 1. ip6_rt_check(): If route was host route,
862 * check that cached destination is current.
863 * If it is network route, we still may
864 * check its validity using saved pointer
865 * to the last used address: daddr_cache.
866 * We do not want to save whole address now,
867 * (because main consumer of this service
868 * is tcp, which has not this problem),
869 * so that the last trick works only on connected
871 * 2. oif also should be the same.
873 if (ip6_rt_check(&rt->rt6i_dst, &fl6->daddr, np->daddr_cache) ||
874 #ifdef CONFIG_IPV6_SUBTREES
875 ip6_rt_check(&rt->rt6i_src, &fl6->saddr, np->saddr_cache) ||
877 (fl6->flowi6_oif && fl6->flowi6_oif != dst->dev->ifindex)) {
886 static int ip6_dst_lookup_tail(struct net *net, struct sock *sk,
887 struct dst_entry **dst, struct flowi6 *fl6)
889 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
895 /* The correct way to handle this would be to do
896 * ip6_route_get_saddr, and then ip6_route_output; however,
897 * the route-specific preferred source forces the
898 * ip6_route_output call _before_ ip6_route_get_saddr.
900 * In source specific routing (no src=any default route),
901 * ip6_route_output will fail given src=any saddr, though, so
902 * that's why we try it again later.
904 if (ipv6_addr_any(&fl6->saddr) && (!*dst || !(*dst)->error)) {
906 bool had_dst = *dst != NULL;
909 *dst = ip6_route_output(net, sk, fl6);
910 rt = (*dst)->error ? NULL : (struct rt6_info *)*dst;
911 err = ip6_route_get_saddr(net, rt, &fl6->daddr,
912 sk ? inet6_sk(sk)->srcprefs : 0,
915 goto out_err_release;
917 /* If we had an erroneous initial result, pretend it
918 * never existed and let the SA-enabled version take
921 if (!had_dst && (*dst)->error) {
928 *dst = ip6_route_output(net, sk, fl6);
932 goto out_err_release;
934 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
936 * Here if the dst entry we've looked up
937 * has a neighbour entry that is in the INCOMPLETE
938 * state and the src address from the flow is
939 * marked as OPTIMISTIC, we release the found
940 * dst entry and replace it instead with the
941 * dst entry of the nexthop router
943 rt = (struct rt6_info *) *dst;
945 n = __ipv6_neigh_lookup_noref(rt->dst.dev,
946 rt6_nexthop(rt, &fl6->daddr));
947 err = n && !(n->nud_state & NUD_VALID) ? -EINVAL : 0;
948 rcu_read_unlock_bh();
951 struct inet6_ifaddr *ifp;
952 struct flowi6 fl_gw6;
955 ifp = ipv6_get_ifaddr(net, &fl6->saddr,
958 redirect = (ifp && ifp->flags & IFA_F_OPTIMISTIC);
964 * We need to get the dst entry for the
965 * default router instead
968 memcpy(&fl_gw6, fl6, sizeof(struct flowi6));
969 memset(&fl_gw6.daddr, 0, sizeof(struct in6_addr));
970 *dst = ip6_route_output(net, sk, &fl_gw6);
973 goto out_err_release;
981 if (err == -ENETUNREACH)
982 IP6_INC_STATS(net, NULL, IPSTATS_MIB_OUTNOROUTES);
989 * ip6_dst_lookup - perform route lookup on flow
990 * @sk: socket which provides route info
991 * @dst: pointer to dst_entry * for result
992 * @fl6: flow to lookup
994 * This function performs a route lookup on the given flow.
996 * It returns zero on success, or a standard errno code on error.
998 int ip6_dst_lookup(struct net *net, struct sock *sk, struct dst_entry **dst,
1002 return ip6_dst_lookup_tail(net, sk, dst, fl6);
1004 EXPORT_SYMBOL_GPL(ip6_dst_lookup);
1007 * ip6_dst_lookup_flow - perform route lookup on flow with ipsec
1008 * @sk: socket which provides route info
1009 * @fl6: flow to lookup
1010 * @final_dst: final destination address for ipsec lookup
1012 * This function performs a route lookup on the given flow.
1014 * It returns a valid dst pointer on success, or a pointer encoded
1017 struct dst_entry *ip6_dst_lookup_flow(struct sock *sk, struct flowi6 *fl6,
1018 const struct in6_addr *final_dst)
1020 struct dst_entry *dst = NULL;
1023 err = ip6_dst_lookup_tail(sock_net(sk), sk, &dst, fl6);
1025 return ERR_PTR(err);
1027 fl6->daddr = *final_dst;
1028 if (!fl6->flowi6_oif)
1029 fl6->flowi6_oif = dst->dev->ifindex;
1031 return xfrm_lookup_route(sock_net(sk), dst, flowi6_to_flowi(fl6), sk, 0);
1033 EXPORT_SYMBOL_GPL(ip6_dst_lookup_flow);
1036 * ip6_sk_dst_lookup_flow - perform socket cached route lookup on flow
1037 * @sk: socket which provides the dst cache and route info
1038 * @fl6: flow to lookup
1039 * @final_dst: final destination address for ipsec lookup
1041 * This function performs a route lookup on the given flow with the
1042 * possibility of using the cached route in the socket if it is valid.
1043 * It will take the socket dst lock when operating on the dst cache.
1044 * As a result, this function can only be used in process context.
1046 * It returns a valid dst pointer on success, or a pointer encoded
1049 struct dst_entry *ip6_sk_dst_lookup_flow(struct sock *sk, struct flowi6 *fl6,
1050 const struct in6_addr *final_dst)
1052 struct dst_entry *dst = sk_dst_check(sk, inet6_sk(sk)->dst_cookie);
1055 dst = ip6_sk_dst_check(sk, dst, fl6);
1057 err = ip6_dst_lookup_tail(sock_net(sk), sk, &dst, fl6);
1059 return ERR_PTR(err);
1061 fl6->daddr = *final_dst;
1063 return xfrm_lookup_route(sock_net(sk), dst, flowi6_to_flowi(fl6), sk, 0);
1065 EXPORT_SYMBOL_GPL(ip6_sk_dst_lookup_flow);
1067 static inline int ip6_ufo_append_data(struct sock *sk,
1068 struct sk_buff_head *queue,
1069 int getfrag(void *from, char *to, int offset, int len,
1070 int odd, struct sk_buff *skb),
1071 void *from, int length, int hh_len, int fragheaderlen,
1072 int transhdrlen, int mtu, unsigned int flags,
1073 const struct flowi6 *fl6)
1076 struct sk_buff *skb;
1079 /* There is support for UDP large send offload by network
1080 * device, so create one single skb packet containing complete
1083 skb = skb_peek_tail(queue);
1085 skb = sock_alloc_send_skb(sk,
1086 hh_len + fragheaderlen + transhdrlen + 20,
1087 (flags & MSG_DONTWAIT), &err);
1091 /* reserve space for Hardware header */
1092 skb_reserve(skb, hh_len);
1094 /* create space for UDP/IP header */
1095 skb_put(skb, fragheaderlen + transhdrlen);
1097 /* initialize network header pointer */
1098 skb_reset_network_header(skb);
1100 /* initialize protocol header pointer */
1101 skb->transport_header = skb->network_header + fragheaderlen;
1103 skb->protocol = htons(ETH_P_IPV6);
1106 __skb_queue_tail(queue, skb);
1107 } else if (skb_is_gso(skb)) {
1111 skb->ip_summed = CHECKSUM_PARTIAL;
1112 /* Specify the length of each IPv6 datagram fragment.
1113 * It has to be a multiple of 8.
1115 skb_shinfo(skb)->gso_size = (mtu - fragheaderlen -
1116 sizeof(struct frag_hdr)) & ~7;
1117 skb_shinfo(skb)->gso_type = SKB_GSO_UDP;
1118 skb_shinfo(skb)->ip6_frag_id = ipv6_select_ident(sock_net(sk),
1123 return skb_append_datato_frags(sk, skb, getfrag, from,
1124 (length - transhdrlen));
1127 static inline struct ipv6_opt_hdr *ip6_opt_dup(struct ipv6_opt_hdr *src,
1130 return src ? kmemdup(src, (src->hdrlen + 1) * 8, gfp) : NULL;
1133 static inline struct ipv6_rt_hdr *ip6_rthdr_dup(struct ipv6_rt_hdr *src,
1136 return src ? kmemdup(src, (src->hdrlen + 1) * 8, gfp) : NULL;
1139 static void ip6_append_data_mtu(unsigned int *mtu,
1141 unsigned int fragheaderlen,
1142 struct sk_buff *skb,
1143 struct rt6_info *rt,
1144 unsigned int orig_mtu)
1146 if (!(rt->dst.flags & DST_XFRM_TUNNEL)) {
1148 /* first fragment, reserve header_len */
1149 *mtu = orig_mtu - rt->dst.header_len;
1153 * this fragment is not first, the headers
1154 * space is regarded as data space.
1158 *maxfraglen = ((*mtu - fragheaderlen) & ~7)
1159 + fragheaderlen - sizeof(struct frag_hdr);
1163 static int ip6_setup_cork(struct sock *sk, struct inet_cork_full *cork,
1164 struct inet6_cork *v6_cork,
1165 int hlimit, int tclass, struct ipv6_txoptions *opt,
1166 struct rt6_info *rt, struct flowi6 *fl6)
1168 struct ipv6_pinfo *np = inet6_sk(sk);
1175 if (WARN_ON(v6_cork->opt))
1178 v6_cork->opt = kzalloc(opt->tot_len, sk->sk_allocation);
1179 if (unlikely(!v6_cork->opt))
1182 v6_cork->opt->tot_len = opt->tot_len;
1183 v6_cork->opt->opt_flen = opt->opt_flen;
1184 v6_cork->opt->opt_nflen = opt->opt_nflen;
1186 v6_cork->opt->dst0opt = ip6_opt_dup(opt->dst0opt,
1188 if (opt->dst0opt && !v6_cork->opt->dst0opt)
1191 v6_cork->opt->dst1opt = ip6_opt_dup(opt->dst1opt,
1193 if (opt->dst1opt && !v6_cork->opt->dst1opt)
1196 v6_cork->opt->hopopt = ip6_opt_dup(opt->hopopt,
1198 if (opt->hopopt && !v6_cork->opt->hopopt)
1201 v6_cork->opt->srcrt = ip6_rthdr_dup(opt->srcrt,
1203 if (opt->srcrt && !v6_cork->opt->srcrt)
1206 /* need source address above miyazawa*/
1209 cork->base.dst = &rt->dst;
1210 cork->fl.u.ip6 = *fl6;
1211 v6_cork->hop_limit = hlimit;
1212 v6_cork->tclass = tclass;
1213 if (rt->dst.flags & DST_XFRM_TUNNEL)
1214 mtu = np->pmtudisc >= IPV6_PMTUDISC_PROBE ?
1215 rt->dst.dev->mtu : dst_mtu(&rt->dst);
1217 mtu = np->pmtudisc >= IPV6_PMTUDISC_PROBE ?
1218 rt->dst.dev->mtu : dst_mtu(rt->dst.path);
1219 if (np->frag_size < mtu) {
1221 mtu = np->frag_size;
1223 cork->base.fragsize = mtu;
1224 if (dst_allfrag(rt->dst.path))
1225 cork->base.flags |= IPCORK_ALLFRAG;
1226 cork->base.length = 0;
1231 static int __ip6_append_data(struct sock *sk,
1233 struct sk_buff_head *queue,
1234 struct inet_cork *cork,
1235 struct inet6_cork *v6_cork,
1236 struct page_frag *pfrag,
1237 int getfrag(void *from, char *to, int offset,
1238 int len, int odd, struct sk_buff *skb),
1239 void *from, int length, int transhdrlen,
1240 unsigned int flags, int dontfrag)
1242 struct sk_buff *skb, *skb_prev = NULL;
1243 unsigned int maxfraglen, fragheaderlen, mtu, orig_mtu;
1245 int dst_exthdrlen = 0;
1252 struct rt6_info *rt = (struct rt6_info *)cork->dst;
1253 struct ipv6_txoptions *opt = v6_cork->opt;
1254 int csummode = CHECKSUM_NONE;
1256 skb = skb_peek_tail(queue);
1258 exthdrlen = opt ? opt->opt_flen : 0;
1259 dst_exthdrlen = rt->dst.header_len - rt->rt6i_nfheader_len;
1262 mtu = cork->fragsize;
1265 hh_len = LL_RESERVED_SPACE(rt->dst.dev);
1267 fragheaderlen = sizeof(struct ipv6hdr) + rt->rt6i_nfheader_len +
1268 (opt ? opt->opt_nflen : 0);
1269 maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen -
1270 sizeof(struct frag_hdr);
1272 if (mtu <= sizeof(struct ipv6hdr) + IPV6_MAXPLEN) {
1273 unsigned int maxnonfragsize, headersize;
1275 headersize = sizeof(struct ipv6hdr) +
1276 (opt ? opt->opt_flen + opt->opt_nflen : 0) +
1277 (dst_allfrag(&rt->dst) ?
1278 sizeof(struct frag_hdr) : 0) +
1279 rt->rt6i_nfheader_len;
1281 if (ip6_sk_ignore_df(sk))
1282 maxnonfragsize = sizeof(struct ipv6hdr) + IPV6_MAXPLEN;
1284 maxnonfragsize = mtu;
1286 /* dontfrag active */
1287 if ((cork->length + length > mtu - headersize) && dontfrag &&
1288 (sk->sk_protocol == IPPROTO_UDP ||
1289 sk->sk_protocol == IPPROTO_RAW)) {
1290 ipv6_local_rxpmtu(sk, fl6, mtu - headersize +
1291 sizeof(struct ipv6hdr));
1295 if (cork->length + length > maxnonfragsize - headersize) {
1297 ipv6_local_error(sk, EMSGSIZE, fl6,
1299 sizeof(struct ipv6hdr));
1304 if (sk->sk_type == SOCK_DGRAM || sk->sk_type == SOCK_RAW) {
1305 sock_tx_timestamp(sk, &tx_flags);
1306 if (tx_flags & SKBTX_ANY_SW_TSTAMP &&
1307 sk->sk_tsflags & SOF_TIMESTAMPING_OPT_ID)
1308 tskey = sk->sk_tskey++;
1311 /* If this is the first and only packet and device
1312 * supports checksum offloading, let's use it.
1313 * Use transhdrlen, same as IPv4, because partial
1314 * sums only work when transhdrlen is set.
1316 if (transhdrlen && sk->sk_protocol == IPPROTO_UDP &&
1317 length + fragheaderlen < mtu &&
1318 rt->dst.dev->features & NETIF_F_V6_CSUM &&
1320 csummode = CHECKSUM_PARTIAL;
1322 * Let's try using as much space as possible.
1323 * Use MTU if total length of the message fits into the MTU.
1324 * Otherwise, we need to reserve fragment header and
1325 * fragment alignment (= 8-15 octects, in total).
1327 * Note that we may need to "move" the data from the tail of
1328 * of the buffer to the new fragment when we split
1331 * FIXME: It may be fragmented into multiple chunks
1332 * at once if non-fragmentable extension headers
1337 cork->length += length;
1338 if (((length > mtu) ||
1339 (skb && skb_is_gso(skb))) &&
1340 (sk->sk_protocol == IPPROTO_UDP) &&
1341 (rt->dst.dev->features & NETIF_F_UFO) &&
1342 (sk->sk_type == SOCK_DGRAM)) {
1343 err = ip6_ufo_append_data(sk, queue, getfrag, from, length,
1344 hh_len, fragheaderlen,
1345 transhdrlen, mtu, flags, fl6);
1354 while (length > 0) {
1355 /* Check if the remaining data fits into current packet. */
1356 copy = (cork->length <= mtu && !(cork->flags & IPCORK_ALLFRAG) ? mtu : maxfraglen) - skb->len;
1358 copy = maxfraglen - skb->len;
1362 unsigned int datalen;
1363 unsigned int fraglen;
1364 unsigned int fraggap;
1365 unsigned int alloclen;
1367 /* There's no room in the current skb */
1369 fraggap = skb->len - maxfraglen;
1372 /* update mtu and maxfraglen if necessary */
1373 if (!skb || !skb_prev)
1374 ip6_append_data_mtu(&mtu, &maxfraglen,
1375 fragheaderlen, skb, rt,
1381 * If remaining data exceeds the mtu,
1382 * we know we need more fragment(s).
1384 datalen = length + fraggap;
1386 if (datalen > (cork->length <= mtu && !(cork->flags & IPCORK_ALLFRAG) ? mtu : maxfraglen) - fragheaderlen)
1387 datalen = maxfraglen - fragheaderlen - rt->dst.trailer_len;
1388 if ((flags & MSG_MORE) &&
1389 !(rt->dst.dev->features&NETIF_F_SG))
1392 alloclen = datalen + fragheaderlen;
1394 alloclen += dst_exthdrlen;
1396 if (datalen != length + fraggap) {
1398 * this is not the last fragment, the trailer
1399 * space is regarded as data space.
1401 datalen += rt->dst.trailer_len;
1404 alloclen += rt->dst.trailer_len;
1405 fraglen = datalen + fragheaderlen;
1408 * We just reserve space for fragment header.
1409 * Note: this may be overallocation if the message
1410 * (without MSG_MORE) fits into the MTU.
1412 alloclen += sizeof(struct frag_hdr);
1415 skb = sock_alloc_send_skb(sk,
1417 (flags & MSG_DONTWAIT), &err);
1420 if (atomic_read(&sk->sk_wmem_alloc) <=
1422 skb = sock_wmalloc(sk,
1423 alloclen + hh_len, 1,
1431 * Fill in the control structures
1433 skb->protocol = htons(ETH_P_IPV6);
1434 skb->ip_summed = csummode;
1436 /* reserve for fragmentation and ipsec header */
1437 skb_reserve(skb, hh_len + sizeof(struct frag_hdr) +
1440 /* Only the initial fragment is time stamped */
1441 skb_shinfo(skb)->tx_flags = tx_flags;
1443 skb_shinfo(skb)->tskey = tskey;
1447 * Find where to start putting bytes
1449 data = skb_put(skb, fraglen);
1450 skb_set_network_header(skb, exthdrlen);
1451 data += fragheaderlen;
1452 skb->transport_header = (skb->network_header +
1455 skb->csum = skb_copy_and_csum_bits(
1456 skb_prev, maxfraglen,
1457 data + transhdrlen, fraggap, 0);
1458 skb_prev->csum = csum_sub(skb_prev->csum,
1461 pskb_trim_unique(skb_prev, maxfraglen);
1463 copy = datalen - transhdrlen - fraggap;
1469 } else if (copy > 0 && getfrag(from, data + transhdrlen, offset, copy, fraggap, skb) < 0) {
1476 length -= datalen - fraggap;
1482 * Put the packet on the pending queue
1484 __skb_queue_tail(queue, skb);
1491 if (!(rt->dst.dev->features&NETIF_F_SG)) {
1495 if (getfrag(from, skb_put(skb, copy),
1496 offset, copy, off, skb) < 0) {
1497 __skb_trim(skb, off);
1502 int i = skb_shinfo(skb)->nr_frags;
1505 if (!sk_page_frag_refill(sk, pfrag))
1508 if (!skb_can_coalesce(skb, i, pfrag->page,
1511 if (i == MAX_SKB_FRAGS)
1514 __skb_fill_page_desc(skb, i, pfrag->page,
1516 skb_shinfo(skb)->nr_frags = ++i;
1517 get_page(pfrag->page);
1519 copy = min_t(int, copy, pfrag->size - pfrag->offset);
1521 page_address(pfrag->page) + pfrag->offset,
1522 offset, copy, skb->len, skb) < 0)
1525 pfrag->offset += copy;
1526 skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy);
1528 skb->data_len += copy;
1529 skb->truesize += copy;
1530 atomic_add(copy, &sk->sk_wmem_alloc);
1541 cork->length -= length;
1542 IP6_INC_STATS(sock_net(sk), rt->rt6i_idev, IPSTATS_MIB_OUTDISCARDS);
1546 int ip6_append_data(struct sock *sk,
1547 int getfrag(void *from, char *to, int offset, int len,
1548 int odd, struct sk_buff *skb),
1549 void *from, int length, int transhdrlen, int hlimit,
1550 int tclass, struct ipv6_txoptions *opt, struct flowi6 *fl6,
1551 struct rt6_info *rt, unsigned int flags, int dontfrag)
1553 struct inet_sock *inet = inet_sk(sk);
1554 struct ipv6_pinfo *np = inet6_sk(sk);
1558 if (flags&MSG_PROBE)
1560 if (skb_queue_empty(&sk->sk_write_queue)) {
1564 err = ip6_setup_cork(sk, &inet->cork, &np->cork, hlimit,
1565 tclass, opt, rt, fl6);
1569 exthdrlen = (opt ? opt->opt_flen : 0);
1570 length += exthdrlen;
1571 transhdrlen += exthdrlen;
1573 fl6 = &inet->cork.fl.u.ip6;
1577 return __ip6_append_data(sk, fl6, &sk->sk_write_queue, &inet->cork.base,
1578 &np->cork, sk_page_frag(sk), getfrag,
1579 from, length, transhdrlen, flags, dontfrag);
1581 EXPORT_SYMBOL_GPL(ip6_append_data);
1583 static void ip6_cork_release(struct inet_cork_full *cork,
1584 struct inet6_cork *v6_cork)
1587 kfree(v6_cork->opt->dst0opt);
1588 kfree(v6_cork->opt->dst1opt);
1589 kfree(v6_cork->opt->hopopt);
1590 kfree(v6_cork->opt->srcrt);
1591 kfree(v6_cork->opt);
1592 v6_cork->opt = NULL;
1595 if (cork->base.dst) {
1596 dst_release(cork->base.dst);
1597 cork->base.dst = NULL;
1598 cork->base.flags &= ~IPCORK_ALLFRAG;
1600 memset(&cork->fl, 0, sizeof(cork->fl));
1603 struct sk_buff *__ip6_make_skb(struct sock *sk,
1604 struct sk_buff_head *queue,
1605 struct inet_cork_full *cork,
1606 struct inet6_cork *v6_cork)
1608 struct sk_buff *skb, *tmp_skb;
1609 struct sk_buff **tail_skb;
1610 struct in6_addr final_dst_buf, *final_dst = &final_dst_buf;
1611 struct ipv6_pinfo *np = inet6_sk(sk);
1612 struct net *net = sock_net(sk);
1613 struct ipv6hdr *hdr;
1614 struct ipv6_txoptions *opt = v6_cork->opt;
1615 struct rt6_info *rt = (struct rt6_info *)cork->base.dst;
1616 struct flowi6 *fl6 = &cork->fl.u.ip6;
1617 unsigned char proto = fl6->flowi6_proto;
1619 skb = __skb_dequeue(queue);
1622 tail_skb = &(skb_shinfo(skb)->frag_list);
1624 /* move skb->data to ip header from ext header */
1625 if (skb->data < skb_network_header(skb))
1626 __skb_pull(skb, skb_network_offset(skb));
1627 while ((tmp_skb = __skb_dequeue(queue)) != NULL) {
1628 __skb_pull(tmp_skb, skb_network_header_len(skb));
1629 *tail_skb = tmp_skb;
1630 tail_skb = &(tmp_skb->next);
1631 skb->len += tmp_skb->len;
1632 skb->data_len += tmp_skb->len;
1633 skb->truesize += tmp_skb->truesize;
1634 tmp_skb->destructor = NULL;
1638 /* Allow local fragmentation. */
1639 skb->ignore_df = ip6_sk_ignore_df(sk);
1641 *final_dst = fl6->daddr;
1642 __skb_pull(skb, skb_network_header_len(skb));
1643 if (opt && opt->opt_flen)
1644 ipv6_push_frag_opts(skb, opt, &proto);
1645 if (opt && opt->opt_nflen)
1646 ipv6_push_nfrag_opts(skb, opt, &proto, &final_dst);
1648 skb_push(skb, sizeof(struct ipv6hdr));
1649 skb_reset_network_header(skb);
1650 hdr = ipv6_hdr(skb);
1652 ip6_flow_hdr(hdr, v6_cork->tclass,
1653 ip6_make_flowlabel(net, skb, fl6->flowlabel,
1654 np->autoflowlabel, fl6));
1655 hdr->hop_limit = v6_cork->hop_limit;
1656 hdr->nexthdr = proto;
1657 hdr->saddr = fl6->saddr;
1658 hdr->daddr = *final_dst;
1660 skb->priority = sk->sk_priority;
1661 skb->mark = sk->sk_mark;
1663 skb_dst_set(skb, dst_clone(&rt->dst));
1664 IP6_UPD_PO_STATS(net, rt->rt6i_idev, IPSTATS_MIB_OUT, skb->len);
1665 if (proto == IPPROTO_ICMPV6) {
1666 struct inet6_dev *idev = ip6_dst_idev(skb_dst(skb));
1668 ICMP6MSGOUT_INC_STATS(net, idev, icmp6_hdr(skb)->icmp6_type);
1669 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
1672 ip6_cork_release(cork, v6_cork);
1677 int ip6_send_skb(struct sk_buff *skb)
1679 struct net *net = sock_net(skb->sk);
1680 struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
1683 err = ip6_local_out(skb);
1686 err = net_xmit_errno(err);
1688 IP6_INC_STATS(net, rt->rt6i_idev,
1689 IPSTATS_MIB_OUTDISCARDS);
1695 int ip6_push_pending_frames(struct sock *sk)
1697 struct sk_buff *skb;
1699 skb = ip6_finish_skb(sk);
1703 return ip6_send_skb(skb);
1705 EXPORT_SYMBOL_GPL(ip6_push_pending_frames);
1707 static void __ip6_flush_pending_frames(struct sock *sk,
1708 struct sk_buff_head *queue,
1709 struct inet_cork_full *cork,
1710 struct inet6_cork *v6_cork)
1712 struct sk_buff *skb;
1714 while ((skb = __skb_dequeue_tail(queue)) != NULL) {
1716 IP6_INC_STATS(sock_net(sk), ip6_dst_idev(skb_dst(skb)),
1717 IPSTATS_MIB_OUTDISCARDS);
1721 ip6_cork_release(cork, v6_cork);
1724 void ip6_flush_pending_frames(struct sock *sk)
1726 __ip6_flush_pending_frames(sk, &sk->sk_write_queue,
1727 &inet_sk(sk)->cork, &inet6_sk(sk)->cork);
1729 EXPORT_SYMBOL_GPL(ip6_flush_pending_frames);
1731 struct sk_buff *ip6_make_skb(struct sock *sk,
1732 int getfrag(void *from, char *to, int offset,
1733 int len, int odd, struct sk_buff *skb),
1734 void *from, int length, int transhdrlen,
1735 int hlimit, int tclass,
1736 struct ipv6_txoptions *opt, struct flowi6 *fl6,
1737 struct rt6_info *rt, unsigned int flags,
1740 struct inet_cork_full cork;
1741 struct inet6_cork v6_cork;
1742 struct sk_buff_head queue;
1743 int exthdrlen = (opt ? opt->opt_flen : 0);
1746 if (flags & MSG_PROBE)
1749 __skb_queue_head_init(&queue);
1751 cork.base.flags = 0;
1753 cork.base.opt = NULL;
1755 err = ip6_setup_cork(sk, &cork, &v6_cork, hlimit, tclass, opt, rt, fl6);
1757 return ERR_PTR(err);
1760 dontfrag = inet6_sk(sk)->dontfrag;
1762 err = __ip6_append_data(sk, fl6, &queue, &cork.base, &v6_cork,
1763 ¤t->task_frag, getfrag, from,
1764 length + exthdrlen, transhdrlen + exthdrlen,
1767 __ip6_flush_pending_frames(sk, &queue, &cork, &v6_cork);
1768 return ERR_PTR(err);
1771 return __ip6_make_skb(sk, &queue, &cork, &v6_cork);