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/bpf-cgroup.h>
43 #include <linux/netfilter.h>
44 #include <linux/netfilter_ipv6.h>
50 #include <net/ndisc.h>
51 #include <net/protocol.h>
52 #include <net/ip6_route.h>
53 #include <net/addrconf.h>
54 #include <net/rawv6.h>
57 #include <net/checksum.h>
58 #include <linux/mroute6.h>
59 #include <net/l3mdev.h>
60 #include <net/lwtunnel.h>
62 static int ip6_finish_output2(struct net *net, struct sock *sk, struct sk_buff *skb)
64 struct dst_entry *dst = skb_dst(skb);
65 struct net_device *dev = dst->dev;
66 struct neighbour *neigh;
67 struct in6_addr *nexthop;
70 if (ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr)) {
71 struct inet6_dev *idev = ip6_dst_idev(skb_dst(skb));
73 if (!(dev->flags & IFF_LOOPBACK) && sk_mc_loop(sk) &&
74 ((mroute6_socket(net, skb) &&
75 !(IP6CB(skb)->flags & IP6SKB_FORWARDED)) ||
76 ipv6_chk_mcast_addr(dev, &ipv6_hdr(skb)->daddr,
77 &ipv6_hdr(skb)->saddr))) {
78 struct sk_buff *newskb = skb_clone(skb, GFP_ATOMIC);
80 /* Do not check for IFF_ALLMULTI; multicast routing
81 is not supported in any case.
84 NF_HOOK(NFPROTO_IPV6, NF_INET_POST_ROUTING,
85 net, sk, newskb, NULL, newskb->dev,
88 if (ipv6_hdr(skb)->hop_limit == 0) {
89 IP6_INC_STATS(net, idev,
90 IPSTATS_MIB_OUTDISCARDS);
96 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUTMCAST, skb->len);
98 if (IPV6_ADDR_MC_SCOPE(&ipv6_hdr(skb)->daddr) <=
99 IPV6_ADDR_SCOPE_NODELOCAL &&
100 !(dev->flags & IFF_LOOPBACK)) {
106 if (lwtunnel_xmit_redirect(dst->lwtstate)) {
107 int res = lwtunnel_xmit(skb);
109 if (res < 0 || res == LWTUNNEL_XMIT_DONE)
114 nexthop = rt6_nexthop((struct rt6_info *)dst, &ipv6_hdr(skb)->daddr);
115 neigh = __ipv6_neigh_lookup_noref(dst->dev, nexthop);
116 if (unlikely(!neigh))
117 neigh = __neigh_create(&nd_tbl, nexthop, dst->dev, false);
118 if (!IS_ERR(neigh)) {
119 sock_confirm_neigh(skb, neigh);
120 ret = neigh_output(neigh, skb);
121 rcu_read_unlock_bh();
124 rcu_read_unlock_bh();
126 IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTNOROUTES);
131 static int ip6_finish_output(struct net *net, struct sock *sk, struct sk_buff *skb)
135 ret = BPF_CGROUP_RUN_PROG_INET_EGRESS(sk, skb);
141 if ((skb->len > ip6_skb_dst_mtu(skb) && !skb_is_gso(skb)) ||
142 dst_allfrag(skb_dst(skb)) ||
143 (IP6CB(skb)->frag_max_size && skb->len > IP6CB(skb)->frag_max_size))
144 return ip6_fragment(net, sk, skb, ip6_finish_output2);
146 return ip6_finish_output2(net, sk, skb);
149 int ip6_output(struct net *net, struct sock *sk, struct sk_buff *skb)
151 struct net_device *dev = skb_dst(skb)->dev;
152 struct inet6_dev *idev = ip6_dst_idev(skb_dst(skb));
154 skb->protocol = htons(ETH_P_IPV6);
157 if (unlikely(idev->cnf.disable_ipv6)) {
158 IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTDISCARDS);
163 return NF_HOOK_COND(NFPROTO_IPV6, NF_INET_POST_ROUTING,
164 net, sk, skb, NULL, dev,
166 !(IP6CB(skb)->flags & IP6SKB_REROUTED));
169 static bool ip6_autoflowlabel(struct net *net, const struct ipv6_pinfo *np)
171 if (!np->autoflowlabel_set)
172 return ip6_default_np_autolabel(net);
174 return np->autoflowlabel;
178 * xmit an sk_buff (used by TCP, SCTP and DCCP)
179 * Note : socket lock is not held for SYNACK packets, but might be modified
180 * by calls to skb_set_owner_w() and ipv6_local_error(),
181 * which are using proper atomic operations or spinlocks.
183 int ip6_xmit(const struct sock *sk, struct sk_buff *skb, struct flowi6 *fl6,
184 __u32 mark, struct ipv6_txoptions *opt, int tclass)
186 struct net *net = sock_net(sk);
187 const struct ipv6_pinfo *np = inet6_sk(sk);
188 struct in6_addr *first_hop = &fl6->daddr;
189 struct dst_entry *dst = skb_dst(skb);
191 u8 proto = fl6->flowi6_proto;
192 int seg_len = skb->len;
197 unsigned int head_room;
199 /* First: exthdrs may take lots of space (~8K for now)
200 MAX_HEADER is not enough.
202 head_room = opt->opt_nflen + opt->opt_flen;
203 seg_len += head_room;
204 head_room += sizeof(struct ipv6hdr) + LL_RESERVED_SPACE(dst->dev);
206 if (skb_headroom(skb) < head_room) {
207 struct sk_buff *skb2 = skb_realloc_headroom(skb, head_room);
209 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
210 IPSTATS_MIB_OUTDISCARDS);
216 /* skb_set_owner_w() changes sk->sk_wmem_alloc atomically,
217 * it is safe to call in our context (socket lock not held)
219 skb_set_owner_w(skb, (struct sock *)sk);
222 ipv6_push_frag_opts(skb, opt, &proto);
224 ipv6_push_nfrag_opts(skb, opt, &proto, &first_hop,
228 skb_push(skb, sizeof(struct ipv6hdr));
229 skb_reset_network_header(skb);
233 * Fill in the IPv6 header
236 hlimit = np->hop_limit;
238 hlimit = ip6_dst_hoplimit(dst);
240 ip6_flow_hdr(hdr, tclass, ip6_make_flowlabel(net, skb, fl6->flowlabel,
241 ip6_autoflowlabel(net, np), fl6));
243 hdr->payload_len = htons(seg_len);
244 hdr->nexthdr = proto;
245 hdr->hop_limit = hlimit;
247 hdr->saddr = fl6->saddr;
248 hdr->daddr = *first_hop;
250 skb->protocol = htons(ETH_P_IPV6);
251 skb->priority = sk->sk_priority;
255 if ((skb->len <= mtu) || skb->ignore_df || skb_is_gso(skb)) {
256 IP6_UPD_PO_STATS(net, ip6_dst_idev(skb_dst(skb)),
257 IPSTATS_MIB_OUT, skb->len);
259 /* if egress device is enslaved to an L3 master device pass the
260 * skb to its handler for processing
262 skb = l3mdev_ip6_out((struct sock *)sk, skb);
266 /* hooks should never assume socket lock is held.
267 * we promote our socket to non const
269 return NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT,
270 net, (struct sock *)sk, skb, NULL, dst->dev,
275 /* ipv6_local_error() does not require socket lock,
276 * we promote our socket to non const
278 ipv6_local_error((struct sock *)sk, EMSGSIZE, fl6, mtu);
280 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_FRAGFAILS);
284 EXPORT_SYMBOL(ip6_xmit);
286 static int ip6_call_ra_chain(struct sk_buff *skb, int sel)
288 struct ip6_ra_chain *ra;
289 struct sock *last = NULL;
291 read_lock(&ip6_ra_lock);
292 for (ra = ip6_ra_chain; ra; ra = ra->next) {
293 struct sock *sk = ra->sk;
294 if (sk && ra->sel == sel &&
295 (!sk->sk_bound_dev_if ||
296 sk->sk_bound_dev_if == skb->dev->ifindex)) {
298 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
300 rawv6_rcv(last, skb2);
307 rawv6_rcv(last, skb);
308 read_unlock(&ip6_ra_lock);
311 read_unlock(&ip6_ra_lock);
315 static int ip6_forward_proxy_check(struct sk_buff *skb)
317 struct ipv6hdr *hdr = ipv6_hdr(skb);
318 u8 nexthdr = hdr->nexthdr;
322 if (ipv6_ext_hdr(nexthdr)) {
323 offset = ipv6_skip_exthdr(skb, sizeof(*hdr), &nexthdr, &frag_off);
327 offset = sizeof(struct ipv6hdr);
329 if (nexthdr == IPPROTO_ICMPV6) {
330 struct icmp6hdr *icmp6;
332 if (!pskb_may_pull(skb, (skb_network_header(skb) +
333 offset + 1 - skb->data)))
336 icmp6 = (struct icmp6hdr *)(skb_network_header(skb) + offset);
338 switch (icmp6->icmp6_type) {
339 case NDISC_ROUTER_SOLICITATION:
340 case NDISC_ROUTER_ADVERTISEMENT:
341 case NDISC_NEIGHBOUR_SOLICITATION:
342 case NDISC_NEIGHBOUR_ADVERTISEMENT:
344 /* For reaction involving unicast neighbor discovery
345 * message destined to the proxied address, pass it to
355 * The proxying router can't forward traffic sent to a link-local
356 * address, so signal the sender and discard the packet. This
357 * behavior is clarified by the MIPv6 specification.
359 if (ipv6_addr_type(&hdr->daddr) & IPV6_ADDR_LINKLOCAL) {
360 dst_link_failure(skb);
367 static inline int ip6_forward_finish(struct net *net, struct sock *sk,
370 return dst_output(net, sk, skb);
373 static unsigned int ip6_dst_mtu_forward(const struct dst_entry *dst)
376 struct inet6_dev *idev;
378 if (dst_metric_locked(dst, RTAX_MTU)) {
379 mtu = dst_metric_raw(dst, RTAX_MTU);
386 idev = __in6_dev_get(dst->dev);
388 mtu = idev->cnf.mtu6;
394 static bool ip6_pkt_too_big(const struct sk_buff *skb, unsigned int mtu)
399 /* ipv6 conntrack defrag sets max_frag_size + ignore_df */
400 if (IP6CB(skb)->frag_max_size && IP6CB(skb)->frag_max_size > mtu)
406 if (skb_is_gso(skb) && skb_gso_validate_mtu(skb, mtu))
412 int ip6_forward(struct sk_buff *skb)
414 struct dst_entry *dst = skb_dst(skb);
415 struct ipv6hdr *hdr = ipv6_hdr(skb);
416 struct inet6_skb_parm *opt = IP6CB(skb);
417 struct net *net = dev_net(dst->dev);
420 if (net->ipv6.devconf_all->forwarding == 0)
423 if (skb->pkt_type != PACKET_HOST)
426 if (unlikely(skb->sk))
429 if (skb_warn_if_lro(skb))
432 if (!xfrm6_policy_check(NULL, XFRM_POLICY_FWD, skb)) {
433 __IP6_INC_STATS(net, ip6_dst_idev(dst),
434 IPSTATS_MIB_INDISCARDS);
438 skb_forward_csum(skb);
441 * We DO NOT make any processing on
442 * RA packets, pushing them to user level AS IS
443 * without ane WARRANTY that application will be able
444 * to interpret them. The reason is that we
445 * cannot make anything clever here.
447 * We are not end-node, so that if packet contains
448 * AH/ESP, we cannot make anything.
449 * Defragmentation also would be mistake, RA packets
450 * cannot be fragmented, because there is no warranty
451 * that different fragments will go along one path. --ANK
453 if (unlikely(opt->flags & IP6SKB_ROUTERALERT)) {
454 if (ip6_call_ra_chain(skb, ntohs(opt->ra)))
459 * check and decrement ttl
461 if (hdr->hop_limit <= 1) {
462 /* Force OUTPUT device used as source address */
464 icmpv6_send(skb, ICMPV6_TIME_EXCEED, ICMPV6_EXC_HOPLIMIT, 0);
465 __IP6_INC_STATS(net, ip6_dst_idev(dst),
466 IPSTATS_MIB_INHDRERRORS);
472 /* XXX: idev->cnf.proxy_ndp? */
473 if (net->ipv6.devconf_all->proxy_ndp &&
474 pneigh_lookup(&nd_tbl, net, &hdr->daddr, skb->dev, 0)) {
475 int proxied = ip6_forward_proxy_check(skb);
477 return ip6_input(skb);
478 else if (proxied < 0) {
479 __IP6_INC_STATS(net, ip6_dst_idev(dst),
480 IPSTATS_MIB_INDISCARDS);
485 if (!xfrm6_route_forward(skb)) {
486 __IP6_INC_STATS(net, ip6_dst_idev(dst),
487 IPSTATS_MIB_INDISCARDS);
492 /* IPv6 specs say nothing about it, but it is clear that we cannot
493 send redirects to source routed frames.
494 We don't send redirects to frames decapsulated from IPsec.
496 if (skb->dev == dst->dev && opt->srcrt == 0 && !skb_sec_path(skb)) {
497 struct in6_addr *target = NULL;
498 struct inet_peer *peer;
502 * incoming and outgoing devices are the same
506 rt = (struct rt6_info *) dst;
507 if (rt->rt6i_flags & RTF_GATEWAY)
508 target = &rt->rt6i_gateway;
510 target = &hdr->daddr;
512 peer = inet_getpeer_v6(net->ipv6.peers, &hdr->daddr, 1);
514 /* Limit redirects both by destination (here)
515 and by source (inside ndisc_send_redirect)
517 if (inet_peer_xrlim_allow(peer, 1*HZ))
518 ndisc_send_redirect(skb, target);
522 int addrtype = ipv6_addr_type(&hdr->saddr);
524 /* This check is security critical. */
525 if (addrtype == IPV6_ADDR_ANY ||
526 addrtype & (IPV6_ADDR_MULTICAST | IPV6_ADDR_LOOPBACK))
528 if (addrtype & IPV6_ADDR_LINKLOCAL) {
529 icmpv6_send(skb, ICMPV6_DEST_UNREACH,
530 ICMPV6_NOT_NEIGHBOUR, 0);
535 mtu = ip6_dst_mtu_forward(dst);
536 if (mtu < IPV6_MIN_MTU)
539 if (ip6_pkt_too_big(skb, mtu)) {
540 /* Again, force OUTPUT device used as source address */
542 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
543 __IP6_INC_STATS(net, ip6_dst_idev(dst),
544 IPSTATS_MIB_INTOOBIGERRORS);
545 __IP6_INC_STATS(net, ip6_dst_idev(dst),
546 IPSTATS_MIB_FRAGFAILS);
551 if (skb_cow(skb, dst->dev->hard_header_len)) {
552 __IP6_INC_STATS(net, ip6_dst_idev(dst),
553 IPSTATS_MIB_OUTDISCARDS);
559 /* Mangling hops number delayed to point after skb COW */
563 __IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTFORWDATAGRAMS);
564 __IP6_ADD_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTOCTETS, skb->len);
565 return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD,
566 net, NULL, skb, skb->dev, dst->dev,
570 __IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_INADDRERRORS);
576 static void ip6_copy_metadata(struct sk_buff *to, struct sk_buff *from)
578 to->pkt_type = from->pkt_type;
579 to->priority = from->priority;
580 to->protocol = from->protocol;
582 skb_dst_set(to, dst_clone(skb_dst(from)));
584 to->mark = from->mark;
586 #ifdef CONFIG_NET_SCHED
587 to->tc_index = from->tc_index;
590 skb_copy_secmark(to, from);
593 int ip6_fragment(struct net *net, struct sock *sk, struct sk_buff *skb,
594 int (*output)(struct net *, struct sock *, struct sk_buff *))
596 struct sk_buff *frag;
597 struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
598 struct ipv6_pinfo *np = skb->sk && !dev_recursion_level() ?
599 inet6_sk(skb->sk) : NULL;
600 struct ipv6hdr *tmp_hdr;
602 unsigned int mtu, hlen, left, len;
605 int ptr, offset = 0, err = 0;
606 u8 *prevhdr, nexthdr = 0;
608 err = ip6_find_1stfragopt(skb, &prevhdr);
614 mtu = ip6_skb_dst_mtu(skb);
616 /* We must not fragment if the socket is set to force MTU discovery
617 * or if the skb it not generated by a local socket.
619 if (unlikely(!skb->ignore_df && skb->len > mtu))
622 if (IP6CB(skb)->frag_max_size) {
623 if (IP6CB(skb)->frag_max_size > mtu)
626 /* don't send fragments larger than what we received */
627 mtu = IP6CB(skb)->frag_max_size;
628 if (mtu < IPV6_MIN_MTU)
632 if (np && np->frag_size < mtu) {
636 if (mtu < hlen + sizeof(struct frag_hdr) + 8)
638 mtu -= hlen + sizeof(struct frag_hdr);
640 frag_id = ipv6_select_ident(net, &ipv6_hdr(skb)->daddr,
641 &ipv6_hdr(skb)->saddr);
643 if (skb->ip_summed == CHECKSUM_PARTIAL &&
644 (err = skb_checksum_help(skb)))
647 hroom = LL_RESERVED_SPACE(rt->dst.dev);
648 if (skb_has_frag_list(skb)) {
649 unsigned int first_len = skb_pagelen(skb);
650 struct sk_buff *frag2;
652 if (first_len - hlen > mtu ||
653 ((first_len - hlen) & 7) ||
655 skb_headroom(skb) < (hroom + sizeof(struct frag_hdr)))
658 skb_walk_frags(skb, frag) {
659 /* Correct geometry. */
660 if (frag->len > mtu ||
661 ((frag->len & 7) && frag->next) ||
662 skb_headroom(frag) < (hlen + hroom + sizeof(struct frag_hdr)))
663 goto slow_path_clean;
665 /* Partially cloned skb? */
666 if (skb_shared(frag))
667 goto slow_path_clean;
672 frag->destructor = sock_wfree;
674 skb->truesize -= frag->truesize;
681 *prevhdr = NEXTHDR_FRAGMENT;
682 tmp_hdr = kmemdup(skb_network_header(skb), hlen, GFP_ATOMIC);
687 frag = skb_shinfo(skb)->frag_list;
688 skb_frag_list_init(skb);
690 __skb_pull(skb, hlen);
691 fh = __skb_push(skb, sizeof(struct frag_hdr));
692 __skb_push(skb, hlen);
693 skb_reset_network_header(skb);
694 memcpy(skb_network_header(skb), tmp_hdr, hlen);
696 fh->nexthdr = nexthdr;
698 fh->frag_off = htons(IP6_MF);
699 fh->identification = frag_id;
701 first_len = skb_pagelen(skb);
702 skb->data_len = first_len - skb_headlen(skb);
703 skb->len = first_len;
704 ipv6_hdr(skb)->payload_len = htons(first_len -
705 sizeof(struct ipv6hdr));
708 /* Prepare header of the next frame,
709 * before previous one went down. */
711 frag->ip_summed = CHECKSUM_NONE;
712 skb_reset_transport_header(frag);
713 fh = __skb_push(frag, sizeof(struct frag_hdr));
714 __skb_push(frag, hlen);
715 skb_reset_network_header(frag);
716 memcpy(skb_network_header(frag), tmp_hdr,
718 offset += skb->len - hlen - sizeof(struct frag_hdr);
719 fh->nexthdr = nexthdr;
721 fh->frag_off = htons(offset);
723 fh->frag_off |= htons(IP6_MF);
724 fh->identification = frag_id;
725 ipv6_hdr(frag)->payload_len =
727 sizeof(struct ipv6hdr));
728 ip6_copy_metadata(frag, skb);
731 err = output(net, sk, skb);
733 IP6_INC_STATS(net, ip6_dst_idev(&rt->dst),
734 IPSTATS_MIB_FRAGCREATES);
747 IP6_INC_STATS(net, ip6_dst_idev(&rt->dst),
748 IPSTATS_MIB_FRAGOKS);
752 kfree_skb_list(frag);
754 IP6_INC_STATS(net, ip6_dst_idev(&rt->dst),
755 IPSTATS_MIB_FRAGFAILS);
759 skb_walk_frags(skb, frag2) {
763 frag2->destructor = NULL;
764 skb->truesize += frag2->truesize;
769 left = skb->len - hlen; /* Space per frame */
770 ptr = hlen; /* Where to start from */
773 * Fragment the datagram.
776 troom = rt->dst.dev->needed_tailroom;
779 * Keep copying data until we run out.
782 u8 *fragnexthdr_offset;
785 /* IF: it doesn't fit, use 'mtu' - the data space left */
788 /* IF: we are not sending up to and including the packet end
789 then align the next start on an eight byte boundary */
794 /* Allocate buffer */
795 frag = alloc_skb(len + hlen + sizeof(struct frag_hdr) +
796 hroom + troom, GFP_ATOMIC);
803 * Set up data on packet
806 ip6_copy_metadata(frag, skb);
807 skb_reserve(frag, hroom);
808 skb_put(frag, len + hlen + sizeof(struct frag_hdr));
809 skb_reset_network_header(frag);
810 fh = (struct frag_hdr *)(skb_network_header(frag) + hlen);
811 frag->transport_header = (frag->network_header + hlen +
812 sizeof(struct frag_hdr));
815 * Charge the memory for the fragment to any owner
819 skb_set_owner_w(frag, skb->sk);
822 * Copy the packet header into the new buffer.
824 skb_copy_from_linear_data(skb, skb_network_header(frag), hlen);
826 fragnexthdr_offset = skb_network_header(frag);
827 fragnexthdr_offset += prevhdr - skb_network_header(skb);
828 *fragnexthdr_offset = NEXTHDR_FRAGMENT;
831 * Build fragment header.
833 fh->nexthdr = nexthdr;
835 fh->identification = frag_id;
838 * Copy a block of the IP datagram.
840 BUG_ON(skb_copy_bits(skb, ptr, skb_transport_header(frag),
844 fh->frag_off = htons(offset);
846 fh->frag_off |= htons(IP6_MF);
847 ipv6_hdr(frag)->payload_len = htons(frag->len -
848 sizeof(struct ipv6hdr));
854 * Put this fragment into the sending queue.
856 err = output(net, sk, frag);
860 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
861 IPSTATS_MIB_FRAGCREATES);
863 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
864 IPSTATS_MIB_FRAGOKS);
869 if (skb->sk && dst_allfrag(skb_dst(skb)))
870 sk_nocaps_add(skb->sk, NETIF_F_GSO_MASK);
872 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
876 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
877 IPSTATS_MIB_FRAGFAILS);
882 static inline int ip6_rt_check(const struct rt6key *rt_key,
883 const struct in6_addr *fl_addr,
884 const struct in6_addr *addr_cache)
886 return (rt_key->plen != 128 || !ipv6_addr_equal(fl_addr, &rt_key->addr)) &&
887 (!addr_cache || !ipv6_addr_equal(fl_addr, addr_cache));
890 static struct dst_entry *ip6_sk_dst_check(struct sock *sk,
891 struct dst_entry *dst,
892 const struct flowi6 *fl6)
894 struct ipv6_pinfo *np = inet6_sk(sk);
900 if (dst->ops->family != AF_INET6) {
905 rt = (struct rt6_info *)dst;
906 /* Yes, checking route validity in not connected
907 * case is not very simple. Take into account,
908 * that we do not support routing by source, TOS,
909 * and MSG_DONTROUTE --ANK (980726)
911 * 1. ip6_rt_check(): If route was host route,
912 * check that cached destination is current.
913 * If it is network route, we still may
914 * check its validity using saved pointer
915 * to the last used address: daddr_cache.
916 * We do not want to save whole address now,
917 * (because main consumer of this service
918 * is tcp, which has not this problem),
919 * so that the last trick works only on connected
921 * 2. oif also should be the same.
923 if (ip6_rt_check(&rt->rt6i_dst, &fl6->daddr, np->daddr_cache) ||
924 #ifdef CONFIG_IPV6_SUBTREES
925 ip6_rt_check(&rt->rt6i_src, &fl6->saddr, np->saddr_cache) ||
927 (!(fl6->flowi6_flags & FLOWI_FLAG_SKIP_NH_OIF) &&
928 (fl6->flowi6_oif && fl6->flowi6_oif != dst->dev->ifindex))) {
937 static int ip6_dst_lookup_tail(struct net *net, const struct sock *sk,
938 struct dst_entry **dst, struct flowi6 *fl6)
940 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
947 /* The correct way to handle this would be to do
948 * ip6_route_get_saddr, and then ip6_route_output; however,
949 * the route-specific preferred source forces the
950 * ip6_route_output call _before_ ip6_route_get_saddr.
952 * In source specific routing (no src=any default route),
953 * ip6_route_output will fail given src=any saddr, though, so
954 * that's why we try it again later.
956 if (ipv6_addr_any(&fl6->saddr) && (!*dst || !(*dst)->error)) {
958 bool had_dst = *dst != NULL;
961 *dst = ip6_route_output(net, sk, fl6);
962 rt = (*dst)->error ? NULL : (struct rt6_info *)*dst;
963 err = ip6_route_get_saddr(net, rt, &fl6->daddr,
964 sk ? inet6_sk(sk)->srcprefs : 0,
967 goto out_err_release;
969 /* If we had an erroneous initial result, pretend it
970 * never existed and let the SA-enabled version take
973 if (!had_dst && (*dst)->error) {
979 flags |= RT6_LOOKUP_F_IFACE;
983 *dst = ip6_route_output_flags(net, sk, fl6, flags);
987 goto out_err_release;
989 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
991 * Here if the dst entry we've looked up
992 * has a neighbour entry that is in the INCOMPLETE
993 * state and the src address from the flow is
994 * marked as OPTIMISTIC, we release the found
995 * dst entry and replace it instead with the
996 * dst entry of the nexthop router
998 rt = (struct rt6_info *) *dst;
1000 n = __ipv6_neigh_lookup_noref(rt->dst.dev,
1001 rt6_nexthop(rt, &fl6->daddr));
1002 err = n && !(n->nud_state & NUD_VALID) ? -EINVAL : 0;
1003 rcu_read_unlock_bh();
1006 struct inet6_ifaddr *ifp;
1007 struct flowi6 fl_gw6;
1010 ifp = ipv6_get_ifaddr(net, &fl6->saddr,
1013 redirect = (ifp && ifp->flags & IFA_F_OPTIMISTIC);
1019 * We need to get the dst entry for the
1020 * default router instead
1023 memcpy(&fl_gw6, fl6, sizeof(struct flowi6));
1024 memset(&fl_gw6.daddr, 0, sizeof(struct in6_addr));
1025 *dst = ip6_route_output(net, sk, &fl_gw6);
1026 err = (*dst)->error;
1028 goto out_err_release;
1032 if (ipv6_addr_v4mapped(&fl6->saddr) &&
1033 !(ipv6_addr_v4mapped(&fl6->daddr) || ipv6_addr_any(&fl6->daddr))) {
1034 err = -EAFNOSUPPORT;
1035 goto out_err_release;
1044 if (err == -ENETUNREACH)
1045 IP6_INC_STATS(net, NULL, IPSTATS_MIB_OUTNOROUTES);
1050 * ip6_dst_lookup - perform route lookup on flow
1051 * @sk: socket which provides route info
1052 * @dst: pointer to dst_entry * for result
1053 * @fl6: flow to lookup
1055 * This function performs a route lookup on the given flow.
1057 * It returns zero on success, or a standard errno code on error.
1059 int ip6_dst_lookup(struct net *net, struct sock *sk, struct dst_entry **dst,
1063 return ip6_dst_lookup_tail(net, sk, dst, fl6);
1065 EXPORT_SYMBOL_GPL(ip6_dst_lookup);
1068 * ip6_dst_lookup_flow - perform route lookup on flow with ipsec
1069 * @sk: socket which provides route info
1070 * @fl6: flow to lookup
1071 * @final_dst: final destination address for ipsec lookup
1073 * This function performs a route lookup on the given flow.
1075 * It returns a valid dst pointer on success, or a pointer encoded
1078 struct dst_entry *ip6_dst_lookup_flow(const struct sock *sk, struct flowi6 *fl6,
1079 const struct in6_addr *final_dst)
1081 struct dst_entry *dst = NULL;
1084 err = ip6_dst_lookup_tail(sock_net(sk), sk, &dst, fl6);
1086 return ERR_PTR(err);
1088 fl6->daddr = *final_dst;
1090 return xfrm_lookup_route(sock_net(sk), dst, flowi6_to_flowi(fl6), sk, 0);
1092 EXPORT_SYMBOL_GPL(ip6_dst_lookup_flow);
1095 * ip6_sk_dst_lookup_flow - perform socket cached route lookup on flow
1096 * @sk: socket which provides the dst cache and route info
1097 * @fl6: flow to lookup
1098 * @final_dst: final destination address for ipsec lookup
1100 * This function performs a route lookup on the given flow with the
1101 * possibility of using the cached route in the socket if it is valid.
1102 * It will take the socket dst lock when operating on the dst cache.
1103 * As a result, this function can only be used in process context.
1105 * It returns a valid dst pointer on success, or a pointer encoded
1108 struct dst_entry *ip6_sk_dst_lookup_flow(struct sock *sk, struct flowi6 *fl6,
1109 const struct in6_addr *final_dst)
1111 struct dst_entry *dst = sk_dst_check(sk, inet6_sk(sk)->dst_cookie);
1113 dst = ip6_sk_dst_check(sk, dst, fl6);
1115 dst = ip6_dst_lookup_flow(sk, fl6, final_dst);
1119 EXPORT_SYMBOL_GPL(ip6_sk_dst_lookup_flow);
1121 static inline struct ipv6_opt_hdr *ip6_opt_dup(struct ipv6_opt_hdr *src,
1124 return src ? kmemdup(src, (src->hdrlen + 1) * 8, gfp) : NULL;
1127 static inline struct ipv6_rt_hdr *ip6_rthdr_dup(struct ipv6_rt_hdr *src,
1130 return src ? kmemdup(src, (src->hdrlen + 1) * 8, gfp) : NULL;
1133 static void ip6_append_data_mtu(unsigned int *mtu,
1135 unsigned int fragheaderlen,
1136 struct sk_buff *skb,
1137 struct rt6_info *rt,
1138 unsigned int orig_mtu)
1140 if (!(rt->dst.flags & DST_XFRM_TUNNEL)) {
1142 /* first fragment, reserve header_len */
1143 *mtu = orig_mtu - rt->dst.header_len;
1147 * this fragment is not first, the headers
1148 * space is regarded as data space.
1152 *maxfraglen = ((*mtu - fragheaderlen) & ~7)
1153 + fragheaderlen - sizeof(struct frag_hdr);
1157 static int ip6_setup_cork(struct sock *sk, struct inet_cork_full *cork,
1158 struct inet6_cork *v6_cork, struct ipcm6_cookie *ipc6,
1159 struct rt6_info *rt, struct flowi6 *fl6)
1161 struct ipv6_pinfo *np = inet6_sk(sk);
1163 struct ipv6_txoptions *opt = ipc6->opt;
1169 if (WARN_ON(v6_cork->opt))
1172 v6_cork->opt = kzalloc(sizeof(*opt), sk->sk_allocation);
1173 if (unlikely(!v6_cork->opt))
1176 v6_cork->opt->tot_len = sizeof(*opt);
1177 v6_cork->opt->opt_flen = opt->opt_flen;
1178 v6_cork->opt->opt_nflen = opt->opt_nflen;
1180 v6_cork->opt->dst0opt = ip6_opt_dup(opt->dst0opt,
1182 if (opt->dst0opt && !v6_cork->opt->dst0opt)
1185 v6_cork->opt->dst1opt = ip6_opt_dup(opt->dst1opt,
1187 if (opt->dst1opt && !v6_cork->opt->dst1opt)
1190 v6_cork->opt->hopopt = ip6_opt_dup(opt->hopopt,
1192 if (opt->hopopt && !v6_cork->opt->hopopt)
1195 v6_cork->opt->srcrt = ip6_rthdr_dup(opt->srcrt,
1197 if (opt->srcrt && !v6_cork->opt->srcrt)
1200 /* need source address above miyazawa*/
1203 cork->base.dst = &rt->dst;
1204 cork->fl.u.ip6 = *fl6;
1205 v6_cork->hop_limit = ipc6->hlimit;
1206 v6_cork->tclass = ipc6->tclass;
1207 if (rt->dst.flags & DST_XFRM_TUNNEL)
1208 mtu = np->pmtudisc >= IPV6_PMTUDISC_PROBE ?
1209 rt->dst.dev->mtu : dst_mtu(&rt->dst);
1211 mtu = np->pmtudisc >= IPV6_PMTUDISC_PROBE ?
1212 rt->dst.dev->mtu : dst_mtu(rt->dst.path);
1213 if (np->frag_size < mtu) {
1215 mtu = np->frag_size;
1217 cork->base.fragsize = mtu;
1218 if (dst_allfrag(rt->dst.path))
1219 cork->base.flags |= IPCORK_ALLFRAG;
1220 cork->base.length = 0;
1225 static int __ip6_append_data(struct sock *sk,
1227 struct sk_buff_head *queue,
1228 struct inet_cork *cork,
1229 struct inet6_cork *v6_cork,
1230 struct page_frag *pfrag,
1231 int getfrag(void *from, char *to, int offset,
1232 int len, int odd, struct sk_buff *skb),
1233 void *from, int length, int transhdrlen,
1234 unsigned int flags, struct ipcm6_cookie *ipc6,
1235 const struct sockcm_cookie *sockc)
1237 struct sk_buff *skb, *skb_prev = NULL;
1238 unsigned int maxfraglen, fragheaderlen, mtu, orig_mtu;
1240 int dst_exthdrlen = 0;
1247 struct rt6_info *rt = (struct rt6_info *)cork->dst;
1248 struct ipv6_txoptions *opt = v6_cork->opt;
1249 int csummode = CHECKSUM_NONE;
1250 unsigned int maxnonfragsize, headersize;
1252 skb = skb_peek_tail(queue);
1254 exthdrlen = opt ? opt->opt_flen : 0;
1255 dst_exthdrlen = rt->dst.header_len - rt->rt6i_nfheader_len;
1258 mtu = cork->fragsize;
1261 hh_len = LL_RESERVED_SPACE(rt->dst.dev);
1263 fragheaderlen = sizeof(struct ipv6hdr) + rt->rt6i_nfheader_len +
1264 (opt ? opt->opt_nflen : 0);
1265 maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen -
1266 sizeof(struct frag_hdr);
1268 headersize = sizeof(struct ipv6hdr) +
1269 (opt ? opt->opt_flen + opt->opt_nflen : 0) +
1270 (dst_allfrag(&rt->dst) ?
1271 sizeof(struct frag_hdr) : 0) +
1272 rt->rt6i_nfheader_len;
1274 if (cork->length + length > mtu - headersize && ipc6->dontfrag &&
1275 (sk->sk_protocol == IPPROTO_UDP ||
1276 sk->sk_protocol == IPPROTO_RAW)) {
1277 ipv6_local_rxpmtu(sk, fl6, mtu - headersize +
1278 sizeof(struct ipv6hdr));
1282 if (ip6_sk_ignore_df(sk))
1283 maxnonfragsize = sizeof(struct ipv6hdr) + IPV6_MAXPLEN;
1285 maxnonfragsize = mtu;
1287 if (cork->length + length > maxnonfragsize - headersize) {
1289 ipv6_local_error(sk, EMSGSIZE, fl6,
1291 sizeof(struct ipv6hdr));
1295 /* CHECKSUM_PARTIAL only with no extension headers and when
1296 * we are not going to fragment
1298 if (transhdrlen && sk->sk_protocol == IPPROTO_UDP &&
1299 headersize == sizeof(struct ipv6hdr) &&
1300 length <= mtu - headersize &&
1301 !(flags & MSG_MORE) &&
1302 rt->dst.dev->features & (NETIF_F_IPV6_CSUM | NETIF_F_HW_CSUM))
1303 csummode = CHECKSUM_PARTIAL;
1305 if (sk->sk_type == SOCK_DGRAM || sk->sk_type == SOCK_RAW) {
1306 sock_tx_timestamp(sk, sockc->tsflags, &tx_flags);
1307 if (tx_flags & SKBTX_ANY_SW_TSTAMP &&
1308 sk->sk_tsflags & SOF_TIMESTAMPING_OPT_ID)
1309 tskey = sk->sk_tskey++;
1313 * Let's try using as much space as possible.
1314 * Use MTU if total length of the message fits into the MTU.
1315 * Otherwise, we need to reserve fragment header and
1316 * fragment alignment (= 8-15 octects, in total).
1318 * Note that we may need to "move" the data from the tail of
1319 * of the buffer to the new fragment when we split
1322 * FIXME: It may be fragmented into multiple chunks
1323 * at once if non-fragmentable extension headers
1328 cork->length += length;
1332 while (length > 0) {
1333 /* Check if the remaining data fits into current packet. */
1334 copy = (cork->length <= mtu && !(cork->flags & IPCORK_ALLFRAG) ? mtu : maxfraglen) - skb->len;
1336 copy = maxfraglen - skb->len;
1340 unsigned int datalen;
1341 unsigned int fraglen;
1342 unsigned int fraggap;
1343 unsigned int alloclen;
1345 /* There's no room in the current skb */
1347 fraggap = skb->len - maxfraglen;
1350 /* update mtu and maxfraglen if necessary */
1351 if (!skb || !skb_prev)
1352 ip6_append_data_mtu(&mtu, &maxfraglen,
1353 fragheaderlen, skb, rt,
1359 * If remaining data exceeds the mtu,
1360 * we know we need more fragment(s).
1362 datalen = length + fraggap;
1364 if (datalen > (cork->length <= mtu && !(cork->flags & IPCORK_ALLFRAG) ? mtu : maxfraglen) - fragheaderlen)
1365 datalen = maxfraglen - fragheaderlen - rt->dst.trailer_len;
1366 if ((flags & MSG_MORE) &&
1367 !(rt->dst.dev->features&NETIF_F_SG))
1370 alloclen = datalen + fragheaderlen;
1372 alloclen += dst_exthdrlen;
1374 if (datalen != length + fraggap) {
1376 * this is not the last fragment, the trailer
1377 * space is regarded as data space.
1379 datalen += rt->dst.trailer_len;
1382 alloclen += rt->dst.trailer_len;
1383 fraglen = datalen + fragheaderlen;
1386 * We just reserve space for fragment header.
1387 * Note: this may be overallocation if the message
1388 * (without MSG_MORE) fits into the MTU.
1390 alloclen += sizeof(struct frag_hdr);
1392 copy = datalen - transhdrlen - fraggap;
1398 skb = sock_alloc_send_skb(sk,
1400 (flags & MSG_DONTWAIT), &err);
1403 if (refcount_read(&sk->sk_wmem_alloc) <=
1405 skb = sock_wmalloc(sk,
1406 alloclen + hh_len, 1,
1414 * Fill in the control structures
1416 skb->protocol = htons(ETH_P_IPV6);
1417 skb->ip_summed = csummode;
1419 /* reserve for fragmentation and ipsec header */
1420 skb_reserve(skb, hh_len + sizeof(struct frag_hdr) +
1423 /* Only the initial fragment is time stamped */
1424 skb_shinfo(skb)->tx_flags = tx_flags;
1426 skb_shinfo(skb)->tskey = tskey;
1430 * Find where to start putting bytes
1432 data = skb_put(skb, fraglen);
1433 skb_set_network_header(skb, exthdrlen);
1434 data += fragheaderlen;
1435 skb->transport_header = (skb->network_header +
1438 skb->csum = skb_copy_and_csum_bits(
1439 skb_prev, maxfraglen,
1440 data + transhdrlen, fraggap, 0);
1441 skb_prev->csum = csum_sub(skb_prev->csum,
1444 pskb_trim_unique(skb_prev, maxfraglen);
1447 getfrag(from, data + transhdrlen, offset,
1448 copy, fraggap, skb) < 0) {
1455 length -= datalen - fraggap;
1460 if ((flags & MSG_CONFIRM) && !skb_prev)
1461 skb_set_dst_pending_confirm(skb, 1);
1464 * Put the packet on the pending queue
1466 __skb_queue_tail(queue, skb);
1473 if (!(rt->dst.dev->features&NETIF_F_SG)) {
1477 if (getfrag(from, skb_put(skb, copy),
1478 offset, copy, off, skb) < 0) {
1479 __skb_trim(skb, off);
1484 int i = skb_shinfo(skb)->nr_frags;
1487 if (!sk_page_frag_refill(sk, pfrag))
1490 if (!skb_can_coalesce(skb, i, pfrag->page,
1493 if (i == MAX_SKB_FRAGS)
1496 __skb_fill_page_desc(skb, i, pfrag->page,
1498 skb_shinfo(skb)->nr_frags = ++i;
1499 get_page(pfrag->page);
1501 copy = min_t(int, copy, pfrag->size - pfrag->offset);
1503 page_address(pfrag->page) + pfrag->offset,
1504 offset, copy, skb->len, skb) < 0)
1507 pfrag->offset += copy;
1508 skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy);
1510 skb->data_len += copy;
1511 skb->truesize += copy;
1512 refcount_add(copy, &sk->sk_wmem_alloc);
1523 cork->length -= length;
1524 IP6_INC_STATS(sock_net(sk), rt->rt6i_idev, IPSTATS_MIB_OUTDISCARDS);
1528 int ip6_append_data(struct sock *sk,
1529 int getfrag(void *from, char *to, int offset, int len,
1530 int odd, struct sk_buff *skb),
1531 void *from, int length, int transhdrlen,
1532 struct ipcm6_cookie *ipc6, struct flowi6 *fl6,
1533 struct rt6_info *rt, unsigned int flags,
1534 const struct sockcm_cookie *sockc)
1536 struct inet_sock *inet = inet_sk(sk);
1537 struct ipv6_pinfo *np = inet6_sk(sk);
1541 if (flags&MSG_PROBE)
1543 if (skb_queue_empty(&sk->sk_write_queue)) {
1547 err = ip6_setup_cork(sk, &inet->cork, &np->cork,
1552 exthdrlen = (ipc6->opt ? ipc6->opt->opt_flen : 0);
1553 length += exthdrlen;
1554 transhdrlen += exthdrlen;
1556 fl6 = &inet->cork.fl.u.ip6;
1560 return __ip6_append_data(sk, fl6, &sk->sk_write_queue, &inet->cork.base,
1561 &np->cork, sk_page_frag(sk), getfrag,
1562 from, length, transhdrlen, flags, ipc6, sockc);
1564 EXPORT_SYMBOL_GPL(ip6_append_data);
1566 static void ip6_cork_release(struct inet_cork_full *cork,
1567 struct inet6_cork *v6_cork)
1570 kfree(v6_cork->opt->dst0opt);
1571 kfree(v6_cork->opt->dst1opt);
1572 kfree(v6_cork->opt->hopopt);
1573 kfree(v6_cork->opt->srcrt);
1574 kfree(v6_cork->opt);
1575 v6_cork->opt = NULL;
1578 if (cork->base.dst) {
1579 dst_release(cork->base.dst);
1580 cork->base.dst = NULL;
1581 cork->base.flags &= ~IPCORK_ALLFRAG;
1583 memset(&cork->fl, 0, sizeof(cork->fl));
1586 struct sk_buff *__ip6_make_skb(struct sock *sk,
1587 struct sk_buff_head *queue,
1588 struct inet_cork_full *cork,
1589 struct inet6_cork *v6_cork)
1591 struct sk_buff *skb, *tmp_skb;
1592 struct sk_buff **tail_skb;
1593 struct in6_addr final_dst_buf, *final_dst = &final_dst_buf;
1594 struct ipv6_pinfo *np = inet6_sk(sk);
1595 struct net *net = sock_net(sk);
1596 struct ipv6hdr *hdr;
1597 struct ipv6_txoptions *opt = v6_cork->opt;
1598 struct rt6_info *rt = (struct rt6_info *)cork->base.dst;
1599 struct flowi6 *fl6 = &cork->fl.u.ip6;
1600 unsigned char proto = fl6->flowi6_proto;
1602 skb = __skb_dequeue(queue);
1605 tail_skb = &(skb_shinfo(skb)->frag_list);
1607 /* move skb->data to ip header from ext header */
1608 if (skb->data < skb_network_header(skb))
1609 __skb_pull(skb, skb_network_offset(skb));
1610 while ((tmp_skb = __skb_dequeue(queue)) != NULL) {
1611 __skb_pull(tmp_skb, skb_network_header_len(skb));
1612 *tail_skb = tmp_skb;
1613 tail_skb = &(tmp_skb->next);
1614 skb->len += tmp_skb->len;
1615 skb->data_len += tmp_skb->len;
1616 skb->truesize += tmp_skb->truesize;
1617 tmp_skb->destructor = NULL;
1621 /* Allow local fragmentation. */
1622 skb->ignore_df = ip6_sk_ignore_df(sk);
1624 *final_dst = fl6->daddr;
1625 __skb_pull(skb, skb_network_header_len(skb));
1626 if (opt && opt->opt_flen)
1627 ipv6_push_frag_opts(skb, opt, &proto);
1628 if (opt && opt->opt_nflen)
1629 ipv6_push_nfrag_opts(skb, opt, &proto, &final_dst, &fl6->saddr);
1631 skb_push(skb, sizeof(struct ipv6hdr));
1632 skb_reset_network_header(skb);
1633 hdr = ipv6_hdr(skb);
1635 ip6_flow_hdr(hdr, v6_cork->tclass,
1636 ip6_make_flowlabel(net, skb, fl6->flowlabel,
1637 ip6_autoflowlabel(net, np), fl6));
1638 hdr->hop_limit = v6_cork->hop_limit;
1639 hdr->nexthdr = proto;
1640 hdr->saddr = fl6->saddr;
1641 hdr->daddr = *final_dst;
1643 skb->priority = sk->sk_priority;
1644 skb->mark = sk->sk_mark;
1646 skb_dst_set(skb, dst_clone(&rt->dst));
1647 IP6_UPD_PO_STATS(net, rt->rt6i_idev, IPSTATS_MIB_OUT, skb->len);
1648 if (proto == IPPROTO_ICMPV6) {
1649 struct inet6_dev *idev = ip6_dst_idev(skb_dst(skb));
1651 ICMP6MSGOUT_INC_STATS(net, idev, icmp6_hdr(skb)->icmp6_type);
1652 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
1655 ip6_cork_release(cork, v6_cork);
1660 int ip6_send_skb(struct sk_buff *skb)
1662 struct net *net = sock_net(skb->sk);
1663 struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
1666 err = ip6_local_out(net, skb->sk, skb);
1669 err = net_xmit_errno(err);
1671 IP6_INC_STATS(net, rt->rt6i_idev,
1672 IPSTATS_MIB_OUTDISCARDS);
1678 int ip6_push_pending_frames(struct sock *sk)
1680 struct sk_buff *skb;
1682 skb = ip6_finish_skb(sk);
1686 return ip6_send_skb(skb);
1688 EXPORT_SYMBOL_GPL(ip6_push_pending_frames);
1690 static void __ip6_flush_pending_frames(struct sock *sk,
1691 struct sk_buff_head *queue,
1692 struct inet_cork_full *cork,
1693 struct inet6_cork *v6_cork)
1695 struct sk_buff *skb;
1697 while ((skb = __skb_dequeue_tail(queue)) != NULL) {
1699 IP6_INC_STATS(sock_net(sk), ip6_dst_idev(skb_dst(skb)),
1700 IPSTATS_MIB_OUTDISCARDS);
1704 ip6_cork_release(cork, v6_cork);
1707 void ip6_flush_pending_frames(struct sock *sk)
1709 __ip6_flush_pending_frames(sk, &sk->sk_write_queue,
1710 &inet_sk(sk)->cork, &inet6_sk(sk)->cork);
1712 EXPORT_SYMBOL_GPL(ip6_flush_pending_frames);
1714 struct sk_buff *ip6_make_skb(struct sock *sk,
1715 int getfrag(void *from, char *to, int offset,
1716 int len, int odd, struct sk_buff *skb),
1717 void *from, int length, int transhdrlen,
1718 struct ipcm6_cookie *ipc6, struct flowi6 *fl6,
1719 struct rt6_info *rt, unsigned int flags,
1720 const struct sockcm_cookie *sockc)
1722 struct inet_cork_full cork;
1723 struct inet6_cork v6_cork;
1724 struct sk_buff_head queue;
1725 int exthdrlen = (ipc6->opt ? ipc6->opt->opt_flen : 0);
1728 if (flags & MSG_PROBE)
1731 __skb_queue_head_init(&queue);
1733 cork.base.flags = 0;
1735 cork.base.opt = NULL;
1737 err = ip6_setup_cork(sk, &cork, &v6_cork, ipc6, rt, fl6);
1739 ip6_cork_release(&cork, &v6_cork);
1740 return ERR_PTR(err);
1742 if (ipc6->dontfrag < 0)
1743 ipc6->dontfrag = inet6_sk(sk)->dontfrag;
1745 err = __ip6_append_data(sk, fl6, &queue, &cork.base, &v6_cork,
1746 ¤t->task_frag, getfrag, from,
1747 length + exthdrlen, transhdrlen + exthdrlen,
1748 flags, ipc6, sockc);
1750 __ip6_flush_pending_frames(sk, &queue, &cork, &v6_cork);
1751 return ERR_PTR(err);
1754 return __ip6_make_skb(sk, &queue, &cork, &v6_cork);