Branch data Line data Source code
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 : : * Support for INET connection oriented protocols.
7 : : *
8 : : * Authors: See the TCP sources
9 : : *
10 : : * This program is free software; you can redistribute it and/or
11 : : * modify it under the terms of the GNU General Public License
12 : : * as published by the Free Software Foundation; either version
13 : : * 2 of the License, or(at your option) any later version.
14 : : */
15 : :
16 : : #include <linux/module.h>
17 : : #include <linux/jhash.h>
18 : :
19 : : #include <net/inet_connection_sock.h>
20 : : #include <net/inet_hashtables.h>
21 : : #include <net/inet_timewait_sock.h>
22 : : #include <net/ip.h>
23 : : #include <net/route.h>
24 : : #include <net/tcp_states.h>
25 : : #include <net/xfrm.h>
26 : :
27 : : #ifdef INET_CSK_DEBUG
28 : : const char inet_csk_timer_bug_msg[] = "inet_csk BUG: unknown timer value\n";
29 : : EXPORT_SYMBOL(inet_csk_timer_bug_msg);
30 : : #endif
31 : :
32 : : unsigned long *sysctl_local_reserved_ports;
33 : : EXPORT_SYMBOL(sysctl_local_reserved_ports);
34 : :
35 : 80 : void inet_get_local_port_range(struct net *net, int *low, int *high)
36 : : {
37 : : unsigned int seq;
38 : :
39 : : do {
40 : : seq = read_seqbegin(&net->ipv4.sysctl_local_ports.lock);
41 : :
42 : 103 : *low = net->ipv4.sysctl_local_ports.range[0];
43 : 103 : *high = net->ipv4.sysctl_local_ports.range[1];
44 [ - + - + ]: 103 : } while (read_seqretry(&net->ipv4.sysctl_local_ports.lock, seq));
45 : 80 : }
46 : : EXPORT_SYMBOL(inet_get_local_port_range);
47 : :
48 : 0 : int inet_csk_bind_conflict(const struct sock *sk,
49 : : const struct inet_bind_bucket *tb, bool relax)
50 : : {
51 : : struct sock *sk2;
52 : 10 : int reuse = sk->sk_reuse;
53 : 10 : int reuseport = sk->sk_reuseport;
54 : 10 : kuid_t uid = sock_i_uid((struct sock *)sk);
55 : :
56 : : /*
57 : : * Unlike other sk lookup places we do not check
58 : : * for sk_net here, since _all_ the socks listed
59 : : * in tb->owners list belong to the same net - the
60 : : * one this bucket belongs to.
61 : : */
62 : :
63 [ + - ][ + + ]: 20 : sk_for_each_bound(sk2, &tb->owners) {
[ + + ]
64 [ + + ][ + + ]: 13 : if (sk != sk2 &&
65 [ - + ]: 1 : !inet_v6_ipv6only(sk2) &&
66 [ # # ]: 0 : (!sk->sk_bound_dev_if ||
67 [ # # ]: 0 : !sk2->sk_bound_dev_if ||
68 : : sk->sk_bound_dev_if == sk2->sk_bound_dev_if)) {
69 [ + - ][ + - ]: 1 : if ((!reuse || !sk2->sk_reuse ||
[ + - ]
70 [ - ]: 1 : sk2->sk_state == TCP_LISTEN) &&
71 [ # # ][ # # ]: 0 : (!reuseport || !sk2->sk_reuseport ||
72 [ # # ]: 0 : (sk2->sk_state != TCP_TIME_WAIT &&
73 : 0 : !uid_eq(uid, sock_i_uid(sk2))))) {
74 : :
75 [ - ][ # # ]: 0 : if (!sk2->sk_rcv_saddr || !sk->sk_rcv_saddr ||
[ # # ]
76 : : sk2->sk_rcv_saddr == sk->sk_rcv_saddr)
77 : : break;
78 : : }
79 [ # # ][ # # ]: 0 : if (!relax && reuse && sk2->sk_reuse &&
[ # # ]
80 : 0 : sk2->sk_state != TCP_LISTEN) {
81 : :
82 [ # # ][ # # ]: 0 : if (!sk2->sk_rcv_saddr || !sk->sk_rcv_saddr ||
[ # # ]
83 : : sk2->sk_rcv_saddr == sk->sk_rcv_saddr)
84 : : break;
85 : : }
86 : : }
87 : : }
88 : 0 : return sk2 != NULL;
89 : : }
90 : : EXPORT_SYMBOL_GPL(inet_csk_bind_conflict);
91 : :
92 : : /* Obtain a reference to a local port for the given sock,
93 : : * if snum is zero it means select any available local port.
94 : : */
95 : 0 : int inet_csk_get_port(struct sock *sk, unsigned short snum)
96 : : {
97 : 43 : struct inet_hashinfo *hashinfo = sk->sk_prot->h.hashinfo;
98 : : struct inet_bind_hashbucket *head;
99 : : struct inet_bind_bucket *tb;
100 : : int ret, attempts = 5;
101 : : struct net *net = sock_net(sk);
102 : : int smallest_size = -1, smallest_rover;
103 : 43 : kuid_t uid = sock_i_uid(sk);
104 : :
105 : 43 : local_bh_disable();
106 [ + + ]: 43 : if (!snum) {
107 : : int remaining, rover, low, high;
108 : :
109 : : again:
110 : : inet_get_local_port_range(net, &low, &high);
111 : 23 : remaining = (high - low) + 1;
112 : 23 : smallest_rover = rover = net_random() % remaining + low;
113 : :
114 : : smallest_size = -1;
115 : : do {
116 [ + - ]: 23 : if (inet_is_reserved_local_port(rover))
117 : : goto next_nolock;
118 : 69 : head = &hashinfo->bhash[inet_bhashfn(net, rover,
119 : 23 : hashinfo->bhash_size)];
120 : : spin_lock(&head->lock);
121 [ - + ][ # # ]: 23 : inet_bind_bucket_for_each(tb, &head->chain)
[ - + ]
122 [ # # ]: 0 : if (net_eq(ib_net(tb), net) && tb->port == rover) {
123 [ # # ][ # # ]: 0 : if (((tb->fastreuse > 0 &&
124 [ # # ]: 0 : sk->sk_reuse &&
125 [ # # ]: 0 : sk->sk_state != TCP_LISTEN) ||
126 [ # # ]: 0 : (tb->fastreuseport > 0 &&
127 [ # # ]: 0 : sk->sk_reuseport &&
128 [ # # ]: 0 : uid_eq(tb->fastuid, uid))) &&
129 [ # # ]: 0 : (tb->num_owners < smallest_size || smallest_size == -1)) {
130 : : smallest_size = tb->num_owners;
131 : : smallest_rover = rover;
132 [ # # # # ]: 0 : if (atomic_read(&hashinfo->bsockets) > (high - low) + 1 &&
133 : 0 : !inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, false)) {
134 : 0 : snum = smallest_rover;
135 : 0 : goto tb_found;
136 : : }
137 : : }
138 [ # # ]: 0 : if (!inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, false)) {
139 : 0 : snum = rover;
140 : 0 : goto tb_found;
141 : : }
142 : : goto next;
143 : : }
144 : : break;
145 : : next:
146 : : spin_unlock(&head->lock);
147 : : next_nolock:
148 [ # # ]: 0 : if (++rover > high)
149 : : rover = low;
150 [ # # ]: 0 : } while (--remaining > 0);
151 : :
152 : : /* Exhausted local port range during search? It is not
153 : : * possible for us to be holding one of the bind hash
154 : : * locks if this test triggers, because if 'remaining'
155 : : * drops to zero, we broke out of the do/while loop at
156 : : * the top level, not from the 'break;' statement.
157 : : */
158 : : ret = 1;
159 [ - + ]: 23 : if (remaining <= 0) {
160 [ # # ]: 0 : if (smallest_size != -1) {
161 : 0 : snum = smallest_rover;
162 : : goto have_snum;
163 : : }
164 : : goto fail;
165 : : }
166 : : /* OK, here is the one we will use. HEAD is
167 : : * non-NULL and we hold it's mutex.
168 : : */
169 : 23 : snum = rover;
170 : : } else {
171 : : have_snum:
172 : 60 : head = &hashinfo->bhash[inet_bhashfn(net, snum,
173 : 20 : hashinfo->bhash_size)];
174 : : spin_lock(&head->lock);
175 [ + + ][ # # ]: 20 : inet_bind_bucket_for_each(tb, &head->chain)
[ + + ]
176 [ - + ]: 11 : if (net_eq(ib_net(tb), net) && tb->port == snum)
177 : : goto tb_found;
178 : : }
179 : : tb = NULL;
180 : : goto tb_not_found;
181 : : tb_found:
182 [ + - ]: 11 : if (!hlist_empty(&tb->owners)) {
183 [ + - ]: 11 : if (sk->sk_reuse == SK_FORCE_REUSE)
184 : : goto success;
185 : :
186 [ + + ][ + - ]: 11 : if (((tb->fastreuse > 0 &&
187 [ + - ][ - + ]: 11 : sk->sk_reuse && sk->sk_state != TCP_LISTEN) ||
188 [ # # ]: 0 : (tb->fastreuseport > 0 &&
189 [ # # ][ # # ]: 0 : sk->sk_reuseport && uid_eq(tb->fastuid, uid))) &&
190 : : smallest_size == -1) {
191 : : goto success;
192 : : } else {
193 : : ret = 1;
194 [ + + ]: 11 : if (inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, true)) {
195 [ + - ][ - + ]: 2 : if (((sk->sk_reuse && sk->sk_state != TCP_LISTEN) ||
[ # # ]
196 [ # # ]: 0 : (tb->fastreuseport > 0 &&
197 [ # # ][ - + ]: 2 : sk->sk_reuseport && uid_eq(tb->fastuid, uid))) &&
198 [ # # ]: 0 : smallest_size != -1 && --attempts >= 0) {
199 : : spin_unlock(&head->lock);
200 : : goto again;
201 : : }
202 : :
203 : : goto fail_unlock;
204 : : }
205 : : }
206 : : }
207 : : tb_not_found:
208 : : ret = 1;
209 [ + + ][ + - ]: 41 : if (!tb && (tb = inet_bind_bucket_create(hashinfo->bind_bucket_cachep,
210 : : net, head, snum)) == NULL)
211 : : goto fail_unlock;
212 [ + + ]: 41 : if (hlist_empty(&tb->owners)) {
213 [ + + ][ + - ]: 32 : if (sk->sk_reuse && sk->sk_state != TCP_LISTEN)
214 : 1 : tb->fastreuse = 1;
215 : : else
216 : 31 : tb->fastreuse = 0;
217 [ - + ]: 32 : if (sk->sk_reuseport) {
218 : 0 : tb->fastreuseport = 1;
219 : 0 : tb->fastuid = uid;
220 : : } else
221 : 32 : tb->fastreuseport = 0;
222 : : } else {
223 [ + + ][ + - ]: 9 : if (tb->fastreuse &&
224 [ + - ]: 1 : (!sk->sk_reuse || sk->sk_state == TCP_LISTEN))
225 : 1 : tb->fastreuse = 0;
226 [ - + ][ # # ]: 9 : if (tb->fastreuseport &&
227 [ # # ]: 0 : (!sk->sk_reuseport || !uid_eq(tb->fastuid, uid)))
228 : 0 : tb->fastreuseport = 0;
229 : : }
230 : : success:
231 [ + + ]: 41 : if (!inet_csk(sk)->icsk_bind_hash)
232 : 32 : inet_bind_hash(sk, tb, snum);
233 [ - + ]: 41 : WARN_ON(inet_csk(sk)->icsk_bind_hash != tb);
234 : : ret = 0;
235 : :
236 : : fail_unlock:
237 : : spin_unlock(&head->lock);
238 : : fail:
239 : 43 : local_bh_enable();
240 : 43 : return ret;
241 : : }
242 : : EXPORT_SYMBOL_GPL(inet_csk_get_port);
243 : :
244 : : /*
245 : : * Wait for an incoming connection, avoid race conditions. This must be called
246 : : * with the socket locked.
247 : : */
248 : 0 : static int inet_csk_wait_for_connect(struct sock *sk, long timeo)
249 : : {
250 : : struct inet_connection_sock *icsk = inet_csk(sk);
251 : 2 : DEFINE_WAIT(wait);
252 : : int err;
253 : :
254 : : /*
255 : : * True wake-one mechanism for incoming connections: only
256 : : * one process gets woken up, not the 'whole herd'.
257 : : * Since we do not 'race & poll' for established sockets
258 : : * anymore, the common case will execute the loop only once.
259 : : *
260 : : * Subtle issue: "add_wait_queue_exclusive()" will be added
261 : : * after any current non-exclusive waiters, and we know that
262 : : * it will always _stay_ after any new non-exclusive waiters
263 : : * because all non-exclusive waiters are added at the
264 : : * beginning of the wait-queue. As such, it's ok to "drop"
265 : : * our exclusiveness temporarily when we get woken up without
266 : : * having to remove and re-insert us on the wait queue.
267 : : */
268 : : for (;;) {
269 : 2 : prepare_to_wait_exclusive(sk_sleep(sk), &wait,
270 : : TASK_INTERRUPTIBLE);
271 : 2 : release_sock(sk);
272 [ + - ]: 2 : if (reqsk_queue_empty(&icsk->icsk_accept_queue))
273 : 2 : timeo = schedule_timeout(timeo);
274 : : lock_sock(sk);
275 : : err = 0;
276 [ + + ]: 2 : if (!reqsk_queue_empty(&icsk->icsk_accept_queue))
277 : : break;
278 : : err = -EINVAL;
279 [ + - ]: 1 : if (sk->sk_state != TCP_LISTEN)
280 : : break;
281 : : err = sock_intr_errno(timeo);
282 [ - + ]: 1 : if (signal_pending(current))
283 : : break;
284 : : err = -EAGAIN;
285 [ # # ]: 0 : if (!timeo)
286 : : break;
287 : : }
288 : 2 : finish_wait(sk_sleep(sk), &wait);
289 : 2 : return err;
290 : : }
291 : :
292 : : /*
293 : : * This will accept the next outstanding connection.
294 : : */
295 : 0 : struct sock *inet_csk_accept(struct sock *sk, int flags, int *err)
296 : : {
297 : : struct inet_connection_sock *icsk = inet_csk(sk);
298 : 27 : struct request_sock_queue *queue = &icsk->icsk_accept_queue;
299 : : struct sock *newsk;
300 : : struct request_sock *req;
301 : : int error;
302 : :
303 : : lock_sock(sk);
304 : :
305 : : /* We need to make sure that this socket is listening,
306 : : * and that it has something pending.
307 : : */
308 : : error = -EINVAL;
309 [ + + ]: 31 : if (sk->sk_state != TCP_LISTEN)
310 : : goto out_err;
311 : :
312 : : /* Find already established connection */
313 [ + + ]: 27 : if (reqsk_queue_empty(queue)) {
314 : 2 : long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
315 : :
316 : : /* If this is a non blocking socket don't sleep */
317 : : error = -EAGAIN;
318 [ + - ]: 2 : if (!timeo)
319 : : goto out_err;
320 : :
321 : 2 : error = inet_csk_wait_for_connect(sk, timeo);
322 [ + + ]: 2 : if (error)
323 : : goto out_err;
324 : : }
325 : : req = reqsk_queue_remove(queue);
326 : 26 : newsk = req->sk;
327 : :
328 : : sk_acceptq_removed(sk);
329 [ + - ][ - + ]: 26 : if (sk->sk_protocol == IPPROTO_TCP && queue->fastopenq != NULL) {
330 : : spin_lock_bh(&queue->fastopenq->lock);
331 [ # # ]: 0 : if (tcp_rsk(req)->listener) {
332 : : /* We are still waiting for the final ACK from 3WHS
333 : : * so can't free req now. Instead, we set req->sk to
334 : : * NULL to signify that the child socket is taken
335 : : * so reqsk_fastopen_remove() will free the req
336 : : * when 3WHS finishes (or is aborted).
337 : : */
338 : 0 : req->sk = NULL;
339 : : req = NULL;
340 : : }
341 : 0 : spin_unlock_bh(&queue->fastopenq->lock);
342 : : }
343 : : out:
344 : 31 : release_sock(sk);
345 [ + + ]: 31 : if (req)
346 : : __reqsk_free(req);
347 : 31 : return newsk;
348 : : out_err:
349 : : newsk = NULL;
350 : : req = NULL;
351 : 5 : *err = error;
352 : 5 : goto out;
353 : : }
354 : : EXPORT_SYMBOL(inet_csk_accept);
355 : :
356 : : /*
357 : : * Using different timers for retransmit, delayed acks and probes
358 : : * We may wish use just one timer maintaining a list of expire jiffies
359 : : * to optimize.
360 : : */
361 : 0 : void inet_csk_init_xmit_timers(struct sock *sk,
362 : : void (*retransmit_handler)(unsigned long),
363 : : void (*delack_handler)(unsigned long),
364 : : void (*keepalive_handler)(unsigned long))
365 : : {
366 : : struct inet_connection_sock *icsk = inet_csk(sk);
367 : :
368 : 111 : setup_timer(&icsk->icsk_retransmit_timer, retransmit_handler,
369 : : (unsigned long)sk);
370 : 111 : setup_timer(&icsk->icsk_delack_timer, delack_handler,
371 : : (unsigned long)sk);
372 : 111 : setup_timer(&sk->sk_timer, keepalive_handler, (unsigned long)sk);
373 : 111 : icsk->icsk_pending = icsk->icsk_ack.pending = 0;
374 : 111 : }
375 : : EXPORT_SYMBOL(inet_csk_init_xmit_timers);
376 : :
377 : 0 : void inet_csk_clear_xmit_timers(struct sock *sk)
378 : : {
379 : : struct inet_connection_sock *icsk = inet_csk(sk);
380 : :
381 : 156 : icsk->icsk_pending = icsk->icsk_ack.pending = icsk->icsk_ack.blocked = 0;
382 : :
383 : 156 : sk_stop_timer(sk, &icsk->icsk_retransmit_timer);
384 : 156 : sk_stop_timer(sk, &icsk->icsk_delack_timer);
385 : 156 : sk_stop_timer(sk, &sk->sk_timer);
386 : 156 : }
387 : : EXPORT_SYMBOL(inet_csk_clear_xmit_timers);
388 : :
389 : 0 : void inet_csk_delete_keepalive_timer(struct sock *sk)
390 : : {
391 : 37 : sk_stop_timer(sk, &sk->sk_timer);
392 : 28 : }
393 : : EXPORT_SYMBOL(inet_csk_delete_keepalive_timer);
394 : :
395 : 0 : void inet_csk_reset_keepalive_timer(struct sock *sk, unsigned long len)
396 : : {
397 : 127 : sk_reset_timer(sk, &sk->sk_timer, jiffies + len);
398 : 127 : }
399 : : EXPORT_SYMBOL(inet_csk_reset_keepalive_timer);
400 : :
401 : 0 : struct dst_entry *inet_csk_route_req(struct sock *sk,
402 : : struct flowi4 *fl4,
403 : : const struct request_sock *req)
404 : : {
405 : : struct rtable *rt;
406 : : const struct inet_request_sock *ireq = inet_rsk(req);
407 : 28 : struct ip_options_rcu *opt = inet_rsk(req)->opt;
408 : : struct net *net = sock_net(sk);
409 : : int flags = inet_sk_flowi_flags(sk);
410 : :
411 [ - + ]: 28 : flowi4_init_output(fl4, sk->sk_bound_dev_if, sk->sk_mark,
412 : 28 : RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE,
413 : : sk->sk_protocol,
414 : : flags,
415 [ # # ]: 0 : (opt && opt->opt.srr) ? opt->opt.faddr : ireq->ir_rmt_addr,
416 : : ireq->ir_loc_addr, ireq->ir_rmt_port, inet_sk(sk)->inet_sport);
417 : 28 : security_req_classify_flow(req, flowi4_to_flowi(fl4));
418 : 28 : rt = ip_route_output_flow(net, fl4, sk);
419 [ + - ]: 28 : if (IS_ERR(rt))
420 : : goto no_route;
421 [ - + ][ # # ]: 28 : if (opt && opt->opt.is_strictroute && rt->rt_uses_gateway)
[ # # ]
422 : : goto route_err;
423 : 28 : return &rt->dst;
424 : :
425 : : route_err:
426 : : ip_rt_put(rt);
427 : : no_route:
428 : 0 : IP_INC_STATS_BH(net, IPSTATS_MIB_OUTNOROUTES);
429 : 0 : return NULL;
430 : : }
431 : : EXPORT_SYMBOL_GPL(inet_csk_route_req);
432 : :
433 : 0 : struct dst_entry *inet_csk_route_child_sock(struct sock *sk,
434 : : struct sock *newsk,
435 : : const struct request_sock *req)
436 : : {
437 : : const struct inet_request_sock *ireq = inet_rsk(req);
438 : : struct inet_sock *newinet = inet_sk(newsk);
439 : : struct ip_options_rcu *opt;
440 : : struct net *net = sock_net(sk);
441 : : struct flowi4 *fl4;
442 : : struct rtable *rt;
443 : :
444 : 28 : fl4 = &newinet->cork.fl.u.ip4;
445 : :
446 : : rcu_read_lock();
447 : 28 : opt = rcu_dereference(newinet->inet_opt);
448 [ - + ]: 28 : flowi4_init_output(fl4, sk->sk_bound_dev_if, sk->sk_mark,
449 : 28 : RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE,
450 : : sk->sk_protocol, inet_sk_flowi_flags(sk),
451 [ # # ]: 0 : (opt && opt->opt.srr) ? opt->opt.faddr : ireq->ir_rmt_addr,
452 : : ireq->ir_loc_addr, ireq->ir_rmt_port, inet_sk(sk)->inet_sport);
453 : 28 : security_req_classify_flow(req, flowi4_to_flowi(fl4));
454 : 28 : rt = ip_route_output_flow(net, fl4, sk);
455 [ + - ]: 28 : if (IS_ERR(rt))
456 : : goto no_route;
457 [ - + ][ # # ]: 28 : if (opt && opt->opt.is_strictroute && rt->rt_uses_gateway)
[ # # ]
458 : : goto route_err;
459 : : rcu_read_unlock();
460 : 28 : return &rt->dst;
461 : :
462 : : route_err:
463 : : ip_rt_put(rt);
464 : : no_route:
465 : : rcu_read_unlock();
466 : 0 : IP_INC_STATS_BH(net, IPSTATS_MIB_OUTNOROUTES);
467 : 0 : return NULL;
468 : : }
469 : : EXPORT_SYMBOL_GPL(inet_csk_route_child_sock);
470 : :
471 : : static inline u32 inet_synq_hash(const __be32 raddr, const __be16 rport,
472 : : const u32 rnd, const u32 synq_hsize)
473 : : {
474 : 168 : return jhash_2words((__force u32)raddr, (__force u32)rport, rnd) & (synq_hsize - 1);
475 : : }
476 : :
477 : : #if IS_ENABLED(CONFIG_IPV6)
478 : : #define AF_INET_FAMILY(fam) ((fam) == AF_INET)
479 : : #else
480 : : #define AF_INET_FAMILY(fam) 1
481 : : #endif
482 : :
483 : 0 : struct request_sock *inet_csk_search_req(const struct sock *sk,
484 : : struct request_sock ***prevp,
485 : : const __be16 rport, const __be32 raddr,
486 : : const __be32 laddr)
487 : : {
488 : : const struct inet_connection_sock *icsk = inet_csk(sk);
489 : 56 : struct listen_sock *lopt = icsk->icsk_accept_queue.listen_opt;
490 : : struct request_sock *req, **prev;
491 : :
492 [ + + ]: 56 : for (prev = &lopt->syn_table[inet_synq_hash(raddr, rport, lopt->hash_rnd,
493 : : lopt->nr_table_entries)];
494 : 56 : (req = *prev) != NULL;
495 : 0 : prev = &req->dl_next) {
496 : : const struct inet_request_sock *ireq = inet_rsk(req);
497 : :
498 [ + - ][ + - ]: 28 : if (ireq->ir_rmt_port == rport &&
499 [ + - ]: 28 : ireq->ir_rmt_addr == raddr &&
500 [ + - ]: 28 : ireq->ir_loc_addr == laddr &&
501 : 28 : AF_INET_FAMILY(req->rsk_ops->family)) {
502 [ - + ]: 28 : WARN_ON(req->sk);
503 : 28 : *prevp = prev;
504 : 28 : break;
505 : : }
506 : : }
507 : :
508 : 56 : return req;
509 : : }
510 : : EXPORT_SYMBOL_GPL(inet_csk_search_req);
511 : :
512 : 0 : void inet_csk_reqsk_queue_hash_add(struct sock *sk, struct request_sock *req,
513 : : unsigned long timeout)
514 : : {
515 : : struct inet_connection_sock *icsk = inet_csk(sk);
516 : 28 : struct listen_sock *lopt = icsk->icsk_accept_queue.listen_opt;
517 : 28 : const u32 h = inet_synq_hash(inet_rsk(req)->ir_rmt_addr,
518 : : inet_rsk(req)->ir_rmt_port,
519 : : lopt->hash_rnd, lopt->nr_table_entries);
520 : :
521 : : reqsk_queue_hash_req(&icsk->icsk_accept_queue, h, req, timeout);
522 : : inet_csk_reqsk_queue_added(sk, timeout);
523 : 0 : }
524 : : EXPORT_SYMBOL_GPL(inet_csk_reqsk_queue_hash_add);
525 : :
526 : : /* Only thing we need from tcp.h */
527 : : extern int sysctl_tcp_synack_retries;
528 : :
529 : :
530 : : /* Decide when to expire the request and when to resend SYN-ACK */
531 : : static inline void syn_ack_recalc(struct request_sock *req, const int thresh,
532 : : const int max_retries,
533 : : const u8 rskq_defer_accept,
534 : : int *expire, int *resend)
535 : : {
536 [ # # ]: 0 : if (!rskq_defer_accept) {
537 : 0 : *expire = req->num_timeout >= thresh;
538 : : *resend = 1;
539 : : return;
540 : : }
541 [ # # ][ # # ]: 0 : *expire = req->num_timeout >= thresh &&
542 [ # # ]: 0 : (!inet_rsk(req)->acked || req->num_timeout >= max_retries);
543 : : /*
544 : : * Do not resend while waiting for data after ACK,
545 : : * start to resend on end of deferring period to give
546 : : * last chance for data or ACK to create established socket.
547 : : */
548 [ # # ][ # # ]: 0 : *resend = !inet_rsk(req)->acked ||
549 : 0 : req->num_timeout >= rskq_defer_accept - 1;
550 : : }
551 : :
552 : 0 : int inet_rtx_syn_ack(struct sock *parent, struct request_sock *req)
553 : : {
554 : 0 : int err = req->rsk_ops->rtx_syn_ack(parent, req);
555 : :
556 [ # # # # ]: 0 : if (!err)
557 : 0 : req->num_retrans++;
558 : 0 : return err;
559 : : }
560 : : EXPORT_SYMBOL(inet_rtx_syn_ack);
561 : :
562 : 0 : void inet_csk_reqsk_queue_prune(struct sock *parent,
563 : : const unsigned long interval,
564 : : const unsigned long timeout,
565 : : const unsigned long max_rto)
566 : : {
567 : : struct inet_connection_sock *icsk = inet_csk(parent);
568 : 0 : struct request_sock_queue *queue = &icsk->icsk_accept_queue;
569 : 0 : struct listen_sock *lopt = queue->listen_opt;
570 [ # # ]: 0 : int max_retries = icsk->icsk_syn_retries ? : sysctl_tcp_synack_retries;
571 : : int thresh = max_retries;
572 : 0 : unsigned long now = jiffies;
573 : : struct request_sock **reqp, *req;
574 : : int i, budget;
575 : :
576 [ # # ][ # # ]: 0 : if (lopt == NULL || lopt->qlen == 0)
577 : 0 : return;
578 : :
579 : : /* Normally all the openreqs are young and become mature
580 : : * (i.e. converted to established socket) for first timeout.
581 : : * If synack was not acknowledged for 1 second, it means
582 : : * one of the following things: synack was lost, ack was lost,
583 : : * rtt is high or nobody planned to ack (i.e. synflood).
584 : : * When server is a bit loaded, queue is populated with old
585 : : * open requests, reducing effective size of queue.
586 : : * When server is well loaded, queue size reduces to zero
587 : : * after several minutes of work. It is not synflood,
588 : : * it is normal operation. The solution is pruning
589 : : * too old entries overriding normal timeout, when
590 : : * situation becomes dangerous.
591 : : *
592 : : * Essentially, we reserve half of room for young
593 : : * embrions; and abort old ones without pity, if old
594 : : * ones are about to clog our table.
595 : : */
596 [ # # ]: 0 : if (lopt->qlen>>(lopt->max_qlen_log-1)) {
597 : 0 : int young = (lopt->qlen_young<<1);
598 : :
599 [ # # ]: 0 : while (thresh > 2) {
600 [ # # ]: 0 : if (lopt->qlen < young)
601 : : break;
602 : 0 : thresh--;
603 : 0 : young <<= 1;
604 : : }
605 : : }
606 : :
607 [ # # ]: 0 : if (queue->rskq_defer_accept)
608 : 0 : max_retries = queue->rskq_defer_accept;
609 : :
610 : 0 : budget = 2 * (lopt->nr_table_entries / (timeout / interval));
611 : 0 : i = lopt->clock_hand;
612 : :
613 : : do {
614 : 0 : reqp=&lopt->syn_table[i];
615 [ # # ]: 0 : while ((req = *reqp) != NULL) {
616 [ # # ]: 0 : if (time_after_eq(now, req->expires)) {
617 : : int expire = 0, resend = 0;
618 : :
619 : 0 : syn_ack_recalc(req, thresh, max_retries,
620 : : queue->rskq_defer_accept,
621 : : &expire, &resend);
622 : 0 : req->rsk_ops->syn_ack_timeout(parent, req);
623 [ # # ][ # # ]: 0 : if (!expire &&
624 [ # # ]: 0 : (!resend ||
625 [ # # ]: 0 : !inet_rtx_syn_ack(parent, req) ||
626 : 0 : inet_rsk(req)->acked)) {
627 : : unsigned long timeo;
628 : :
629 [ # # ]: 0 : if (req->num_timeout++ == 0)
630 : 0 : lopt->qlen_young--;
631 : 0 : timeo = min(timeout << req->num_timeout,
632 : : max_rto);
633 : 0 : req->expires = now + timeo;
634 : 0 : reqp = &req->dl_next;
635 : 0 : continue;
636 : : }
637 : :
638 : : /* Drop this request */
639 : : inet_csk_reqsk_queue_unlink(parent, req, reqp);
640 : : reqsk_queue_removed(queue, req);
641 : : reqsk_free(req);
642 : 0 : continue;
643 : : }
644 : 0 : reqp = &req->dl_next;
645 : : }
646 : :
647 : 0 : i = (i + 1) & (lopt->nr_table_entries - 1);
648 : :
649 [ # # ]: 0 : } while (--budget > 0);
650 : :
651 : 0 : lopt->clock_hand = i;
652 : :
653 [ # # ]: 0 : if (lopt->qlen)
654 : : inet_csk_reset_keepalive_timer(parent, interval);
655 : : }
656 : : EXPORT_SYMBOL_GPL(inet_csk_reqsk_queue_prune);
657 : :
658 : : /**
659 : : * inet_csk_clone_lock - clone an inet socket, and lock its clone
660 : : * @sk: the socket to clone
661 : : * @req: request_sock
662 : : * @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
663 : : *
664 : : * Caller must unlock socket even in error path (bh_unlock_sock(newsk))
665 : : */
666 : 0 : struct sock *inet_csk_clone_lock(const struct sock *sk,
667 : : const struct request_sock *req,
668 : : const gfp_t priority)
669 : : {
670 : 28 : struct sock *newsk = sk_clone_lock(sk, priority);
671 : :
672 [ + - ]: 28 : if (newsk != NULL) {
673 : : struct inet_connection_sock *newicsk = inet_csk(newsk);
674 : :
675 : 28 : newsk->sk_state = TCP_SYN_RECV;
676 : 28 : newicsk->icsk_bind_hash = NULL;
677 : :
678 : 28 : inet_sk(newsk)->inet_dport = inet_rsk(req)->ir_rmt_port;
679 : 28 : inet_sk(newsk)->inet_num = inet_rsk(req)->ir_num;
680 : 56 : inet_sk(newsk)->inet_sport = htons(inet_rsk(req)->ir_num);
681 : 28 : newsk->sk_write_space = sk_stream_write_space;
682 : :
683 : 28 : newicsk->icsk_retransmits = 0;
684 : 28 : newicsk->icsk_backoff = 0;
685 : 28 : newicsk->icsk_probes_out = 0;
686 : :
687 : : /* Deinitialize accept_queue to trap illegal accesses. */
688 : 28 : memset(&newicsk->icsk_accept_queue, 0, sizeof(newicsk->icsk_accept_queue));
689 : :
690 : 28 : security_inet_csk_clone(newsk, req);
691 : : }
692 : 0 : return newsk;
693 : : }
694 : : EXPORT_SYMBOL_GPL(inet_csk_clone_lock);
695 : :
696 : : /*
697 : : * At this point, there should be no process reference to this
698 : : * socket, and thus no user references at all. Therefore we
699 : : * can assume the socket waitqueue is inactive and nobody will
700 : : * try to jump onto it.
701 : : */
702 : 0 : void inet_csk_destroy_sock(struct sock *sk)
703 : : {
704 [ - + ]: 109 : WARN_ON(sk->sk_state != TCP_CLOSE);
705 [ - + ]: 218 : WARN_ON(!sock_flag(sk, SOCK_DEAD));
706 : :
707 : : /* It cannot be in hash table! */
708 [ - + ]: 109 : WARN_ON(!sk_unhashed(sk));
709 : :
710 : : /* If it has not 0 inet_sk(sk)->inet_num, it must be bound */
711 [ + + ][ + - ]: 109 : WARN_ON(inet_sk(sk)->inet_num && !inet_csk(sk)->icsk_bind_hash);
[ - + ]
712 : :
713 : 109 : sk->sk_prot->destroy(sk);
714 : :
715 : 109 : sk_stream_kill_queues(sk);
716 : :
717 : : xfrm_sk_free_policy(sk);
718 : :
719 : : sk_refcnt_debug_release(sk);
720 : :
721 : 109 : percpu_counter_dec(sk->sk_prot->orphan_count);
722 : : sock_put(sk);
723 : 109 : }
724 : : EXPORT_SYMBOL(inet_csk_destroy_sock);
725 : :
726 : : /* This function allows to force a closure of a socket after the call to
727 : : * tcp/dccp_create_openreq_child().
728 : : */
729 : 0 : void inet_csk_prepare_forced_close(struct sock *sk)
730 : : __releases(&sk->sk_lock.slock)
731 : : {
732 : : /* sk_clone_lock locked the socket and set refcnt to 2 */
733 : : bh_unlock_sock(sk);
734 : : sock_put(sk);
735 : :
736 : : /* The below has to be done to allow calling inet_csk_destroy_sock */
737 : : sock_set_flag(sk, SOCK_DEAD);
738 : 0 : percpu_counter_inc(sk->sk_prot->orphan_count);
739 : 0 : inet_sk(sk)->inet_num = 0;
740 : 0 : }
741 : : EXPORT_SYMBOL(inet_csk_prepare_forced_close);
742 : :
743 : 0 : int inet_csk_listen_start(struct sock *sk, const int nr_table_entries)
744 : : {
745 : : struct inet_sock *inet = inet_sk(sk);
746 : : struct inet_connection_sock *icsk = inet_csk(sk);
747 : 9 : int rc = reqsk_queue_alloc(&icsk->icsk_accept_queue, nr_table_entries);
748 : :
749 [ + - ]: 9 : if (rc != 0)
750 : : return rc;
751 : :
752 : 9 : sk->sk_max_ack_backlog = 0;
753 : 9 : sk->sk_ack_backlog = 0;
754 : : inet_csk_delack_init(sk);
755 : :
756 : : /* There is race window here: we announce ourselves listening,
757 : : * but this transition is still not validated by get_port().
758 : : * It is OK, because this socket enters to hash table only
759 : : * after validation is complete.
760 : : */
761 : 9 : sk->sk_state = TCP_LISTEN;
762 [ + - ]: 9 : if (!sk->sk_prot->get_port(sk, inet->inet_num)) {
763 [ - + ]: 9 : inet->inet_sport = htons(inet->inet_num);
764 : :
765 : : sk_dst_reset(sk);
766 : 9 : sk->sk_prot->hash(sk);
767 : :
768 : 9 : return 0;
769 : : }
770 : :
771 : 0 : sk->sk_state = TCP_CLOSE;
772 : 0 : __reqsk_queue_destroy(&icsk->icsk_accept_queue);
773 : 0 : return -EADDRINUSE;
774 : : }
775 : : EXPORT_SYMBOL_GPL(inet_csk_listen_start);
776 : :
777 : : /*
778 : : * This routine closes sockets which have been at least partially
779 : : * opened, but not yet accepted.
780 : : */
781 : 0 : void inet_csk_listen_stop(struct sock *sk)
782 : : {
783 : : struct inet_connection_sock *icsk = inet_csk(sk);
784 : 9 : struct request_sock_queue *queue = &icsk->icsk_accept_queue;
785 : : struct request_sock *acc_req;
786 : : struct request_sock *req;
787 : :
788 : : inet_csk_delete_keepalive_timer(sk);
789 : :
790 : : /* make all the listen_opt local to us */
791 : : acc_req = reqsk_queue_yank_acceptq(queue);
792 : :
793 : : /* Following specs, it would be better either to send FIN
794 : : * (and enter FIN-WAIT-1, it is normal close)
795 : : * or to send active reset (abort).
796 : : * Certainly, it is pretty dangerous while synflood, but it is
797 : : * bad justification for our negligence 8)
798 : : * To be honest, we are not able to make either
799 : : * of the variants now. --ANK
800 : : */
801 : 9 : reqsk_queue_destroy(queue);
802 : :
803 [ + + ]: 11 : while ((req = acc_req) != NULL) {
804 : 2 : struct sock *child = req->sk;
805 : :
806 : 2 : acc_req = req->dl_next;
807 : :
808 : 2 : local_bh_disable();
809 : : bh_lock_sock(child);
810 [ - + ]: 2 : WARN_ON(sock_owned_by_user(child));
811 : : sock_hold(child);
812 : :
813 : 2 : sk->sk_prot->disconnect(child, O_NONBLOCK);
814 : :
815 : : sock_orphan(child);
816 : :
817 : 2 : percpu_counter_inc(sk->sk_prot->orphan_count);
818 : :
819 [ + - ][ - + ]: 2 : if (sk->sk_protocol == IPPROTO_TCP && tcp_rsk(req)->listener) {
820 [ # # ]: 0 : BUG_ON(tcp_sk(child)->fastopen_rsk != req);
821 [ # # ]: 0 : BUG_ON(sk != tcp_rsk(req)->listener);
822 : :
823 : : /* Paranoid, to prevent race condition if
824 : : * an inbound pkt destined for child is
825 : : * blocked by sock lock in tcp_v4_rcv().
826 : : * Also to satisfy an assertion in
827 : : * tcp_v4_destroy_sock().
828 : : */
829 : 0 : tcp_sk(child)->fastopen_rsk = NULL;
830 : : sock_put(sk);
831 : : }
832 : 2 : inet_csk_destroy_sock(child);
833 : :
834 : : bh_unlock_sock(child);
835 : 2 : local_bh_enable();
836 : : sock_put(child);
837 : :
838 : : sk_acceptq_removed(sk);
839 : : __reqsk_free(req);
840 : : }
841 [ - + ]: 9 : if (queue->fastopenq != NULL) {
842 : : /* Free all the reqs queued in rskq_rst_head. */
843 : : spin_lock_bh(&queue->fastopenq->lock);
844 : 0 : acc_req = queue->fastopenq->rskq_rst_head;
845 : 0 : queue->fastopenq->rskq_rst_head = NULL;
846 : 0 : spin_unlock_bh(&queue->fastopenq->lock);
847 [ # # ]: 0 : while ((req = acc_req) != NULL) {
848 : 0 : acc_req = req->dl_next;
849 : : __reqsk_free(req);
850 : : }
851 : : }
852 [ - + ]: 9 : WARN_ON(sk->sk_ack_backlog);
853 : 9 : }
854 : : EXPORT_SYMBOL_GPL(inet_csk_listen_stop);
855 : :
856 : 0 : void inet_csk_addr2sockaddr(struct sock *sk, struct sockaddr *uaddr)
857 : : {
858 : : struct sockaddr_in *sin = (struct sockaddr_in *)uaddr;
859 : : const struct inet_sock *inet = inet_sk(sk);
860 : :
861 : 0 : sin->sin_family = AF_INET;
862 : 0 : sin->sin_addr.s_addr = inet->inet_daddr;
863 : 0 : sin->sin_port = inet->inet_dport;
864 : 0 : }
865 : : EXPORT_SYMBOL_GPL(inet_csk_addr2sockaddr);
866 : :
867 : : #ifdef CONFIG_COMPAT
868 : : int inet_csk_compat_getsockopt(struct sock *sk, int level, int optname,
869 : : char __user *optval, int __user *optlen)
870 : : {
871 : : const struct inet_connection_sock *icsk = inet_csk(sk);
872 : :
873 : : if (icsk->icsk_af_ops->compat_getsockopt != NULL)
874 : : return icsk->icsk_af_ops->compat_getsockopt(sk, level, optname,
875 : : optval, optlen);
876 : : return icsk->icsk_af_ops->getsockopt(sk, level, optname,
877 : : optval, optlen);
878 : : }
879 : : EXPORT_SYMBOL_GPL(inet_csk_compat_getsockopt);
880 : :
881 : : int inet_csk_compat_setsockopt(struct sock *sk, int level, int optname,
882 : : char __user *optval, unsigned int optlen)
883 : : {
884 : : const struct inet_connection_sock *icsk = inet_csk(sk);
885 : :
886 : : if (icsk->icsk_af_ops->compat_setsockopt != NULL)
887 : : return icsk->icsk_af_ops->compat_setsockopt(sk, level, optname,
888 : : optval, optlen);
889 : : return icsk->icsk_af_ops->setsockopt(sk, level, optname,
890 : : optval, optlen);
891 : : }
892 : : EXPORT_SYMBOL_GPL(inet_csk_compat_setsockopt);
893 : : #endif
894 : :
895 : 0 : static struct dst_entry *inet_csk_rebuild_route(struct sock *sk, struct flowi *fl)
896 : : {
897 : : const struct inet_sock *inet = inet_sk(sk);
898 : : const struct ip_options_rcu *inet_opt;
899 : 0 : __be32 daddr = inet->inet_daddr;
900 : : struct flowi4 *fl4;
901 : : struct rtable *rt;
902 : :
903 : : rcu_read_lock();
904 : 0 : inet_opt = rcu_dereference(inet->inet_opt);
905 [ # # ][ # # ]: 0 : if (inet_opt && inet_opt->opt.srr)
906 : 0 : daddr = inet_opt->opt.faddr;
907 : 0 : fl4 = &fl->u.ip4;
908 : 0 : rt = ip_route_output_ports(sock_net(sk), fl4, sk, daddr,
909 : : inet->inet_saddr, inet->inet_dport,
910 : : inet->inet_sport, sk->sk_protocol,
911 : 0 : RT_CONN_FLAGS(sk), sk->sk_bound_dev_if);
912 [ # # ]: 0 : if (IS_ERR(rt))
913 : : rt = NULL;
914 [ # # ]: 0 : if (rt)
915 : 0 : sk_setup_caps(sk, &rt->dst);
916 : : rcu_read_unlock();
917 : :
918 : 0 : return &rt->dst;
919 : : }
920 : :
921 : 0 : struct dst_entry *inet_csk_update_pmtu(struct sock *sk, u32 mtu)
922 : : {
923 : 0 : struct dst_entry *dst = __sk_dst_check(sk, 0);
924 : : struct inet_sock *inet = inet_sk(sk);
925 : :
926 [ # # ]: 0 : if (!dst) {
927 : 0 : dst = inet_csk_rebuild_route(sk, &inet->cork.fl);
928 [ # # ]: 0 : if (!dst)
929 : : goto out;
930 : : }
931 : 0 : dst->ops->update_pmtu(dst, sk, NULL, mtu);
932 : :
933 : 0 : dst = __sk_dst_check(sk, 0);
934 [ # # ]: 0 : if (!dst)
935 : 0 : dst = inet_csk_rebuild_route(sk, &inet->cork.fl);
936 : : out:
937 : 0 : return dst;
938 : : }
939 : : EXPORT_SYMBOL_GPL(inet_csk_update_pmtu);
|
