xref: /openbmc/linux/net/ipv6/udp.c (revision 50805466)
1db8dac20SDavid S. Miller /*
2db8dac20SDavid S. Miller  *	UDP over IPv6
3db8dac20SDavid S. Miller  *	Linux INET6 implementation
4db8dac20SDavid S. Miller  *
5db8dac20SDavid S. Miller  *	Authors:
6db8dac20SDavid S. Miller  *	Pedro Roque		<roque@di.fc.ul.pt>
7db8dac20SDavid S. Miller  *
8db8dac20SDavid S. Miller  *	Based on linux/ipv4/udp.c
9db8dac20SDavid S. Miller  *
10db8dac20SDavid S. Miller  *	Fixes:
11db8dac20SDavid S. Miller  *	Hideaki YOSHIFUJI	:	sin6_scope_id support
12db8dac20SDavid S. Miller  *	YOSHIFUJI Hideaki @USAGI and:	Support IPV6_V6ONLY socket option, which
13db8dac20SDavid S. Miller  *	Alexey Kuznetsov		allow both IPv4 and IPv6 sockets to bind
14db8dac20SDavid S. Miller  *					a single port at the same time.
15db8dac20SDavid S. Miller  *      Kazunori MIYAZAWA @USAGI:       change process style to use ip6_append_data
16db8dac20SDavid S. Miller  *      YOSHIFUJI Hideaki @USAGI:	convert /proc/net/udp6 to seq_file.
17db8dac20SDavid S. Miller  *
18db8dac20SDavid S. Miller  *	This program is free software; you can redistribute it and/or
19db8dac20SDavid S. Miller  *      modify it under the terms of the GNU General Public License
20db8dac20SDavid S. Miller  *      as published by the Free Software Foundation; either version
21db8dac20SDavid S. Miller  *      2 of the License, or (at your option) any later version.
22db8dac20SDavid S. Miller  */
23db8dac20SDavid S. Miller 
24db8dac20SDavid S. Miller #include <linux/errno.h>
25db8dac20SDavid S. Miller #include <linux/types.h>
26db8dac20SDavid S. Miller #include <linux/socket.h>
27db8dac20SDavid S. Miller #include <linux/sockios.h>
28db8dac20SDavid S. Miller #include <linux/net.h>
29db8dac20SDavid S. Miller #include <linux/in6.h>
30db8dac20SDavid S. Miller #include <linux/netdevice.h>
31db8dac20SDavid S. Miller #include <linux/if_arp.h>
32db8dac20SDavid S. Miller #include <linux/ipv6.h>
33db8dac20SDavid S. Miller #include <linux/icmpv6.h>
34db8dac20SDavid S. Miller #include <linux/init.h>
35db8dac20SDavid S. Miller #include <linux/module.h>
36db8dac20SDavid S. Miller #include <linux/skbuff.h>
375a0e3ad6STejun Heo #include <linux/slab.h>
38db8dac20SDavid S. Miller #include <asm/uaccess.h>
39db8dac20SDavid S. Miller 
40db8dac20SDavid S. Miller #include <net/ndisc.h>
41db8dac20SDavid S. Miller #include <net/protocol.h>
42db8dac20SDavid S. Miller #include <net/transp_v6.h>
43db8dac20SDavid S. Miller #include <net/ip6_route.h>
44db8dac20SDavid S. Miller #include <net/raw.h>
45db8dac20SDavid S. Miller #include <net/tcp_states.h>
46db8dac20SDavid S. Miller #include <net/ip6_checksum.h>
47db8dac20SDavid S. Miller #include <net/xfrm.h>
4872289b96STom Herbert #include <net/inet6_hashtables.h>
49076bb0c8SEliezer Tamir #include <net/busy_poll.h>
50db8dac20SDavid S. Miller 
51db8dac20SDavid S. Miller #include <linux/proc_fs.h>
52db8dac20SDavid S. Miller #include <linux/seq_file.h>
5322911fc5SEric Dumazet #include <trace/events/skb.h>
54db8dac20SDavid S. Miller #include "udp_impl.h"
55db8dac20SDavid S. Miller 
56b2f5e7cdSVlad Yasevich int ipv6_rcv_saddr_equal(const struct sock *sk, const struct sock *sk2)
57b2f5e7cdSVlad Yasevich {
58b2f5e7cdSVlad Yasevich 	const struct in6_addr *sk_rcv_saddr6 = &inet6_sk(sk)->rcv_saddr;
59b2f5e7cdSVlad Yasevich 	const struct in6_addr *sk2_rcv_saddr6 = inet6_rcv_saddr(sk2);
60b2f5e7cdSVlad Yasevich 	int sk_ipv6only = ipv6_only_sock(sk);
61b2f5e7cdSVlad Yasevich 	int sk2_ipv6only = inet_v6_ipv6only(sk2);
62b2f5e7cdSVlad Yasevich 	int addr_type = ipv6_addr_type(sk_rcv_saddr6);
63b2f5e7cdSVlad Yasevich 	int addr_type2 = sk2_rcv_saddr6 ? ipv6_addr_type(sk2_rcv_saddr6) : IPV6_ADDR_MAPPED;
64b2f5e7cdSVlad Yasevich 
65b2f5e7cdSVlad Yasevich 	/* if both are mapped, treat as IPv4 */
66b2f5e7cdSVlad Yasevich 	if (addr_type == IPV6_ADDR_MAPPED && addr_type2 == IPV6_ADDR_MAPPED)
67499923c7SVlad Yasevich 		return (!sk2_ipv6only &&
6850805466SEric Dumazet 			(!sk->sk_rcv_saddr || !sk2->sk_rcv_saddr ||
6950805466SEric Dumazet 			  sk->sk_rcv_saddr == sk2->sk_rcv_saddr));
70b2f5e7cdSVlad Yasevich 
71b2f5e7cdSVlad Yasevich 	if (addr_type2 == IPV6_ADDR_ANY &&
72b2f5e7cdSVlad Yasevich 	    !(sk2_ipv6only && addr_type == IPV6_ADDR_MAPPED))
73b2f5e7cdSVlad Yasevich 		return 1;
74b2f5e7cdSVlad Yasevich 
75b2f5e7cdSVlad Yasevich 	if (addr_type == IPV6_ADDR_ANY &&
76b2f5e7cdSVlad Yasevich 	    !(sk_ipv6only && addr_type2 == IPV6_ADDR_MAPPED))
77b2f5e7cdSVlad Yasevich 		return 1;
78b2f5e7cdSVlad Yasevich 
79b2f5e7cdSVlad Yasevich 	if (sk2_rcv_saddr6 &&
80b2f5e7cdSVlad Yasevich 	    ipv6_addr_equal(sk_rcv_saddr6, sk2_rcv_saddr6))
81b2f5e7cdSVlad Yasevich 		return 1;
82b2f5e7cdSVlad Yasevich 
83b2f5e7cdSVlad Yasevich 	return 0;
84b2f5e7cdSVlad Yasevich }
85b2f5e7cdSVlad Yasevich 
86d4cada4aSEric Dumazet static unsigned int udp6_portaddr_hash(struct net *net,
87d4cada4aSEric Dumazet 				       const struct in6_addr *addr6,
88d4cada4aSEric Dumazet 				       unsigned int port)
89d4cada4aSEric Dumazet {
90d4cada4aSEric Dumazet 	unsigned int hash, mix = net_hash_mix(net);
91d4cada4aSEric Dumazet 
92d4cada4aSEric Dumazet 	if (ipv6_addr_any(addr6))
93d4cada4aSEric Dumazet 		hash = jhash_1word(0, mix);
94856540eeSBrian Haley 	else if (ipv6_addr_v4mapped(addr6))
950eae88f3SEric Dumazet 		hash = jhash_1word((__force u32)addr6->s6_addr32[3], mix);
96d4cada4aSEric Dumazet 	else
970eae88f3SEric Dumazet 		hash = jhash2((__force u32 *)addr6->s6_addr32, 4, mix);
98d4cada4aSEric Dumazet 
99d4cada4aSEric Dumazet 	return hash ^ port;
100d4cada4aSEric Dumazet }
101d4cada4aSEric Dumazet 
102d4cada4aSEric Dumazet 
1036ba5a3c5SPavel Emelyanov int udp_v6_get_port(struct sock *sk, unsigned short snum)
104db8dac20SDavid S. Miller {
10530fff923SEric Dumazet 	unsigned int hash2_nulladdr =
10630fff923SEric Dumazet 		udp6_portaddr_hash(sock_net(sk), &in6addr_any, snum);
10730fff923SEric Dumazet 	unsigned int hash2_partial =
10830fff923SEric Dumazet 		udp6_portaddr_hash(sock_net(sk), &inet6_sk(sk)->rcv_saddr, 0);
10930fff923SEric Dumazet 
110d4cada4aSEric Dumazet 	/* precompute partial secondary hash */
11130fff923SEric Dumazet 	udp_sk(sk)->udp_portaddr_hash = hash2_partial;
11230fff923SEric Dumazet 	return udp_lib_get_port(sk, snum, ipv6_rcv_saddr_equal, hash2_nulladdr);
113db8dac20SDavid S. Miller }
114db8dac20SDavid S. Miller 
115719f8358SEric Dumazet static void udp_v6_rehash(struct sock *sk)
116719f8358SEric Dumazet {
117719f8358SEric Dumazet 	u16 new_hash = udp6_portaddr_hash(sock_net(sk),
118719f8358SEric Dumazet 					  &inet6_sk(sk)->rcv_saddr,
119719f8358SEric Dumazet 					  inet_sk(sk)->inet_num);
120719f8358SEric Dumazet 
121719f8358SEric Dumazet 	udp_lib_rehash(sk, new_hash);
122719f8358SEric Dumazet }
123719f8358SEric Dumazet 
124645ca708SEric Dumazet static inline int compute_score(struct sock *sk, struct net *net,
125645ca708SEric Dumazet 				unsigned short hnum,
12688440ae7SBalazs Scheidler 				const struct in6_addr *saddr, __be16 sport,
12788440ae7SBalazs Scheidler 				const struct in6_addr *daddr, __be16 dport,
128645ca708SEric Dumazet 				int dif)
129db8dac20SDavid S. Miller {
130645ca708SEric Dumazet 	int score = -1;
131db8dac20SDavid S. Miller 
132d4cada4aSEric Dumazet 	if (net_eq(sock_net(sk), net) && udp_sk(sk)->udp_port_hash == hnum &&
133db8dac20SDavid S. Miller 			sk->sk_family == PF_INET6) {
134db8dac20SDavid S. Miller 		struct ipv6_pinfo *np = inet6_sk(sk);
135645ca708SEric Dumazet 		struct inet_sock *inet = inet_sk(sk);
136645ca708SEric Dumazet 
137645ca708SEric Dumazet 		score = 0;
138c720c7e8SEric Dumazet 		if (inet->inet_dport) {
139c720c7e8SEric Dumazet 			if (inet->inet_dport != sport)
140645ca708SEric Dumazet 				return -1;
141db8dac20SDavid S. Miller 			score++;
142db8dac20SDavid S. Miller 		}
143db8dac20SDavid S. Miller 		if (!ipv6_addr_any(&np->rcv_saddr)) {
144db8dac20SDavid S. Miller 			if (!ipv6_addr_equal(&np->rcv_saddr, daddr))
145645ca708SEric Dumazet 				return -1;
146db8dac20SDavid S. Miller 			score++;
147db8dac20SDavid S. Miller 		}
148db8dac20SDavid S. Miller 		if (!ipv6_addr_any(&np->daddr)) {
149db8dac20SDavid S. Miller 			if (!ipv6_addr_equal(&np->daddr, saddr))
150645ca708SEric Dumazet 				return -1;
151db8dac20SDavid S. Miller 			score++;
152db8dac20SDavid S. Miller 		}
153db8dac20SDavid S. Miller 		if (sk->sk_bound_dev_if) {
154db8dac20SDavid S. Miller 			if (sk->sk_bound_dev_if != dif)
155645ca708SEric Dumazet 				return -1;
156db8dac20SDavid S. Miller 			score++;
157db8dac20SDavid S. Miller 		}
158645ca708SEric Dumazet 	}
159645ca708SEric Dumazet 	return score;
160645ca708SEric Dumazet }
161645ca708SEric Dumazet 
162fddc17deSEric Dumazet #define SCORE2_MAX (1 + 1 + 1)
163fddc17deSEric Dumazet static inline int compute_score2(struct sock *sk, struct net *net,
164fddc17deSEric Dumazet 				const struct in6_addr *saddr, __be16 sport,
165fddc17deSEric Dumazet 				const struct in6_addr *daddr, unsigned short hnum,
166fddc17deSEric Dumazet 				int dif)
167fddc17deSEric Dumazet {
168fddc17deSEric Dumazet 	int score = -1;
169fddc17deSEric Dumazet 
170fddc17deSEric Dumazet 	if (net_eq(sock_net(sk), net) && udp_sk(sk)->udp_port_hash == hnum &&
171fddc17deSEric Dumazet 			sk->sk_family == PF_INET6) {
172fddc17deSEric Dumazet 		struct ipv6_pinfo *np = inet6_sk(sk);
173fddc17deSEric Dumazet 		struct inet_sock *inet = inet_sk(sk);
174fddc17deSEric Dumazet 
175fddc17deSEric Dumazet 		if (!ipv6_addr_equal(&np->rcv_saddr, daddr))
176fddc17deSEric Dumazet 			return -1;
177fddc17deSEric Dumazet 		score = 0;
178fddc17deSEric Dumazet 		if (inet->inet_dport) {
179fddc17deSEric Dumazet 			if (inet->inet_dport != sport)
180fddc17deSEric Dumazet 				return -1;
181fddc17deSEric Dumazet 			score++;
182fddc17deSEric Dumazet 		}
183fddc17deSEric Dumazet 		if (!ipv6_addr_any(&np->daddr)) {
184fddc17deSEric Dumazet 			if (!ipv6_addr_equal(&np->daddr, saddr))
185fddc17deSEric Dumazet 				return -1;
186fddc17deSEric Dumazet 			score++;
187fddc17deSEric Dumazet 		}
188fddc17deSEric Dumazet 		if (sk->sk_bound_dev_if) {
189fddc17deSEric Dumazet 			if (sk->sk_bound_dev_if != dif)
190fddc17deSEric Dumazet 				return -1;
191fddc17deSEric Dumazet 			score++;
192fddc17deSEric Dumazet 		}
193fddc17deSEric Dumazet 	}
194fddc17deSEric Dumazet 	return score;
195fddc17deSEric Dumazet }
196fddc17deSEric Dumazet 
197fddc17deSEric Dumazet 
198fddc17deSEric Dumazet /* called with read_rcu_lock() */
199fddc17deSEric Dumazet static struct sock *udp6_lib_lookup2(struct net *net,
200fddc17deSEric Dumazet 		const struct in6_addr *saddr, __be16 sport,
201fddc17deSEric Dumazet 		const struct in6_addr *daddr, unsigned int hnum, int dif,
202fddc17deSEric Dumazet 		struct udp_hslot *hslot2, unsigned int slot2)
203fddc17deSEric Dumazet {
204fddc17deSEric Dumazet 	struct sock *sk, *result;
205fddc17deSEric Dumazet 	struct hlist_nulls_node *node;
20672289b96STom Herbert 	int score, badness, matches = 0, reuseport = 0;
20772289b96STom Herbert 	u32 hash = 0;
208fddc17deSEric Dumazet 
209fddc17deSEric Dumazet begin:
210fddc17deSEric Dumazet 	result = NULL;
211fddc17deSEric Dumazet 	badness = -1;
212fddc17deSEric Dumazet 	udp_portaddr_for_each_entry_rcu(sk, node, &hslot2->head) {
213fddc17deSEric Dumazet 		score = compute_score2(sk, net, saddr, sport,
214fddc17deSEric Dumazet 				      daddr, hnum, dif);
215fddc17deSEric Dumazet 		if (score > badness) {
216fddc17deSEric Dumazet 			result = sk;
217fddc17deSEric Dumazet 			badness = score;
21872289b96STom Herbert 			reuseport = sk->sk_reuseport;
21972289b96STom Herbert 			if (reuseport) {
22072289b96STom Herbert 				hash = inet6_ehashfn(net, daddr, hnum,
22172289b96STom Herbert 						     saddr, sport);
22272289b96STom Herbert 				matches = 1;
22372289b96STom Herbert 			} else if (score == SCORE2_MAX)
224fddc17deSEric Dumazet 				goto exact_match;
22572289b96STom Herbert 		} else if (score == badness && reuseport) {
22672289b96STom Herbert 			matches++;
22772289b96STom Herbert 			if (((u64)hash * matches) >> 32 == 0)
22872289b96STom Herbert 				result = sk;
22972289b96STom Herbert 			hash = next_pseudo_random32(hash);
230fddc17deSEric Dumazet 		}
231fddc17deSEric Dumazet 	}
232fddc17deSEric Dumazet 	/*
233fddc17deSEric Dumazet 	 * if the nulls value we got at the end of this lookup is
234fddc17deSEric Dumazet 	 * not the expected one, we must restart lookup.
235fddc17deSEric Dumazet 	 * We probably met an item that was moved to another chain.
236fddc17deSEric Dumazet 	 */
237fddc17deSEric Dumazet 	if (get_nulls_value(node) != slot2)
238fddc17deSEric Dumazet 		goto begin;
239fddc17deSEric Dumazet 
240fddc17deSEric Dumazet 	if (result) {
241fddc17deSEric Dumazet exact_match:
242c31504dcSEric Dumazet 		if (unlikely(!atomic_inc_not_zero_hint(&result->sk_refcnt, 2)))
243fddc17deSEric Dumazet 			result = NULL;
244fddc17deSEric Dumazet 		else if (unlikely(compute_score2(result, net, saddr, sport,
245fddc17deSEric Dumazet 				  daddr, hnum, dif) < badness)) {
246fddc17deSEric Dumazet 			sock_put(result);
247fddc17deSEric Dumazet 			goto begin;
248fddc17deSEric Dumazet 		}
249fddc17deSEric Dumazet 	}
250fddc17deSEric Dumazet 	return result;
251fddc17deSEric Dumazet }
252fddc17deSEric Dumazet 
253fce82338SPavel Emelyanov struct sock *__udp6_lib_lookup(struct net *net,
25488440ae7SBalazs Scheidler 				      const struct in6_addr *saddr, __be16 sport,
25588440ae7SBalazs Scheidler 				      const struct in6_addr *daddr, __be16 dport,
256645ca708SEric Dumazet 				      int dif, struct udp_table *udptable)
257645ca708SEric Dumazet {
258271b72c7SEric Dumazet 	struct sock *sk, *result;
25988ab1932SEric Dumazet 	struct hlist_nulls_node *node;
260645ca708SEric Dumazet 	unsigned short hnum = ntohs(dport);
261fddc17deSEric Dumazet 	unsigned int hash2, slot2, slot = udp_hashfn(net, hnum, udptable->mask);
262fddc17deSEric Dumazet 	struct udp_hslot *hslot2, *hslot = &udptable->hash[slot];
26372289b96STom Herbert 	int score, badness, matches = 0, reuseport = 0;
26472289b96STom Herbert 	u32 hash = 0;
265645ca708SEric Dumazet 
266271b72c7SEric Dumazet 	rcu_read_lock();
267fddc17deSEric Dumazet 	if (hslot->count > 10) {
268fddc17deSEric Dumazet 		hash2 = udp6_portaddr_hash(net, daddr, hnum);
269fddc17deSEric Dumazet 		slot2 = hash2 & udptable->mask;
270fddc17deSEric Dumazet 		hslot2 = &udptable->hash2[slot2];
271fddc17deSEric Dumazet 		if (hslot->count < hslot2->count)
272fddc17deSEric Dumazet 			goto begin;
273fddc17deSEric Dumazet 
274fddc17deSEric Dumazet 		result = udp6_lib_lookup2(net, saddr, sport,
275fddc17deSEric Dumazet 					  daddr, hnum, dif,
276fddc17deSEric Dumazet 					  hslot2, slot2);
277fddc17deSEric Dumazet 		if (!result) {
278fddc17deSEric Dumazet 			hash2 = udp6_portaddr_hash(net, &in6addr_any, hnum);
279fddc17deSEric Dumazet 			slot2 = hash2 & udptable->mask;
280fddc17deSEric Dumazet 			hslot2 = &udptable->hash2[slot2];
281fddc17deSEric Dumazet 			if (hslot->count < hslot2->count)
282fddc17deSEric Dumazet 				goto begin;
283fddc17deSEric Dumazet 
2841223c67cSJorge Boncompte [DTI2] 			result = udp6_lib_lookup2(net, saddr, sport,
2851223c67cSJorge Boncompte [DTI2] 						  &in6addr_any, hnum, dif,
286fddc17deSEric Dumazet 						  hslot2, slot2);
287fddc17deSEric Dumazet 		}
288fddc17deSEric Dumazet 		rcu_read_unlock();
289fddc17deSEric Dumazet 		return result;
290fddc17deSEric Dumazet 	}
291271b72c7SEric Dumazet begin:
292271b72c7SEric Dumazet 	result = NULL;
293271b72c7SEric Dumazet 	badness = -1;
29488ab1932SEric Dumazet 	sk_nulls_for_each_rcu(sk, node, &hslot->head) {
295645ca708SEric Dumazet 		score = compute_score(sk, net, hnum, saddr, sport, daddr, dport, dif);
296645ca708SEric Dumazet 		if (score > badness) {
297db8dac20SDavid S. Miller 			result = sk;
298db8dac20SDavid S. Miller 			badness = score;
29972289b96STom Herbert 			reuseport = sk->sk_reuseport;
30072289b96STom Herbert 			if (reuseport) {
30172289b96STom Herbert 				hash = inet6_ehashfn(net, daddr, hnum,
30272289b96STom Herbert 						     saddr, sport);
30372289b96STom Herbert 				matches = 1;
30472289b96STom Herbert 			}
30572289b96STom Herbert 		} else if (score == badness && reuseport) {
30672289b96STom Herbert 			matches++;
30772289b96STom Herbert 			if (((u64)hash * matches) >> 32 == 0)
30872289b96STom Herbert 				result = sk;
30972289b96STom Herbert 			hash = next_pseudo_random32(hash);
310db8dac20SDavid S. Miller 		}
311db8dac20SDavid S. Miller 	}
31288ab1932SEric Dumazet 	/*
31388ab1932SEric Dumazet 	 * if the nulls value we got at the end of this lookup is
31488ab1932SEric Dumazet 	 * not the expected one, we must restart lookup.
31588ab1932SEric Dumazet 	 * We probably met an item that was moved to another chain.
31688ab1932SEric Dumazet 	 */
317fddc17deSEric Dumazet 	if (get_nulls_value(node) != slot)
31888ab1932SEric Dumazet 		goto begin;
31988ab1932SEric Dumazet 
320271b72c7SEric Dumazet 	if (result) {
321c31504dcSEric Dumazet 		if (unlikely(!atomic_inc_not_zero_hint(&result->sk_refcnt, 2)))
322271b72c7SEric Dumazet 			result = NULL;
323271b72c7SEric Dumazet 		else if (unlikely(compute_score(result, net, hnum, saddr, sport,
324271b72c7SEric Dumazet 					daddr, dport, dif) < badness)) {
325271b72c7SEric Dumazet 			sock_put(result);
326271b72c7SEric Dumazet 			goto begin;
327271b72c7SEric Dumazet 		}
328271b72c7SEric Dumazet 	}
329271b72c7SEric Dumazet 	rcu_read_unlock();
330db8dac20SDavid S. Miller 	return result;
331db8dac20SDavid S. Miller }
332fce82338SPavel Emelyanov EXPORT_SYMBOL_GPL(__udp6_lib_lookup);
333db8dac20SDavid S. Miller 
334607c4aafSKOVACS Krisztian static struct sock *__udp6_lib_lookup_skb(struct sk_buff *skb,
335607c4aafSKOVACS Krisztian 					  __be16 sport, __be16 dport,
336645ca708SEric Dumazet 					  struct udp_table *udptable)
337607c4aafSKOVACS Krisztian {
33823542618SKOVACS Krisztian 	struct sock *sk;
339b71d1d42SEric Dumazet 	const struct ipv6hdr *iph = ipv6_hdr(skb);
340607c4aafSKOVACS Krisztian 
34123542618SKOVACS Krisztian 	if (unlikely(sk = skb_steal_sock(skb)))
34223542618SKOVACS Krisztian 		return sk;
343adf30907SEric Dumazet 	return __udp6_lib_lookup(dev_net(skb_dst(skb)->dev), &iph->saddr, sport,
344607c4aafSKOVACS Krisztian 				 &iph->daddr, dport, inet6_iif(skb),
345607c4aafSKOVACS Krisztian 				 udptable);
346607c4aafSKOVACS Krisztian }
347607c4aafSKOVACS Krisztian 
348aa976fc0SBalazs Scheidler struct sock *udp6_lib_lookup(struct net *net, const struct in6_addr *saddr, __be16 sport,
349aa976fc0SBalazs Scheidler 			     const struct in6_addr *daddr, __be16 dport, int dif)
350aa976fc0SBalazs Scheidler {
351aa976fc0SBalazs Scheidler 	return __udp6_lib_lookup(net, saddr, sport, daddr, dport, dif, &udp_table);
352aa976fc0SBalazs Scheidler }
353aa976fc0SBalazs Scheidler EXPORT_SYMBOL_GPL(udp6_lib_lookup);
354aa976fc0SBalazs Scheidler 
355aa976fc0SBalazs Scheidler 
356db8dac20SDavid S. Miller /*
357db8dac20SDavid S. Miller  * 	This should be easy, if there is something there we
358db8dac20SDavid S. Miller  * 	return it, otherwise we block.
359db8dac20SDavid S. Miller  */
360db8dac20SDavid S. Miller 
361db8dac20SDavid S. Miller int udpv6_recvmsg(struct kiocb *iocb, struct sock *sk,
362db8dac20SDavid S. Miller 		  struct msghdr *msg, size_t len,
363db8dac20SDavid S. Miller 		  int noblock, int flags, int *addr_len)
364db8dac20SDavid S. Miller {
365db8dac20SDavid S. Miller 	struct ipv6_pinfo *np = inet6_sk(sk);
366db8dac20SDavid S. Miller 	struct inet_sock *inet = inet_sk(sk);
367db8dac20SDavid S. Miller 	struct sk_buff *skb;
36859c2cdaeSDavid S. Miller 	unsigned int ulen, copied;
3693f518bf7SPavel Emelyanov 	int peeked, off = 0;
370db8dac20SDavid S. Miller 	int err;
371db8dac20SDavid S. Miller 	int is_udplite = IS_UDPLITE(sk);
372f26ba175SWei Yongjun 	int is_udp4;
3738a74ad60SEric Dumazet 	bool slow;
374db8dac20SDavid S. Miller 
375db8dac20SDavid S. Miller 	if (addr_len)
376db8dac20SDavid S. Miller 		*addr_len = sizeof(struct sockaddr_in6);
377db8dac20SDavid S. Miller 
378db8dac20SDavid S. Miller 	if (flags & MSG_ERRQUEUE)
379db8dac20SDavid S. Miller 		return ipv6_recv_error(sk, msg, len);
380db8dac20SDavid S. Miller 
3814b340ae2SBrian Haley 	if (np->rxpmtu && np->rxopt.bits.rxpmtu)
3824b340ae2SBrian Haley 		return ipv6_recv_rxpmtu(sk, msg, len);
3834b340ae2SBrian Haley 
384db8dac20SDavid S. Miller try_again:
385db8dac20SDavid S. Miller 	skb = __skb_recv_datagram(sk, flags | (noblock ? MSG_DONTWAIT : 0),
3863f518bf7SPavel Emelyanov 				  &peeked, &off, &err);
387db8dac20SDavid S. Miller 	if (!skb)
388db8dac20SDavid S. Miller 		goto out;
389db8dac20SDavid S. Miller 
390db8dac20SDavid S. Miller 	ulen = skb->len - sizeof(struct udphdr);
39159c2cdaeSDavid S. Miller 	copied = len;
39259c2cdaeSDavid S. Miller 	if (copied > ulen)
39359c2cdaeSDavid S. Miller 		copied = ulen;
39459c2cdaeSDavid S. Miller 	else if (copied < ulen)
395db8dac20SDavid S. Miller 		msg->msg_flags |= MSG_TRUNC;
396db8dac20SDavid S. Miller 
397f26ba175SWei Yongjun 	is_udp4 = (skb->protocol == htons(ETH_P_IP));
398f26ba175SWei Yongjun 
399db8dac20SDavid S. Miller 	/*
400db8dac20SDavid S. Miller 	 * If checksum is needed at all, try to do it while copying the
401db8dac20SDavid S. Miller 	 * data.  If the data is truncated, or if we only want a partial
402db8dac20SDavid S. Miller 	 * coverage checksum (UDP-Lite), do it before the copy.
403db8dac20SDavid S. Miller 	 */
404db8dac20SDavid S. Miller 
40559c2cdaeSDavid S. Miller 	if (copied < ulen || UDP_SKB_CB(skb)->partial_cov) {
406db8dac20SDavid S. Miller 		if (udp_lib_checksum_complete(skb))
407db8dac20SDavid S. Miller 			goto csum_copy_err;
408db8dac20SDavid S. Miller 	}
409db8dac20SDavid S. Miller 
410db8dac20SDavid S. Miller 	if (skb_csum_unnecessary(skb))
411db8dac20SDavid S. Miller 		err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr),
41259c2cdaeSDavid S. Miller 					      msg->msg_iov, copied);
413db8dac20SDavid S. Miller 	else {
414db8dac20SDavid S. Miller 		err = skb_copy_and_csum_datagram_iovec(skb, sizeof(struct udphdr), msg->msg_iov);
415db8dac20SDavid S. Miller 		if (err == -EINVAL)
416db8dac20SDavid S. Miller 			goto csum_copy_err;
417db8dac20SDavid S. Miller 	}
41822911fc5SEric Dumazet 	if (unlikely(err)) {
41922911fc5SEric Dumazet 		trace_kfree_skb(skb, udpv6_recvmsg);
420979402b1SEric Dumazet 		if (!peeked) {
421979402b1SEric Dumazet 			atomic_inc(&sk->sk_drops);
422979402b1SEric Dumazet 			if (is_udp4)
423979402b1SEric Dumazet 				UDP_INC_STATS_USER(sock_net(sk),
424979402b1SEric Dumazet 						   UDP_MIB_INERRORS,
425979402b1SEric Dumazet 						   is_udplite);
426979402b1SEric Dumazet 			else
427979402b1SEric Dumazet 				UDP6_INC_STATS_USER(sock_net(sk),
428979402b1SEric Dumazet 						    UDP_MIB_INERRORS,
429979402b1SEric Dumazet 						    is_udplite);
430979402b1SEric Dumazet 		}
431db8dac20SDavid S. Miller 		goto out_free;
43222911fc5SEric Dumazet 	}
433f26ba175SWei Yongjun 	if (!peeked) {
434f26ba175SWei Yongjun 		if (is_udp4)
435f26ba175SWei Yongjun 			UDP_INC_STATS_USER(sock_net(sk),
436f26ba175SWei Yongjun 					UDP_MIB_INDATAGRAMS, is_udplite);
437f26ba175SWei Yongjun 		else
438235b9f7aSPavel Emelyanov 			UDP6_INC_STATS_USER(sock_net(sk),
439235b9f7aSPavel Emelyanov 					UDP_MIB_INDATAGRAMS, is_udplite);
440f26ba175SWei Yongjun 	}
441db8dac20SDavid S. Miller 
4423b885787SNeil Horman 	sock_recv_ts_and_drops(msg, sk, skb);
443db8dac20SDavid S. Miller 
444db8dac20SDavid S. Miller 	/* Copy the address. */
445db8dac20SDavid S. Miller 	if (msg->msg_name) {
446db8dac20SDavid S. Miller 		struct sockaddr_in6 *sin6;
447db8dac20SDavid S. Miller 
448db8dac20SDavid S. Miller 		sin6 = (struct sockaddr_in6 *) msg->msg_name;
449db8dac20SDavid S. Miller 		sin6->sin6_family = AF_INET6;
450db8dac20SDavid S. Miller 		sin6->sin6_port = udp_hdr(skb)->source;
451db8dac20SDavid S. Miller 		sin6->sin6_flowinfo = 0;
452db8dac20SDavid S. Miller 
453842df073SHannes Frederic Sowa 		if (is_udp4) {
454b301e82cSBrian Haley 			ipv6_addr_set_v4mapped(ip_hdr(skb)->saddr,
455b301e82cSBrian Haley 					       &sin6->sin6_addr);
456842df073SHannes Frederic Sowa 			sin6->sin6_scope_id = 0;
457842df073SHannes Frederic Sowa 		} else {
4584e3fd7a0SAlexey Dobriyan 			sin6->sin6_addr = ipv6_hdr(skb)->saddr;
459842df073SHannes Frederic Sowa 			sin6->sin6_scope_id =
460842df073SHannes Frederic Sowa 				ipv6_iface_scope_id(&sin6->sin6_addr,
461842df073SHannes Frederic Sowa 						    IP6CB(skb)->iif);
462db8dac20SDavid S. Miller 		}
463db8dac20SDavid S. Miller 
464db8dac20SDavid S. Miller 	}
465f26ba175SWei Yongjun 	if (is_udp4) {
466db8dac20SDavid S. Miller 		if (inet->cmsg_flags)
467db8dac20SDavid S. Miller 			ip_cmsg_recv(msg, skb);
468db8dac20SDavid S. Miller 	} else {
469db8dac20SDavid S. Miller 		if (np->rxopt.all)
47073df66f8STom Parkin 			ip6_datagram_recv_ctl(sk, msg, skb);
471db8dac20SDavid S. Miller 	}
472db8dac20SDavid S. Miller 
47359c2cdaeSDavid S. Miller 	err = copied;
474db8dac20SDavid S. Miller 	if (flags & MSG_TRUNC)
475db8dac20SDavid S. Miller 		err = ulen;
476db8dac20SDavid S. Miller 
477db8dac20SDavid S. Miller out_free:
4789d410c79SEric Dumazet 	skb_free_datagram_locked(sk, skb);
479db8dac20SDavid S. Miller out:
480db8dac20SDavid S. Miller 	return err;
481db8dac20SDavid S. Miller 
482db8dac20SDavid S. Miller csum_copy_err:
4838a74ad60SEric Dumazet 	slow = lock_sock_fast(sk);
4840856f939SWei Yongjun 	if (!skb_kill_datagram(sk, skb, flags)) {
4856a5dc9e5SEric Dumazet 		if (is_udp4) {
4866a5dc9e5SEric Dumazet 			UDP_INC_STATS_USER(sock_net(sk),
4876a5dc9e5SEric Dumazet 					UDP_MIB_CSUMERRORS, is_udplite);
4880856f939SWei Yongjun 			UDP_INC_STATS_USER(sock_net(sk),
4890856f939SWei Yongjun 					UDP_MIB_INERRORS, is_udplite);
4906a5dc9e5SEric Dumazet 		} else {
4916a5dc9e5SEric Dumazet 			UDP6_INC_STATS_USER(sock_net(sk),
4926a5dc9e5SEric Dumazet 					UDP_MIB_CSUMERRORS, is_udplite);
4930856f939SWei Yongjun 			UDP6_INC_STATS_USER(sock_net(sk),
4940856f939SWei Yongjun 					UDP_MIB_INERRORS, is_udplite);
4950856f939SWei Yongjun 		}
4966a5dc9e5SEric Dumazet 	}
4978a74ad60SEric Dumazet 	unlock_sock_fast(sk, slow);
498db8dac20SDavid S. Miller 
49932c90254SXufeng Zhang 	if (noblock)
500db8dac20SDavid S. Miller 		return -EAGAIN;
5019cfaa8deSXufeng Zhang 
5029cfaa8deSXufeng Zhang 	/* starting over for a new packet */
5039cfaa8deSXufeng Zhang 	msg->msg_flags &= ~MSG_TRUNC;
504db8dac20SDavid S. Miller 	goto try_again;
505db8dac20SDavid S. Miller }
506db8dac20SDavid S. Miller 
507db8dac20SDavid S. Miller void __udp6_lib_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
508d5fdd6baSBrian Haley 		    u8 type, u8 code, int offset, __be32 info,
509645ca708SEric Dumazet 		    struct udp_table *udptable)
510db8dac20SDavid S. Miller {
511db8dac20SDavid S. Miller 	struct ipv6_pinfo *np;
512b71d1d42SEric Dumazet 	const struct ipv6hdr *hdr = (const struct ipv6hdr *)skb->data;
513b71d1d42SEric Dumazet 	const struct in6_addr *saddr = &hdr->saddr;
514b71d1d42SEric Dumazet 	const struct in6_addr *daddr = &hdr->daddr;
515db8dac20SDavid S. Miller 	struct udphdr *uh = (struct udphdr*)(skb->data+offset);
516db8dac20SDavid S. Miller 	struct sock *sk;
517db8dac20SDavid S. Miller 	int err;
518db8dac20SDavid S. Miller 
519c346dca1SYOSHIFUJI Hideaki 	sk = __udp6_lib_lookup(dev_net(skb->dev), daddr, uh->dest,
520db8dac20SDavid S. Miller 			       saddr, uh->source, inet6_iif(skb), udptable);
521db8dac20SDavid S. Miller 	if (sk == NULL)
522db8dac20SDavid S. Miller 		return;
523db8dac20SDavid S. Miller 
52481aded24SDavid S. Miller 	if (type == ICMPV6_PKT_TOOBIG)
52581aded24SDavid S. Miller 		ip6_sk_update_pmtu(skb, sk, info);
5261a462d18SDuan Jiong 	if (type == NDISC_REDIRECT) {
527ec18d9a2SDavid S. Miller 		ip6_sk_redirect(skb, sk);
5281a462d18SDuan Jiong 		goto out;
5291a462d18SDuan Jiong 	}
53081aded24SDavid S. Miller 
531db8dac20SDavid S. Miller 	np = inet6_sk(sk);
532db8dac20SDavid S. Miller 
533db8dac20SDavid S. Miller 	if (!icmpv6_err_convert(type, code, &err) && !np->recverr)
534db8dac20SDavid S. Miller 		goto out;
535db8dac20SDavid S. Miller 
536db8dac20SDavid S. Miller 	if (sk->sk_state != TCP_ESTABLISHED && !np->recverr)
537db8dac20SDavid S. Miller 		goto out;
538db8dac20SDavid S. Miller 
539b1faf566SEric Dumazet 	if (np->recverr)
540db8dac20SDavid S. Miller 		ipv6_icmp_error(sk, skb, err, uh->dest, ntohl(info), (u8 *)(uh+1));
541b1faf566SEric Dumazet 
542db8dac20SDavid S. Miller 	sk->sk_err = err;
543db8dac20SDavid S. Miller 	sk->sk_error_report(sk);
544db8dac20SDavid S. Miller out:
545db8dac20SDavid S. Miller 	sock_put(sk);
546db8dac20SDavid S. Miller }
547db8dac20SDavid S. Miller 
548f7ad74feSBenjamin LaHaise static int __udpv6_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
549f7ad74feSBenjamin LaHaise {
550f7ad74feSBenjamin LaHaise 	int rc;
551f7ad74feSBenjamin LaHaise 
552f7ad74feSBenjamin LaHaise 	if (!ipv6_addr_any(&inet6_sk(sk)->daddr))
553f7ad74feSBenjamin LaHaise 		sock_rps_save_rxhash(sk, skb);
554f7ad74feSBenjamin LaHaise 
555f7ad74feSBenjamin LaHaise 	rc = sock_queue_rcv_skb(sk, skb);
556f7ad74feSBenjamin LaHaise 	if (rc < 0) {
557f7ad74feSBenjamin LaHaise 		int is_udplite = IS_UDPLITE(sk);
558f7ad74feSBenjamin LaHaise 
559f7ad74feSBenjamin LaHaise 		/* Note that an ENOMEM error is charged twice */
560f7ad74feSBenjamin LaHaise 		if (rc == -ENOMEM)
561f7ad74feSBenjamin LaHaise 			UDP6_INC_STATS_BH(sock_net(sk),
562f7ad74feSBenjamin LaHaise 					UDP_MIB_RCVBUFERRORS, is_udplite);
563f7ad74feSBenjamin LaHaise 		UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
564f7ad74feSBenjamin LaHaise 		kfree_skb(skb);
565f7ad74feSBenjamin LaHaise 		return -1;
566f7ad74feSBenjamin LaHaise 	}
567f7ad74feSBenjamin LaHaise 	return 0;
568f7ad74feSBenjamin LaHaise }
569f7ad74feSBenjamin LaHaise 
570db8dac20SDavid S. Miller static __inline__ void udpv6_err(struct sk_buff *skb,
571d5fdd6baSBrian Haley 				 struct inet6_skb_parm *opt, u8 type,
572d5fdd6baSBrian Haley 				 u8 code, int offset, __be32 info     )
573db8dac20SDavid S. Miller {
574645ca708SEric Dumazet 	__udp6_lib_err(skb, opt, type, code, offset, info, &udp_table);
575db8dac20SDavid S. Miller }
576db8dac20SDavid S. Miller 
577d7f3f621SBenjamin LaHaise static struct static_key udpv6_encap_needed __read_mostly;
578d7f3f621SBenjamin LaHaise void udpv6_encap_enable(void)
579d7f3f621SBenjamin LaHaise {
580d7f3f621SBenjamin LaHaise 	if (!static_key_enabled(&udpv6_encap_needed))
581d7f3f621SBenjamin LaHaise 		static_key_slow_inc(&udpv6_encap_needed);
582d7f3f621SBenjamin LaHaise }
583d7f3f621SBenjamin LaHaise EXPORT_SYMBOL(udpv6_encap_enable);
584d7f3f621SBenjamin LaHaise 
585db8dac20SDavid S. Miller int udpv6_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
586db8dac20SDavid S. Miller {
587db8dac20SDavid S. Miller 	struct udp_sock *up = udp_sk(sk);
588db8dac20SDavid S. Miller 	int rc;
589db8dac20SDavid S. Miller 	int is_udplite = IS_UDPLITE(sk);
590db8dac20SDavid S. Miller 
591db8dac20SDavid S. Miller 	if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
592db8dac20SDavid S. Miller 		goto drop;
593db8dac20SDavid S. Miller 
594d7f3f621SBenjamin LaHaise 	if (static_key_false(&udpv6_encap_needed) && up->encap_type) {
595d7f3f621SBenjamin LaHaise 		int (*encap_rcv)(struct sock *sk, struct sk_buff *skb);
596d7f3f621SBenjamin LaHaise 
597d7f3f621SBenjamin LaHaise 		/*
598d7f3f621SBenjamin LaHaise 		 * This is an encapsulation socket so pass the skb to
599d7f3f621SBenjamin LaHaise 		 * the socket's udp_encap_rcv() hook. Otherwise, just
600d7f3f621SBenjamin LaHaise 		 * fall through and pass this up the UDP socket.
601d7f3f621SBenjamin LaHaise 		 * up->encap_rcv() returns the following value:
602d7f3f621SBenjamin LaHaise 		 * =0 if skb was successfully passed to the encap
603d7f3f621SBenjamin LaHaise 		 *    handler or was discarded by it.
604d7f3f621SBenjamin LaHaise 		 * >0 if skb should be passed on to UDP.
605d7f3f621SBenjamin LaHaise 		 * <0 if skb should be resubmitted as proto -N
606d7f3f621SBenjamin LaHaise 		 */
607d7f3f621SBenjamin LaHaise 
608d7f3f621SBenjamin LaHaise 		/* if we're overly short, let UDP handle it */
609d7f3f621SBenjamin LaHaise 		encap_rcv = ACCESS_ONCE(up->encap_rcv);
610d7f3f621SBenjamin LaHaise 		if (skb->len > sizeof(struct udphdr) && encap_rcv != NULL) {
611d7f3f621SBenjamin LaHaise 			int ret;
612d7f3f621SBenjamin LaHaise 
613d7f3f621SBenjamin LaHaise 			ret = encap_rcv(sk, skb);
614d7f3f621SBenjamin LaHaise 			if (ret <= 0) {
615d7f3f621SBenjamin LaHaise 				UDP_INC_STATS_BH(sock_net(sk),
616d7f3f621SBenjamin LaHaise 						 UDP_MIB_INDATAGRAMS,
617d7f3f621SBenjamin LaHaise 						 is_udplite);
618d7f3f621SBenjamin LaHaise 				return -ret;
619d7f3f621SBenjamin LaHaise 			}
620d7f3f621SBenjamin LaHaise 		}
621d7f3f621SBenjamin LaHaise 
622d7f3f621SBenjamin LaHaise 		/* FALLTHROUGH -- it's a UDP Packet */
623d7f3f621SBenjamin LaHaise 	}
624d7f3f621SBenjamin LaHaise 
625db8dac20SDavid S. Miller 	/*
626db8dac20SDavid S. Miller 	 * UDP-Lite specific tests, ignored on UDP sockets (see net/ipv4/udp.c).
627db8dac20SDavid S. Miller 	 */
628db8dac20SDavid S. Miller 	if ((is_udplite & UDPLITE_RECV_CC)  &&  UDP_SKB_CB(skb)->partial_cov) {
629db8dac20SDavid S. Miller 
630db8dac20SDavid S. Miller 		if (up->pcrlen == 0) {          /* full coverage was set  */
631db8dac20SDavid S. Miller 			LIMIT_NETDEBUG(KERN_WARNING "UDPLITE6: partial coverage"
632db8dac20SDavid S. Miller 				" %d while full coverage %d requested\n",
633db8dac20SDavid S. Miller 				UDP_SKB_CB(skb)->cscov, skb->len);
634db8dac20SDavid S. Miller 			goto drop;
635db8dac20SDavid S. Miller 		}
636db8dac20SDavid S. Miller 		if (UDP_SKB_CB(skb)->cscov  <  up->pcrlen) {
637db8dac20SDavid S. Miller 			LIMIT_NETDEBUG(KERN_WARNING "UDPLITE6: coverage %d "
638db8dac20SDavid S. Miller 						    "too small, need min %d\n",
639db8dac20SDavid S. Miller 				       UDP_SKB_CB(skb)->cscov, up->pcrlen);
640db8dac20SDavid S. Miller 			goto drop;
641db8dac20SDavid S. Miller 		}
642db8dac20SDavid S. Miller 	}
643db8dac20SDavid S. Miller 
64433d480ceSEric Dumazet 	if (rcu_access_pointer(sk->sk_filter)) {
645db8dac20SDavid S. Miller 		if (udp_lib_checksum_complete(skb))
6466a5dc9e5SEric Dumazet 			goto csum_error;
647db8dac20SDavid S. Miller 	}
648db8dac20SDavid S. Miller 
649cb80ef46SBenjamin LaHaise 	if (sk_rcvqueues_full(sk, skb, sk->sk_rcvbuf))
650cb80ef46SBenjamin LaHaise 		goto drop;
651cb80ef46SBenjamin LaHaise 
652d826eb14SEric Dumazet 	skb_dst_drop(skb);
653db8dac20SDavid S. Miller 
654cb80ef46SBenjamin LaHaise 	bh_lock_sock(sk);
655cb80ef46SBenjamin LaHaise 	rc = 0;
656cb80ef46SBenjamin LaHaise 	if (!sock_owned_by_user(sk))
657f7ad74feSBenjamin LaHaise 		rc = __udpv6_queue_rcv_skb(sk, skb);
658cb80ef46SBenjamin LaHaise 	else if (sk_add_backlog(sk, skb, sk->sk_rcvbuf)) {
659cb80ef46SBenjamin LaHaise 		bh_unlock_sock(sk);
660cb80ef46SBenjamin LaHaise 		goto drop;
661cb80ef46SBenjamin LaHaise 	}
662cb80ef46SBenjamin LaHaise 	bh_unlock_sock(sk);
663f7ad74feSBenjamin LaHaise 
664f7ad74feSBenjamin LaHaise 	return rc;
6656a5dc9e5SEric Dumazet csum_error:
6666a5dc9e5SEric Dumazet 	UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_CSUMERRORS, is_udplite);
667db8dac20SDavid S. Miller drop:
668ef28d1a2SPavel Emelyanov 	UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
669cb80ef46SBenjamin LaHaise 	atomic_inc(&sk->sk_drops);
670db8dac20SDavid S. Miller 	kfree_skb(skb);
671db8dac20SDavid S. Miller 	return -1;
672db8dac20SDavid S. Miller }
673db8dac20SDavid S. Miller 
674920a4611SEric Dumazet static struct sock *udp_v6_mcast_next(struct net *net, struct sock *sk,
675b71d1d42SEric Dumazet 				      __be16 loc_port, const struct in6_addr *loc_addr,
676b71d1d42SEric Dumazet 				      __be16 rmt_port, const struct in6_addr *rmt_addr,
677db8dac20SDavid S. Miller 				      int dif)
678db8dac20SDavid S. Miller {
67988ab1932SEric Dumazet 	struct hlist_nulls_node *node;
680db8dac20SDavid S. Miller 	struct sock *s = sk;
681db8dac20SDavid S. Miller 	unsigned short num = ntohs(loc_port);
682db8dac20SDavid S. Miller 
68388ab1932SEric Dumazet 	sk_nulls_for_each_from(s, node) {
684db8dac20SDavid S. Miller 		struct inet_sock *inet = inet_sk(s);
685db8dac20SDavid S. Miller 
686920a4611SEric Dumazet 		if (!net_eq(sock_net(s), net))
687b8ad0cbcSDaniel Lezcano 			continue;
688b8ad0cbcSDaniel Lezcano 
689d4cada4aSEric Dumazet 		if (udp_sk(s)->udp_port_hash == num &&
690d4cada4aSEric Dumazet 		    s->sk_family == PF_INET6) {
691db8dac20SDavid S. Miller 			struct ipv6_pinfo *np = inet6_sk(s);
692c720c7e8SEric Dumazet 			if (inet->inet_dport) {
693c720c7e8SEric Dumazet 				if (inet->inet_dport != rmt_port)
694db8dac20SDavid S. Miller 					continue;
695db8dac20SDavid S. Miller 			}
696db8dac20SDavid S. Miller 			if (!ipv6_addr_any(&np->daddr) &&
697db8dac20SDavid S. Miller 			    !ipv6_addr_equal(&np->daddr, rmt_addr))
698db8dac20SDavid S. Miller 				continue;
699db8dac20SDavid S. Miller 
700db8dac20SDavid S. Miller 			if (s->sk_bound_dev_if && s->sk_bound_dev_if != dif)
701db8dac20SDavid S. Miller 				continue;
702db8dac20SDavid S. Miller 
703db8dac20SDavid S. Miller 			if (!ipv6_addr_any(&np->rcv_saddr)) {
704db8dac20SDavid S. Miller 				if (!ipv6_addr_equal(&np->rcv_saddr, loc_addr))
705db8dac20SDavid S. Miller 					continue;
706db8dac20SDavid S. Miller 			}
707db8dac20SDavid S. Miller 			if (!inet6_mc_check(s, loc_addr, rmt_addr))
708db8dac20SDavid S. Miller 				continue;
709db8dac20SDavid S. Miller 			return s;
710db8dac20SDavid S. Miller 		}
711db8dac20SDavid S. Miller 	}
712db8dac20SDavid S. Miller 	return NULL;
713db8dac20SDavid S. Miller }
714db8dac20SDavid S. Miller 
715a1ab77f9SEric Dumazet static void flush_stack(struct sock **stack, unsigned int count,
716a1ab77f9SEric Dumazet 			struct sk_buff *skb, unsigned int final)
717a1ab77f9SEric Dumazet {
718cb80ef46SBenjamin LaHaise 	struct sk_buff *skb1 = NULL;
719a1ab77f9SEric Dumazet 	struct sock *sk;
720cb80ef46SBenjamin LaHaise 	unsigned int i;
721a1ab77f9SEric Dumazet 
722a1ab77f9SEric Dumazet 	for (i = 0; i < count; i++) {
723a1ab77f9SEric Dumazet 		sk = stack[i];
724cb80ef46SBenjamin LaHaise 		if (likely(skb1 == NULL))
725cb80ef46SBenjamin LaHaise 			skb1 = (i == final) ? skb : skb_clone(skb, GFP_ATOMIC);
726cb80ef46SBenjamin LaHaise 		if (!skb1) {
727f6b8f32cSEric Dumazet 			atomic_inc(&sk->sk_drops);
728cb80ef46SBenjamin LaHaise 			UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_RCVBUFERRORS,
729cb80ef46SBenjamin LaHaise 					  IS_UDPLITE(sk));
730cb80ef46SBenjamin LaHaise 			UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS,
731cb80ef46SBenjamin LaHaise 					  IS_UDPLITE(sk));
732a1ab77f9SEric Dumazet 		}
733cb80ef46SBenjamin LaHaise 
734cb80ef46SBenjamin LaHaise 		if (skb1 && udpv6_queue_rcv_skb(sk, skb1) <= 0)
735cb80ef46SBenjamin LaHaise 			skb1 = NULL;
736cb80ef46SBenjamin LaHaise 	}
737cb80ef46SBenjamin LaHaise 	if (unlikely(skb1))
738cb80ef46SBenjamin LaHaise 		kfree_skb(skb1);
739a1ab77f9SEric Dumazet }
740db8dac20SDavid S. Miller /*
741db8dac20SDavid S. Miller  * Note: called only from the BH handler context,
742db8dac20SDavid S. Miller  * so we don't need to lock the hashes.
743db8dac20SDavid S. Miller  */
744e3163493SPavel Emelyanov static int __udp6_lib_mcast_deliver(struct net *net, struct sk_buff *skb,
745b71d1d42SEric Dumazet 		const struct in6_addr *saddr, const struct in6_addr *daddr,
746645ca708SEric Dumazet 		struct udp_table *udptable)
747db8dac20SDavid S. Miller {
748a1ab77f9SEric Dumazet 	struct sock *sk, *stack[256 / sizeof(struct sock *)];
749db8dac20SDavid S. Miller 	const struct udphdr *uh = udp_hdr(skb);
750f86dcc5aSEric Dumazet 	struct udp_hslot *hslot = udp_hashslot(udptable, net, ntohs(uh->dest));
751db8dac20SDavid S. Miller 	int dif;
752a1ab77f9SEric Dumazet 	unsigned int i, count = 0;
753db8dac20SDavid S. Miller 
754645ca708SEric Dumazet 	spin_lock(&hslot->lock);
75588ab1932SEric Dumazet 	sk = sk_nulls_head(&hslot->head);
756db8dac20SDavid S. Miller 	dif = inet6_iif(skb);
757920a4611SEric Dumazet 	sk = udp_v6_mcast_next(net, sk, uh->dest, daddr, uh->source, saddr, dif);
758a1ab77f9SEric Dumazet 	while (sk) {
759a1ab77f9SEric Dumazet 		stack[count++] = sk;
760a1ab77f9SEric Dumazet 		sk = udp_v6_mcast_next(net, sk_nulls_next(sk), uh->dest, daddr,
761a1ab77f9SEric Dumazet 				       uh->source, saddr, dif);
762a1ab77f9SEric Dumazet 		if (unlikely(count == ARRAY_SIZE(stack))) {
763a1ab77f9SEric Dumazet 			if (!sk)
764a1ab77f9SEric Dumazet 				break;
765a1ab77f9SEric Dumazet 			flush_stack(stack, count, skb, ~0);
766a1ab77f9SEric Dumazet 			count = 0;
767db8dac20SDavid S. Miller 		}
768a1ab77f9SEric Dumazet 	}
769a1ab77f9SEric Dumazet 	/*
770a1ab77f9SEric Dumazet 	 * before releasing the lock, we must take reference on sockets
771a1ab77f9SEric Dumazet 	 */
772a1ab77f9SEric Dumazet 	for (i = 0; i < count; i++)
773a1ab77f9SEric Dumazet 		sock_hold(stack[i]);
774db8dac20SDavid S. Miller 
775645ca708SEric Dumazet 	spin_unlock(&hslot->lock);
776a1ab77f9SEric Dumazet 
777a1ab77f9SEric Dumazet 	if (count) {
778a1ab77f9SEric Dumazet 		flush_stack(stack, count, skb, count - 1);
779a1ab77f9SEric Dumazet 
780a1ab77f9SEric Dumazet 		for (i = 0; i < count; i++)
781a1ab77f9SEric Dumazet 			sock_put(stack[i]);
782a1ab77f9SEric Dumazet 	} else {
783a1ab77f9SEric Dumazet 		kfree_skb(skb);
784a1ab77f9SEric Dumazet 	}
785db8dac20SDavid S. Miller 	return 0;
786db8dac20SDavid S. Miller }
787db8dac20SDavid S. Miller 
788645ca708SEric Dumazet int __udp6_lib_rcv(struct sk_buff *skb, struct udp_table *udptable,
789db8dac20SDavid S. Miller 		   int proto)
790db8dac20SDavid S. Miller {
7913ffe533cSAlexey Dobriyan 	struct net *net = dev_net(skb->dev);
792db8dac20SDavid S. Miller 	struct sock *sk;
793db8dac20SDavid S. Miller 	struct udphdr *uh;
794b71d1d42SEric Dumazet 	const struct in6_addr *saddr, *daddr;
795db8dac20SDavid S. Miller 	u32 ulen = 0;
796db8dac20SDavid S. Miller 
797db8dac20SDavid S. Miller 	if (!pskb_may_pull(skb, sizeof(struct udphdr)))
798d6bc0149SBjørn Mork 		goto discard;
799db8dac20SDavid S. Miller 
800db8dac20SDavid S. Miller 	saddr = &ipv6_hdr(skb)->saddr;
801db8dac20SDavid S. Miller 	daddr = &ipv6_hdr(skb)->daddr;
802db8dac20SDavid S. Miller 	uh = udp_hdr(skb);
803db8dac20SDavid S. Miller 
804db8dac20SDavid S. Miller 	ulen = ntohs(uh->len);
805db8dac20SDavid S. Miller 	if (ulen > skb->len)
806db8dac20SDavid S. Miller 		goto short_packet;
807db8dac20SDavid S. Miller 
808db8dac20SDavid S. Miller 	if (proto == IPPROTO_UDP) {
809db8dac20SDavid S. Miller 		/* UDP validates ulen. */
810db8dac20SDavid S. Miller 
811db8dac20SDavid S. Miller 		/* Check for jumbo payload */
812db8dac20SDavid S. Miller 		if (ulen == 0)
813db8dac20SDavid S. Miller 			ulen = skb->len;
814db8dac20SDavid S. Miller 
815db8dac20SDavid S. Miller 		if (ulen < sizeof(*uh))
816db8dac20SDavid S. Miller 			goto short_packet;
817db8dac20SDavid S. Miller 
818db8dac20SDavid S. Miller 		if (ulen < skb->len) {
819db8dac20SDavid S. Miller 			if (pskb_trim_rcsum(skb, ulen))
820db8dac20SDavid S. Miller 				goto short_packet;
821db8dac20SDavid S. Miller 			saddr = &ipv6_hdr(skb)->saddr;
822db8dac20SDavid S. Miller 			daddr = &ipv6_hdr(skb)->daddr;
823db8dac20SDavid S. Miller 			uh = udp_hdr(skb);
824db8dac20SDavid S. Miller 		}
825db8dac20SDavid S. Miller 	}
826db8dac20SDavid S. Miller 
827db8dac20SDavid S. Miller 	if (udp6_csum_init(skb, uh, proto))
8286a5dc9e5SEric Dumazet 		goto csum_error;
829db8dac20SDavid S. Miller 
830db8dac20SDavid S. Miller 	/*
831db8dac20SDavid S. Miller 	 *	Multicast receive code
832db8dac20SDavid S. Miller 	 */
833db8dac20SDavid S. Miller 	if (ipv6_addr_is_multicast(daddr))
834e3163493SPavel Emelyanov 		return __udp6_lib_mcast_deliver(net, skb,
835e3163493SPavel Emelyanov 				saddr, daddr, udptable);
836db8dac20SDavid S. Miller 
837db8dac20SDavid S. Miller 	/* Unicast */
838db8dac20SDavid S. Miller 
839db8dac20SDavid S. Miller 	/*
840db8dac20SDavid S. Miller 	 * check socket cache ... must talk to Alan about his plans
841db8dac20SDavid S. Miller 	 * for sock caches... i'll skip this for now.
842db8dac20SDavid S. Miller 	 */
843607c4aafSKOVACS Krisztian 	sk = __udp6_lib_lookup_skb(skb, uh->source, uh->dest, udptable);
844cb80ef46SBenjamin LaHaise 	if (sk != NULL) {
845a5b50476SEliezer Tamir 		int ret;
846a5b50476SEliezer Tamir 
8478b80cda5SEliezer Tamir 		sk_mark_napi_id(sk, skb);
848a5b50476SEliezer Tamir 		ret = udpv6_queue_rcv_skb(sk, skb);
849cb80ef46SBenjamin LaHaise 		sock_put(sk);
850db8dac20SDavid S. Miller 
851cb80ef46SBenjamin LaHaise 		/* a return value > 0 means to resubmit the input, but
852cb80ef46SBenjamin LaHaise 		 * it wants the return to be -protocol, or 0
853cb80ef46SBenjamin LaHaise 		 */
854cb80ef46SBenjamin LaHaise 		if (ret > 0)
855cb80ef46SBenjamin LaHaise 			return -ret;
856cb80ef46SBenjamin LaHaise 
857cb80ef46SBenjamin LaHaise 		return 0;
858cb80ef46SBenjamin LaHaise 	}
859cb80ef46SBenjamin LaHaise 
860db8dac20SDavid S. Miller 	if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
861db8dac20SDavid S. Miller 		goto discard;
862db8dac20SDavid S. Miller 
863db8dac20SDavid S. Miller 	if (udp_lib_checksum_complete(skb))
8646a5dc9e5SEric Dumazet 		goto csum_error;
865db8dac20SDavid S. Miller 
866cb80ef46SBenjamin LaHaise 	UDP6_INC_STATS_BH(net, UDP_MIB_NOPORTS, proto == IPPROTO_UDPLITE);
8673ffe533cSAlexey Dobriyan 	icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH, 0);
868db8dac20SDavid S. Miller 
869db8dac20SDavid S. Miller 	kfree_skb(skb);
870db8dac20SDavid S. Miller 	return 0;
871db8dac20SDavid S. Miller 
872db8dac20SDavid S. Miller short_packet:
873d6bc0149SBjørn Mork 	LIMIT_NETDEBUG(KERN_DEBUG "UDP%sv6: short packet: From [%pI6c]:%u %d/%d to [%pI6c]:%u\n",
874db8dac20SDavid S. Miller 		       proto == IPPROTO_UDPLITE ? "-Lite" : "",
875d6bc0149SBjørn Mork 		       saddr,
876d6bc0149SBjørn Mork 		       ntohs(uh->source),
877d6bc0149SBjørn Mork 		       ulen,
878d6bc0149SBjørn Mork 		       skb->len,
879d6bc0149SBjørn Mork 		       daddr,
880d6bc0149SBjørn Mork 		       ntohs(uh->dest));
8816a5dc9e5SEric Dumazet 	goto discard;
8826a5dc9e5SEric Dumazet csum_error:
8836a5dc9e5SEric Dumazet 	UDP6_INC_STATS_BH(net, UDP_MIB_CSUMERRORS, proto == IPPROTO_UDPLITE);
884db8dac20SDavid S. Miller discard:
885ef28d1a2SPavel Emelyanov 	UDP6_INC_STATS_BH(net, UDP_MIB_INERRORS, proto == IPPROTO_UDPLITE);
886db8dac20SDavid S. Miller 	kfree_skb(skb);
887db8dac20SDavid S. Miller 	return 0;
888db8dac20SDavid S. Miller }
889db8dac20SDavid S. Miller 
890db8dac20SDavid S. Miller static __inline__ int udpv6_rcv(struct sk_buff *skb)
891db8dac20SDavid S. Miller {
892645ca708SEric Dumazet 	return __udp6_lib_rcv(skb, &udp_table, IPPROTO_UDP);
893db8dac20SDavid S. Miller }
894db8dac20SDavid S. Miller 
895db8dac20SDavid S. Miller /*
896db8dac20SDavid S. Miller  * Throw away all pending data and cancel the corking. Socket is locked.
897db8dac20SDavid S. Miller  */
898db8dac20SDavid S. Miller static void udp_v6_flush_pending_frames(struct sock *sk)
899db8dac20SDavid S. Miller {
900db8dac20SDavid S. Miller 	struct udp_sock *up = udp_sk(sk);
901db8dac20SDavid S. Miller 
90236d926b9SDenis V. Lunev 	if (up->pending == AF_INET)
90336d926b9SDenis V. Lunev 		udp_flush_pending_frames(sk);
90436d926b9SDenis V. Lunev 	else if (up->pending) {
905db8dac20SDavid S. Miller 		up->len = 0;
906db8dac20SDavid S. Miller 		up->pending = 0;
907db8dac20SDavid S. Miller 		ip6_flush_pending_frames(sk);
908db8dac20SDavid S. Miller 	}
909db8dac20SDavid S. Miller }
910db8dac20SDavid S. Miller 
911493c6be3SSridhar Samudrala /**
912493c6be3SSridhar Samudrala  * 	udp6_hwcsum_outgoing  -  handle outgoing HW checksumming
913493c6be3SSridhar Samudrala  * 	@sk: 	socket we are sending on
914493c6be3SSridhar Samudrala  * 	@skb: 	sk_buff containing the filled-in UDP header
915493c6be3SSridhar Samudrala  * 	        (checksum field must be zeroed out)
916493c6be3SSridhar Samudrala  */
917493c6be3SSridhar Samudrala static void udp6_hwcsum_outgoing(struct sock *sk, struct sk_buff *skb,
918493c6be3SSridhar Samudrala 				 const struct in6_addr *saddr,
919493c6be3SSridhar Samudrala 				 const struct in6_addr *daddr, int len)
920493c6be3SSridhar Samudrala {
921493c6be3SSridhar Samudrala 	unsigned int offset;
922493c6be3SSridhar Samudrala 	struct udphdr *uh = udp_hdr(skb);
923493c6be3SSridhar Samudrala 	__wsum csum = 0;
924493c6be3SSridhar Samudrala 
925493c6be3SSridhar Samudrala 	if (skb_queue_len(&sk->sk_write_queue) == 1) {
926493c6be3SSridhar Samudrala 		/* Only one fragment on the socket.  */
927493c6be3SSridhar Samudrala 		skb->csum_start = skb_transport_header(skb) - skb->head;
928493c6be3SSridhar Samudrala 		skb->csum_offset = offsetof(struct udphdr, check);
929493c6be3SSridhar Samudrala 		uh->check = ~csum_ipv6_magic(saddr, daddr, len, IPPROTO_UDP, 0);
930493c6be3SSridhar Samudrala 	} else {
931493c6be3SSridhar Samudrala 		/*
932493c6be3SSridhar Samudrala 		 * HW-checksum won't work as there are two or more
933493c6be3SSridhar Samudrala 		 * fragments on the socket so that all csums of sk_buffs
934493c6be3SSridhar Samudrala 		 * should be together
935493c6be3SSridhar Samudrala 		 */
936493c6be3SSridhar Samudrala 		offset = skb_transport_offset(skb);
937493c6be3SSridhar Samudrala 		skb->csum = skb_checksum(skb, offset, skb->len - offset, 0);
938493c6be3SSridhar Samudrala 
939493c6be3SSridhar Samudrala 		skb->ip_summed = CHECKSUM_NONE;
940493c6be3SSridhar Samudrala 
941493c6be3SSridhar Samudrala 		skb_queue_walk(&sk->sk_write_queue, skb) {
942493c6be3SSridhar Samudrala 			csum = csum_add(csum, skb->csum);
943493c6be3SSridhar Samudrala 		}
944493c6be3SSridhar Samudrala 
945493c6be3SSridhar Samudrala 		uh->check = csum_ipv6_magic(saddr, daddr, len, IPPROTO_UDP,
946493c6be3SSridhar Samudrala 					    csum);
947493c6be3SSridhar Samudrala 		if (uh->check == 0)
948493c6be3SSridhar Samudrala 			uh->check = CSUM_MANGLED_0;
949493c6be3SSridhar Samudrala 	}
950493c6be3SSridhar Samudrala }
951493c6be3SSridhar Samudrala 
952db8dac20SDavid S. Miller /*
953db8dac20SDavid S. Miller  *	Sending
954db8dac20SDavid S. Miller  */
955db8dac20SDavid S. Miller 
956db8dac20SDavid S. Miller static int udp_v6_push_pending_frames(struct sock *sk)
957db8dac20SDavid S. Miller {
958db8dac20SDavid S. Miller 	struct sk_buff *skb;
959db8dac20SDavid S. Miller 	struct udphdr *uh;
960db8dac20SDavid S. Miller 	struct udp_sock  *up = udp_sk(sk);
961db8dac20SDavid S. Miller 	struct inet_sock *inet = inet_sk(sk);
9628822b64aSHannes Frederic Sowa 	struct flowi6 *fl6;
963db8dac20SDavid S. Miller 	int err = 0;
964db8dac20SDavid S. Miller 	int is_udplite = IS_UDPLITE(sk);
965db8dac20SDavid S. Miller 	__wsum csum = 0;
966db8dac20SDavid S. Miller 
9678822b64aSHannes Frederic Sowa 	if (up->pending == AF_INET)
9688822b64aSHannes Frederic Sowa 		return udp_push_pending_frames(sk);
9698822b64aSHannes Frederic Sowa 
9708822b64aSHannes Frederic Sowa 	fl6 = &inet->cork.fl.u.ip6;
9718822b64aSHannes Frederic Sowa 
972db8dac20SDavid S. Miller 	/* Grab the skbuff where UDP header space exists. */
973db8dac20SDavid S. Miller 	if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
974db8dac20SDavid S. Miller 		goto out;
975db8dac20SDavid S. Miller 
976db8dac20SDavid S. Miller 	/*
977db8dac20SDavid S. Miller 	 * Create a UDP header
978db8dac20SDavid S. Miller 	 */
979db8dac20SDavid S. Miller 	uh = udp_hdr(skb);
9801958b856SDavid S. Miller 	uh->source = fl6->fl6_sport;
9811958b856SDavid S. Miller 	uh->dest = fl6->fl6_dport;
982db8dac20SDavid S. Miller 	uh->len = htons(up->len);
983db8dac20SDavid S. Miller 	uh->check = 0;
984db8dac20SDavid S. Miller 
985db8dac20SDavid S. Miller 	if (is_udplite)
986db8dac20SDavid S. Miller 		csum = udplite_csum_outgoing(sk, skb);
987493c6be3SSridhar Samudrala 	else if (skb->ip_summed == CHECKSUM_PARTIAL) { /* UDP hardware csum */
9884c9483b2SDavid S. Miller 		udp6_hwcsum_outgoing(sk, skb, &fl6->saddr, &fl6->daddr,
989493c6be3SSridhar Samudrala 				     up->len);
990493c6be3SSridhar Samudrala 		goto send;
991493c6be3SSridhar Samudrala 	} else
992db8dac20SDavid S. Miller 		csum = udp_csum_outgoing(sk, skb);
993db8dac20SDavid S. Miller 
994db8dac20SDavid S. Miller 	/* add protocol-dependent pseudo-header */
9954c9483b2SDavid S. Miller 	uh->check = csum_ipv6_magic(&fl6->saddr, &fl6->daddr,
9964c9483b2SDavid S. Miller 				    up->len, fl6->flowi6_proto, csum);
997db8dac20SDavid S. Miller 	if (uh->check == 0)
998db8dac20SDavid S. Miller 		uh->check = CSUM_MANGLED_0;
999db8dac20SDavid S. Miller 
1000493c6be3SSridhar Samudrala send:
1001db8dac20SDavid S. Miller 	err = ip6_push_pending_frames(sk);
10026ce9e7b5SEric Dumazet 	if (err) {
10036ce9e7b5SEric Dumazet 		if (err == -ENOBUFS && !inet6_sk(sk)->recverr) {
10046ce9e7b5SEric Dumazet 			UDP6_INC_STATS_USER(sock_net(sk),
10056ce9e7b5SEric Dumazet 					    UDP_MIB_SNDBUFERRORS, is_udplite);
10066ce9e7b5SEric Dumazet 			err = 0;
10076ce9e7b5SEric Dumazet 		}
10086ce9e7b5SEric Dumazet 	} else
10096ce9e7b5SEric Dumazet 		UDP6_INC_STATS_USER(sock_net(sk),
10106ce9e7b5SEric Dumazet 				    UDP_MIB_OUTDATAGRAMS, is_udplite);
1011db8dac20SDavid S. Miller out:
1012db8dac20SDavid S. Miller 	up->len = 0;
1013db8dac20SDavid S. Miller 	up->pending = 0;
1014db8dac20SDavid S. Miller 	return err;
1015db8dac20SDavid S. Miller }
1016db8dac20SDavid S. Miller 
1017db8dac20SDavid S. Miller int udpv6_sendmsg(struct kiocb *iocb, struct sock *sk,
1018db8dac20SDavid S. Miller 		  struct msghdr *msg, size_t len)
1019db8dac20SDavid S. Miller {
1020db8dac20SDavid S. Miller 	struct ipv6_txoptions opt_space;
1021db8dac20SDavid S. Miller 	struct udp_sock *up = udp_sk(sk);
1022db8dac20SDavid S. Miller 	struct inet_sock *inet = inet_sk(sk);
1023db8dac20SDavid S. Miller 	struct ipv6_pinfo *np = inet6_sk(sk);
1024db8dac20SDavid S. Miller 	struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) msg->msg_name;
102520c59de2SArnaud Ebalard 	struct in6_addr *daddr, *final_p, final;
1026db8dac20SDavid S. Miller 	struct ipv6_txoptions *opt = NULL;
1027db8dac20SDavid S. Miller 	struct ip6_flowlabel *flowlabel = NULL;
10284c9483b2SDavid S. Miller 	struct flowi6 fl6;
1029db8dac20SDavid S. Miller 	struct dst_entry *dst;
1030db8dac20SDavid S. Miller 	int addr_len = msg->msg_namelen;
1031db8dac20SDavid S. Miller 	int ulen = len;
1032db8dac20SDavid S. Miller 	int hlimit = -1;
1033db8dac20SDavid S. Miller 	int tclass = -1;
103413b52cd4SBrian Haley 	int dontfrag = -1;
1035db8dac20SDavid S. Miller 	int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
1036db8dac20SDavid S. Miller 	int err;
1037db8dac20SDavid S. Miller 	int connected = 0;
1038db8dac20SDavid S. Miller 	int is_udplite = IS_UDPLITE(sk);
1039db8dac20SDavid S. Miller 	int (*getfrag)(void *, char *, int, int, int, struct sk_buff *);
1040db8dac20SDavid S. Miller 
1041db8dac20SDavid S. Miller 	/* destination address check */
1042db8dac20SDavid S. Miller 	if (sin6) {
1043db8dac20SDavid S. Miller 		if (addr_len < offsetof(struct sockaddr, sa_data))
1044db8dac20SDavid S. Miller 			return -EINVAL;
1045db8dac20SDavid S. Miller 
1046db8dac20SDavid S. Miller 		switch (sin6->sin6_family) {
1047db8dac20SDavid S. Miller 		case AF_INET6:
1048db8dac20SDavid S. Miller 			if (addr_len < SIN6_LEN_RFC2133)
1049db8dac20SDavid S. Miller 				return -EINVAL;
1050db8dac20SDavid S. Miller 			daddr = &sin6->sin6_addr;
1051db8dac20SDavid S. Miller 			break;
1052db8dac20SDavid S. Miller 		case AF_INET:
1053db8dac20SDavid S. Miller 			goto do_udp_sendmsg;
1054db8dac20SDavid S. Miller 		case AF_UNSPEC:
1055db8dac20SDavid S. Miller 			msg->msg_name = sin6 = NULL;
1056db8dac20SDavid S. Miller 			msg->msg_namelen = addr_len = 0;
1057db8dac20SDavid S. Miller 			daddr = NULL;
1058db8dac20SDavid S. Miller 			break;
1059db8dac20SDavid S. Miller 		default:
1060db8dac20SDavid S. Miller 			return -EINVAL;
1061db8dac20SDavid S. Miller 		}
1062db8dac20SDavid S. Miller 	} else if (!up->pending) {
1063db8dac20SDavid S. Miller 		if (sk->sk_state != TCP_ESTABLISHED)
1064db8dac20SDavid S. Miller 			return -EDESTADDRREQ;
1065db8dac20SDavid S. Miller 		daddr = &np->daddr;
1066db8dac20SDavid S. Miller 	} else
1067db8dac20SDavid S. Miller 		daddr = NULL;
1068db8dac20SDavid S. Miller 
1069db8dac20SDavid S. Miller 	if (daddr) {
1070db8dac20SDavid S. Miller 		if (ipv6_addr_v4mapped(daddr)) {
1071db8dac20SDavid S. Miller 			struct sockaddr_in sin;
1072db8dac20SDavid S. Miller 			sin.sin_family = AF_INET;
1073c720c7e8SEric Dumazet 			sin.sin_port = sin6 ? sin6->sin6_port : inet->inet_dport;
1074db8dac20SDavid S. Miller 			sin.sin_addr.s_addr = daddr->s6_addr32[3];
1075db8dac20SDavid S. Miller 			msg->msg_name = &sin;
1076db8dac20SDavid S. Miller 			msg->msg_namelen = sizeof(sin);
1077db8dac20SDavid S. Miller do_udp_sendmsg:
1078db8dac20SDavid S. Miller 			if (__ipv6_only_sock(sk))
1079db8dac20SDavid S. Miller 				return -ENETUNREACH;
1080db8dac20SDavid S. Miller 			return udp_sendmsg(iocb, sk, msg, len);
1081db8dac20SDavid S. Miller 		}
1082db8dac20SDavid S. Miller 	}
1083db8dac20SDavid S. Miller 
1084db8dac20SDavid S. Miller 	if (up->pending == AF_INET)
1085db8dac20SDavid S. Miller 		return udp_sendmsg(iocb, sk, msg, len);
1086db8dac20SDavid S. Miller 
1087db8dac20SDavid S. Miller 	/* Rough check on arithmetic overflow,
1088db8dac20SDavid S. Miller 	   better check is made in ip6_append_data().
1089db8dac20SDavid S. Miller 	   */
1090db8dac20SDavid S. Miller 	if (len > INT_MAX - sizeof(struct udphdr))
1091db8dac20SDavid S. Miller 		return -EMSGSIZE;
1092db8dac20SDavid S. Miller 
1093db8dac20SDavid S. Miller 	if (up->pending) {
1094db8dac20SDavid S. Miller 		/*
1095db8dac20SDavid S. Miller 		 * There are pending frames.
1096db8dac20SDavid S. Miller 		 * The socket lock must be held while it's corked.
1097db8dac20SDavid S. Miller 		 */
1098db8dac20SDavid S. Miller 		lock_sock(sk);
1099db8dac20SDavid S. Miller 		if (likely(up->pending)) {
1100db8dac20SDavid S. Miller 			if (unlikely(up->pending != AF_INET6)) {
1101db8dac20SDavid S. Miller 				release_sock(sk);
1102db8dac20SDavid S. Miller 				return -EAFNOSUPPORT;
1103db8dac20SDavid S. Miller 			}
1104db8dac20SDavid S. Miller 			dst = NULL;
1105db8dac20SDavid S. Miller 			goto do_append_data;
1106db8dac20SDavid S. Miller 		}
1107db8dac20SDavid S. Miller 		release_sock(sk);
1108db8dac20SDavid S. Miller 	}
1109db8dac20SDavid S. Miller 	ulen += sizeof(struct udphdr);
1110db8dac20SDavid S. Miller 
11114c9483b2SDavid S. Miller 	memset(&fl6, 0, sizeof(fl6));
1112db8dac20SDavid S. Miller 
1113db8dac20SDavid S. Miller 	if (sin6) {
1114db8dac20SDavid S. Miller 		if (sin6->sin6_port == 0)
1115db8dac20SDavid S. Miller 			return -EINVAL;
1116db8dac20SDavid S. Miller 
11171958b856SDavid S. Miller 		fl6.fl6_dport = sin6->sin6_port;
1118db8dac20SDavid S. Miller 		daddr = &sin6->sin6_addr;
1119db8dac20SDavid S. Miller 
1120db8dac20SDavid S. Miller 		if (np->sndflow) {
11214c9483b2SDavid S. Miller 			fl6.flowlabel = sin6->sin6_flowinfo&IPV6_FLOWINFO_MASK;
11224c9483b2SDavid S. Miller 			if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
11234c9483b2SDavid S. Miller 				flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
1124db8dac20SDavid S. Miller 				if (flowlabel == NULL)
1125db8dac20SDavid S. Miller 					return -EINVAL;
1126db8dac20SDavid S. Miller 				daddr = &flowlabel->dst;
1127db8dac20SDavid S. Miller 			}
1128db8dac20SDavid S. Miller 		}
1129db8dac20SDavid S. Miller 
1130db8dac20SDavid S. Miller 		/*
1131db8dac20SDavid S. Miller 		 * Otherwise it will be difficult to maintain
1132db8dac20SDavid S. Miller 		 * sk->sk_dst_cache.
1133db8dac20SDavid S. Miller 		 */
1134db8dac20SDavid S. Miller 		if (sk->sk_state == TCP_ESTABLISHED &&
1135db8dac20SDavid S. Miller 		    ipv6_addr_equal(daddr, &np->daddr))
1136db8dac20SDavid S. Miller 			daddr = &np->daddr;
1137db8dac20SDavid S. Miller 
1138db8dac20SDavid S. Miller 		if (addr_len >= sizeof(struct sockaddr_in6) &&
1139db8dac20SDavid S. Miller 		    sin6->sin6_scope_id &&
1140842df073SHannes Frederic Sowa 		    __ipv6_addr_needs_scope_id(__ipv6_addr_type(daddr)))
11414c9483b2SDavid S. Miller 			fl6.flowi6_oif = sin6->sin6_scope_id;
1142db8dac20SDavid S. Miller 	} else {
1143db8dac20SDavid S. Miller 		if (sk->sk_state != TCP_ESTABLISHED)
1144db8dac20SDavid S. Miller 			return -EDESTADDRREQ;
1145db8dac20SDavid S. Miller 
11461958b856SDavid S. Miller 		fl6.fl6_dport = inet->inet_dport;
1147db8dac20SDavid S. Miller 		daddr = &np->daddr;
11484c9483b2SDavid S. Miller 		fl6.flowlabel = np->flow_label;
1149db8dac20SDavid S. Miller 		connected = 1;
1150db8dac20SDavid S. Miller 	}
1151db8dac20SDavid S. Miller 
11524c9483b2SDavid S. Miller 	if (!fl6.flowi6_oif)
11534c9483b2SDavid S. Miller 		fl6.flowi6_oif = sk->sk_bound_dev_if;
1154db8dac20SDavid S. Miller 
11554c9483b2SDavid S. Miller 	if (!fl6.flowi6_oif)
11564c9483b2SDavid S. Miller 		fl6.flowi6_oif = np->sticky_pktinfo.ipi6_ifindex;
11579f690db7SYang Hongyang 
11584c9483b2SDavid S. Miller 	fl6.flowi6_mark = sk->sk_mark;
115951953d5bSBrian Haley 
1160db8dac20SDavid S. Miller 	if (msg->msg_controllen) {
1161db8dac20SDavid S. Miller 		opt = &opt_space;
1162db8dac20SDavid S. Miller 		memset(opt, 0, sizeof(struct ipv6_txoptions));
1163db8dac20SDavid S. Miller 		opt->tot_len = sizeof(*opt);
1164db8dac20SDavid S. Miller 
116573df66f8STom Parkin 		err = ip6_datagram_send_ctl(sock_net(sk), sk, msg, &fl6, opt,
1166ec0506dbSMaciej Żenczykowski 					    &hlimit, &tclass, &dontfrag);
1167db8dac20SDavid S. Miller 		if (err < 0) {
1168db8dac20SDavid S. Miller 			fl6_sock_release(flowlabel);
1169db8dac20SDavid S. Miller 			return err;
1170db8dac20SDavid S. Miller 		}
11714c9483b2SDavid S. Miller 		if ((fl6.flowlabel&IPV6_FLOWLABEL_MASK) && !flowlabel) {
11724c9483b2SDavid S. Miller 			flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
1173db8dac20SDavid S. Miller 			if (flowlabel == NULL)
1174db8dac20SDavid S. Miller 				return -EINVAL;
1175db8dac20SDavid S. Miller 		}
1176db8dac20SDavid S. Miller 		if (!(opt->opt_nflen|opt->opt_flen))
1177db8dac20SDavid S. Miller 			opt = NULL;
1178db8dac20SDavid S. Miller 		connected = 0;
1179db8dac20SDavid S. Miller 	}
1180db8dac20SDavid S. Miller 	if (opt == NULL)
1181db8dac20SDavid S. Miller 		opt = np->opt;
1182db8dac20SDavid S. Miller 	if (flowlabel)
1183db8dac20SDavid S. Miller 		opt = fl6_merge_options(&opt_space, flowlabel, opt);
1184db8dac20SDavid S. Miller 	opt = ipv6_fixup_options(&opt_space, opt);
1185db8dac20SDavid S. Miller 
11864c9483b2SDavid S. Miller 	fl6.flowi6_proto = sk->sk_protocol;
1187876c7f41SBrian Haley 	if (!ipv6_addr_any(daddr))
11884e3fd7a0SAlexey Dobriyan 		fl6.daddr = *daddr;
1189876c7f41SBrian Haley 	else
11904c9483b2SDavid S. Miller 		fl6.daddr.s6_addr[15] = 0x1; /* :: means loopback (BSD'ism) */
11914c9483b2SDavid S. Miller 	if (ipv6_addr_any(&fl6.saddr) && !ipv6_addr_any(&np->saddr))
11924e3fd7a0SAlexey Dobriyan 		fl6.saddr = np->saddr;
11931958b856SDavid S. Miller 	fl6.fl6_sport = inet->inet_sport;
1194db8dac20SDavid S. Miller 
11954c9483b2SDavid S. Miller 	final_p = fl6_update_dst(&fl6, opt, &final);
119620c59de2SArnaud Ebalard 	if (final_p)
1197db8dac20SDavid S. Miller 		connected = 0;
1198db8dac20SDavid S. Miller 
11994c9483b2SDavid S. Miller 	if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr)) {
12004c9483b2SDavid S. Miller 		fl6.flowi6_oif = np->mcast_oif;
1201db8dac20SDavid S. Miller 		connected = 0;
1202c4062dfcSErich E. Hoover 	} else if (!fl6.flowi6_oif)
1203c4062dfcSErich E. Hoover 		fl6.flowi6_oif = np->ucast_oif;
1204db8dac20SDavid S. Miller 
12054c9483b2SDavid S. Miller 	security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
1206db8dac20SDavid S. Miller 
12074c9483b2SDavid S. Miller 	dst = ip6_sk_dst_lookup_flow(sk, &fl6, final_p, true);
120868d0c6d3SDavid S. Miller 	if (IS_ERR(dst)) {
120968d0c6d3SDavid S. Miller 		err = PTR_ERR(dst);
121068d0c6d3SDavid S. Miller 		dst = NULL;
1211db8dac20SDavid S. Miller 		goto out;
1212db8dac20SDavid S. Miller 	}
1213db8dac20SDavid S. Miller 
1214db8dac20SDavid S. Miller 	if (hlimit < 0) {
12154c9483b2SDavid S. Miller 		if (ipv6_addr_is_multicast(&fl6.daddr))
1216db8dac20SDavid S. Miller 			hlimit = np->mcast_hops;
1217db8dac20SDavid S. Miller 		else
1218db8dac20SDavid S. Miller 			hlimit = np->hop_limit;
1219db8dac20SDavid S. Miller 		if (hlimit < 0)
12206b75d090SYOSHIFUJI Hideaki 			hlimit = ip6_dst_hoplimit(dst);
1221db8dac20SDavid S. Miller 	}
1222db8dac20SDavid S. Miller 
1223db8dac20SDavid S. Miller 	if (tclass < 0)
1224e651f03aSGerrit Renker 		tclass = np->tclass;
1225db8dac20SDavid S. Miller 
122613b52cd4SBrian Haley 	if (dontfrag < 0)
122713b52cd4SBrian Haley 		dontfrag = np->dontfrag;
122813b52cd4SBrian Haley 
1229db8dac20SDavid S. Miller 	if (msg->msg_flags&MSG_CONFIRM)
1230db8dac20SDavid S. Miller 		goto do_confirm;
1231db8dac20SDavid S. Miller back_from_confirm:
1232db8dac20SDavid S. Miller 
1233db8dac20SDavid S. Miller 	lock_sock(sk);
1234db8dac20SDavid S. Miller 	if (unlikely(up->pending)) {
1235db8dac20SDavid S. Miller 		/* The socket is already corked while preparing it. */
1236db8dac20SDavid S. Miller 		/* ... which is an evident application bug. --ANK */
1237db8dac20SDavid S. Miller 		release_sock(sk);
1238db8dac20SDavid S. Miller 
1239db8dac20SDavid S. Miller 		LIMIT_NETDEBUG(KERN_DEBUG "udp cork app bug 2\n");
1240db8dac20SDavid S. Miller 		err = -EINVAL;
1241db8dac20SDavid S. Miller 		goto out;
1242db8dac20SDavid S. Miller 	}
1243db8dac20SDavid S. Miller 
1244db8dac20SDavid S. Miller 	up->pending = AF_INET6;
1245db8dac20SDavid S. Miller 
1246db8dac20SDavid S. Miller do_append_data:
1247db8dac20SDavid S. Miller 	up->len += ulen;
1248db8dac20SDavid S. Miller 	getfrag  =  is_udplite ?  udplite_getfrag : ip_generic_getfrag;
1249db8dac20SDavid S. Miller 	err = ip6_append_data(sk, getfrag, msg->msg_iov, ulen,
12504c9483b2SDavid S. Miller 		sizeof(struct udphdr), hlimit, tclass, opt, &fl6,
1251db8dac20SDavid S. Miller 		(struct rt6_info*)dst,
125213b52cd4SBrian Haley 		corkreq ? msg->msg_flags|MSG_MORE : msg->msg_flags, dontfrag);
1253db8dac20SDavid S. Miller 	if (err)
1254db8dac20SDavid S. Miller 		udp_v6_flush_pending_frames(sk);
1255db8dac20SDavid S. Miller 	else if (!corkreq)
1256db8dac20SDavid S. Miller 		err = udp_v6_push_pending_frames(sk);
1257db8dac20SDavid S. Miller 	else if (unlikely(skb_queue_empty(&sk->sk_write_queue)))
1258db8dac20SDavid S. Miller 		up->pending = 0;
1259db8dac20SDavid S. Miller 
1260db8dac20SDavid S. Miller 	if (dst) {
1261db8dac20SDavid S. Miller 		if (connected) {
1262db8dac20SDavid S. Miller 			ip6_dst_store(sk, dst,
12634c9483b2SDavid S. Miller 				      ipv6_addr_equal(&fl6.daddr, &np->daddr) ?
1264db8dac20SDavid S. Miller 				      &np->daddr : NULL,
1265db8dac20SDavid S. Miller #ifdef CONFIG_IPV6_SUBTREES
12664c9483b2SDavid S. Miller 				      ipv6_addr_equal(&fl6.saddr, &np->saddr) ?
1267db8dac20SDavid S. Miller 				      &np->saddr :
1268db8dac20SDavid S. Miller #endif
1269db8dac20SDavid S. Miller 				      NULL);
1270db8dac20SDavid S. Miller 		} else {
1271db8dac20SDavid S. Miller 			dst_release(dst);
1272db8dac20SDavid S. Miller 		}
1273a3c96089SYOSHIFUJI Hideaki 		dst = NULL;
1274db8dac20SDavid S. Miller 	}
1275db8dac20SDavid S. Miller 
1276db8dac20SDavid S. Miller 	if (err > 0)
1277db8dac20SDavid S. Miller 		err = np->recverr ? net_xmit_errno(err) : 0;
1278db8dac20SDavid S. Miller 	release_sock(sk);
1279db8dac20SDavid S. Miller out:
1280a3c96089SYOSHIFUJI Hideaki 	dst_release(dst);
1281db8dac20SDavid S. Miller 	fl6_sock_release(flowlabel);
1282db8dac20SDavid S. Miller 	if (!err)
1283db8dac20SDavid S. Miller 		return len;
1284db8dac20SDavid S. Miller 	/*
1285db8dac20SDavid S. Miller 	 * ENOBUFS = no kernel mem, SOCK_NOSPACE = no sndbuf space.  Reporting
1286db8dac20SDavid S. Miller 	 * ENOBUFS might not be good (it's not tunable per se), but otherwise
1287db8dac20SDavid S. Miller 	 * we don't have a good statistic (IpOutDiscards but it can be too many
1288db8dac20SDavid S. Miller 	 * things).  We could add another new stat but at least for now that
1289db8dac20SDavid S. Miller 	 * seems like overkill.
1290db8dac20SDavid S. Miller 	 */
1291db8dac20SDavid S. Miller 	if (err == -ENOBUFS || test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
1292235b9f7aSPavel Emelyanov 		UDP6_INC_STATS_USER(sock_net(sk),
1293235b9f7aSPavel Emelyanov 				UDP_MIB_SNDBUFERRORS, is_udplite);
1294db8dac20SDavid S. Miller 	}
1295db8dac20SDavid S. Miller 	return err;
1296db8dac20SDavid S. Miller 
1297db8dac20SDavid S. Miller do_confirm:
1298db8dac20SDavid S. Miller 	dst_confirm(dst);
1299db8dac20SDavid S. Miller 	if (!(msg->msg_flags&MSG_PROBE) || len)
1300db8dac20SDavid S. Miller 		goto back_from_confirm;
1301db8dac20SDavid S. Miller 	err = 0;
1302db8dac20SDavid S. Miller 	goto out;
1303db8dac20SDavid S. Miller }
1304db8dac20SDavid S. Miller 
13057d06b2e0SBrian Haley void udpv6_destroy_sock(struct sock *sk)
1306db8dac20SDavid S. Miller {
130744046a59STom Parkin 	struct udp_sock *up = udp_sk(sk);
1308db8dac20SDavid S. Miller 	lock_sock(sk);
1309db8dac20SDavid S. Miller 	udp_v6_flush_pending_frames(sk);
1310db8dac20SDavid S. Miller 	release_sock(sk);
1311db8dac20SDavid S. Miller 
131244046a59STom Parkin 	if (static_key_false(&udpv6_encap_needed) && up->encap_type) {
131344046a59STom Parkin 		void (*encap_destroy)(struct sock *sk);
131444046a59STom Parkin 		encap_destroy = ACCESS_ONCE(up->encap_destroy);
131544046a59STom Parkin 		if (encap_destroy)
131644046a59STom Parkin 			encap_destroy(sk);
131744046a59STom Parkin 	}
131844046a59STom Parkin 
1319db8dac20SDavid S. Miller 	inet6_destroy_sock(sk);
1320db8dac20SDavid S. Miller }
1321db8dac20SDavid S. Miller 
1322db8dac20SDavid S. Miller /*
1323db8dac20SDavid S. Miller  *	Socket option code for UDP
1324db8dac20SDavid S. Miller  */
1325db8dac20SDavid S. Miller int udpv6_setsockopt(struct sock *sk, int level, int optname,
1326b7058842SDavid S. Miller 		     char __user *optval, unsigned int optlen)
1327db8dac20SDavid S. Miller {
1328db8dac20SDavid S. Miller 	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1329db8dac20SDavid S. Miller 		return udp_lib_setsockopt(sk, level, optname, optval, optlen,
1330db8dac20SDavid S. Miller 					  udp_v6_push_pending_frames);
1331db8dac20SDavid S. Miller 	return ipv6_setsockopt(sk, level, optname, optval, optlen);
1332db8dac20SDavid S. Miller }
1333db8dac20SDavid S. Miller 
1334db8dac20SDavid S. Miller #ifdef CONFIG_COMPAT
1335db8dac20SDavid S. Miller int compat_udpv6_setsockopt(struct sock *sk, int level, int optname,
1336b7058842SDavid S. Miller 			    char __user *optval, unsigned int optlen)
1337db8dac20SDavid S. Miller {
1338db8dac20SDavid S. Miller 	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1339db8dac20SDavid S. Miller 		return udp_lib_setsockopt(sk, level, optname, optval, optlen,
1340db8dac20SDavid S. Miller 					  udp_v6_push_pending_frames);
1341db8dac20SDavid S. Miller 	return compat_ipv6_setsockopt(sk, level, optname, optval, optlen);
1342db8dac20SDavid S. Miller }
1343db8dac20SDavid S. Miller #endif
1344db8dac20SDavid S. Miller 
1345db8dac20SDavid S. Miller int udpv6_getsockopt(struct sock *sk, int level, int optname,
1346db8dac20SDavid S. Miller 		     char __user *optval, int __user *optlen)
1347db8dac20SDavid S. Miller {
1348db8dac20SDavid S. Miller 	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1349db8dac20SDavid S. Miller 		return udp_lib_getsockopt(sk, level, optname, optval, optlen);
1350db8dac20SDavid S. Miller 	return ipv6_getsockopt(sk, level, optname, optval, optlen);
1351db8dac20SDavid S. Miller }
1352db8dac20SDavid S. Miller 
1353db8dac20SDavid S. Miller #ifdef CONFIG_COMPAT
1354db8dac20SDavid S. Miller int compat_udpv6_getsockopt(struct sock *sk, int level, int optname,
1355db8dac20SDavid S. Miller 			    char __user *optval, int __user *optlen)
1356db8dac20SDavid S. Miller {
1357db8dac20SDavid S. Miller 	if (level == SOL_UDP  ||  level == SOL_UDPLITE)
1358db8dac20SDavid S. Miller 		return udp_lib_getsockopt(sk, level, optname, optval, optlen);
1359db8dac20SDavid S. Miller 	return compat_ipv6_getsockopt(sk, level, optname, optval, optlen);
1360db8dac20SDavid S. Miller }
1361db8dac20SDavid S. Miller #endif
1362db8dac20SDavid S. Miller 
136341135cc8SAlexey Dobriyan static const struct inet6_protocol udpv6_protocol = {
1364db8dac20SDavid S. Miller 	.handler	=	udpv6_rcv,
1365db8dac20SDavid S. Miller 	.err_handler	=	udpv6_err,
1366db8dac20SDavid S. Miller 	.flags		=	INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
1367db8dac20SDavid S. Miller };
1368db8dac20SDavid S. Miller 
1369db8dac20SDavid S. Miller /* ------------------------------------------------------------------------ */
1370db8dac20SDavid S. Miller #ifdef CONFIG_PROC_FS
1371db8dac20SDavid S. Miller int udp6_seq_show(struct seq_file *seq, void *v)
1372db8dac20SDavid S. Miller {
137317ef66afSLorenzo Colitti 	if (v == SEQ_START_TOKEN) {
137417ef66afSLorenzo Colitti 		seq_puts(seq, IPV6_SEQ_DGRAM_HEADER);
137517ef66afSLorenzo Colitti 	} else {
137617ef66afSLorenzo Colitti 		int bucket = ((struct udp_iter_state *)seq->private)->bucket;
137717ef66afSLorenzo Colitti 		struct inet_sock *inet = inet_sk(v);
137817ef66afSLorenzo Colitti 		__u16 srcp = ntohs(inet->inet_sport);
137917ef66afSLorenzo Colitti 		__u16 destp = ntohs(inet->inet_dport);
138017ef66afSLorenzo Colitti 		ip6_dgram_sock_seq_show(seq, v, srcp, destp, bucket);
138117ef66afSLorenzo Colitti 	}
1382db8dac20SDavid S. Miller 	return 0;
1383db8dac20SDavid S. Miller }
1384db8dac20SDavid S. Miller 
138573cb88ecSArjan van de Ven static const struct file_operations udp6_afinfo_seq_fops = {
138673cb88ecSArjan van de Ven 	.owner    = THIS_MODULE,
138773cb88ecSArjan van de Ven 	.open     = udp_seq_open,
138873cb88ecSArjan van de Ven 	.read     = seq_read,
138973cb88ecSArjan van de Ven 	.llseek   = seq_lseek,
139073cb88ecSArjan van de Ven 	.release  = seq_release_net
139173cb88ecSArjan van de Ven };
139273cb88ecSArjan van de Ven 
1393db8dac20SDavid S. Miller static struct udp_seq_afinfo udp6_seq_afinfo = {
1394db8dac20SDavid S. Miller 	.name		= "udp6",
1395db8dac20SDavid S. Miller 	.family		= AF_INET6,
1396645ca708SEric Dumazet 	.udp_table	= &udp_table,
139773cb88ecSArjan van de Ven 	.seq_fops	= &udp6_afinfo_seq_fops,
1398dda61925SDenis V. Lunev 	.seq_ops	= {
1399dda61925SDenis V. Lunev 		.show		= udp6_seq_show,
1400dda61925SDenis V. Lunev 	},
1401db8dac20SDavid S. Miller };
1402db8dac20SDavid S. Miller 
14032c8c1e72SAlexey Dobriyan int __net_init udp6_proc_init(struct net *net)
1404db8dac20SDavid S. Miller {
14050c96d8c5SDaniel Lezcano 	return udp_proc_register(net, &udp6_seq_afinfo);
1406db8dac20SDavid S. Miller }
1407db8dac20SDavid S. Miller 
14080c96d8c5SDaniel Lezcano void udp6_proc_exit(struct net *net) {
14090c96d8c5SDaniel Lezcano 	udp_proc_unregister(net, &udp6_seq_afinfo);
1410db8dac20SDavid S. Miller }
1411db8dac20SDavid S. Miller #endif /* CONFIG_PROC_FS */
1412db8dac20SDavid S. Miller 
1413f77d6021SEric Dumazet void udp_v6_clear_sk(struct sock *sk, int size)
1414f77d6021SEric Dumazet {
1415f77d6021SEric Dumazet 	struct inet_sock *inet = inet_sk(sk);
1416f77d6021SEric Dumazet 
1417f77d6021SEric Dumazet 	/* we do not want to clear pinet6 field, because of RCU lookups */
1418f77d6021SEric Dumazet 	sk_prot_clear_portaddr_nulls(sk, offsetof(struct inet_sock, pinet6));
1419f77d6021SEric Dumazet 
1420f77d6021SEric Dumazet 	size -= offsetof(struct inet_sock, pinet6) + sizeof(inet->pinet6);
1421f77d6021SEric Dumazet 	memset(&inet->pinet6 + 1, 0, size);
1422f77d6021SEric Dumazet }
1423f77d6021SEric Dumazet 
1424db8dac20SDavid S. Miller /* ------------------------------------------------------------------------ */
1425db8dac20SDavid S. Miller 
1426db8dac20SDavid S. Miller struct proto udpv6_prot = {
1427db8dac20SDavid S. Miller 	.name		   = "UDPv6",
1428db8dac20SDavid S. Miller 	.owner		   = THIS_MODULE,
1429db8dac20SDavid S. Miller 	.close		   = udp_lib_close,
1430db8dac20SDavid S. Miller 	.connect	   = ip6_datagram_connect,
1431db8dac20SDavid S. Miller 	.disconnect	   = udp_disconnect,
1432db8dac20SDavid S. Miller 	.ioctl		   = udp_ioctl,
1433db8dac20SDavid S. Miller 	.destroy	   = udpv6_destroy_sock,
1434db8dac20SDavid S. Miller 	.setsockopt	   = udpv6_setsockopt,
1435db8dac20SDavid S. Miller 	.getsockopt	   = udpv6_getsockopt,
1436db8dac20SDavid S. Miller 	.sendmsg	   = udpv6_sendmsg,
1437db8dac20SDavid S. Miller 	.recvmsg	   = udpv6_recvmsg,
1438f7ad74feSBenjamin LaHaise 	.backlog_rcv	   = __udpv6_queue_rcv_skb,
1439db8dac20SDavid S. Miller 	.hash		   = udp_lib_hash,
1440db8dac20SDavid S. Miller 	.unhash		   = udp_lib_unhash,
1441719f8358SEric Dumazet 	.rehash		   = udp_v6_rehash,
1442db8dac20SDavid S. Miller 	.get_port	   = udp_v6_get_port,
1443db8dac20SDavid S. Miller 	.memory_allocated  = &udp_memory_allocated,
1444db8dac20SDavid S. Miller 	.sysctl_mem	   = sysctl_udp_mem,
1445db8dac20SDavid S. Miller 	.sysctl_wmem	   = &sysctl_udp_wmem_min,
1446db8dac20SDavid S. Miller 	.sysctl_rmem	   = &sysctl_udp_rmem_min,
1447db8dac20SDavid S. Miller 	.obj_size	   = sizeof(struct udp6_sock),
1448271b72c7SEric Dumazet 	.slab_flags	   = SLAB_DESTROY_BY_RCU,
1449645ca708SEric Dumazet 	.h.udp_table	   = &udp_table,
1450db8dac20SDavid S. Miller #ifdef CONFIG_COMPAT
1451db8dac20SDavid S. Miller 	.compat_setsockopt = compat_udpv6_setsockopt,
1452db8dac20SDavid S. Miller 	.compat_getsockopt = compat_udpv6_getsockopt,
1453db8dac20SDavid S. Miller #endif
1454f77d6021SEric Dumazet 	.clear_sk	   = udp_v6_clear_sk,
1455db8dac20SDavid S. Miller };
1456db8dac20SDavid S. Miller 
1457db8dac20SDavid S. Miller static struct inet_protosw udpv6_protosw = {
1458db8dac20SDavid S. Miller 	.type =      SOCK_DGRAM,
1459db8dac20SDavid S. Miller 	.protocol =  IPPROTO_UDP,
1460db8dac20SDavid S. Miller 	.prot =      &udpv6_prot,
1461db8dac20SDavid S. Miller 	.ops =       &inet6_dgram_ops,
1462db8dac20SDavid S. Miller 	.no_check =  UDP_CSUM_DEFAULT,
1463db8dac20SDavid S. Miller 	.flags =     INET_PROTOSW_PERMANENT,
1464db8dac20SDavid S. Miller };
1465db8dac20SDavid S. Miller 
1466db8dac20SDavid S. Miller 
1467db8dac20SDavid S. Miller int __init udpv6_init(void)
1468db8dac20SDavid S. Miller {
1469db8dac20SDavid S. Miller 	int ret;
1470db8dac20SDavid S. Miller 
14713336288aSVlad Yasevich 	ret = inet6_add_protocol(&udpv6_protocol, IPPROTO_UDP);
14723336288aSVlad Yasevich 	if (ret)
1473c6b641a4SVlad Yasevich 		goto out;
14743336288aSVlad Yasevich 
1475db8dac20SDavid S. Miller 	ret = inet6_register_protosw(&udpv6_protosw);
1476db8dac20SDavid S. Miller 	if (ret)
1477db8dac20SDavid S. Miller 		goto out_udpv6_protocol;
1478db8dac20SDavid S. Miller out:
1479db8dac20SDavid S. Miller 	return ret;
1480db8dac20SDavid S. Miller 
1481db8dac20SDavid S. Miller out_udpv6_protocol:
1482db8dac20SDavid S. Miller 	inet6_del_protocol(&udpv6_protocol, IPPROTO_UDP);
1483db8dac20SDavid S. Miller 	goto out;
1484db8dac20SDavid S. Miller }
1485db8dac20SDavid S. Miller 
1486db8dac20SDavid S. Miller void udpv6_exit(void)
1487db8dac20SDavid S. Miller {
1488db8dac20SDavid S. Miller 	inet6_unregister_protosw(&udpv6_protosw);
1489db8dac20SDavid S. Miller 	inet6_del_protocol(&udpv6_protocol, IPPROTO_UDP);
1490db8dac20SDavid S. Miller }
1491