Release 4.11 net/ipv6/raw.c

/*
 *      RAW sockets for IPv6
 *      Linux INET6 implementation
 *
 *      Authors:
 *      Pedro Roque             <roque@di.fc.ul.pt>
 *
 *      Adapted from linux/net/ipv4/raw.c
 *
 *      Fixes:
 *      Hideaki YOSHIFUJI       :       sin6_scope_id support
 *      YOSHIFUJI,H.@USAGI      :       raw checksum (RFC2292(bis) compliance)
 *      Kazunori MIYAZAWA @USAGI:       change process style to use ip6_append_data
 *
 *      This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.
 */

#include <linux/errno.h>
#include <linux/types.h>
#include <linux/socket.h>
#include <linux/slab.h>
#include <linux/sockios.h>
#include <linux/net.h>
#include <linux/in6.h>
#include <linux/netdevice.h>
#include <linux/if_arp.h>
#include <linux/icmpv6.h>
#include <linux/netfilter.h>
#include <linux/netfilter_ipv6.h>
#include <linux/skbuff.h>
#include <linux/compat.h>
#include <linux/uaccess.h>
#include <asm/ioctls.h>

#include <net/net_namespace.h>
#include <net/ip.h>
#include <net/sock.h>
#include <net/snmp.h>

#include <net/ipv6.h>
#include <net/ndisc.h>
#include <net/protocol.h>
#include <net/ip6_route.h>
#include <net/ip6_checksum.h>
#include <net/addrconf.h>
#include <net/transp_v6.h>
#include <net/udp.h>
#include <net/inet_common.h>
#include <net/tcp_states.h>
#if IS_ENABLED(CONFIG_IPV6_MIP6)
#include <net/mip6.h>
#endif
#include <linux/mroute6.h>

#include <net/raw.h>
#include <net/rawv6.h>
#include <net/xfrm.h>

#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/export.h>


#define	ICMPV6_HDRLEN	4	
/* ICMPv6 header, RFC 4443 Section 2.1 */


struct raw_hashinfo raw_v6_hashinfo = {
	.lock = __RW_LOCK_UNLOCKED(raw_v6_hashinfo.lock),
};

EXPORT_SYMBOL_GPL(raw_v6_hashinfo);



struct sock *__raw_v6_lookup(struct net *net, struct sock *sk,
		unsigned short num, const struct in6_addr *loc_addr,
		const struct in6_addr *rmt_addr, int dif)
{
	bool is_multicast = ipv6_addr_is_multicast(loc_addr);

	sk_for_each_from(sk)
		if (inet_sk(sk)->inet_num == num) {

			if (!net_eq(sock_net(sk), net))
				continue;

			if (!ipv6_addr_any(&sk->sk_v6_daddr) &&
			    !ipv6_addr_equal(&sk->sk_v6_daddr, rmt_addr))
				continue;

			if (sk->sk_bound_dev_if && sk->sk_bound_dev_if != dif)
				continue;

			if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr)) {
				if (ipv6_addr_equal(&sk->sk_v6_rcv_saddr, loc_addr))
					goto found;
				if (is_multicast &&
				    inet6_mc_check(sk, loc_addr, rmt_addr))
					goto found;
				continue;
			}
			goto found;
		}
	sk = NULL;
found:
	return sk;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
88
52.38%
2
13.33%
Arnaldo Carvalho de Melo
22
13.10%
1
6.67%
Andrew McDonald
16
9.52%
1
6.67%
Hideaki Yoshifuji / 吉藤英明
14
8.33%
4
26.67%
Eric Dumazet
12
7.14%
4
26.67%
Pavel Emelyanov
11
6.55%
1
6.67%
David S. Miller
3
1.79%
1
6.67%
David L Stevens
2
1.19%
1
6.67%
Total
168
100.00%
15
100.00%


EXPORT_SYMBOL_GPL(__raw_v6_lookup);

/*
 *      0 - deliver
 *      1 - block
 */


static int icmpv6_filter(const struct sock *sk, const struct sk_buff *skb)
{
	struct icmp6hdr _hdr;
	const struct icmp6hdr *hdr;

	/* We require only the four bytes of the ICMPv6 header, not any
         * additional bytes of message body in "struct icmp6hdr".
         */
	hdr = skb_header_pointer(skb, skb_transport_offset(skb),
				 ICMPV6_HDRLEN, &_hdr);
	if (hdr) {
		const __u32 *data = &raw6_sk(sk)->filter.data[0];
		unsigned int type = hdr->icmp6_type;

		return (data[type >> 5] & (1U << (type & 31))) != 0;
	}
	return 1;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
40
38.83%
2
28.57%
Eric Dumazet
35
33.98%
1
14.29%
Linus Torvalds (pre-git)
25
24.27%
2
28.57%
Werner Almesberger
2
1.94%
1
14.29%
David S. Miller
1
0.97%
1
14.29%
Total
103
100.00%
7
100.00%

#if IS_ENABLED(CONFIG_IPV6_MIP6)

typedef int mh_filter_t(struct sock *sock, struct sk_buff *skb);


static mh_filter_t __rcu *mh_filter __read_mostly;



int rawv6_mh_filter_register(mh_filter_t filter)
{
	rcu_assign_pointer(mh_filter, filter);
	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Masahide Nakamura
16
88.89%
1
33.33%
Eric Dumazet
2
11.11%
2
66.67%
Total
18
100.00%
3
100.00%


EXPORT_SYMBOL(rawv6_mh_filter_register);



int rawv6_mh_filter_unregister(mh_filter_t filter)
{
	RCU_INIT_POINTER(mh_filter, NULL);
	synchronize_rcu();
	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Masahide Nakamura
19
90.48%
1
33.33%
Eric Dumazet
1
4.76%
1
33.33%
Stephen Hemminger
1
4.76%
1
33.33%
Total
21
100.00%
3
100.00%


EXPORT_SYMBOL(rawv6_mh_filter_unregister);

#endif

/*
 *      demultiplex raw sockets.
 *      (should consider queueing the skb in the sock receive_queue
 *      without calling rawv6.c)
 *
 *      Caller owns SKB so we must make clones.
 */


static bool ipv6_raw_deliver(struct sk_buff *skb, int nexthdr)
{
	const struct in6_addr *saddr;
	const struct in6_addr *daddr;
	struct sock *sk;
	bool delivered = false;
	__u8 hash;
	struct net *net;

	saddr = &ipv6_hdr(skb)->saddr;
	daddr = saddr + 1;

	hash = nexthdr & (RAW_HTABLE_SIZE - 1);

	read_lock(&raw_v6_hashinfo.lock);
	sk = sk_head(&raw_v6_hashinfo.ht[hash]);

	if (!sk)
		goto out;

	net = dev_net(skb->dev);
	sk = __raw_v6_lookup(net, sk, nexthdr, daddr, saddr, inet6_iif(skb));

	while (sk) {
		int filtered;

		delivered = true;
		switch (nexthdr) {
		case IPPROTO_ICMPV6:
			filtered = icmpv6_filter(sk, skb);
			break;

#if IS_ENABLED(CONFIG_IPV6_MIP6)
		case IPPROTO_MH:
		{
			/* XXX: To validate MH only once for each packet,
                         * this is placed here. It should be after checking
                         * xfrm policy, however it doesn't. The checking xfrm
                         * policy is placed in rawv6_rcv() because it is
                         * required for each socket.
                         */
			mh_filter_t *filter;

			filter = rcu_dereference(mh_filter);
			filtered = filter ? (*filter)(sk, skb) : 0;
			break;
		}
#endif
		default:
			filtered = 0;
			break;
		}

		if (filtered < 0)
			break;
		if (filtered == 0) {
			struct sk_buff *clone = skb_clone(skb, GFP_ATOMIC);

			/* Not releasing hash table! */
			if (clone) {
				nf_reset(clone);
				rawv6_rcv(sk, clone);
			}
		}
		sk = __raw_v6_lookup(net, sk_next(sk), nexthdr, daddr, saddr,
				     inet6_iif(skb));
	}
out:
	read_unlock(&raw_v6_hashinfo.lock);
	return delivered;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
123
42.41%
2
8.70%
Masahide Nakamura
67
23.10%
2
8.70%
Pavel Emelyanov
25
8.62%
3
13.04%
David S. Miller
22
7.59%
2
8.70%
Eric Dumazet
11
3.79%
3
13.04%
Arnaldo Carvalho de Melo
11
3.79%
3
13.04%
Patrick McHardy
9
3.10%
1
4.35%
Hideaki Yoshifuji / 吉藤英明
7
2.41%
2
8.70%
Yasuyuki Kozakai
7
2.41%
1
4.35%
Andrew McDonald
4
1.38%
1
4.35%
Duan Jiong
2
0.69%
1
4.35%
Ian Morris
1
0.34%
1
4.35%
Américo Wang
1
0.34%
1
4.35%
Total
290
100.00%
23
100.00%



bool raw6_local_deliver(struct sk_buff *skb, int nexthdr)
{
	struct sock *raw_sk;

	raw_sk = sk_head(&raw_v6_hashinfo.ht[nexthdr & (RAW_HTABLE_SIZE - 1)]);
	if (raw_sk && !ipv6_raw_deliver(skb, nexthdr))
		raw_sk = NULL;

	return raw_sk != NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Pavel Emelyanov
56
96.55%
2
50.00%
David S. Miller
1
1.72%
1
25.00%
Eric Dumazet
1
1.72%
1
25.00%
Total
58
100.00%
4
100.00%

/* This cleans up af_inet6 a bit. -DaveM */


static int rawv6_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
{
	struct inet_sock *inet = inet_sk(sk);
	struct ipv6_pinfo *np = inet6_sk(sk);
	struct sockaddr_in6 *addr = (struct sockaddr_in6 *) uaddr;
	__be32 v4addr = 0;
	int addr_type;
	int err;

	if (addr_len < SIN6_LEN_RFC2133)
		return -EINVAL;

	if (addr->sin6_family != AF_INET6)
		return -EINVAL;

	addr_type = ipv6_addr_type(&addr->sin6_addr);

	/* Raw sockets are IPv6 only */
	if (addr_type == IPV6_ADDR_MAPPED)
		return -EADDRNOTAVAIL;

	lock_sock(sk);

	err = -EINVAL;
	if (sk->sk_state != TCP_CLOSE)
		goto out;

	rcu_read_lock();
	/* Check if the address belongs to the host. */
	if (addr_type != IPV6_ADDR_ANY) {
		struct net_device *dev = NULL;

		if (__ipv6_addr_needs_scope_id(addr_type)) {
			if (addr_len >= sizeof(struct sockaddr_in6) &&
			    addr->sin6_scope_id) {
				/* Override any existing binding, if another
                                 * one is supplied by user.
                                 */
				sk->sk_bound_dev_if = addr->sin6_scope_id;
			}

			/* Binding to link-local address requires an interface */
			if (!sk->sk_bound_dev_if)
				goto out_unlock;

			err = -ENODEV;
			dev = dev_get_by_index_rcu(sock_net(sk),
						   sk->sk_bound_dev_if);
			if (!dev)
				goto out_unlock;
		}

		/* ipv4 addr of the socket is invalid.  Only the
                 * unspecified and mapped address have a v4 equivalent.
                 */
		v4addr = LOOPBACK4_IPV6;
		if (!(addr_type & IPV6_ADDR_MULTICAST) &&
		    !sock_net(sk)->ipv6.sysctl.ip_nonlocal_bind) {
			err = -EADDRNOTAVAIL;
			if (!ipv6_chk_addr(sock_net(sk), &addr->sin6_addr,
					   dev, 0)) {
				goto out_unlock;
			}
		}
	}

	inet->inet_rcv_saddr = inet->inet_saddr = v4addr;
	sk->sk_v6_rcv_saddr = addr->sin6_addr;
	if (!(addr_type & IPV6_ADDR_MULTICAST))
		np->saddr = addr->sin6_addr;
	err = 0;
out_unlock:
	rcu_read_unlock();
out:
	release_sock(sk);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
205
62.31%
4
17.39%
Ville Nuorvala
34
10.33%
2
8.70%
David S. Miller
22
6.69%
2
8.70%
Eric Dumazet
21
6.38%
3
13.04%
Hannes Frederic Sowa
15
4.56%
2
8.70%
Tom Herbert
12
3.65%
1
4.35%
Hideaki Yoshifuji / 吉藤英明
7
2.13%
2
8.70%
Arnaldo Carvalho de Melo
5
1.52%
2
8.70%
Pavel Emelyanov
2
0.61%
1
4.35%
Daniel Lezcano
2
0.61%
1
4.35%
Alexey Dobriyan
2
0.61%
1
4.35%
Eric W. Biedermann
1
0.30%
1
4.35%
Al Viro
1
0.30%
1
4.35%
Total
329
100.00%
23
100.00%



static void rawv6_err(struct sock *sk, struct sk_buff *skb,
	       struct inet6_skb_parm *opt,
	       u8 type, u8 code, int offset, __be32 info)
{
	struct inet_sock *inet = inet_sk(sk);
	struct ipv6_pinfo *np = inet6_sk(sk);
	int err;
	int harderr;

	/* Report error on raw socket, if:
           1. User requested recverr.
           2. Socket is connected (otherwise the error indication
              is useless without recverr and error is hard.
         */
	if (!np->recverr && sk->sk_state != TCP_ESTABLISHED)
		return;

	harderr = icmpv6_err_convert(type, code, &err);
	if (type == ICMPV6_PKT_TOOBIG) {
		ip6_sk_update_pmtu(skb, sk, info);
		harderr = (np->pmtudisc == IPV6_PMTUDISC_DO);
	}
	if (type == NDISC_REDIRECT) {
		ip6_sk_redirect(skb, sk);
		return;
	}
	if (np->recverr) {
		u8 *payload = skb->data;
		if (!inet->hdrincl)
			payload += offset;
		ipv6_icmp_error(sk, skb, err, 0, ntohl(info), payload);
	}

	if (np->recverr || harderr) {
		sk->sk_err = err;
		sk->sk_error_report(sk);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
115
58.38%
3
23.08%
David S. Miller
48
24.37%
3
23.08%
Linus Torvalds
23
11.68%
1
7.69%
Arnaldo Carvalho de Melo
4
2.03%
2
15.38%
Duan Jiong
3
1.52%
1
7.69%
Brian Haley
2
1.02%
1
7.69%
Al Viro
1
0.51%
1
7.69%
Pavel Emelyanov
1
0.51%
1
7.69%
Total
197
100.00%
13
100.00%



void raw6_icmp_error(struct sk_buff *skb, int nexthdr,
		u8 type, u8 code, int inner_offset, __be32 info)
{
	struct sock *sk;
	int hash;
	const struct in6_addr *saddr, *daddr;
	struct net *net;

	hash = nexthdr & (RAW_HTABLE_SIZE - 1);

	read_lock(&raw_v6_hashinfo.lock);
	sk = sk_head(&raw_v6_hashinfo.ht[hash]);
	if (sk) {
		/* Note: ipv6_hdr(skb) != skb->data */
		const struct ipv6hdr *ip6h = (const struct ipv6hdr *)skb->data;
		saddr = &ip6h->saddr;
		daddr = &ip6h->daddr;
		net = dev_net(skb->dev);

		while ((sk = __raw_v6_lookup(net, sk, nexthdr, saddr, daddr,
						inet6_iif(skb)))) {
			rawv6_err(sk, skb, NULL, type, code,
					inner_offset, info);
			sk = sk_next(sk);
		}
	}
	read_unlock(&raw_v6_hashinfo.lock);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Pavel Emelyanov
156
85.71%
3
37.50%
Hideaki Yoshifuji / 吉藤英明
20
10.99%
2
25.00%
Eric Dumazet
3
1.65%
1
12.50%
Brian Haley
2
1.10%
1
12.50%
Duan Jiong
1
0.55%
1
12.50%
Total
182
100.00%
8
100.00%



static inline int rawv6_rcv_skb(struct sock *sk, struct sk_buff *skb)
{
	if ((raw6_sk(sk)->checksum || rcu_access_pointer(sk->sk_filter)) &&
	    skb_checksum_complete(skb)) {
		atomic_inc(&sk->sk_drops);
		kfree_skb(skb);
		return NET_RX_DROP;
	}

	/* Charge it to the socket. */
	skb_dst_drop(skb);
	if (sock_queue_rcv_skb(sk, skb) < 0) {
		kfree_skb(skb);
		return NET_RX_DROP;
	}

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
40
45.45%
1
10.00%
Alexey Kuznetsov
18
20.45%
1
10.00%
Eric Dumazet
9
10.23%
3
30.00%
Hideaki Yoshifuji / 吉藤英明
9
10.23%
1
10.00%
Wang Chen
8
9.09%
1
10.00%
Yang Hongyang
2
2.27%
1
10.00%
Herbert Xu
1
1.14%
1
10.00%
Arnaldo Carvalho de Melo
1
1.14%
1
10.00%
Total
88
100.00%
10
100.00%

/*
 *      This is next to useless...
 *      if we demultiplex in network layer we don't need the extra call
 *      just to queue the skb...
 *      maybe we could have the network decide upon a hint if it
 *      should call raw_rcv for demultiplexing
 */


int rawv6_rcv(struct sock *sk, struct sk_buff *skb)
{
	struct inet_sock *inet = inet_sk(sk);
	struct raw6_sock *rp = raw6_sk(sk);

	if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb)) {
		atomic_inc(&sk->sk_drops);
		kfree_skb(skb);
		return NET_RX_DROP;
	}

	if (!rp->checksum)
		skb->ip_summed = CHECKSUM_UNNECESSARY;

	if (skb->ip_summed == CHECKSUM_COMPLETE) {
		skb_postpull_rcsum(skb, skb_network_header(skb),
				   skb_network_header_len(skb));
		if (!csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
				     &ipv6_hdr(skb)->daddr,
				     skb->len, inet->inet_num, skb->csum))
			skb->ip_summed = CHECKSUM_UNNECESSARY;
	}
	if (!skb_csum_unnecessary(skb))
		skb->csum = ~csum_unfold(csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
							 &ipv6_hdr(skb)->daddr,
							 skb->len,
							 inet->inet_num, 0));

	if (inet->hdrincl) {
		if (skb_checksum_complete(skb)) {
			atomic_inc(&sk->sk_drops);
			kfree_skb(skb);
			return NET_RX_DROP;
		}
	}

	rawv6_rcv_skb(sk, skb);
	return 0;
}


Contributors
Person
Tokens
Prop
Commits
CommitProp
Alexey Kuznetsov
97
41.99%
1
5.00%
Linus Torvalds (pre-git)
32
13.85%
3
15.00%
Arnaldo Carvalho de Melo
22
9.52%
5
25.00%
Kazunori Miyazawa
22
9.52%
1
5.00%
Wang Chen
16
6.93%
1
5.00%
Patrick McHardy
10
4.33%
2
10.00%
Linus Torvalds
10
4.33%
1
5.00%
David S. Miller
9
3.90%
1
5.00%
Herbert Xu
7
3.03%
2
10.00%
Al Viro
3
1.30%
1
5.00%
Eric Dumazet
2
0.87%
1
5.00%
Yang Hongyang
1
0.43%
1
5.00%
Total
231
100.00%
20
100.00%

/*
 *      This should be easy, if there is something there
 *      we return it, otherwise we block.
 */



static int rawv6_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
			 int noblock, int flags, int *addr_len)
{
	struct ipv6_pinfo *np = inet6_sk(sk);
	DECLARE_SOCKADDR(struct sockaddr_in6 *, sin6, msg->msg_name);
	struct sk_buff *skb;
	size_t copied;
	int err;

	if (flags & MSG_OOB)
		return -EOPNOTSUPP;

	if (flags & MSG_ERRQUEUE)
		return ipv6_recv_error(sk, msg, len, addr_len);

	if (np->rxpmtu && np->rxopt.bits.rxpmtu)
		return ipv6_recv_rxpmtu(sk, msg, len, addr_len);

	skb = skb_recv_datagram(sk, flags, noblock, &err);
	if (!skb)
		goto out;

	copied = skb->len;
	if (copied > len) {
		copied = len;
		msg->msg_flags |= MSG_TRUNC;
	}

	if (skb_csum_unnecessary(skb)) {
		err = skb_copy_datagram_msg(skb, 0, msg, copied);
	} else if (msg->msg_flags&MSG_TRUNC) {
		if (__skb_checksum_complete(skb))
			goto csum_copy_err;
		err = skb_copy_datagram_msg(skb, 0, msg, copied);
	} else {
		err = skb_copy_and_csum_datagram_msg(skb, 0, msg);
		if (err == -EINVAL)
			goto csum_copy_err;
	}
	if (err)
		goto out_free;

	/* Copy the address. */
	if (sin6) {
		sin6->sin6_family = AF_INET6;
		sin6->sin6_port = 0;
		sin6->sin6_addr = ipv6_hdr(skb)->saddr;
		sin6->sin6_flowinfo = 0;
		sin6->sin6_scope_id = ipv6_iface_scope_id(&sin6->sin6_addr,
							  inet6_iif(skb));
		*addr_len = sizeof(*sin6);
	}

	sock_recv_ts_and_drops(msg, sk, skb);

	if (np->rxopt.all)
		ip6_datagram_recv_ctl(sk, msg, skb);

	err = copied;
	if (flags & MSG_TRUNC)
		err = skb->len;

out_free:
	skb_free_datagram(sk, skb);
out:
	return err;

csum_copy_err:
	skb_kill_datagram(sk, skb, flags);

	/* Error for blocking case is chosen to masquerade
           as some normal condition.
         */
	err = (flags&MSG_DONTWAIT) ? -EAGAIN : -EHOSTUNREACH;
	goto out;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
209
52.64%
8
25.81%
Alexey Kuznetsov
86
21.66%
1
3.23%
David S. Miller
24
6.05%
3
9.68%
Brian Haley
24
6.05%
1
3.23%
Hannes Frederic Sowa
16
4.03%
3
9.68%
Herbert Xu
8
2.02%
3
9.68%
Steffen Hurrle
7
1.76%
1
3.23%
Tetsuo Handa
6
1.51%
1
3.23%
Stephen Hemminger
4
1.01%
1
3.23%
Arnaldo Carvalho de Melo
3
0.76%
1
3.23%
Hideaki Yoshifuji / 吉藤英明
3
0.76%
1
3.23%
Al Viro
1
0.25%
1
3.23%
Duan Jiong
1
0.25%
1
3.23%
Tom Parkin
1
0.25%
1
3.23%
Alexey Dobriyan
1
0.25%
1
3.23%
Linus Torvalds
1
0.25%
1
3.23%
Stephen Rothwell
1
0.25%
1
3.23%
Neil Horman
1
0.25%
1
3.23%
Total
397
100.00%
31
100.00%



static int rawv6_push_pending_frames(struct sock *sk, struct flowi6 *fl6,
				     struct raw6_sock *rp)
{
	struct sk_buff *skb;
	int err = 0;
	int offset;
	int len;
	int total_len;
	__wsum tmp_csum;
	__sum16 csum;

	if (!rp->checksum)
		goto send;

	skb = skb_peek(&sk->sk_write_queue);
	if (!skb)
		goto out;

	offset = rp->offset;
	total_len = inet_sk(sk)->cork.base.length;
	if (offset >= total_len - 1) {
		err = -EINVAL;
		ip6_flush_pending_frames(sk);
		goto out;
	}

	/* should be check HW csum miyazawa */
	if (skb_queue_len(&sk->sk_write_queue) == 1) {
		/*
                 * Only one fragment on the socket.
                 */
		tmp_csum = skb->csum;
	} else {
		struct sk_buff *csum_skb = NULL;
		tmp_csum = 0;

		skb_queue_walk(&sk->sk_write_queue, skb) {
			tmp_csum = csum_add(tmp_csum, skb->csum);

			if (csum_skb)
				continue;

			len = skb->len - skb_transport_offset(skb);
			if (offset >= len) {
				offset -= len;
				continue;
			}

			csum_skb = skb;
		}

		skb = csum_skb;
	}

	offset += skb_transport_offset(skb);
	err = skb_copy_bits(skb, offset, &csum, 2);
	if (err < 0) {
		ip6_flush_pending_frames(sk);
		goto out;
	}

	/* in case cksum was not initialized */
	if (unlikely(csum))
		tmp_csum = csum_sub(tmp_csum, csum_unfold(csum));

	csum = csum_ipv6_magic(&fl6->saddr, &fl6->daddr,
			       total_len, fl6->flowi6_proto, tmp_csum);

	if (csum == 0 && fl6->flowi6_proto == IPPROTO_UDP)
		csum = CSUM_MANGLED_0;

	BUG_ON(skb_store_bits(skb, offset, &csum, 2));

send:
	err = ip6_push_pending_frames(sk);
out:
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Herbert Xu
104
31.23%
2
8.33%
Kazunori Miyazawa
76
22.82%
1
4.17%
Linus Torvalds (pre-git)
44
13.21%
3
12.50%
Hideaki Yoshifuji / 吉藤英明
35
10.51%
4
16.67%
Dave Jones
17
5.11%
1
4.17%
David S. Miller
14
4.20%
3
12.50%
Arnaldo Carvalho de Melo
13
3.90%
3
12.50%
Al Viro
9
2.70%
3
12.50%
Alexey Kuznetsov
8
2.40%
1
4.17%
Fabian Frederick
5
1.50%
1
4.17%
Brian Haley
4
1.20%
1
4.17%
Himangi Saraogi
4
1.20%
1
4.17%
Total
333
100.00%
24
100.00%



static int rawv6_send_hdrinc(struct sock *sk, struct msghdr *msg, int length,
			struct flowi6 *fl6, struct dst_entry **dstp,
			unsigned int flags)
{
	struct ipv6_pinfo *np = inet6_sk(sk);
	struct net *net = sock_net(sk);
	struct ipv6hdr *iph;
	struct sk_buff *skb;
	int err;
	struct rt6_info *rt = (struct rt6_info *)*dstp;
	int hlen = LL_RESERVED_SPACE(rt->dst.dev);
	int tlen = rt->dst.dev->needed_tailroom;

	if (length > rt->dst.dev->mtu) {
		ipv6_local_error(sk, EMSGSIZE, fl6, rt->dst.dev->mtu);
		return -EMSGSIZE;
	}
	if (flags&MSG_PROBE)
		goto out;

	skb =