xref: /openbmc/linux/net/ipv4/ip_output.c (revision 82e91ffef60e6eba9848fe149ce1eecd2b5aef12)
11da177e4SLinus Torvalds /*
21da177e4SLinus Torvalds  * INET		An implementation of the TCP/IP protocol suite for the LINUX
31da177e4SLinus Torvalds  *		operating system.  INET is implemented using the  BSD Socket
41da177e4SLinus Torvalds  *		interface as the means of communication with the user level.
51da177e4SLinus Torvalds  *
61da177e4SLinus Torvalds  *		The Internet Protocol (IP) output module.
71da177e4SLinus Torvalds  *
81da177e4SLinus Torvalds  * Version:	$Id: ip_output.c,v 1.100 2002/02/01 22:01:03 davem Exp $
91da177e4SLinus Torvalds  *
1002c30a84SJesper Juhl  * Authors:	Ross Biro
111da177e4SLinus Torvalds  *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
121da177e4SLinus Torvalds  *		Donald Becker, <becker@super.org>
131da177e4SLinus Torvalds  *		Alan Cox, <Alan.Cox@linux.org>
141da177e4SLinus Torvalds  *		Richard Underwood
151da177e4SLinus Torvalds  *		Stefan Becker, <stefanb@yello.ping.de>
161da177e4SLinus Torvalds  *		Jorge Cwik, <jorge@laser.satlink.net>
171da177e4SLinus Torvalds  *		Arnt Gulbrandsen, <agulbra@nvg.unit.no>
181da177e4SLinus Torvalds  *		Hirokazu Takahashi, <taka@valinux.co.jp>
191da177e4SLinus Torvalds  *
201da177e4SLinus Torvalds  *	See ip_input.c for original log
211da177e4SLinus Torvalds  *
221da177e4SLinus Torvalds  *	Fixes:
231da177e4SLinus Torvalds  *		Alan Cox	:	Missing nonblock feature in ip_build_xmit.
241da177e4SLinus Torvalds  *		Mike Kilburn	:	htons() missing in ip_build_xmit.
251da177e4SLinus Torvalds  *		Bradford Johnson:	Fix faulty handling of some frames when
261da177e4SLinus Torvalds  *					no route is found.
271da177e4SLinus Torvalds  *		Alexander Demenshin:	Missing sk/skb free in ip_queue_xmit
281da177e4SLinus Torvalds  *					(in case if packet not accepted by
291da177e4SLinus Torvalds  *					output firewall rules)
301da177e4SLinus Torvalds  *		Mike McLagan	:	Routing by source
311da177e4SLinus Torvalds  *		Alexey Kuznetsov:	use new route cache
321da177e4SLinus Torvalds  *		Andi Kleen:		Fix broken PMTU recovery and remove
331da177e4SLinus Torvalds  *					some redundant tests.
341da177e4SLinus Torvalds  *	Vitaly E. Lavrov	:	Transparent proxy revived after year coma.
351da177e4SLinus Torvalds  *		Andi Kleen	: 	Replace ip_reply with ip_send_reply.
361da177e4SLinus Torvalds  *		Andi Kleen	:	Split fast and slow ip_build_xmit path
371da177e4SLinus Torvalds  *					for decreased register pressure on x86
381da177e4SLinus Torvalds  *					and more readibility.
391da177e4SLinus Torvalds  *		Marc Boucher	:	When call_out_firewall returns FW_QUEUE,
401da177e4SLinus Torvalds  *					silently drop skb instead of failing with -EPERM.
411da177e4SLinus Torvalds  *		Detlev Wengorz	:	Copy protocol for fragments.
421da177e4SLinus Torvalds  *		Hirokazu Takahashi:	HW checksumming for outgoing UDP
431da177e4SLinus Torvalds  *					datagrams.
441da177e4SLinus Torvalds  *		Hirokazu Takahashi:	sendfile() on UDP works now.
451da177e4SLinus Torvalds  */
461da177e4SLinus Torvalds 
471da177e4SLinus Torvalds #include <asm/uaccess.h>
481da177e4SLinus Torvalds #include <asm/system.h>
491da177e4SLinus Torvalds #include <linux/module.h>
501da177e4SLinus Torvalds #include <linux/types.h>
511da177e4SLinus Torvalds #include <linux/kernel.h>
521da177e4SLinus Torvalds #include <linux/sched.h>
531da177e4SLinus Torvalds #include <linux/mm.h>
541da177e4SLinus Torvalds #include <linux/string.h>
551da177e4SLinus Torvalds #include <linux/errno.h>
561da177e4SLinus Torvalds 
571da177e4SLinus Torvalds #include <linux/socket.h>
581da177e4SLinus Torvalds #include <linux/sockios.h>
591da177e4SLinus Torvalds #include <linux/in.h>
601da177e4SLinus Torvalds #include <linux/inet.h>
611da177e4SLinus Torvalds #include <linux/netdevice.h>
621da177e4SLinus Torvalds #include <linux/etherdevice.h>
631da177e4SLinus Torvalds #include <linux/proc_fs.h>
641da177e4SLinus Torvalds #include <linux/stat.h>
651da177e4SLinus Torvalds #include <linux/init.h>
661da177e4SLinus Torvalds 
671da177e4SLinus Torvalds #include <net/snmp.h>
681da177e4SLinus Torvalds #include <net/ip.h>
691da177e4SLinus Torvalds #include <net/protocol.h>
701da177e4SLinus Torvalds #include <net/route.h>
71cfacb057SPatrick McHardy #include <net/xfrm.h>
721da177e4SLinus Torvalds #include <linux/skbuff.h>
731da177e4SLinus Torvalds #include <net/sock.h>
741da177e4SLinus Torvalds #include <net/arp.h>
751da177e4SLinus Torvalds #include <net/icmp.h>
761da177e4SLinus Torvalds #include <net/checksum.h>
771da177e4SLinus Torvalds #include <net/inetpeer.h>
781da177e4SLinus Torvalds #include <net/checksum.h>
791da177e4SLinus Torvalds #include <linux/igmp.h>
801da177e4SLinus Torvalds #include <linux/netfilter_ipv4.h>
811da177e4SLinus Torvalds #include <linux/netfilter_bridge.h>
821da177e4SLinus Torvalds #include <linux/mroute.h>
831da177e4SLinus Torvalds #include <linux/netlink.h>
846cbb0df7SArnaldo Carvalho de Melo #include <linux/tcp.h>
851da177e4SLinus Torvalds 
86ab32ea5dSBrian Haley int sysctl_ip_default_ttl __read_mostly = IPDEFTTL;
871da177e4SLinus Torvalds 
881da177e4SLinus Torvalds /* Generate a checksum for an outgoing IP datagram. */
891da177e4SLinus Torvalds __inline__ void ip_send_check(struct iphdr *iph)
901da177e4SLinus Torvalds {
911da177e4SLinus Torvalds 	iph->check = 0;
921da177e4SLinus Torvalds 	iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
931da177e4SLinus Torvalds }
941da177e4SLinus Torvalds 
951da177e4SLinus Torvalds /* dev_loopback_xmit for use with netfilter. */
961da177e4SLinus Torvalds static int ip_dev_loopback_xmit(struct sk_buff *newskb)
971da177e4SLinus Torvalds {
981da177e4SLinus Torvalds 	newskb->mac.raw = newskb->data;
991da177e4SLinus Torvalds 	__skb_pull(newskb, newskb->nh.raw - newskb->data);
1001da177e4SLinus Torvalds 	newskb->pkt_type = PACKET_LOOPBACK;
1011da177e4SLinus Torvalds 	newskb->ip_summed = CHECKSUM_UNNECESSARY;
1021da177e4SLinus Torvalds 	BUG_TRAP(newskb->dst);
1031da177e4SLinus Torvalds 	netif_rx(newskb);
1041da177e4SLinus Torvalds 	return 0;
1051da177e4SLinus Torvalds }
1061da177e4SLinus Torvalds 
1071da177e4SLinus Torvalds static inline int ip_select_ttl(struct inet_sock *inet, struct dst_entry *dst)
1081da177e4SLinus Torvalds {
1091da177e4SLinus Torvalds 	int ttl = inet->uc_ttl;
1101da177e4SLinus Torvalds 
1111da177e4SLinus Torvalds 	if (ttl < 0)
1121da177e4SLinus Torvalds 		ttl = dst_metric(dst, RTAX_HOPLIMIT);
1131da177e4SLinus Torvalds 	return ttl;
1141da177e4SLinus Torvalds }
1151da177e4SLinus Torvalds 
1161da177e4SLinus Torvalds /*
1171da177e4SLinus Torvalds  *		Add an ip header to a skbuff and send it out.
1181da177e4SLinus Torvalds  *
1191da177e4SLinus Torvalds  */
1201da177e4SLinus Torvalds int ip_build_and_send_pkt(struct sk_buff *skb, struct sock *sk,
12113d8eaa0SAl Viro 			  __be32 saddr, __be32 daddr, struct ip_options *opt)
1221da177e4SLinus Torvalds {
1231da177e4SLinus Torvalds 	struct inet_sock *inet = inet_sk(sk);
1241da177e4SLinus Torvalds 	struct rtable *rt = (struct rtable *)skb->dst;
1251da177e4SLinus Torvalds 	struct iphdr *iph;
1261da177e4SLinus Torvalds 
1271da177e4SLinus Torvalds 	/* Build the IP header. */
1281da177e4SLinus Torvalds 	if (opt)
1291da177e4SLinus Torvalds 		iph=(struct iphdr *)skb_push(skb,sizeof(struct iphdr) + opt->optlen);
1301da177e4SLinus Torvalds 	else
1311da177e4SLinus Torvalds 		iph=(struct iphdr *)skb_push(skb,sizeof(struct iphdr));
1321da177e4SLinus Torvalds 
1331da177e4SLinus Torvalds 	iph->version  = 4;
1341da177e4SLinus Torvalds 	iph->ihl      = 5;
1351da177e4SLinus Torvalds 	iph->tos      = inet->tos;
1361da177e4SLinus Torvalds 	if (ip_dont_fragment(sk, &rt->u.dst))
1371da177e4SLinus Torvalds 		iph->frag_off = htons(IP_DF);
1381da177e4SLinus Torvalds 	else
1391da177e4SLinus Torvalds 		iph->frag_off = 0;
1401da177e4SLinus Torvalds 	iph->ttl      = ip_select_ttl(inet, &rt->u.dst);
1411da177e4SLinus Torvalds 	iph->daddr    = rt->rt_dst;
1421da177e4SLinus Torvalds 	iph->saddr    = rt->rt_src;
1431da177e4SLinus Torvalds 	iph->protocol = sk->sk_protocol;
1441da177e4SLinus Torvalds 	iph->tot_len  = htons(skb->len);
1451da177e4SLinus Torvalds 	ip_select_ident(iph, &rt->u.dst, sk);
1461da177e4SLinus Torvalds 	skb->nh.iph   = iph;
1471da177e4SLinus Torvalds 
1481da177e4SLinus Torvalds 	if (opt && opt->optlen) {
1491da177e4SLinus Torvalds 		iph->ihl += opt->optlen>>2;
1501da177e4SLinus Torvalds 		ip_options_build(skb, opt, daddr, rt, 0);
1511da177e4SLinus Torvalds 	}
1521da177e4SLinus Torvalds 	ip_send_check(iph);
1531da177e4SLinus Torvalds 
1541da177e4SLinus Torvalds 	skb->priority = sk->sk_priority;
1551da177e4SLinus Torvalds 
1561da177e4SLinus Torvalds 	/* Send it out. */
1571da177e4SLinus Torvalds 	return NF_HOOK(PF_INET, NF_IP_LOCAL_OUT, skb, NULL, rt->u.dst.dev,
1581da177e4SLinus Torvalds 		       dst_output);
1591da177e4SLinus Torvalds }
1601da177e4SLinus Torvalds 
161d8c97a94SArnaldo Carvalho de Melo EXPORT_SYMBOL_GPL(ip_build_and_send_pkt);
162d8c97a94SArnaldo Carvalho de Melo 
1631da177e4SLinus Torvalds static inline int ip_finish_output2(struct sk_buff *skb)
1641da177e4SLinus Torvalds {
1651da177e4SLinus Torvalds 	struct dst_entry *dst = skb->dst;
1661da177e4SLinus Torvalds 	struct hh_cache *hh = dst->hh;
1671da177e4SLinus Torvalds 	struct net_device *dev = dst->dev;
1681da177e4SLinus Torvalds 	int hh_len = LL_RESERVED_SPACE(dev);
1691da177e4SLinus Torvalds 
1701da177e4SLinus Torvalds 	/* Be paranoid, rather than too clever. */
1711da177e4SLinus Torvalds 	if (unlikely(skb_headroom(skb) < hh_len && dev->hard_header)) {
1721da177e4SLinus Torvalds 		struct sk_buff *skb2;
1731da177e4SLinus Torvalds 
1741da177e4SLinus Torvalds 		skb2 = skb_realloc_headroom(skb, LL_RESERVED_SPACE(dev));
1751da177e4SLinus Torvalds 		if (skb2 == NULL) {
1761da177e4SLinus Torvalds 			kfree_skb(skb);
1771da177e4SLinus Torvalds 			return -ENOMEM;
1781da177e4SLinus Torvalds 		}
1791da177e4SLinus Torvalds 		if (skb->sk)
1801da177e4SLinus Torvalds 			skb_set_owner_w(skb2, skb->sk);
1811da177e4SLinus Torvalds 		kfree_skb(skb);
1821da177e4SLinus Torvalds 		skb = skb2;
1831da177e4SLinus Torvalds 	}
1841da177e4SLinus Torvalds 
1851da177e4SLinus Torvalds 	if (hh) {
1861da177e4SLinus Torvalds 		int hh_alen;
1871da177e4SLinus Torvalds 
1881da177e4SLinus Torvalds 		read_lock_bh(&hh->hh_lock);
1891da177e4SLinus Torvalds 		hh_alen = HH_DATA_ALIGN(hh->hh_len);
1901da177e4SLinus Torvalds   		memcpy(skb->data - hh_alen, hh->hh_data, hh_alen);
1911da177e4SLinus Torvalds 		read_unlock_bh(&hh->hh_lock);
1921da177e4SLinus Torvalds 	        skb_push(skb, hh->hh_len);
1931da177e4SLinus Torvalds 		return hh->hh_output(skb);
1941da177e4SLinus Torvalds 	} else if (dst->neighbour)
1951da177e4SLinus Torvalds 		return dst->neighbour->output(skb);
1961da177e4SLinus Torvalds 
1971da177e4SLinus Torvalds 	if (net_ratelimit())
1981da177e4SLinus Torvalds 		printk(KERN_DEBUG "ip_finish_output2: No header cache and no neighbour!\n");
1991da177e4SLinus Torvalds 	kfree_skb(skb);
2001da177e4SLinus Torvalds 	return -EINVAL;
2011da177e4SLinus Torvalds }
2021da177e4SLinus Torvalds 
20333d043d6SThomas Graf static inline int ip_finish_output(struct sk_buff *skb)
2041da177e4SLinus Torvalds {
2055c901daaSPatrick McHardy #if defined(CONFIG_NETFILTER) && defined(CONFIG_XFRM)
2065c901daaSPatrick McHardy 	/* Policy lookup after SNAT yielded a new policy */
20748d5cad8SPatrick McHardy 	if (skb->dst->xfrm != NULL) {
20848d5cad8SPatrick McHardy 		IPCB(skb)->flags |= IPSKB_REROUTED;
20948d5cad8SPatrick McHardy 		return dst_output(skb);
21048d5cad8SPatrick McHardy 	}
2115c901daaSPatrick McHardy #endif
21289114afdSHerbert Xu 	if (skb->len > dst_mtu(skb->dst) && !skb_is_gso(skb))
2131bd9bef6SPatrick McHardy 		return ip_fragment(skb, ip_finish_output2);
2141bd9bef6SPatrick McHardy 	else
2151bd9bef6SPatrick McHardy 		return ip_finish_output2(skb);
2161da177e4SLinus Torvalds }
2171da177e4SLinus Torvalds 
2181da177e4SLinus Torvalds int ip_mc_output(struct sk_buff *skb)
2191da177e4SLinus Torvalds {
2201da177e4SLinus Torvalds 	struct sock *sk = skb->sk;
2211da177e4SLinus Torvalds 	struct rtable *rt = (struct rtable*)skb->dst;
2221da177e4SLinus Torvalds 	struct net_device *dev = rt->u.dst.dev;
2231da177e4SLinus Torvalds 
2241da177e4SLinus Torvalds 	/*
2251da177e4SLinus Torvalds 	 *	If the indicated interface is up and running, send the packet.
2261da177e4SLinus Torvalds 	 */
2271da177e4SLinus Torvalds 	IP_INC_STATS(IPSTATS_MIB_OUTREQUESTS);
2281da177e4SLinus Torvalds 
2291da177e4SLinus Torvalds 	skb->dev = dev;
2301da177e4SLinus Torvalds 	skb->protocol = htons(ETH_P_IP);
2311da177e4SLinus Torvalds 
2321da177e4SLinus Torvalds 	/*
2331da177e4SLinus Torvalds 	 *	Multicasts are looped back for other local users
2341da177e4SLinus Torvalds 	 */
2351da177e4SLinus Torvalds 
2361da177e4SLinus Torvalds 	if (rt->rt_flags&RTCF_MULTICAST) {
2371da177e4SLinus Torvalds 		if ((!sk || inet_sk(sk)->mc_loop)
2381da177e4SLinus Torvalds #ifdef CONFIG_IP_MROUTE
2391da177e4SLinus Torvalds 		/* Small optimization: do not loopback not local frames,
2401da177e4SLinus Torvalds 		   which returned after forwarding; they will be  dropped
2411da177e4SLinus Torvalds 		   by ip_mr_input in any case.
2421da177e4SLinus Torvalds 		   Note, that local frames are looped back to be delivered
2431da177e4SLinus Torvalds 		   to local recipients.
2441da177e4SLinus Torvalds 
2451da177e4SLinus Torvalds 		   This check is duplicated in ip_mr_input at the moment.
2461da177e4SLinus Torvalds 		 */
2471da177e4SLinus Torvalds 		    && ((rt->rt_flags&RTCF_LOCAL) || !(IPCB(skb)->flags&IPSKB_FORWARDED))
2481da177e4SLinus Torvalds #endif
2491da177e4SLinus Torvalds 		) {
2501da177e4SLinus Torvalds 			struct sk_buff *newskb = skb_clone(skb, GFP_ATOMIC);
2511da177e4SLinus Torvalds 			if (newskb)
2521da177e4SLinus Torvalds 				NF_HOOK(PF_INET, NF_IP_POST_ROUTING, newskb, NULL,
2531da177e4SLinus Torvalds 					newskb->dev,
2541da177e4SLinus Torvalds 					ip_dev_loopback_xmit);
2551da177e4SLinus Torvalds 		}
2561da177e4SLinus Torvalds 
2571da177e4SLinus Torvalds 		/* Multicasts with ttl 0 must not go beyond the host */
2581da177e4SLinus Torvalds 
2591da177e4SLinus Torvalds 		if (skb->nh.iph->ttl == 0) {
2601da177e4SLinus Torvalds 			kfree_skb(skb);
2611da177e4SLinus Torvalds 			return 0;
2621da177e4SLinus Torvalds 		}
2631da177e4SLinus Torvalds 	}
2641da177e4SLinus Torvalds 
2651da177e4SLinus Torvalds 	if (rt->rt_flags&RTCF_BROADCAST) {
2661da177e4SLinus Torvalds 		struct sk_buff *newskb = skb_clone(skb, GFP_ATOMIC);
2671da177e4SLinus Torvalds 		if (newskb)
2681da177e4SLinus Torvalds 			NF_HOOK(PF_INET, NF_IP_POST_ROUTING, newskb, NULL,
2691da177e4SLinus Torvalds 				newskb->dev, ip_dev_loopback_xmit);
2701da177e4SLinus Torvalds 	}
2711da177e4SLinus Torvalds 
27248d5cad8SPatrick McHardy 	return NF_HOOK_COND(PF_INET, NF_IP_POST_ROUTING, skb, NULL, skb->dev,
27348d5cad8SPatrick McHardy 			    ip_finish_output,
27448d5cad8SPatrick McHardy 			    !(IPCB(skb)->flags & IPSKB_REROUTED));
2751da177e4SLinus Torvalds }
2761da177e4SLinus Torvalds 
2771da177e4SLinus Torvalds int ip_output(struct sk_buff *skb)
2781da177e4SLinus Torvalds {
2791bd9bef6SPatrick McHardy 	struct net_device *dev = skb->dst->dev;
2801bd9bef6SPatrick McHardy 
2811da177e4SLinus Torvalds 	IP_INC_STATS(IPSTATS_MIB_OUTREQUESTS);
2821da177e4SLinus Torvalds 
2831bd9bef6SPatrick McHardy 	skb->dev = dev;
2841bd9bef6SPatrick McHardy 	skb->protocol = htons(ETH_P_IP);
2851bd9bef6SPatrick McHardy 
28648d5cad8SPatrick McHardy 	return NF_HOOK_COND(PF_INET, NF_IP_POST_ROUTING, skb, NULL, dev,
28748d5cad8SPatrick McHardy 		            ip_finish_output,
28848d5cad8SPatrick McHardy 			    !(IPCB(skb)->flags & IPSKB_REROUTED));
2891da177e4SLinus Torvalds }
2901da177e4SLinus Torvalds 
2911da177e4SLinus Torvalds int ip_queue_xmit(struct sk_buff *skb, int ipfragok)
2921da177e4SLinus Torvalds {
2931da177e4SLinus Torvalds 	struct sock *sk = skb->sk;
2941da177e4SLinus Torvalds 	struct inet_sock *inet = inet_sk(sk);
2951da177e4SLinus Torvalds 	struct ip_options *opt = inet->opt;
2961da177e4SLinus Torvalds 	struct rtable *rt;
2971da177e4SLinus Torvalds 	struct iphdr *iph;
2981da177e4SLinus Torvalds 
2991da177e4SLinus Torvalds 	/* Skip all of this if the packet is already routed,
3001da177e4SLinus Torvalds 	 * f.e. by something like SCTP.
3011da177e4SLinus Torvalds 	 */
3021da177e4SLinus Torvalds 	rt = (struct rtable *) skb->dst;
3031da177e4SLinus Torvalds 	if (rt != NULL)
3041da177e4SLinus Torvalds 		goto packet_routed;
3051da177e4SLinus Torvalds 
3061da177e4SLinus Torvalds 	/* Make sure we can route this packet. */
3071da177e4SLinus Torvalds 	rt = (struct rtable *)__sk_dst_check(sk, 0);
3081da177e4SLinus Torvalds 	if (rt == NULL) {
3093ca3c68eSAl Viro 		__be32 daddr;
3101da177e4SLinus Torvalds 
3111da177e4SLinus Torvalds 		/* Use correct destination address if we have options. */
3121da177e4SLinus Torvalds 		daddr = inet->daddr;
3131da177e4SLinus Torvalds 		if(opt && opt->srr)
3141da177e4SLinus Torvalds 			daddr = opt->faddr;
3151da177e4SLinus Torvalds 
3161da177e4SLinus Torvalds 		{
3171da177e4SLinus Torvalds 			struct flowi fl = { .oif = sk->sk_bound_dev_if,
3181da177e4SLinus Torvalds 					    .nl_u = { .ip4_u =
3191da177e4SLinus Torvalds 						      { .daddr = daddr,
3201da177e4SLinus Torvalds 							.saddr = inet->saddr,
3211da177e4SLinus Torvalds 							.tos = RT_CONN_FLAGS(sk) } },
3221da177e4SLinus Torvalds 					    .proto = sk->sk_protocol,
3231da177e4SLinus Torvalds 					    .uli_u = { .ports =
3241da177e4SLinus Torvalds 						       { .sport = inet->sport,
3251da177e4SLinus Torvalds 							 .dport = inet->dport } } };
3261da177e4SLinus Torvalds 
3271da177e4SLinus Torvalds 			/* If this fails, retransmit mechanism of transport layer will
3281da177e4SLinus Torvalds 			 * keep trying until route appears or the connection times
3291da177e4SLinus Torvalds 			 * itself out.
3301da177e4SLinus Torvalds 			 */
331beb8d13bSVenkat Yekkirala 			security_sk_classify_flow(sk, &fl);
3321da177e4SLinus Torvalds 			if (ip_route_output_flow(&rt, &fl, sk, 0))
3331da177e4SLinus Torvalds 				goto no_route;
3341da177e4SLinus Torvalds 		}
3356cbb0df7SArnaldo Carvalho de Melo 		sk_setup_caps(sk, &rt->u.dst);
3361da177e4SLinus Torvalds 	}
3371da177e4SLinus Torvalds 	skb->dst = dst_clone(&rt->u.dst);
3381da177e4SLinus Torvalds 
3391da177e4SLinus Torvalds packet_routed:
3401da177e4SLinus Torvalds 	if (opt && opt->is_strictroute && rt->rt_dst != rt->rt_gateway)
3411da177e4SLinus Torvalds 		goto no_route;
3421da177e4SLinus Torvalds 
3431da177e4SLinus Torvalds 	/* OK, we know where to send it, allocate and build IP header. */
3441da177e4SLinus Torvalds 	iph = (struct iphdr *) skb_push(skb, sizeof(struct iphdr) + (opt ? opt->optlen : 0));
3451da177e4SLinus Torvalds 	*((__u16 *)iph)	= htons((4 << 12) | (5 << 8) | (inet->tos & 0xff));
3461da177e4SLinus Torvalds 	iph->tot_len = htons(skb->len);
3471da177e4SLinus Torvalds 	if (ip_dont_fragment(sk, &rt->u.dst) && !ipfragok)
3481da177e4SLinus Torvalds 		iph->frag_off = htons(IP_DF);
3491da177e4SLinus Torvalds 	else
3501da177e4SLinus Torvalds 		iph->frag_off = 0;
3511da177e4SLinus Torvalds 	iph->ttl      = ip_select_ttl(inet, &rt->u.dst);
3521da177e4SLinus Torvalds 	iph->protocol = sk->sk_protocol;
3531da177e4SLinus Torvalds 	iph->saddr    = rt->rt_src;
3541da177e4SLinus Torvalds 	iph->daddr    = rt->rt_dst;
3551da177e4SLinus Torvalds 	skb->nh.iph   = iph;
3561da177e4SLinus Torvalds 	/* Transport layer set skb->h.foo itself. */
3571da177e4SLinus Torvalds 
3581da177e4SLinus Torvalds 	if (opt && opt->optlen) {
3591da177e4SLinus Torvalds 		iph->ihl += opt->optlen >> 2;
3601da177e4SLinus Torvalds 		ip_options_build(skb, opt, inet->daddr, rt, 0);
3611da177e4SLinus Torvalds 	}
3621da177e4SLinus Torvalds 
36389f5f0aeSHerbert Xu 	ip_select_ident_more(iph, &rt->u.dst, sk,
3647967168cSHerbert Xu 			     (skb_shinfo(skb)->gso_segs ?: 1) - 1);
3651da177e4SLinus Torvalds 
3661da177e4SLinus Torvalds 	/* Add an IP checksum. */
3671da177e4SLinus Torvalds 	ip_send_check(iph);
3681da177e4SLinus Torvalds 
3691da177e4SLinus Torvalds 	skb->priority = sk->sk_priority;
3701da177e4SLinus Torvalds 
3711da177e4SLinus Torvalds 	return NF_HOOK(PF_INET, NF_IP_LOCAL_OUT, skb, NULL, rt->u.dst.dev,
3721da177e4SLinus Torvalds 		       dst_output);
3731da177e4SLinus Torvalds 
3741da177e4SLinus Torvalds no_route:
3751da177e4SLinus Torvalds 	IP_INC_STATS(IPSTATS_MIB_OUTNOROUTES);
3761da177e4SLinus Torvalds 	kfree_skb(skb);
3771da177e4SLinus Torvalds 	return -EHOSTUNREACH;
3781da177e4SLinus Torvalds }
3791da177e4SLinus Torvalds 
3801da177e4SLinus Torvalds 
3811da177e4SLinus Torvalds static void ip_copy_metadata(struct sk_buff *to, struct sk_buff *from)
3821da177e4SLinus Torvalds {
3831da177e4SLinus Torvalds 	to->pkt_type = from->pkt_type;
3841da177e4SLinus Torvalds 	to->priority = from->priority;
3851da177e4SLinus Torvalds 	to->protocol = from->protocol;
3861da177e4SLinus Torvalds 	dst_release(to->dst);
3871da177e4SLinus Torvalds 	to->dst = dst_clone(from->dst);
3881da177e4SLinus Torvalds 	to->dev = from->dev;
389*82e91ffeSThomas Graf 	to->mark = from->mark;
3901da177e4SLinus Torvalds 
3911da177e4SLinus Torvalds 	/* Copy the flags to each fragment. */
3921da177e4SLinus Torvalds 	IPCB(to)->flags = IPCB(from)->flags;
3931da177e4SLinus Torvalds 
3941da177e4SLinus Torvalds #ifdef CONFIG_NET_SCHED
3951da177e4SLinus Torvalds 	to->tc_index = from->tc_index;
3961da177e4SLinus Torvalds #endif
3971da177e4SLinus Torvalds #ifdef CONFIG_NETFILTER
3981da177e4SLinus Torvalds 	/* Connection association is same as pre-frag packet */
3991da177e4SLinus Torvalds 	nf_conntrack_put(to->nfct);
4001da177e4SLinus Torvalds 	to->nfct = from->nfct;
4011da177e4SLinus Torvalds 	nf_conntrack_get(to->nfct);
4021da177e4SLinus Torvalds 	to->nfctinfo = from->nfctinfo;
403c98d80edSJulian Anastasov #if defined(CONFIG_IP_VS) || defined(CONFIG_IP_VS_MODULE)
404c98d80edSJulian Anastasov 	to->ipvs_property = from->ipvs_property;
405c98d80edSJulian Anastasov #endif
4061da177e4SLinus Torvalds #ifdef CONFIG_BRIDGE_NETFILTER
4071da177e4SLinus Torvalds 	nf_bridge_put(to->nf_bridge);
4081da177e4SLinus Torvalds 	to->nf_bridge = from->nf_bridge;
4091da177e4SLinus Torvalds 	nf_bridge_get(to->nf_bridge);
4101da177e4SLinus Torvalds #endif
4111da177e4SLinus Torvalds #endif
412984bc16cSJames Morris 	skb_copy_secmark(to, from);
4131da177e4SLinus Torvalds }
4141da177e4SLinus Torvalds 
4151da177e4SLinus Torvalds /*
4161da177e4SLinus Torvalds  *	This IP datagram is too large to be sent in one piece.  Break it up into
4171da177e4SLinus Torvalds  *	smaller pieces (each of size equal to IP header plus
4181da177e4SLinus Torvalds  *	a block of the data of the original IP data part) that will yet fit in a
4191da177e4SLinus Torvalds  *	single device frame, and queue such a frame for sending.
4201da177e4SLinus Torvalds  */
4211da177e4SLinus Torvalds 
4222e2f7aefSPatrick McHardy int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff*))
4231da177e4SLinus Torvalds {
4241da177e4SLinus Torvalds 	struct iphdr *iph;
4251da177e4SLinus Torvalds 	int raw = 0;
4261da177e4SLinus Torvalds 	int ptr;
4271da177e4SLinus Torvalds 	struct net_device *dev;
4281da177e4SLinus Torvalds 	struct sk_buff *skb2;
4299bcfcaf5SStephen Hemminger 	unsigned int mtu, hlen, left, len, ll_rs, pad;
4301da177e4SLinus Torvalds 	int offset;
43176ab608dSAlexey Dobriyan 	__be16 not_last_frag;
4321da177e4SLinus Torvalds 	struct rtable *rt = (struct rtable*)skb->dst;
4331da177e4SLinus Torvalds 	int err = 0;
4341da177e4SLinus Torvalds 
4351da177e4SLinus Torvalds 	dev = rt->u.dst.dev;
4361da177e4SLinus Torvalds 
4371da177e4SLinus Torvalds 	/*
4381da177e4SLinus Torvalds 	 *	Point into the IP datagram header.
4391da177e4SLinus Torvalds 	 */
4401da177e4SLinus Torvalds 
4411da177e4SLinus Torvalds 	iph = skb->nh.iph;
4421da177e4SLinus Torvalds 
4431da177e4SLinus Torvalds 	if (unlikely((iph->frag_off & htons(IP_DF)) && !skb->local_df)) {
4440668b472SWei Dong 		IP_INC_STATS(IPSTATS_MIB_FRAGFAILS);
4451da177e4SLinus Torvalds 		icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
4461da177e4SLinus Torvalds 			  htonl(dst_mtu(&rt->u.dst)));
4471da177e4SLinus Torvalds 		kfree_skb(skb);
4481da177e4SLinus Torvalds 		return -EMSGSIZE;
4491da177e4SLinus Torvalds 	}
4501da177e4SLinus Torvalds 
4511da177e4SLinus Torvalds 	/*
4521da177e4SLinus Torvalds 	 *	Setup starting values.
4531da177e4SLinus Torvalds 	 */
4541da177e4SLinus Torvalds 
4551da177e4SLinus Torvalds 	hlen = iph->ihl * 4;
4561da177e4SLinus Torvalds 	mtu = dst_mtu(&rt->u.dst) - hlen;	/* Size of data space */
45789cee8b1SHerbert Xu 	IPCB(skb)->flags |= IPSKB_FRAG_COMPLETE;
4581da177e4SLinus Torvalds 
4591da177e4SLinus Torvalds 	/* When frag_list is given, use it. First, check its validity:
4601da177e4SLinus Torvalds 	 * some transformers could create wrong frag_list or break existing
4611da177e4SLinus Torvalds 	 * one, it is not prohibited. In this case fall back to copying.
4621da177e4SLinus Torvalds 	 *
4631da177e4SLinus Torvalds 	 * LATER: this step can be merged to real generation of fragments,
4641da177e4SLinus Torvalds 	 * we can switch to copy when see the first bad fragment.
4651da177e4SLinus Torvalds 	 */
4661da177e4SLinus Torvalds 	if (skb_shinfo(skb)->frag_list) {
4671da177e4SLinus Torvalds 		struct sk_buff *frag;
4681da177e4SLinus Torvalds 		int first_len = skb_pagelen(skb);
4691da177e4SLinus Torvalds 
4701da177e4SLinus Torvalds 		if (first_len - hlen > mtu ||
4711da177e4SLinus Torvalds 		    ((first_len - hlen) & 7) ||
4721da177e4SLinus Torvalds 		    (iph->frag_off & htons(IP_MF|IP_OFFSET)) ||
4731da177e4SLinus Torvalds 		    skb_cloned(skb))
4741da177e4SLinus Torvalds 			goto slow_path;
4751da177e4SLinus Torvalds 
4761da177e4SLinus Torvalds 		for (frag = skb_shinfo(skb)->frag_list; frag; frag = frag->next) {
4771da177e4SLinus Torvalds 			/* Correct geometry. */
4781da177e4SLinus Torvalds 			if (frag->len > mtu ||
4791da177e4SLinus Torvalds 			    ((frag->len & 7) && frag->next) ||
4801da177e4SLinus Torvalds 			    skb_headroom(frag) < hlen)
4811da177e4SLinus Torvalds 			    goto slow_path;
4821da177e4SLinus Torvalds 
4831da177e4SLinus Torvalds 			/* Partially cloned skb? */
4841da177e4SLinus Torvalds 			if (skb_shared(frag))
4851da177e4SLinus Torvalds 				goto slow_path;
4862fdba6b0SHerbert Xu 
4872fdba6b0SHerbert Xu 			BUG_ON(frag->sk);
4882fdba6b0SHerbert Xu 			if (skb->sk) {
4892fdba6b0SHerbert Xu 				sock_hold(skb->sk);
4902fdba6b0SHerbert Xu 				frag->sk = skb->sk;
4912fdba6b0SHerbert Xu 				frag->destructor = sock_wfree;
4922fdba6b0SHerbert Xu 				skb->truesize -= frag->truesize;
4932fdba6b0SHerbert Xu 			}
4941da177e4SLinus Torvalds 		}
4951da177e4SLinus Torvalds 
4961da177e4SLinus Torvalds 		/* Everything is OK. Generate! */
4971da177e4SLinus Torvalds 
4981da177e4SLinus Torvalds 		err = 0;
4991da177e4SLinus Torvalds 		offset = 0;
5001da177e4SLinus Torvalds 		frag = skb_shinfo(skb)->frag_list;
5011da177e4SLinus Torvalds 		skb_shinfo(skb)->frag_list = NULL;
5021da177e4SLinus Torvalds 		skb->data_len = first_len - skb_headlen(skb);
5031da177e4SLinus Torvalds 		skb->len = first_len;
5041da177e4SLinus Torvalds 		iph->tot_len = htons(first_len);
5051da177e4SLinus Torvalds 		iph->frag_off = htons(IP_MF);
5061da177e4SLinus Torvalds 		ip_send_check(iph);
5071da177e4SLinus Torvalds 
5081da177e4SLinus Torvalds 		for (;;) {
5091da177e4SLinus Torvalds 			/* Prepare header of the next frame,
5101da177e4SLinus Torvalds 			 * before previous one went down. */
5111da177e4SLinus Torvalds 			if (frag) {
5121da177e4SLinus Torvalds 				frag->ip_summed = CHECKSUM_NONE;
5131da177e4SLinus Torvalds 				frag->h.raw = frag->data;
5141da177e4SLinus Torvalds 				frag->nh.raw = __skb_push(frag, hlen);
5151da177e4SLinus Torvalds 				memcpy(frag->nh.raw, iph, hlen);
5161da177e4SLinus Torvalds 				iph = frag->nh.iph;
5171da177e4SLinus Torvalds 				iph->tot_len = htons(frag->len);
5181da177e4SLinus Torvalds 				ip_copy_metadata(frag, skb);
5191da177e4SLinus Torvalds 				if (offset == 0)
5201da177e4SLinus Torvalds 					ip_options_fragment(frag);
5211da177e4SLinus Torvalds 				offset += skb->len - hlen;
5221da177e4SLinus Torvalds 				iph->frag_off = htons(offset>>3);
5231da177e4SLinus Torvalds 				if (frag->next != NULL)
5241da177e4SLinus Torvalds 					iph->frag_off |= htons(IP_MF);
5251da177e4SLinus Torvalds 				/* Ready, complete checksum */
5261da177e4SLinus Torvalds 				ip_send_check(iph);
5271da177e4SLinus Torvalds 			}
5281da177e4SLinus Torvalds 
5291da177e4SLinus Torvalds 			err = output(skb);
5301da177e4SLinus Torvalds 
531dafee490SWei Dong 			if (!err)
532dafee490SWei Dong 				IP_INC_STATS(IPSTATS_MIB_FRAGCREATES);
5331da177e4SLinus Torvalds 			if (err || !frag)
5341da177e4SLinus Torvalds 				break;
5351da177e4SLinus Torvalds 
5361da177e4SLinus Torvalds 			skb = frag;
5371da177e4SLinus Torvalds 			frag = skb->next;
5381da177e4SLinus Torvalds 			skb->next = NULL;
5391da177e4SLinus Torvalds 		}
5401da177e4SLinus Torvalds 
5411da177e4SLinus Torvalds 		if (err == 0) {
5421da177e4SLinus Torvalds 			IP_INC_STATS(IPSTATS_MIB_FRAGOKS);
5431da177e4SLinus Torvalds 			return 0;
5441da177e4SLinus Torvalds 		}
5451da177e4SLinus Torvalds 
5461da177e4SLinus Torvalds 		while (frag) {
5471da177e4SLinus Torvalds 			skb = frag->next;
5481da177e4SLinus Torvalds 			kfree_skb(frag);
5491da177e4SLinus Torvalds 			frag = skb;
5501da177e4SLinus Torvalds 		}
5511da177e4SLinus Torvalds 		IP_INC_STATS(IPSTATS_MIB_FRAGFAILS);
5521da177e4SLinus Torvalds 		return err;
5531da177e4SLinus Torvalds 	}
5541da177e4SLinus Torvalds 
5551da177e4SLinus Torvalds slow_path:
5561da177e4SLinus Torvalds 	left = skb->len - hlen;		/* Space per frame */
5571da177e4SLinus Torvalds 	ptr = raw + hlen;		/* Where to start from */
5581da177e4SLinus Torvalds 
5591da177e4SLinus Torvalds 	/* for bridged IP traffic encapsulated inside f.e. a vlan header,
5609bcfcaf5SStephen Hemminger 	 * we need to make room for the encapsulating header
5619bcfcaf5SStephen Hemminger 	 */
5629bcfcaf5SStephen Hemminger 	pad = nf_bridge_pad(skb);
5639bcfcaf5SStephen Hemminger 	ll_rs = LL_RESERVED_SPACE_EXTRA(rt->u.dst.dev, pad);
5649bcfcaf5SStephen Hemminger 	mtu -= pad;
5659bcfcaf5SStephen Hemminger 
5661da177e4SLinus Torvalds 	/*
5671da177e4SLinus Torvalds 	 *	Fragment the datagram.
5681da177e4SLinus Torvalds 	 */
5691da177e4SLinus Torvalds 
5701da177e4SLinus Torvalds 	offset = (ntohs(iph->frag_off) & IP_OFFSET) << 3;
5711da177e4SLinus Torvalds 	not_last_frag = iph->frag_off & htons(IP_MF);
5721da177e4SLinus Torvalds 
5731da177e4SLinus Torvalds 	/*
5741da177e4SLinus Torvalds 	 *	Keep copying data until we run out.
5751da177e4SLinus Torvalds 	 */
5761da177e4SLinus Torvalds 
5771da177e4SLinus Torvalds 	while(left > 0)	{
5781da177e4SLinus Torvalds 		len = left;
5791da177e4SLinus Torvalds 		/* IF: it doesn't fit, use 'mtu' - the data space left */
5801da177e4SLinus Torvalds 		if (len > mtu)
5811da177e4SLinus Torvalds 			len = mtu;
5821da177e4SLinus Torvalds 		/* IF: we are not sending upto and including the packet end
5831da177e4SLinus Torvalds 		   then align the next start on an eight byte boundary */
5841da177e4SLinus Torvalds 		if (len < left)	{
5851da177e4SLinus Torvalds 			len &= ~7;
5861da177e4SLinus Torvalds 		}
5871da177e4SLinus Torvalds 		/*
5881da177e4SLinus Torvalds 		 *	Allocate buffer.
5891da177e4SLinus Torvalds 		 */
5901da177e4SLinus Torvalds 
5911da177e4SLinus Torvalds 		if ((skb2 = alloc_skb(len+hlen+ll_rs, GFP_ATOMIC)) == NULL) {
59264ce2073SPatrick McHardy 			NETDEBUG(KERN_INFO "IP: frag: no memory for new fragment!\n");
5931da177e4SLinus Torvalds 			err = -ENOMEM;
5941da177e4SLinus Torvalds 			goto fail;
5951da177e4SLinus Torvalds 		}
5961da177e4SLinus Torvalds 
5971da177e4SLinus Torvalds 		/*
5981da177e4SLinus Torvalds 		 *	Set up data on packet
5991da177e4SLinus Torvalds 		 */
6001da177e4SLinus Torvalds 
6011da177e4SLinus Torvalds 		ip_copy_metadata(skb2, skb);
6021da177e4SLinus Torvalds 		skb_reserve(skb2, ll_rs);
6031da177e4SLinus Torvalds 		skb_put(skb2, len + hlen);
6041da177e4SLinus Torvalds 		skb2->nh.raw = skb2->data;
6051da177e4SLinus Torvalds 		skb2->h.raw = skb2->data + hlen;
6061da177e4SLinus Torvalds 
6071da177e4SLinus Torvalds 		/*
6081da177e4SLinus Torvalds 		 *	Charge the memory for the fragment to any owner
6091da177e4SLinus Torvalds 		 *	it might possess
6101da177e4SLinus Torvalds 		 */
6111da177e4SLinus Torvalds 
6121da177e4SLinus Torvalds 		if (skb->sk)
6131da177e4SLinus Torvalds 			skb_set_owner_w(skb2, skb->sk);
6141da177e4SLinus Torvalds 
6151da177e4SLinus Torvalds 		/*
6161da177e4SLinus Torvalds 		 *	Copy the packet header into the new buffer.
6171da177e4SLinus Torvalds 		 */
6181da177e4SLinus Torvalds 
6191da177e4SLinus Torvalds 		memcpy(skb2->nh.raw, skb->data, hlen);
6201da177e4SLinus Torvalds 
6211da177e4SLinus Torvalds 		/*
6221da177e4SLinus Torvalds 		 *	Copy a block of the IP datagram.
6231da177e4SLinus Torvalds 		 */
6241da177e4SLinus Torvalds 		if (skb_copy_bits(skb, ptr, skb2->h.raw, len))
6251da177e4SLinus Torvalds 			BUG();
6261da177e4SLinus Torvalds 		left -= len;
6271da177e4SLinus Torvalds 
6281da177e4SLinus Torvalds 		/*
6291da177e4SLinus Torvalds 		 *	Fill in the new header fields.
6301da177e4SLinus Torvalds 		 */
6311da177e4SLinus Torvalds 		iph = skb2->nh.iph;
6321da177e4SLinus Torvalds 		iph->frag_off = htons((offset >> 3));
6331da177e4SLinus Torvalds 
6341da177e4SLinus Torvalds 		/* ANK: dirty, but effective trick. Upgrade options only if
6351da177e4SLinus Torvalds 		 * the segment to be fragmented was THE FIRST (otherwise,
6361da177e4SLinus Torvalds 		 * options are already fixed) and make it ONCE
6371da177e4SLinus Torvalds 		 * on the initial skb, so that all the following fragments
6381da177e4SLinus Torvalds 		 * will inherit fixed options.
6391da177e4SLinus Torvalds 		 */
6401da177e4SLinus Torvalds 		if (offset == 0)
6411da177e4SLinus Torvalds 			ip_options_fragment(skb);
6421da177e4SLinus Torvalds 
6431da177e4SLinus Torvalds 		/*
6441da177e4SLinus Torvalds 		 *	Added AC : If we are fragmenting a fragment that's not the
6451da177e4SLinus Torvalds 		 *		   last fragment then keep MF on each bit
6461da177e4SLinus Torvalds 		 */
6471da177e4SLinus Torvalds 		if (left > 0 || not_last_frag)
6481da177e4SLinus Torvalds 			iph->frag_off |= htons(IP_MF);
6491da177e4SLinus Torvalds 		ptr += len;
6501da177e4SLinus Torvalds 		offset += len;
6511da177e4SLinus Torvalds 
6521da177e4SLinus Torvalds 		/*
6531da177e4SLinus Torvalds 		 *	Put this fragment into the sending queue.
6541da177e4SLinus Torvalds 		 */
6551da177e4SLinus Torvalds 		iph->tot_len = htons(len + hlen);
6561da177e4SLinus Torvalds 
6571da177e4SLinus Torvalds 		ip_send_check(iph);
6581da177e4SLinus Torvalds 
6591da177e4SLinus Torvalds 		err = output(skb2);
6601da177e4SLinus Torvalds 		if (err)
6611da177e4SLinus Torvalds 			goto fail;
662dafee490SWei Dong 
663dafee490SWei Dong 		IP_INC_STATS(IPSTATS_MIB_FRAGCREATES);
6641da177e4SLinus Torvalds 	}
6651da177e4SLinus Torvalds 	kfree_skb(skb);
6661da177e4SLinus Torvalds 	IP_INC_STATS(IPSTATS_MIB_FRAGOKS);
6671da177e4SLinus Torvalds 	return err;
6681da177e4SLinus Torvalds 
6691da177e4SLinus Torvalds fail:
6701da177e4SLinus Torvalds 	kfree_skb(skb);
6711da177e4SLinus Torvalds 	IP_INC_STATS(IPSTATS_MIB_FRAGFAILS);
6721da177e4SLinus Torvalds 	return err;
6731da177e4SLinus Torvalds }
6741da177e4SLinus Torvalds 
6752e2f7aefSPatrick McHardy EXPORT_SYMBOL(ip_fragment);
6762e2f7aefSPatrick McHardy 
6771da177e4SLinus Torvalds int
6781da177e4SLinus Torvalds ip_generic_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
6791da177e4SLinus Torvalds {
6801da177e4SLinus Torvalds 	struct iovec *iov = from;
6811da177e4SLinus Torvalds 
68284fa7933SPatrick McHardy 	if (skb->ip_summed == CHECKSUM_PARTIAL) {
6831da177e4SLinus Torvalds 		if (memcpy_fromiovecend(to, iov, offset, len) < 0)
6841da177e4SLinus Torvalds 			return -EFAULT;
6851da177e4SLinus Torvalds 	} else {
6861da177e4SLinus Torvalds 		unsigned int csum = 0;
6871da177e4SLinus Torvalds 		if (csum_partial_copy_fromiovecend(to, iov, offset, len, &csum) < 0)
6881da177e4SLinus Torvalds 			return -EFAULT;
6891da177e4SLinus Torvalds 		skb->csum = csum_block_add(skb->csum, csum, odd);
6901da177e4SLinus Torvalds 	}
6911da177e4SLinus Torvalds 	return 0;
6921da177e4SLinus Torvalds }
6931da177e4SLinus Torvalds 
6941da177e4SLinus Torvalds static inline unsigned int
6951da177e4SLinus Torvalds csum_page(struct page *page, int offset, int copy)
6961da177e4SLinus Torvalds {
6971da177e4SLinus Torvalds 	char *kaddr;
6981da177e4SLinus Torvalds 	unsigned int csum;
6991da177e4SLinus Torvalds 	kaddr = kmap(page);
7001da177e4SLinus Torvalds 	csum = csum_partial(kaddr + offset, copy, 0);
7011da177e4SLinus Torvalds 	kunmap(page);
7021da177e4SLinus Torvalds 	return csum;
7031da177e4SLinus Torvalds }
7041da177e4SLinus Torvalds 
7054b30b1c6SAdrian Bunk static inline int ip_ufo_append_data(struct sock *sk,
706e89e9cf5SAnanda Raju 			int getfrag(void *from, char *to, int offset, int len,
707e89e9cf5SAnanda Raju 			       int odd, struct sk_buff *skb),
708e89e9cf5SAnanda Raju 			void *from, int length, int hh_len, int fragheaderlen,
709e89e9cf5SAnanda Raju 			int transhdrlen, int mtu,unsigned int flags)
710e89e9cf5SAnanda Raju {
711e89e9cf5SAnanda Raju 	struct sk_buff *skb;
712e89e9cf5SAnanda Raju 	int err;
713e89e9cf5SAnanda Raju 
714e89e9cf5SAnanda Raju 	/* There is support for UDP fragmentation offload by network
715e89e9cf5SAnanda Raju 	 * device, so create one single skb packet containing complete
716e89e9cf5SAnanda Raju 	 * udp datagram
717e89e9cf5SAnanda Raju 	 */
718e89e9cf5SAnanda Raju 	if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL) {
719e89e9cf5SAnanda Raju 		skb = sock_alloc_send_skb(sk,
720e89e9cf5SAnanda Raju 			hh_len + fragheaderlen + transhdrlen + 20,
721e89e9cf5SAnanda Raju 			(flags & MSG_DONTWAIT), &err);
722e89e9cf5SAnanda Raju 
723e89e9cf5SAnanda Raju 		if (skb == NULL)
724e89e9cf5SAnanda Raju 			return err;
725e89e9cf5SAnanda Raju 
726e89e9cf5SAnanda Raju 		/* reserve space for Hardware header */
727e89e9cf5SAnanda Raju 		skb_reserve(skb, hh_len);
728e89e9cf5SAnanda Raju 
729e89e9cf5SAnanda Raju 		/* create space for UDP/IP header */
730e89e9cf5SAnanda Raju 		skb_put(skb,fragheaderlen + transhdrlen);
731e89e9cf5SAnanda Raju 
732e89e9cf5SAnanda Raju 		/* initialize network header pointer */
733e89e9cf5SAnanda Raju 		skb->nh.raw = skb->data;
734e89e9cf5SAnanda Raju 
735e89e9cf5SAnanda Raju 		/* initialize protocol header pointer */
736e89e9cf5SAnanda Raju 		skb->h.raw = skb->data + fragheaderlen;
737e89e9cf5SAnanda Raju 
73884fa7933SPatrick McHardy 		skb->ip_summed = CHECKSUM_PARTIAL;
739e89e9cf5SAnanda Raju 		skb->csum = 0;
740e89e9cf5SAnanda Raju 		sk->sk_sndmsg_off = 0;
741e89e9cf5SAnanda Raju 	}
742e89e9cf5SAnanda Raju 
743e89e9cf5SAnanda Raju 	err = skb_append_datato_frags(sk,skb, getfrag, from,
744e89e9cf5SAnanda Raju 			       (length - transhdrlen));
745e89e9cf5SAnanda Raju 	if (!err) {
746e89e9cf5SAnanda Raju 		/* specify the length of each IP datagram fragment*/
7477967168cSHerbert Xu 		skb_shinfo(skb)->gso_size = mtu - fragheaderlen;
748f83ef8c0SHerbert Xu 		skb_shinfo(skb)->gso_type = SKB_GSO_UDP;
749e89e9cf5SAnanda Raju 		__skb_queue_tail(&sk->sk_write_queue, skb);
750e89e9cf5SAnanda Raju 
751e89e9cf5SAnanda Raju 		return 0;
752e89e9cf5SAnanda Raju 	}
753e89e9cf5SAnanda Raju 	/* There is not enough support do UFO ,
754e89e9cf5SAnanda Raju 	 * so follow normal path
755e89e9cf5SAnanda Raju 	 */
756e89e9cf5SAnanda Raju 	kfree_skb(skb);
757e89e9cf5SAnanda Raju 	return err;
758e89e9cf5SAnanda Raju }
759e89e9cf5SAnanda Raju 
7601da177e4SLinus Torvalds /*
7611da177e4SLinus Torvalds  *	ip_append_data() and ip_append_page() can make one large IP datagram
7621da177e4SLinus Torvalds  *	from many pieces of data. Each pieces will be holded on the socket
7631da177e4SLinus Torvalds  *	until ip_push_pending_frames() is called. Each piece can be a page
7641da177e4SLinus Torvalds  *	or non-page data.
7651da177e4SLinus Torvalds  *
7661da177e4SLinus Torvalds  *	Not only UDP, other transport protocols - e.g. raw sockets - can use
7671da177e4SLinus Torvalds  *	this interface potentially.
7681da177e4SLinus Torvalds  *
7691da177e4SLinus Torvalds  *	LATER: length must be adjusted by pad at tail, when it is required.
7701da177e4SLinus Torvalds  */
7711da177e4SLinus Torvalds int ip_append_data(struct sock *sk,
7721da177e4SLinus Torvalds 		   int getfrag(void *from, char *to, int offset, int len,
7731da177e4SLinus Torvalds 			       int odd, struct sk_buff *skb),
7741da177e4SLinus Torvalds 		   void *from, int length, int transhdrlen,
7751da177e4SLinus Torvalds 		   struct ipcm_cookie *ipc, struct rtable *rt,
7761da177e4SLinus Torvalds 		   unsigned int flags)
7771da177e4SLinus Torvalds {
7781da177e4SLinus Torvalds 	struct inet_sock *inet = inet_sk(sk);
7791da177e4SLinus Torvalds 	struct sk_buff *skb;
7801da177e4SLinus Torvalds 
7811da177e4SLinus Torvalds 	struct ip_options *opt = NULL;
7821da177e4SLinus Torvalds 	int hh_len;
7831da177e4SLinus Torvalds 	int exthdrlen;
7841da177e4SLinus Torvalds 	int mtu;
7851da177e4SLinus Torvalds 	int copy;
7861da177e4SLinus Torvalds 	int err;
7871da177e4SLinus Torvalds 	int offset = 0;
7881da177e4SLinus Torvalds 	unsigned int maxfraglen, fragheaderlen;
7891da177e4SLinus Torvalds 	int csummode = CHECKSUM_NONE;
7901da177e4SLinus Torvalds 
7911da177e4SLinus Torvalds 	if (flags&MSG_PROBE)
7921da177e4SLinus Torvalds 		return 0;
7931da177e4SLinus Torvalds 
7941da177e4SLinus Torvalds 	if (skb_queue_empty(&sk->sk_write_queue)) {
7951da177e4SLinus Torvalds 		/*
7961da177e4SLinus Torvalds 		 * setup for corking.
7971da177e4SLinus Torvalds 		 */
7981da177e4SLinus Torvalds 		opt = ipc->opt;
7991da177e4SLinus Torvalds 		if (opt) {
8001da177e4SLinus Torvalds 			if (inet->cork.opt == NULL) {
8011da177e4SLinus Torvalds 				inet->cork.opt = kmalloc(sizeof(struct ip_options) + 40, sk->sk_allocation);
8021da177e4SLinus Torvalds 				if (unlikely(inet->cork.opt == NULL))
8031da177e4SLinus Torvalds 					return -ENOBUFS;
8041da177e4SLinus Torvalds 			}
8051da177e4SLinus Torvalds 			memcpy(inet->cork.opt, opt, sizeof(struct ip_options)+opt->optlen);
8061da177e4SLinus Torvalds 			inet->cork.flags |= IPCORK_OPT;
8071da177e4SLinus Torvalds 			inet->cork.addr = ipc->addr;
8081da177e4SLinus Torvalds 		}
8091da177e4SLinus Torvalds 		dst_hold(&rt->u.dst);
8101da177e4SLinus Torvalds 		inet->cork.fragsize = mtu = dst_mtu(rt->u.dst.path);
8111da177e4SLinus Torvalds 		inet->cork.rt = rt;
8121da177e4SLinus Torvalds 		inet->cork.length = 0;
8131da177e4SLinus Torvalds 		sk->sk_sndmsg_page = NULL;
8141da177e4SLinus Torvalds 		sk->sk_sndmsg_off = 0;
8151da177e4SLinus Torvalds 		if ((exthdrlen = rt->u.dst.header_len) != 0) {
8161da177e4SLinus Torvalds 			length += exthdrlen;
8171da177e4SLinus Torvalds 			transhdrlen += exthdrlen;
8181da177e4SLinus Torvalds 		}
8191da177e4SLinus Torvalds 	} else {
8201da177e4SLinus Torvalds 		rt = inet->cork.rt;
8211da177e4SLinus Torvalds 		if (inet->cork.flags & IPCORK_OPT)
8221da177e4SLinus Torvalds 			opt = inet->cork.opt;
8231da177e4SLinus Torvalds 
8241da177e4SLinus Torvalds 		transhdrlen = 0;
8251da177e4SLinus Torvalds 		exthdrlen = 0;
8261da177e4SLinus Torvalds 		mtu = inet->cork.fragsize;
8271da177e4SLinus Torvalds 	}
8281da177e4SLinus Torvalds 	hh_len = LL_RESERVED_SPACE(rt->u.dst.dev);
8291da177e4SLinus Torvalds 
8301da177e4SLinus Torvalds 	fragheaderlen = sizeof(struct iphdr) + (opt ? opt->optlen : 0);
8311da177e4SLinus Torvalds 	maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen;
8321da177e4SLinus Torvalds 
8331da177e4SLinus Torvalds 	if (inet->cork.length + length > 0xFFFF - fragheaderlen) {
8341da177e4SLinus Torvalds 		ip_local_error(sk, EMSGSIZE, rt->rt_dst, inet->dport, mtu-exthdrlen);
8351da177e4SLinus Torvalds 		return -EMSGSIZE;
8361da177e4SLinus Torvalds 	}
8371da177e4SLinus Torvalds 
8381da177e4SLinus Torvalds 	/*
8391da177e4SLinus Torvalds 	 * transhdrlen > 0 means that this is the first fragment and we wish
8401da177e4SLinus Torvalds 	 * it won't be fragmented in the future.
8411da177e4SLinus Torvalds 	 */
8421da177e4SLinus Torvalds 	if (transhdrlen &&
8431da177e4SLinus Torvalds 	    length + fragheaderlen <= mtu &&
8448648b305SHerbert Xu 	    rt->u.dst.dev->features & NETIF_F_ALL_CSUM &&
8451da177e4SLinus Torvalds 	    !exthdrlen)
84684fa7933SPatrick McHardy 		csummode = CHECKSUM_PARTIAL;
8471da177e4SLinus Torvalds 
8481da177e4SLinus Torvalds 	inet->cork.length += length;
849e89e9cf5SAnanda Raju 	if (((length > mtu) && (sk->sk_protocol == IPPROTO_UDP)) &&
850e89e9cf5SAnanda Raju 			(rt->u.dst.dev->features & NETIF_F_UFO)) {
851e89e9cf5SAnanda Raju 
852baa829d8SPatrick McHardy 		err = ip_ufo_append_data(sk, getfrag, from, length, hh_len,
853baa829d8SPatrick McHardy 					 fragheaderlen, transhdrlen, mtu,
854baa829d8SPatrick McHardy 					 flags);
855baa829d8SPatrick McHardy 		if (err)
856e89e9cf5SAnanda Raju 			goto error;
857e89e9cf5SAnanda Raju 		return 0;
858e89e9cf5SAnanda Raju 	}
8591da177e4SLinus Torvalds 
8601da177e4SLinus Torvalds 	/* So, what's going on in the loop below?
8611da177e4SLinus Torvalds 	 *
8621da177e4SLinus Torvalds 	 * We use calculated fragment length to generate chained skb,
8631da177e4SLinus Torvalds 	 * each of segments is IP fragment ready for sending to network after
8641da177e4SLinus Torvalds 	 * adding appropriate IP header.
8651da177e4SLinus Torvalds 	 */
8661da177e4SLinus Torvalds 
8671da177e4SLinus Torvalds 	if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL)
8681da177e4SLinus Torvalds 		goto alloc_new_skb;
8691da177e4SLinus Torvalds 
8701da177e4SLinus Torvalds 	while (length > 0) {
8711da177e4SLinus Torvalds 		/* Check if the remaining data fits into current packet. */
8721da177e4SLinus Torvalds 		copy = mtu - skb->len;
8731da177e4SLinus Torvalds 		if (copy < length)
8741da177e4SLinus Torvalds 			copy = maxfraglen - skb->len;
8751da177e4SLinus Torvalds 		if (copy <= 0) {
8761da177e4SLinus Torvalds 			char *data;
8771da177e4SLinus Torvalds 			unsigned int datalen;
8781da177e4SLinus Torvalds 			unsigned int fraglen;
8791da177e4SLinus Torvalds 			unsigned int fraggap;
8801da177e4SLinus Torvalds 			unsigned int alloclen;
8811da177e4SLinus Torvalds 			struct sk_buff *skb_prev;
8821da177e4SLinus Torvalds alloc_new_skb:
8831da177e4SLinus Torvalds 			skb_prev = skb;
8841da177e4SLinus Torvalds 			if (skb_prev)
8851da177e4SLinus Torvalds 				fraggap = skb_prev->len - maxfraglen;
8861da177e4SLinus Torvalds 			else
8871da177e4SLinus Torvalds 				fraggap = 0;
8881da177e4SLinus Torvalds 
8891da177e4SLinus Torvalds 			/*
8901da177e4SLinus Torvalds 			 * If remaining data exceeds the mtu,
8911da177e4SLinus Torvalds 			 * we know we need more fragment(s).
8921da177e4SLinus Torvalds 			 */
8931da177e4SLinus Torvalds 			datalen = length + fraggap;
8941da177e4SLinus Torvalds 			if (datalen > mtu - fragheaderlen)
8951da177e4SLinus Torvalds 				datalen = maxfraglen - fragheaderlen;
8961da177e4SLinus Torvalds 			fraglen = datalen + fragheaderlen;
8971da177e4SLinus Torvalds 
8981da177e4SLinus Torvalds 			if ((flags & MSG_MORE) &&
8991da177e4SLinus Torvalds 			    !(rt->u.dst.dev->features&NETIF_F_SG))
9001da177e4SLinus Torvalds 				alloclen = mtu;
9011da177e4SLinus Torvalds 			else
9021da177e4SLinus Torvalds 				alloclen = datalen + fragheaderlen;
9031da177e4SLinus Torvalds 
9041da177e4SLinus Torvalds 			/* The last fragment gets additional space at tail.
9051da177e4SLinus Torvalds 			 * Note, with MSG_MORE we overallocate on fragments,
9061da177e4SLinus Torvalds 			 * because we have no idea what fragment will be
9071da177e4SLinus Torvalds 			 * the last.
9081da177e4SLinus Torvalds 			 */
9093d9dd756SZach Brown 			if (datalen == length + fraggap)
9101da177e4SLinus Torvalds 				alloclen += rt->u.dst.trailer_len;
9111da177e4SLinus Torvalds 
9121da177e4SLinus Torvalds 			if (transhdrlen) {
9131da177e4SLinus Torvalds 				skb = sock_alloc_send_skb(sk,
9141da177e4SLinus Torvalds 						alloclen + hh_len + 15,
9151da177e4SLinus Torvalds 						(flags & MSG_DONTWAIT), &err);
9161da177e4SLinus Torvalds 			} else {
9171da177e4SLinus Torvalds 				skb = NULL;
9181da177e4SLinus Torvalds 				if (atomic_read(&sk->sk_wmem_alloc) <=
9191da177e4SLinus Torvalds 				    2 * sk->sk_sndbuf)
9201da177e4SLinus Torvalds 					skb = sock_wmalloc(sk,
9211da177e4SLinus Torvalds 							   alloclen + hh_len + 15, 1,
9221da177e4SLinus Torvalds 							   sk->sk_allocation);
9231da177e4SLinus Torvalds 				if (unlikely(skb == NULL))
9241da177e4SLinus Torvalds 					err = -ENOBUFS;
9251da177e4SLinus Torvalds 			}
9261da177e4SLinus Torvalds 			if (skb == NULL)
9271da177e4SLinus Torvalds 				goto error;
9281da177e4SLinus Torvalds 
9291da177e4SLinus Torvalds 			/*
9301da177e4SLinus Torvalds 			 *	Fill in the control structures
9311da177e4SLinus Torvalds 			 */
9321da177e4SLinus Torvalds 			skb->ip_summed = csummode;
9331da177e4SLinus Torvalds 			skb->csum = 0;
9341da177e4SLinus Torvalds 			skb_reserve(skb, hh_len);
9351da177e4SLinus Torvalds 
9361da177e4SLinus Torvalds 			/*
9371da177e4SLinus Torvalds 			 *	Find where to start putting bytes.
9381da177e4SLinus Torvalds 			 */
9391da177e4SLinus Torvalds 			data = skb_put(skb, fraglen);
9401da177e4SLinus Torvalds 			skb->nh.raw = data + exthdrlen;
9411da177e4SLinus Torvalds 			data += fragheaderlen;
9421da177e4SLinus Torvalds 			skb->h.raw = data + exthdrlen;
9431da177e4SLinus Torvalds 
9441da177e4SLinus Torvalds 			if (fraggap) {
9451da177e4SLinus Torvalds 				skb->csum = skb_copy_and_csum_bits(
9461da177e4SLinus Torvalds 					skb_prev, maxfraglen,
9471da177e4SLinus Torvalds 					data + transhdrlen, fraggap, 0);
9481da177e4SLinus Torvalds 				skb_prev->csum = csum_sub(skb_prev->csum,
9491da177e4SLinus Torvalds 							  skb->csum);
9501da177e4SLinus Torvalds 				data += fraggap;
951e9fa4f7bSHerbert Xu 				pskb_trim_unique(skb_prev, maxfraglen);
9521da177e4SLinus Torvalds 			}
9531da177e4SLinus Torvalds 
9541da177e4SLinus Torvalds 			copy = datalen - transhdrlen - fraggap;
9551da177e4SLinus Torvalds 			if (copy > 0 && getfrag(from, data + transhdrlen, offset, copy, fraggap, skb) < 0) {
9561da177e4SLinus Torvalds 				err = -EFAULT;
9571da177e4SLinus Torvalds 				kfree_skb(skb);
9581da177e4SLinus Torvalds 				goto error;
9591da177e4SLinus Torvalds 			}
9601da177e4SLinus Torvalds 
9611da177e4SLinus Torvalds 			offset += copy;
9621da177e4SLinus Torvalds 			length -= datalen - fraggap;
9631da177e4SLinus Torvalds 			transhdrlen = 0;
9641da177e4SLinus Torvalds 			exthdrlen = 0;
9651da177e4SLinus Torvalds 			csummode = CHECKSUM_NONE;
9661da177e4SLinus Torvalds 
9671da177e4SLinus Torvalds 			/*
9681da177e4SLinus Torvalds 			 * Put the packet on the pending queue.
9691da177e4SLinus Torvalds 			 */
9701da177e4SLinus Torvalds 			__skb_queue_tail(&sk->sk_write_queue, skb);
9711da177e4SLinus Torvalds 			continue;
9721da177e4SLinus Torvalds 		}
9731da177e4SLinus Torvalds 
9741da177e4SLinus Torvalds 		if (copy > length)
9751da177e4SLinus Torvalds 			copy = length;
9761da177e4SLinus Torvalds 
9771da177e4SLinus Torvalds 		if (!(rt->u.dst.dev->features&NETIF_F_SG)) {
9781da177e4SLinus Torvalds 			unsigned int off;
9791da177e4SLinus Torvalds 
9801da177e4SLinus Torvalds 			off = skb->len;
9811da177e4SLinus Torvalds 			if (getfrag(from, skb_put(skb, copy),
9821da177e4SLinus Torvalds 					offset, copy, off, skb) < 0) {
9831da177e4SLinus Torvalds 				__skb_trim(skb, off);
9841da177e4SLinus Torvalds 				err = -EFAULT;
9851da177e4SLinus Torvalds 				goto error;
9861da177e4SLinus Torvalds 			}
9871da177e4SLinus Torvalds 		} else {
9881da177e4SLinus Torvalds 			int i = skb_shinfo(skb)->nr_frags;
9891da177e4SLinus Torvalds 			skb_frag_t *frag = &skb_shinfo(skb)->frags[i-1];
9901da177e4SLinus Torvalds 			struct page *page = sk->sk_sndmsg_page;
9911da177e4SLinus Torvalds 			int off = sk->sk_sndmsg_off;
9921da177e4SLinus Torvalds 			unsigned int left;
9931da177e4SLinus Torvalds 
9941da177e4SLinus Torvalds 			if (page && (left = PAGE_SIZE - off) > 0) {
9951da177e4SLinus Torvalds 				if (copy >= left)
9961da177e4SLinus Torvalds 					copy = left;
9971da177e4SLinus Torvalds 				if (page != frag->page) {
9981da177e4SLinus Torvalds 					if (i == MAX_SKB_FRAGS) {
9991da177e4SLinus Torvalds 						err = -EMSGSIZE;
10001da177e4SLinus Torvalds 						goto error;
10011da177e4SLinus Torvalds 					}
10021da177e4SLinus Torvalds 					get_page(page);
10031da177e4SLinus Torvalds 	 				skb_fill_page_desc(skb, i, page, sk->sk_sndmsg_off, 0);
10041da177e4SLinus Torvalds 					frag = &skb_shinfo(skb)->frags[i];
10051da177e4SLinus Torvalds 				}
10061da177e4SLinus Torvalds 			} else if (i < MAX_SKB_FRAGS) {
10071da177e4SLinus Torvalds 				if (copy > PAGE_SIZE)
10081da177e4SLinus Torvalds 					copy = PAGE_SIZE;
10091da177e4SLinus Torvalds 				page = alloc_pages(sk->sk_allocation, 0);
10101da177e4SLinus Torvalds 				if (page == NULL)  {
10111da177e4SLinus Torvalds 					err = -ENOMEM;
10121da177e4SLinus Torvalds 					goto error;
10131da177e4SLinus Torvalds 				}
10141da177e4SLinus Torvalds 				sk->sk_sndmsg_page = page;
10151da177e4SLinus Torvalds 				sk->sk_sndmsg_off = 0;
10161da177e4SLinus Torvalds 
10171da177e4SLinus Torvalds 				skb_fill_page_desc(skb, i, page, 0, 0);
10181da177e4SLinus Torvalds 				frag = &skb_shinfo(skb)->frags[i];
10191da177e4SLinus Torvalds 				skb->truesize += PAGE_SIZE;
10201da177e4SLinus Torvalds 				atomic_add(PAGE_SIZE, &sk->sk_wmem_alloc);
10211da177e4SLinus Torvalds 			} else {
10221da177e4SLinus Torvalds 				err = -EMSGSIZE;
10231da177e4SLinus Torvalds 				goto error;
10241da177e4SLinus Torvalds 			}
10251da177e4SLinus Torvalds 			if (getfrag(from, page_address(frag->page)+frag->page_offset+frag->size, offset, copy, skb->len, skb) < 0) {
10261da177e4SLinus Torvalds 				err = -EFAULT;
10271da177e4SLinus Torvalds 				goto error;
10281da177e4SLinus Torvalds 			}
10291da177e4SLinus Torvalds 			sk->sk_sndmsg_off += copy;
10301da177e4SLinus Torvalds 			frag->size += copy;
10311da177e4SLinus Torvalds 			skb->len += copy;
10321da177e4SLinus Torvalds 			skb->data_len += copy;
10331da177e4SLinus Torvalds 		}
10341da177e4SLinus Torvalds 		offset += copy;
10351da177e4SLinus Torvalds 		length -= copy;
10361da177e4SLinus Torvalds 	}
10371da177e4SLinus Torvalds 
10381da177e4SLinus Torvalds 	return 0;
10391da177e4SLinus Torvalds 
10401da177e4SLinus Torvalds error:
10411da177e4SLinus Torvalds 	inet->cork.length -= length;
10421da177e4SLinus Torvalds 	IP_INC_STATS(IPSTATS_MIB_OUTDISCARDS);
10431da177e4SLinus Torvalds 	return err;
10441da177e4SLinus Torvalds }
10451da177e4SLinus Torvalds 
10461da177e4SLinus Torvalds ssize_t	ip_append_page(struct sock *sk, struct page *page,
10471da177e4SLinus Torvalds 		       int offset, size_t size, int flags)
10481da177e4SLinus Torvalds {
10491da177e4SLinus Torvalds 	struct inet_sock *inet = inet_sk(sk);
10501da177e4SLinus Torvalds 	struct sk_buff *skb;
10511da177e4SLinus Torvalds 	struct rtable *rt;
10521da177e4SLinus Torvalds 	struct ip_options *opt = NULL;
10531da177e4SLinus Torvalds 	int hh_len;
10541da177e4SLinus Torvalds 	int mtu;
10551da177e4SLinus Torvalds 	int len;
10561da177e4SLinus Torvalds 	int err;
10571da177e4SLinus Torvalds 	unsigned int maxfraglen, fragheaderlen, fraggap;
10581da177e4SLinus Torvalds 
10591da177e4SLinus Torvalds 	if (inet->hdrincl)
10601da177e4SLinus Torvalds 		return -EPERM;
10611da177e4SLinus Torvalds 
10621da177e4SLinus Torvalds 	if (flags&MSG_PROBE)
10631da177e4SLinus Torvalds 		return 0;
10641da177e4SLinus Torvalds 
10651da177e4SLinus Torvalds 	if (skb_queue_empty(&sk->sk_write_queue))
10661da177e4SLinus Torvalds 		return -EINVAL;
10671da177e4SLinus Torvalds 
10681da177e4SLinus Torvalds 	rt = inet->cork.rt;
10691da177e4SLinus Torvalds 	if (inet->cork.flags & IPCORK_OPT)
10701da177e4SLinus Torvalds 		opt = inet->cork.opt;
10711da177e4SLinus Torvalds 
10721da177e4SLinus Torvalds 	if (!(rt->u.dst.dev->features&NETIF_F_SG))
10731da177e4SLinus Torvalds 		return -EOPNOTSUPP;
10741da177e4SLinus Torvalds 
10751da177e4SLinus Torvalds 	hh_len = LL_RESERVED_SPACE(rt->u.dst.dev);
10761da177e4SLinus Torvalds 	mtu = inet->cork.fragsize;
10771da177e4SLinus Torvalds 
10781da177e4SLinus Torvalds 	fragheaderlen = sizeof(struct iphdr) + (opt ? opt->optlen : 0);
10791da177e4SLinus Torvalds 	maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen;
10801da177e4SLinus Torvalds 
10811da177e4SLinus Torvalds 	if (inet->cork.length + size > 0xFFFF - fragheaderlen) {
10821da177e4SLinus Torvalds 		ip_local_error(sk, EMSGSIZE, rt->rt_dst, inet->dport, mtu);
10831da177e4SLinus Torvalds 		return -EMSGSIZE;
10841da177e4SLinus Torvalds 	}
10851da177e4SLinus Torvalds 
10861da177e4SLinus Torvalds 	if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL)
10871da177e4SLinus Torvalds 		return -EINVAL;
10881da177e4SLinus Torvalds 
10891da177e4SLinus Torvalds 	inet->cork.length += size;
1090e89e9cf5SAnanda Raju 	if ((sk->sk_protocol == IPPROTO_UDP) &&
10917967168cSHerbert Xu 	    (rt->u.dst.dev->features & NETIF_F_UFO)) {
10927967168cSHerbert Xu 		skb_shinfo(skb)->gso_size = mtu - fragheaderlen;
1093f83ef8c0SHerbert Xu 		skb_shinfo(skb)->gso_type = SKB_GSO_UDP;
10947967168cSHerbert Xu 	}
1095e89e9cf5SAnanda Raju 
10961da177e4SLinus Torvalds 
10971da177e4SLinus Torvalds 	while (size > 0) {
10981da177e4SLinus Torvalds 		int i;
10991da177e4SLinus Torvalds 
110089114afdSHerbert Xu 		if (skb_is_gso(skb))
1101e89e9cf5SAnanda Raju 			len = size;
1102e89e9cf5SAnanda Raju 		else {
1103e89e9cf5SAnanda Raju 
11041da177e4SLinus Torvalds 			/* Check if the remaining data fits into current packet. */
11051da177e4SLinus Torvalds 			len = mtu - skb->len;
11061da177e4SLinus Torvalds 			if (len < size)
11071da177e4SLinus Torvalds 				len = maxfraglen - skb->len;
1108e89e9cf5SAnanda Raju 		}
11091da177e4SLinus Torvalds 		if (len <= 0) {
11101da177e4SLinus Torvalds 			struct sk_buff *skb_prev;
11111da177e4SLinus Torvalds 			char *data;
11121da177e4SLinus Torvalds 			struct iphdr *iph;
11131da177e4SLinus Torvalds 			int alloclen;
11141da177e4SLinus Torvalds 
11151da177e4SLinus Torvalds 			skb_prev = skb;
11161da177e4SLinus Torvalds 			fraggap = skb_prev->len - maxfraglen;
11171da177e4SLinus Torvalds 
11181da177e4SLinus Torvalds 			alloclen = fragheaderlen + hh_len + fraggap + 15;
11191da177e4SLinus Torvalds 			skb = sock_wmalloc(sk, alloclen, 1, sk->sk_allocation);
11201da177e4SLinus Torvalds 			if (unlikely(!skb)) {
11211da177e4SLinus Torvalds 				err = -ENOBUFS;
11221da177e4SLinus Torvalds 				goto error;
11231da177e4SLinus Torvalds 			}
11241da177e4SLinus Torvalds 
11251da177e4SLinus Torvalds 			/*
11261da177e4SLinus Torvalds 			 *	Fill in the control structures
11271da177e4SLinus Torvalds 			 */
11281da177e4SLinus Torvalds 			skb->ip_summed = CHECKSUM_NONE;
11291da177e4SLinus Torvalds 			skb->csum = 0;
11301da177e4SLinus Torvalds 			skb_reserve(skb, hh_len);
11311da177e4SLinus Torvalds 
11321da177e4SLinus Torvalds 			/*
11331da177e4SLinus Torvalds 			 *	Find where to start putting bytes.
11341da177e4SLinus Torvalds 			 */
11351da177e4SLinus Torvalds 			data = skb_put(skb, fragheaderlen + fraggap);
11361da177e4SLinus Torvalds 			skb->nh.iph = iph = (struct iphdr *)data;
11371da177e4SLinus Torvalds 			data += fragheaderlen;
11381da177e4SLinus Torvalds 			skb->h.raw = data;
11391da177e4SLinus Torvalds 
11401da177e4SLinus Torvalds 			if (fraggap) {
11411da177e4SLinus Torvalds 				skb->csum = skb_copy_and_csum_bits(
11421da177e4SLinus Torvalds 					skb_prev, maxfraglen,
11431da177e4SLinus Torvalds 					data, fraggap, 0);
11441da177e4SLinus Torvalds 				skb_prev->csum = csum_sub(skb_prev->csum,
11451da177e4SLinus Torvalds 							  skb->csum);
1146e9fa4f7bSHerbert Xu 				pskb_trim_unique(skb_prev, maxfraglen);
11471da177e4SLinus Torvalds 			}
11481da177e4SLinus Torvalds 
11491da177e4SLinus Torvalds 			/*
11501da177e4SLinus Torvalds 			 * Put the packet on the pending queue.
11511da177e4SLinus Torvalds 			 */
11521da177e4SLinus Torvalds 			__skb_queue_tail(&sk->sk_write_queue, skb);
11531da177e4SLinus Torvalds 			continue;
11541da177e4SLinus Torvalds 		}
11551da177e4SLinus Torvalds 
11561da177e4SLinus Torvalds 		i = skb_shinfo(skb)->nr_frags;
11571da177e4SLinus Torvalds 		if (len > size)
11581da177e4SLinus Torvalds 			len = size;
11591da177e4SLinus Torvalds 		if (skb_can_coalesce(skb, i, page, offset)) {
11601da177e4SLinus Torvalds 			skb_shinfo(skb)->frags[i-1].size += len;
11611da177e4SLinus Torvalds 		} else if (i < MAX_SKB_FRAGS) {
11621da177e4SLinus Torvalds 			get_page(page);
11631da177e4SLinus Torvalds 			skb_fill_page_desc(skb, i, page, offset, len);
11641da177e4SLinus Torvalds 		} else {
11651da177e4SLinus Torvalds 			err = -EMSGSIZE;
11661da177e4SLinus Torvalds 			goto error;
11671da177e4SLinus Torvalds 		}
11681da177e4SLinus Torvalds 
11691da177e4SLinus Torvalds 		if (skb->ip_summed == CHECKSUM_NONE) {
11701da177e4SLinus Torvalds 			unsigned int csum;
11711da177e4SLinus Torvalds 			csum = csum_page(page, offset, len);
11721da177e4SLinus Torvalds 			skb->csum = csum_block_add(skb->csum, csum, skb->len);
11731da177e4SLinus Torvalds 		}
11741da177e4SLinus Torvalds 
11751da177e4SLinus Torvalds 		skb->len += len;
11761da177e4SLinus Torvalds 		skb->data_len += len;
11771da177e4SLinus Torvalds 		offset += len;
11781da177e4SLinus Torvalds 		size -= len;
11791da177e4SLinus Torvalds 	}
11801da177e4SLinus Torvalds 	return 0;
11811da177e4SLinus Torvalds 
11821da177e4SLinus Torvalds error:
11831da177e4SLinus Torvalds 	inet->cork.length -= size;
11841da177e4SLinus Torvalds 	IP_INC_STATS(IPSTATS_MIB_OUTDISCARDS);
11851da177e4SLinus Torvalds 	return err;
11861da177e4SLinus Torvalds }
11871da177e4SLinus Torvalds 
11881da177e4SLinus Torvalds /*
11891da177e4SLinus Torvalds  *	Combined all pending IP fragments on the socket as one IP datagram
11901da177e4SLinus Torvalds  *	and push them out.
11911da177e4SLinus Torvalds  */
11921da177e4SLinus Torvalds int ip_push_pending_frames(struct sock *sk)
11931da177e4SLinus Torvalds {
11941da177e4SLinus Torvalds 	struct sk_buff *skb, *tmp_skb;
11951da177e4SLinus Torvalds 	struct sk_buff **tail_skb;
11961da177e4SLinus Torvalds 	struct inet_sock *inet = inet_sk(sk);
11971da177e4SLinus Torvalds 	struct ip_options *opt = NULL;
11981da177e4SLinus Torvalds 	struct rtable *rt = inet->cork.rt;
11991da177e4SLinus Torvalds 	struct iphdr *iph;
120076ab608dSAlexey Dobriyan 	__be16 df = 0;
12011da177e4SLinus Torvalds 	__u8 ttl;
12021da177e4SLinus Torvalds 	int err = 0;
12031da177e4SLinus Torvalds 
12041da177e4SLinus Torvalds 	if ((skb = __skb_dequeue(&sk->sk_write_queue)) == NULL)
12051da177e4SLinus Torvalds 		goto out;
12061da177e4SLinus Torvalds 	tail_skb = &(skb_shinfo(skb)->frag_list);
12071da177e4SLinus Torvalds 
12081da177e4SLinus Torvalds 	/* move skb->data to ip header from ext header */
12091da177e4SLinus Torvalds 	if (skb->data < skb->nh.raw)
12101da177e4SLinus Torvalds 		__skb_pull(skb, skb->nh.raw - skb->data);
12111da177e4SLinus Torvalds 	while ((tmp_skb = __skb_dequeue(&sk->sk_write_queue)) != NULL) {
12121da177e4SLinus Torvalds 		__skb_pull(tmp_skb, skb->h.raw - skb->nh.raw);
12131da177e4SLinus Torvalds 		*tail_skb = tmp_skb;
12141da177e4SLinus Torvalds 		tail_skb = &(tmp_skb->next);
12151da177e4SLinus Torvalds 		skb->len += tmp_skb->len;
12161da177e4SLinus Torvalds 		skb->data_len += tmp_skb->len;
12171da177e4SLinus Torvalds 		skb->truesize += tmp_skb->truesize;
12181da177e4SLinus Torvalds 		__sock_put(tmp_skb->sk);
12191da177e4SLinus Torvalds 		tmp_skb->destructor = NULL;
12201da177e4SLinus Torvalds 		tmp_skb->sk = NULL;
12211da177e4SLinus Torvalds 	}
12221da177e4SLinus Torvalds 
12231da177e4SLinus Torvalds 	/* Unless user demanded real pmtu discovery (IP_PMTUDISC_DO), we allow
12241da177e4SLinus Torvalds 	 * to fragment the frame generated here. No matter, what transforms
12251da177e4SLinus Torvalds 	 * how transforms change size of the packet, it will come out.
12261da177e4SLinus Torvalds 	 */
12271da177e4SLinus Torvalds 	if (inet->pmtudisc != IP_PMTUDISC_DO)
12281da177e4SLinus Torvalds 		skb->local_df = 1;
12291da177e4SLinus Torvalds 
12301da177e4SLinus Torvalds 	/* DF bit is set when we want to see DF on outgoing frames.
12311da177e4SLinus Torvalds 	 * If local_df is set too, we still allow to fragment this frame
12321da177e4SLinus Torvalds 	 * locally. */
12331da177e4SLinus Torvalds 	if (inet->pmtudisc == IP_PMTUDISC_DO ||
12341da177e4SLinus Torvalds 	    (skb->len <= dst_mtu(&rt->u.dst) &&
12351da177e4SLinus Torvalds 	     ip_dont_fragment(sk, &rt->u.dst)))
12361da177e4SLinus Torvalds 		df = htons(IP_DF);
12371da177e4SLinus Torvalds 
12381da177e4SLinus Torvalds 	if (inet->cork.flags & IPCORK_OPT)
12391da177e4SLinus Torvalds 		opt = inet->cork.opt;
12401da177e4SLinus Torvalds 
12411da177e4SLinus Torvalds 	if (rt->rt_type == RTN_MULTICAST)
12421da177e4SLinus Torvalds 		ttl = inet->mc_ttl;
12431da177e4SLinus Torvalds 	else
12441da177e4SLinus Torvalds 		ttl = ip_select_ttl(inet, &rt->u.dst);
12451da177e4SLinus Torvalds 
12461da177e4SLinus Torvalds 	iph = (struct iphdr *)skb->data;
12471da177e4SLinus Torvalds 	iph->version = 4;
12481da177e4SLinus Torvalds 	iph->ihl = 5;
12491da177e4SLinus Torvalds 	if (opt) {
12501da177e4SLinus Torvalds 		iph->ihl += opt->optlen>>2;
12511da177e4SLinus Torvalds 		ip_options_build(skb, opt, inet->cork.addr, rt, 0);
12521da177e4SLinus Torvalds 	}
12531da177e4SLinus Torvalds 	iph->tos = inet->tos;
12541da177e4SLinus Torvalds 	iph->tot_len = htons(skb->len);
12551da177e4SLinus Torvalds 	iph->frag_off = df;
12561a55d57bSAlexey Kuznetsov 	ip_select_ident(iph, &rt->u.dst, sk);
12571da177e4SLinus Torvalds 	iph->ttl = ttl;
12581da177e4SLinus Torvalds 	iph->protocol = sk->sk_protocol;
12591da177e4SLinus Torvalds 	iph->saddr = rt->rt_src;
12601da177e4SLinus Torvalds 	iph->daddr = rt->rt_dst;
12611da177e4SLinus Torvalds 	ip_send_check(iph);
12621da177e4SLinus Torvalds 
12631da177e4SLinus Torvalds 	skb->priority = sk->sk_priority;
12641da177e4SLinus Torvalds 	skb->dst = dst_clone(&rt->u.dst);
12651da177e4SLinus Torvalds 
12661da177e4SLinus Torvalds 	/* Netfilter gets whole the not fragmented skb. */
12671da177e4SLinus Torvalds 	err = NF_HOOK(PF_INET, NF_IP_LOCAL_OUT, skb, NULL,
12681da177e4SLinus Torvalds 		      skb->dst->dev, dst_output);
12691da177e4SLinus Torvalds 	if (err) {
12701da177e4SLinus Torvalds 		if (err > 0)
12711da177e4SLinus Torvalds 			err = inet->recverr ? net_xmit_errno(err) : 0;
12721da177e4SLinus Torvalds 		if (err)
12731da177e4SLinus Torvalds 			goto error;
12741da177e4SLinus Torvalds 	}
12751da177e4SLinus Torvalds 
12761da177e4SLinus Torvalds out:
12771da177e4SLinus Torvalds 	inet->cork.flags &= ~IPCORK_OPT;
12781da177e4SLinus Torvalds 	kfree(inet->cork.opt);
12791da177e4SLinus Torvalds 	inet->cork.opt = NULL;
12801da177e4SLinus Torvalds 	if (inet->cork.rt) {
12811da177e4SLinus Torvalds 		ip_rt_put(inet->cork.rt);
12821da177e4SLinus Torvalds 		inet->cork.rt = NULL;
12831da177e4SLinus Torvalds 	}
12841da177e4SLinus Torvalds 	return err;
12851da177e4SLinus Torvalds 
12861da177e4SLinus Torvalds error:
12871da177e4SLinus Torvalds 	IP_INC_STATS(IPSTATS_MIB_OUTDISCARDS);
12881da177e4SLinus Torvalds 	goto out;
12891da177e4SLinus Torvalds }
12901da177e4SLinus Torvalds 
12911da177e4SLinus Torvalds /*
12921da177e4SLinus Torvalds  *	Throw away all pending data on the socket.
12931da177e4SLinus Torvalds  */
12941da177e4SLinus Torvalds void ip_flush_pending_frames(struct sock *sk)
12951da177e4SLinus Torvalds {
12961da177e4SLinus Torvalds 	struct inet_sock *inet = inet_sk(sk);
12971da177e4SLinus Torvalds 	struct sk_buff *skb;
12981da177e4SLinus Torvalds 
12991da177e4SLinus Torvalds 	while ((skb = __skb_dequeue_tail(&sk->sk_write_queue)) != NULL)
13001da177e4SLinus Torvalds 		kfree_skb(skb);
13011da177e4SLinus Torvalds 
13021da177e4SLinus Torvalds 	inet->cork.flags &= ~IPCORK_OPT;
13031da177e4SLinus Torvalds 	kfree(inet->cork.opt);
13041da177e4SLinus Torvalds 	inet->cork.opt = NULL;
13051da177e4SLinus Torvalds 	if (inet->cork.rt) {
13061da177e4SLinus Torvalds 		ip_rt_put(inet->cork.rt);
13071da177e4SLinus Torvalds 		inet->cork.rt = NULL;
13081da177e4SLinus Torvalds 	}
13091da177e4SLinus Torvalds }
13101da177e4SLinus Torvalds 
13111da177e4SLinus Torvalds 
13121da177e4SLinus Torvalds /*
13131da177e4SLinus Torvalds  *	Fetch data from kernel space and fill in checksum if needed.
13141da177e4SLinus Torvalds  */
13151da177e4SLinus Torvalds static int ip_reply_glue_bits(void *dptr, char *to, int offset,
13161da177e4SLinus Torvalds 			      int len, int odd, struct sk_buff *skb)
13171da177e4SLinus Torvalds {
13181da177e4SLinus Torvalds 	unsigned int csum;
13191da177e4SLinus Torvalds 
13201da177e4SLinus Torvalds 	csum = csum_partial_copy_nocheck(dptr+offset, to, len, 0);
13211da177e4SLinus Torvalds 	skb->csum = csum_block_add(skb->csum, csum, odd);
13221da177e4SLinus Torvalds 	return 0;
13231da177e4SLinus Torvalds }
13241da177e4SLinus Torvalds 
13251da177e4SLinus Torvalds /*
13261da177e4SLinus Torvalds  *	Generic function to send a packet as reply to another packet.
13271da177e4SLinus Torvalds  *	Used to send TCP resets so far. ICMP should use this function too.
13281da177e4SLinus Torvalds  *
13291da177e4SLinus Torvalds  *	Should run single threaded per socket because it uses the sock
13301da177e4SLinus Torvalds  *     	structure to pass arguments.
13311da177e4SLinus Torvalds  *
13321da177e4SLinus Torvalds  *	LATER: switch from ip_build_xmit to ip_append_*
13331da177e4SLinus Torvalds  */
13341da177e4SLinus Torvalds void ip_send_reply(struct sock *sk, struct sk_buff *skb, struct ip_reply_arg *arg,
13351da177e4SLinus Torvalds 		   unsigned int len)
13361da177e4SLinus Torvalds {
13371da177e4SLinus Torvalds 	struct inet_sock *inet = inet_sk(sk);
13381da177e4SLinus Torvalds 	struct {
13391da177e4SLinus Torvalds 		struct ip_options	opt;
13401da177e4SLinus Torvalds 		char			data[40];
13411da177e4SLinus Torvalds 	} replyopts;
13421da177e4SLinus Torvalds 	struct ipcm_cookie ipc;
13433ca3c68eSAl Viro 	__be32 daddr;
13441da177e4SLinus Torvalds 	struct rtable *rt = (struct rtable*)skb->dst;
13451da177e4SLinus Torvalds 
13461da177e4SLinus Torvalds 	if (ip_options_echo(&replyopts.opt, skb))
13471da177e4SLinus Torvalds 		return;
13481da177e4SLinus Torvalds 
13491da177e4SLinus Torvalds 	daddr = ipc.addr = rt->rt_src;
13501da177e4SLinus Torvalds 	ipc.opt = NULL;
13511da177e4SLinus Torvalds 
13521da177e4SLinus Torvalds 	if (replyopts.opt.optlen) {
13531da177e4SLinus Torvalds 		ipc.opt = &replyopts.opt;
13541da177e4SLinus Torvalds 
13551da177e4SLinus Torvalds 		if (ipc.opt->srr)
13561da177e4SLinus Torvalds 			daddr = replyopts.opt.faddr;
13571da177e4SLinus Torvalds 	}
13581da177e4SLinus Torvalds 
13591da177e4SLinus Torvalds 	{
13601da177e4SLinus Torvalds 		struct flowi fl = { .nl_u = { .ip4_u =
13611da177e4SLinus Torvalds 					      { .daddr = daddr,
13621da177e4SLinus Torvalds 						.saddr = rt->rt_spec_dst,
13631da177e4SLinus Torvalds 						.tos = RT_TOS(skb->nh.iph->tos) } },
13641da177e4SLinus Torvalds 				    /* Not quite clean, but right. */
13651da177e4SLinus Torvalds 				    .uli_u = { .ports =
13661da177e4SLinus Torvalds 					       { .sport = skb->h.th->dest,
13671da177e4SLinus Torvalds 					         .dport = skb->h.th->source } },
13681da177e4SLinus Torvalds 				    .proto = sk->sk_protocol };
1369beb8d13bSVenkat Yekkirala 		security_skb_classify_flow(skb, &fl);
13701da177e4SLinus Torvalds 		if (ip_route_output_key(&rt, &fl))
13711da177e4SLinus Torvalds 			return;
13721da177e4SLinus Torvalds 	}
13731da177e4SLinus Torvalds 
13741da177e4SLinus Torvalds 	/* And let IP do all the hard work.
13751da177e4SLinus Torvalds 
13761da177e4SLinus Torvalds 	   This chunk is not reenterable, hence spinlock.
13771da177e4SLinus Torvalds 	   Note that it uses the fact, that this function is called
13781da177e4SLinus Torvalds 	   with locally disabled BH and that sk cannot be already spinlocked.
13791da177e4SLinus Torvalds 	 */
13801da177e4SLinus Torvalds 	bh_lock_sock(sk);
13811da177e4SLinus Torvalds 	inet->tos = skb->nh.iph->tos;
13821da177e4SLinus Torvalds 	sk->sk_priority = skb->priority;
13831da177e4SLinus Torvalds 	sk->sk_protocol = skb->nh.iph->protocol;
13841da177e4SLinus Torvalds 	ip_append_data(sk, ip_reply_glue_bits, arg->iov->iov_base, len, 0,
13851da177e4SLinus Torvalds 		       &ipc, rt, MSG_DONTWAIT);
13861da177e4SLinus Torvalds 	if ((skb = skb_peek(&sk->sk_write_queue)) != NULL) {
13871da177e4SLinus Torvalds 		if (arg->csumoffset >= 0)
13881da177e4SLinus Torvalds 			*((u16 *)skb->h.raw + arg->csumoffset) = csum_fold(csum_add(skb->csum, arg->csum));
13891da177e4SLinus Torvalds 		skb->ip_summed = CHECKSUM_NONE;
13901da177e4SLinus Torvalds 		ip_push_pending_frames(sk);
13911da177e4SLinus Torvalds 	}
13921da177e4SLinus Torvalds 
13931da177e4SLinus Torvalds 	bh_unlock_sock(sk);
13941da177e4SLinus Torvalds 
13951da177e4SLinus Torvalds 	ip_rt_put(rt);
13961da177e4SLinus Torvalds }
13971da177e4SLinus Torvalds 
13981da177e4SLinus Torvalds void __init ip_init(void)
13991da177e4SLinus Torvalds {
14001da177e4SLinus Torvalds 	ip_rt_init();
14011da177e4SLinus Torvalds 	inet_initpeers();
14021da177e4SLinus Torvalds 
14031da177e4SLinus Torvalds #if defined(CONFIG_IP_MULTICAST) && defined(CONFIG_PROC_FS)
14041da177e4SLinus Torvalds 	igmp_mc_proc_init();
14051da177e4SLinus Torvalds #endif
14061da177e4SLinus Torvalds }
14071da177e4SLinus Torvalds 
14081da177e4SLinus Torvalds EXPORT_SYMBOL(ip_generic_getfrag);
14091da177e4SLinus Torvalds EXPORT_SYMBOL(ip_queue_xmit);
14101da177e4SLinus Torvalds EXPORT_SYMBOL(ip_send_check);
1411