~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/ipv6/inet6_hashtables.c

Version: ~ [ linux-5.5-rc6 ] ~ [ linux-5.4.11 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.95 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.164 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.209 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.209 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * INET         An implementation of the TCP/IP protocol suite for the LINUX
  3  *              operating system.  INET is implemented using the BSD Socket
  4  *              interface as the means of communication with the user level.
  5  *
  6  *              Generic INET6 transport hashtables
  7  *
  8  * Authors:     Lotsa people, from code originally in tcp, generalised here
  9  *              by Arnaldo Carvalho de Melo <acme@mandriva.com>
 10  *
 11  *      This program is free software; you can redistribute it and/or
 12  *      modify it under the terms of the GNU General Public License
 13  *      as published by the Free Software Foundation; either version
 14  *      2 of the License, or (at your option) any later version.
 15  */
 16 
 17 #include <linux/module.h>
 18 #include <linux/random.h>
 19 
 20 #include <net/addrconf.h>
 21 #include <net/inet_connection_sock.h>
 22 #include <net/inet_hashtables.h>
 23 #include <net/inet6_hashtables.h>
 24 #include <net/secure_seq.h>
 25 #include <net/ip.h>
 26 #include <net/sock_reuseport.h>
 27 
 28 u32 inet6_ehashfn(const struct net *net,
 29                   const struct in6_addr *laddr, const u16 lport,
 30                   const struct in6_addr *faddr, const __be16 fport)
 31 {
 32         static u32 inet6_ehash_secret __read_mostly;
 33         static u32 ipv6_hash_secret __read_mostly;
 34 
 35         u32 lhash, fhash;
 36 
 37         net_get_random_once(&inet6_ehash_secret, sizeof(inet6_ehash_secret));
 38         net_get_random_once(&ipv6_hash_secret, sizeof(ipv6_hash_secret));
 39 
 40         lhash = (__force u32)laddr->s6_addr32[3];
 41         fhash = __ipv6_addr_jhash(faddr, ipv6_hash_secret);
 42 
 43         return __inet6_ehashfn(lhash, lport, fhash, fport,
 44                                inet6_ehash_secret + net_hash_mix(net));
 45 }
 46 
 47 /*
 48  * Sockets in TCP_CLOSE state are _always_ taken out of the hash, so
 49  * we need not check it for TCP lookups anymore, thanks Alexey. -DaveM
 50  *
 51  * The sockhash lock must be held as a reader here.
 52  */
 53 struct sock *__inet6_lookup_established(struct net *net,
 54                                         struct inet_hashinfo *hashinfo,
 55                                            const struct in6_addr *saddr,
 56                                            const __be16 sport,
 57                                            const struct in6_addr *daddr,
 58                                            const u16 hnum,
 59                                            const int dif)
 60 {
 61         struct sock *sk;
 62         const struct hlist_nulls_node *node;
 63         const __portpair ports = INET_COMBINED_PORTS(sport, hnum);
 64         /* Optimize here for direct hit, only listening connections can
 65          * have wildcards anyways.
 66          */
 67         unsigned int hash = inet6_ehashfn(net, daddr, hnum, saddr, sport);
 68         unsigned int slot = hash & hashinfo->ehash_mask;
 69         struct inet_ehash_bucket *head = &hashinfo->ehash[slot];
 70 
 71 
 72         rcu_read_lock();
 73 begin:
 74         sk_nulls_for_each_rcu(sk, node, &head->chain) {
 75                 if (sk->sk_hash != hash)
 76                         continue;
 77                 if (!INET6_MATCH(sk, net, saddr, daddr, ports, dif))
 78                         continue;
 79                 if (unlikely(!atomic_inc_not_zero(&sk->sk_refcnt)))
 80                         goto out;
 81 
 82                 if (unlikely(!INET6_MATCH(sk, net, saddr, daddr, ports, dif))) {
 83                         sock_gen_put(sk);
 84                         goto begin;
 85                 }
 86                 goto found;
 87         }
 88         if (get_nulls_value(node) != slot)
 89                 goto begin;
 90 out:
 91         sk = NULL;
 92 found:
 93         rcu_read_unlock();
 94         return sk;
 95 }
 96 EXPORT_SYMBOL(__inet6_lookup_established);
 97 
 98 static inline int compute_score(struct sock *sk, struct net *net,
 99                                 const unsigned short hnum,
100                                 const struct in6_addr *daddr,
101                                 const int dif)
102 {
103         int score = -1;
104 
105         if (net_eq(sock_net(sk), net) && inet_sk(sk)->inet_num == hnum &&
106             sk->sk_family == PF_INET6) {
107 
108                 score = 1;
109                 if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr)) {
110                         if (!ipv6_addr_equal(&sk->sk_v6_rcv_saddr, daddr))
111                                 return -1;
112                         score++;
113                 }
114                 if (sk->sk_bound_dev_if) {
115                         if (sk->sk_bound_dev_if != dif)
116                                 return -1;
117                         score++;
118                 }
119                 if (sk->sk_incoming_cpu == raw_smp_processor_id())
120                         score++;
121         }
122         return score;
123 }
124 
125 struct sock *inet6_lookup_listener(struct net *net,
126                 struct inet_hashinfo *hashinfo,
127                 struct sk_buff *skb, int doff,
128                 const struct in6_addr *saddr,
129                 const __be16 sport, const struct in6_addr *daddr,
130                 const unsigned short hnum, const int dif)
131 {
132         struct sock *sk;
133         const struct hlist_nulls_node *node;
134         struct sock *result;
135         int score, hiscore, matches = 0, reuseport = 0;
136         bool select_ok = true;
137         u32 phash = 0;
138         unsigned int hash = inet_lhashfn(net, hnum);
139         struct inet_listen_hashbucket *ilb = &hashinfo->listening_hash[hash];
140 
141         rcu_read_lock();
142 begin:
143         result = NULL;
144         hiscore = 0;
145         sk_nulls_for_each(sk, node, &ilb->head) {
146                 score = compute_score(sk, net, hnum, daddr, dif);
147                 if (score > hiscore) {
148                         hiscore = score;
149                         result = sk;
150                         reuseport = sk->sk_reuseport;
151                         if (reuseport) {
152                                 phash = inet6_ehashfn(net, daddr, hnum,
153                                                       saddr, sport);
154                                 if (select_ok) {
155                                         struct sock *sk2;
156                                         sk2 = reuseport_select_sock(sk, phash,
157                                                                     skb, doff);
158                                         if (sk2) {
159                                                 result = sk2;
160                                                 goto found;
161                                         }
162                                 }
163                                 matches = 1;
164                         }
165                 } else if (score == hiscore && reuseport) {
166                         matches++;
167                         if (reciprocal_scale(phash, matches) == 0)
168                                 result = sk;
169                         phash = next_pseudo_random32(phash);
170                 }
171         }
172         /*
173          * if the nulls value we got at the end of this lookup is
174          * not the expected one, we must restart lookup.
175          * We probably met an item that was moved to another chain.
176          */
177         if (get_nulls_value(node) != hash + LISTENING_NULLS_BASE)
178                 goto begin;
179         if (result) {
180 found:
181                 if (unlikely(!atomic_inc_not_zero(&result->sk_refcnt)))
182                         result = NULL;
183                 else if (unlikely(compute_score(result, net, hnum, daddr,
184                                   dif) < hiscore)) {
185                         sock_put(result);
186                         select_ok = false;
187                         goto begin;
188                 }
189         }
190         rcu_read_unlock();
191         return result;
192 }
193 EXPORT_SYMBOL_GPL(inet6_lookup_listener);
194 
195 struct sock *inet6_lookup(struct net *net, struct inet_hashinfo *hashinfo,
196                           struct sk_buff *skb, int doff,
197                           const struct in6_addr *saddr, const __be16 sport,
198                           const struct in6_addr *daddr, const __be16 dport,
199                           const int dif)
200 {
201         struct sock *sk;
202 
203         local_bh_disable();
204         sk = __inet6_lookup(net, hashinfo, skb, doff, saddr, sport, daddr,
205                             ntohs(dport), dif);
206         local_bh_enable();
207 
208         return sk;
209 }
210 EXPORT_SYMBOL_GPL(inet6_lookup);
211 
212 static int __inet6_check_established(struct inet_timewait_death_row *death_row,
213                                      struct sock *sk, const __u16 lport,
214                                      struct inet_timewait_sock **twp)
215 {
216         struct inet_hashinfo *hinfo = death_row->hashinfo;
217         struct inet_sock *inet = inet_sk(sk);
218         const struct in6_addr *daddr = &sk->sk_v6_rcv_saddr;
219         const struct in6_addr *saddr = &sk->sk_v6_daddr;
220         const int dif = sk->sk_bound_dev_if;
221         const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport);
222         struct net *net = sock_net(sk);
223         const unsigned int hash = inet6_ehashfn(net, daddr, lport, saddr,
224                                                 inet->inet_dport);
225         struct inet_ehash_bucket *head = inet_ehash_bucket(hinfo, hash);
226         spinlock_t *lock = inet_ehash_lockp(hinfo, hash);
227         struct sock *sk2;
228         const struct hlist_nulls_node *node;
229         struct inet_timewait_sock *tw = NULL;
230 
231         spin_lock(lock);
232 
233         sk_nulls_for_each(sk2, node, &head->chain) {
234                 if (sk2->sk_hash != hash)
235                         continue;
236 
237                 if (likely(INET6_MATCH(sk2, net, saddr, daddr, ports, dif))) {
238                         if (sk2->sk_state == TCP_TIME_WAIT) {
239                                 tw = inet_twsk(sk2);
240                                 if (twsk_unique(sk, sk2, twp))
241                                         break;
242                         }
243                         goto not_unique;
244                 }
245         }
246 
247         /* Must record num and sport now. Otherwise we will see
248          * in hash table socket with a funny identity.
249          */
250         inet->inet_num = lport;
251         inet->inet_sport = htons(lport);
252         sk->sk_hash = hash;
253         WARN_ON(!sk_unhashed(sk));
254         __sk_nulls_add_node_rcu(sk, &head->chain);
255         if (tw) {
256                 sk_nulls_del_node_init_rcu((struct sock *)tw);
257                 NET_INC_STATS_BH(net, LINUX_MIB_TIMEWAITRECYCLED);
258         }
259         spin_unlock(lock);
260         sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
261 
262         if (twp) {
263                 *twp = tw;
264         } else if (tw) {
265                 /* Silly. Should hash-dance instead... */
266                 inet_twsk_deschedule_put(tw);
267         }
268         return 0;
269 
270 not_unique:
271         spin_unlock(lock);
272         return -EADDRNOTAVAIL;
273 }
274 
275 static u32 inet6_sk_port_offset(const struct sock *sk)
276 {
277         const struct inet_sock *inet = inet_sk(sk);
278 
279         return secure_ipv6_port_ephemeral(sk->sk_v6_rcv_saddr.s6_addr32,
280                                           sk->sk_v6_daddr.s6_addr32,
281                                           inet->inet_dport);
282 }
283 
284 int inet6_hash_connect(struct inet_timewait_death_row *death_row,
285                        struct sock *sk)
286 {
287         u32 port_offset = 0;
288 
289         if (!inet_sk(sk)->inet_num)
290                 port_offset = inet6_sk_port_offset(sk);
291         return __inet_hash_connect(death_row, sk, port_offset,
292                                    __inet6_check_established);
293 }
294 EXPORT_SYMBOL_GPL(inet6_hash_connect);
295 
296 int inet6_hash(struct sock *sk)
297 {
298         if (sk->sk_state != TCP_CLOSE) {
299                 local_bh_disable();
300                 __inet_hash(sk, NULL, ipv6_rcv_saddr_equal);
301                 local_bh_enable();
302         }
303 
304         return 0;
305 }
306 EXPORT_SYMBOL_GPL(inet6_hash);
307 
308 /* match_wildcard == true:  IPV6_ADDR_ANY equals to any IPv6 addresses if IPv6
309  *                          only, and any IPv4 addresses if not IPv6 only
310  * match_wildcard == false: addresses must be exactly the same, i.e.
311  *                          IPV6_ADDR_ANY only equals to IPV6_ADDR_ANY,
312  *                          and 0.0.0.0 equals to 0.0.0.0 only
313  */
314 int ipv6_rcv_saddr_equal(const struct sock *sk, const struct sock *sk2,
315                          bool match_wildcard)
316 {
317         const struct in6_addr *sk2_rcv_saddr6 = inet6_rcv_saddr(sk2);
318         int sk2_ipv6only = inet_v6_ipv6only(sk2);
319         int addr_type = ipv6_addr_type(&sk->sk_v6_rcv_saddr);
320         int addr_type2 = sk2_rcv_saddr6 ? ipv6_addr_type(sk2_rcv_saddr6) : IPV6_ADDR_MAPPED;
321 
322         /* if both are mapped, treat as IPv4 */
323         if (addr_type == IPV6_ADDR_MAPPED && addr_type2 == IPV6_ADDR_MAPPED) {
324                 if (!sk2_ipv6only) {
325                         if (sk->sk_rcv_saddr == sk2->sk_rcv_saddr)
326                                 return 1;
327                         if (!sk->sk_rcv_saddr || !sk2->sk_rcv_saddr)
328                                 return match_wildcard;
329                 }
330                 return 0;
331         }
332 
333         if (addr_type == IPV6_ADDR_ANY && addr_type2 == IPV6_ADDR_ANY)
334                 return 1;
335 
336         if (addr_type2 == IPV6_ADDR_ANY && match_wildcard &&
337             !(sk2_ipv6only && addr_type == IPV6_ADDR_MAPPED))
338                 return 1;
339 
340         if (addr_type == IPV6_ADDR_ANY && match_wildcard &&
341             !(ipv6_only_sock(sk) && addr_type2 == IPV6_ADDR_MAPPED))
342                 return 1;
343 
344         if (sk2_rcv_saddr6 &&
345             ipv6_addr_equal(&sk->sk_v6_rcv_saddr, sk2_rcv_saddr6))
346                 return 1;
347 
348         return 0;
349 }
350 EXPORT_SYMBOL_GPL(ipv6_rcv_saddr_equal);
351 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp