Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 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 | |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 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> |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 25 | #include <net/xfrm.h> |
Eric Dumazet | fa76ce73 | 2015-03-19 19:04:20 -0700 | [diff] [blame] | 26 | #include <net/tcp.h> |
Craig Gallek | c125e80 | 2016-02-10 11:50:40 -0500 | [diff] [blame] | 27 | #include <net/sock_reuseport.h> |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 28 | |
| 29 | #ifdef INET_CSK_DEBUG |
| 30 | const char inet_csk_timer_bug_msg[] = "inet_csk BUG: unknown timer value\n"; |
| 31 | EXPORT_SYMBOL(inet_csk_timer_bug_msg); |
| 32 | #endif |
| 33 | |
Eric W. Biederman | 0bbf87d | 2013-09-28 14:10:59 -0700 | [diff] [blame] | 34 | void inet_get_local_port_range(struct net *net, int *low, int *high) |
Stephen Hemminger | 227b60f | 2007-10-10 17:30:46 -0700 | [diff] [blame] | 35 | { |
Eric Dumazet | 95c9617 | 2012-04-15 05:58:06 +0000 | [diff] [blame] | 36 | unsigned int seq; |
| 37 | |
Stephen Hemminger | 227b60f | 2007-10-10 17:30:46 -0700 | [diff] [blame] | 38 | do { |
Cong Wang | c9d8f1a | 2014-05-06 11:02:49 -0700 | [diff] [blame] | 39 | seq = read_seqbegin(&net->ipv4.ip_local_ports.lock); |
Stephen Hemminger | 227b60f | 2007-10-10 17:30:46 -0700 | [diff] [blame] | 40 | |
Cong Wang | c9d8f1a | 2014-05-06 11:02:49 -0700 | [diff] [blame] | 41 | *low = net->ipv4.ip_local_ports.range[0]; |
| 42 | *high = net->ipv4.ip_local_ports.range[1]; |
| 43 | } while (read_seqretry(&net->ipv4.ip_local_ports.lock, seq)); |
Stephen Hemminger | 227b60f | 2007-10-10 17:30:46 -0700 | [diff] [blame] | 44 | } |
| 45 | EXPORT_SYMBOL(inet_get_local_port_range); |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 46 | |
Arnaldo Carvalho de Melo | 971af18 | 2005-12-13 23:14:47 -0800 | [diff] [blame] | 47 | int inet_csk_bind_conflict(const struct sock *sk, |
Alex Copot | aacd928 | 2012-04-12 22:21:45 +0000 | [diff] [blame] | 48 | const struct inet_bind_bucket *tb, bool relax) |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 49 | { |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 50 | struct sock *sk2; |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 51 | int reuse = sk->sk_reuse; |
Tom Herbert | da5e363 | 2013-01-22 09:50:24 +0000 | [diff] [blame] | 52 | int reuseport = sk->sk_reuseport; |
| 53 | kuid_t uid = sock_i_uid((struct sock *)sk); |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 54 | |
Pavel Emelyanov | 7477fd2e | 2008-04-14 02:42:27 -0700 | [diff] [blame] | 55 | /* |
| 56 | * Unlike other sk lookup places we do not check |
| 57 | * for sk_net here, since _all_ the socks listed |
| 58 | * in tb->owners list belong to the same net - the |
| 59 | * one this bucket belongs to. |
| 60 | */ |
| 61 | |
Sasha Levin | b67bfe0 | 2013-02-27 17:06:00 -0800 | [diff] [blame] | 62 | sk_for_each_bound(sk2, &tb->owners) { |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 63 | if (sk != sk2 && |
| 64 | !inet_v6_ipv6only(sk2) && |
| 65 | (!sk->sk_bound_dev_if || |
| 66 | !sk2->sk_bound_dev_if || |
| 67 | sk->sk_bound_dev_if == sk2->sk_bound_dev_if)) { |
Tom Herbert | da5e363 | 2013-01-22 09:50:24 +0000 | [diff] [blame] | 68 | if ((!reuse || !sk2->sk_reuse || |
| 69 | sk2->sk_state == TCP_LISTEN) && |
| 70 | (!reuseport || !sk2->sk_reuseport || |
Craig Gallek | c125e80 | 2016-02-10 11:50:40 -0500 | [diff] [blame] | 71 | rcu_access_pointer(sk->sk_reuseport_cb) || |
| 72 | (sk2->sk_state != TCP_TIME_WAIT && |
Tom Herbert | da5e363 | 2013-01-22 09:50:24 +0000 | [diff] [blame] | 73 | !uid_eq(uid, sock_i_uid(sk2))))) { |
Eric Dumazet | 5080546 | 2013-10-02 04:29:50 -0700 | [diff] [blame] | 74 | |
| 75 | if (!sk2->sk_rcv_saddr || !sk->sk_rcv_saddr || |
| 76 | sk2->sk_rcv_saddr == sk->sk_rcv_saddr) |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 77 | break; |
David S. Miller | 8d238b2 | 2010-04-28 11:25:59 -0700 | [diff] [blame] | 78 | } |
Alex Copot | aacd928 | 2012-04-12 22:21:45 +0000 | [diff] [blame] | 79 | if (!relax && reuse && sk2->sk_reuse && |
| 80 | sk2->sk_state != TCP_LISTEN) { |
Alex Copot | aacd928 | 2012-04-12 22:21:45 +0000 | [diff] [blame] | 81 | |
Eric Dumazet | 5080546 | 2013-10-02 04:29:50 -0700 | [diff] [blame] | 82 | if (!sk2->sk_rcv_saddr || !sk->sk_rcv_saddr || |
| 83 | sk2->sk_rcv_saddr == sk->sk_rcv_saddr) |
Alex Copot | aacd928 | 2012-04-12 22:21:45 +0000 | [diff] [blame] | 84 | break; |
| 85 | } |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 86 | } |
| 87 | } |
Sasha Levin | b67bfe0 | 2013-02-27 17:06:00 -0800 | [diff] [blame] | 88 | return sk2 != NULL; |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 89 | } |
Arnaldo Carvalho de Melo | 971af18 | 2005-12-13 23:14:47 -0800 | [diff] [blame] | 90 | EXPORT_SYMBOL_GPL(inet_csk_bind_conflict); |
| 91 | |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 92 | /* Obtain a reference to a local port for the given sock, |
| 93 | * if snum is zero it means select any available local port. |
Eric Dumazet | ea8add2 | 2016-02-11 16:28:50 -0800 | [diff] [blame] | 94 | * We try to allocate an odd port (and leave even ports for connect()) |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 95 | */ |
Arnaldo Carvalho de Melo | ab1e0a1 | 2008-02-03 04:06:04 -0800 | [diff] [blame] | 96 | int inet_csk_get_port(struct sock *sk, unsigned short snum) |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 97 | { |
Eric Dumazet | ea8add2 | 2016-02-11 16:28:50 -0800 | [diff] [blame] | 98 | bool reuse = sk->sk_reuse && sk->sk_state != TCP_LISTEN; |
| 99 | struct inet_hashinfo *hinfo = sk->sk_prot->h.hashinfo; |
| 100 | int ret = 1, attempts = 5, port = snum; |
| 101 | int smallest_size = -1, smallest_port; |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 102 | struct inet_bind_hashbucket *head; |
YOSHIFUJI Hideaki | 3b1e0a6 | 2008-03-26 02:26:21 +0900 | [diff] [blame] | 103 | struct net *net = sock_net(sk); |
Eric Dumazet | ea8add2 | 2016-02-11 16:28:50 -0800 | [diff] [blame] | 104 | int i, low, high, attempt_half; |
| 105 | struct inet_bind_bucket *tb; |
Tom Herbert | da5e363 | 2013-01-22 09:50:24 +0000 | [diff] [blame] | 106 | kuid_t uid = sock_i_uid(sk); |
Eric Dumazet | ea8add2 | 2016-02-11 16:28:50 -0800 | [diff] [blame] | 107 | u32 remaining, offset; |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 108 | |
Eric Dumazet | ea8add2 | 2016-02-11 16:28:50 -0800 | [diff] [blame] | 109 | if (port) { |
| 110 | have_port: |
| 111 | head = &hinfo->bhash[inet_bhashfn(net, port, |
| 112 | hinfo->bhash_size)]; |
| 113 | spin_lock_bh(&head->lock); |
Sasha Levin | b67bfe0 | 2013-02-27 17:06:00 -0800 | [diff] [blame] | 114 | inet_bind_bucket_for_each(tb, &head->chain) |
Eric Dumazet | ea8add2 | 2016-02-11 16:28:50 -0800 | [diff] [blame] | 115 | if (net_eq(ib_net(tb), net) && tb->port == port) |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 116 | goto tb_found; |
Eric Dumazet | ea8add2 | 2016-02-11 16:28:50 -0800 | [diff] [blame] | 117 | |
| 118 | goto tb_not_found; |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 119 | } |
Eric Dumazet | ea8add2 | 2016-02-11 16:28:50 -0800 | [diff] [blame] | 120 | again: |
| 121 | attempt_half = (sk->sk_reuse == SK_CAN_REUSE) ? 1 : 0; |
| 122 | other_half_scan: |
| 123 | inet_get_local_port_range(net, &low, &high); |
| 124 | high++; /* [32768, 60999] -> [32768, 61000[ */ |
| 125 | if (high - low < 4) |
| 126 | attempt_half = 0; |
| 127 | if (attempt_half) { |
| 128 | int half = low + (((high - low) >> 2) << 1); |
| 129 | |
| 130 | if (attempt_half == 1) |
| 131 | high = half; |
| 132 | else |
| 133 | low = half; |
| 134 | } |
| 135 | remaining = high - low; |
| 136 | if (likely(remaining > 1)) |
| 137 | remaining &= ~1U; |
| 138 | |
| 139 | offset = prandom_u32() % remaining; |
| 140 | /* __inet_hash_connect() favors ports having @low parity |
| 141 | * We do the opposite to not pollute connect() users. |
| 142 | */ |
| 143 | offset |= 1U; |
| 144 | smallest_size = -1; |
| 145 | smallest_port = low; /* avoid compiler warning */ |
| 146 | |
| 147 | other_parity_scan: |
| 148 | port = low + offset; |
| 149 | for (i = 0; i < remaining; i += 2, port += 2) { |
| 150 | if (unlikely(port >= high)) |
| 151 | port -= remaining; |
| 152 | if (inet_is_local_reserved_port(net, port)) |
| 153 | continue; |
| 154 | head = &hinfo->bhash[inet_bhashfn(net, port, |
| 155 | hinfo->bhash_size)]; |
| 156 | spin_lock_bh(&head->lock); |
| 157 | inet_bind_bucket_for_each(tb, &head->chain) |
| 158 | if (net_eq(ib_net(tb), net) && tb->port == port) { |
| 159 | if (((tb->fastreuse > 0 && reuse) || |
| 160 | (tb->fastreuseport > 0 && |
| 161 | sk->sk_reuseport && |
| 162 | !rcu_access_pointer(sk->sk_reuseport_cb) && |
| 163 | uid_eq(tb->fastuid, uid))) && |
| 164 | (tb->num_owners < smallest_size || smallest_size == -1)) { |
| 165 | smallest_size = tb->num_owners; |
| 166 | smallest_port = port; |
| 167 | } |
| 168 | if (!inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, false)) |
| 169 | goto tb_found; |
| 170 | goto next_port; |
| 171 | } |
| 172 | goto tb_not_found; |
| 173 | next_port: |
| 174 | spin_unlock_bh(&head->lock); |
| 175 | cond_resched(); |
| 176 | } |
| 177 | |
| 178 | if (smallest_size != -1) { |
| 179 | port = smallest_port; |
| 180 | goto have_port; |
| 181 | } |
| 182 | offset--; |
| 183 | if (!(offset & 1)) |
| 184 | goto other_parity_scan; |
| 185 | |
| 186 | if (attempt_half == 1) { |
| 187 | /* OK we now try the upper half of the range */ |
| 188 | attempt_half = 2; |
| 189 | goto other_half_scan; |
| 190 | } |
| 191 | return ret; |
| 192 | |
| 193 | tb_not_found: |
| 194 | tb = inet_bind_bucket_create(hinfo->bind_bucket_cachep, |
| 195 | net, head, port); |
| 196 | if (!tb) |
| 197 | goto fail_unlock; |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 198 | tb_found: |
| 199 | if (!hlist_empty(&tb->owners)) { |
Pavel Emelyanov | 4a17fd5 | 2012-04-19 03:39:36 +0000 | [diff] [blame] | 200 | if (sk->sk_reuse == SK_FORCE_REUSE) |
| 201 | goto success; |
| 202 | |
Eric Dumazet | ea8add2 | 2016-02-11 16:28:50 -0800 | [diff] [blame] | 203 | if (((tb->fastreuse > 0 && reuse) || |
Tom Herbert | da5e363 | 2013-01-22 09:50:24 +0000 | [diff] [blame] | 204 | (tb->fastreuseport > 0 && |
Craig Gallek | e5fbfc1 | 2016-02-22 10:45:29 -0500 | [diff] [blame] | 205 | !rcu_access_pointer(sk->sk_reuseport_cb) && |
Eric Dumazet | ea8add2 | 2016-02-11 16:28:50 -0800 | [diff] [blame] | 206 | sk->sk_reuseport && uid_eq(tb->fastuid, uid))) && |
| 207 | smallest_size == -1) |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 208 | goto success; |
Eric Dumazet | ea8add2 | 2016-02-11 16:28:50 -0800 | [diff] [blame] | 209 | if (inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, true)) { |
| 210 | if ((reuse || |
| 211 | (tb->fastreuseport > 0 && |
| 212 | sk->sk_reuseport && |
| 213 | !rcu_access_pointer(sk->sk_reuseport_cb) && |
| 214 | uid_eq(tb->fastuid, uid))) && |
| 215 | smallest_size != -1 && --attempts >= 0) { |
| 216 | spin_unlock_bh(&head->lock); |
| 217 | goto again; |
Evgeniy Polyakov | a9d8f91 | 2009-01-19 16:46:02 -0800 | [diff] [blame] | 218 | } |
Eric Dumazet | ea8add2 | 2016-02-11 16:28:50 -0800 | [diff] [blame] | 219 | goto fail_unlock; |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 220 | } |
Eric Dumazet | ea8add2 | 2016-02-11 16:28:50 -0800 | [diff] [blame] | 221 | if (!reuse) |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 222 | tb->fastreuse = 0; |
Eric Dumazet | ea8add2 | 2016-02-11 16:28:50 -0800 | [diff] [blame] | 223 | if (!sk->sk_reuseport || !uid_eq(tb->fastuid, uid)) |
| 224 | tb->fastreuseport = 0; |
| 225 | } else { |
| 226 | tb->fastreuse = reuse; |
Tom Herbert | da5e363 | 2013-01-22 09:50:24 +0000 | [diff] [blame] | 227 | if (sk->sk_reuseport) { |
| 228 | tb->fastreuseport = 1; |
| 229 | tb->fastuid = uid; |
Eric Dumazet | ea8add2 | 2016-02-11 16:28:50 -0800 | [diff] [blame] | 230 | } else { |
Tom Herbert | da5e363 | 2013-01-22 09:50:24 +0000 | [diff] [blame] | 231 | tb->fastreuseport = 0; |
Eric Dumazet | ea8add2 | 2016-02-11 16:28:50 -0800 | [diff] [blame] | 232 | } |
Tom Herbert | da5e363 | 2013-01-22 09:50:24 +0000 | [diff] [blame] | 233 | } |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 234 | success: |
| 235 | if (!inet_csk(sk)->icsk_bind_hash) |
Eric Dumazet | ea8add2 | 2016-02-11 16:28:50 -0800 | [diff] [blame] | 236 | inet_bind_hash(sk, tb, port); |
Ilpo Järvinen | 547b792 | 2008-07-25 21:43:18 -0700 | [diff] [blame] | 237 | WARN_ON(inet_csk(sk)->icsk_bind_hash != tb); |
YOSHIFUJI Hideaki | e905a9e | 2007-02-09 23:24:47 +0900 | [diff] [blame] | 238 | ret = 0; |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 239 | |
| 240 | fail_unlock: |
Eric Dumazet | ea8add2 | 2016-02-11 16:28:50 -0800 | [diff] [blame] | 241 | spin_unlock_bh(&head->lock); |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 242 | return ret; |
| 243 | } |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 244 | EXPORT_SYMBOL_GPL(inet_csk_get_port); |
| 245 | |
| 246 | /* |
| 247 | * Wait for an incoming connection, avoid race conditions. This must be called |
| 248 | * with the socket locked. |
| 249 | */ |
| 250 | static int inet_csk_wait_for_connect(struct sock *sk, long timeo) |
| 251 | { |
| 252 | struct inet_connection_sock *icsk = inet_csk(sk); |
| 253 | DEFINE_WAIT(wait); |
| 254 | int err; |
| 255 | |
| 256 | /* |
| 257 | * True wake-one mechanism for incoming connections: only |
| 258 | * one process gets woken up, not the 'whole herd'. |
| 259 | * Since we do not 'race & poll' for established sockets |
| 260 | * anymore, the common case will execute the loop only once. |
| 261 | * |
| 262 | * Subtle issue: "add_wait_queue_exclusive()" will be added |
| 263 | * after any current non-exclusive waiters, and we know that |
| 264 | * it will always _stay_ after any new non-exclusive waiters |
| 265 | * because all non-exclusive waiters are added at the |
| 266 | * beginning of the wait-queue. As such, it's ok to "drop" |
| 267 | * our exclusiveness temporarily when we get woken up without |
| 268 | * having to remove and re-insert us on the wait queue. |
| 269 | */ |
| 270 | for (;;) { |
Eric Dumazet | aa39514 | 2010-04-20 13:03:51 +0000 | [diff] [blame] | 271 | prepare_to_wait_exclusive(sk_sleep(sk), &wait, |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 272 | TASK_INTERRUPTIBLE); |
| 273 | release_sock(sk); |
| 274 | if (reqsk_queue_empty(&icsk->icsk_accept_queue)) |
| 275 | timeo = schedule_timeout(timeo); |
Eric Dumazet | cb7cf8a | 2015-03-16 12:19:24 -0700 | [diff] [blame] | 276 | sched_annotate_sleep(); |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 277 | lock_sock(sk); |
| 278 | err = 0; |
| 279 | if (!reqsk_queue_empty(&icsk->icsk_accept_queue)) |
| 280 | break; |
| 281 | err = -EINVAL; |
| 282 | if (sk->sk_state != TCP_LISTEN) |
| 283 | break; |
| 284 | err = sock_intr_errno(timeo); |
| 285 | if (signal_pending(current)) |
| 286 | break; |
| 287 | err = -EAGAIN; |
| 288 | if (!timeo) |
| 289 | break; |
| 290 | } |
Eric Dumazet | aa39514 | 2010-04-20 13:03:51 +0000 | [diff] [blame] | 291 | finish_wait(sk_sleep(sk), &wait); |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 292 | return err; |
| 293 | } |
| 294 | |
| 295 | /* |
| 296 | * This will accept the next outstanding connection. |
| 297 | */ |
| 298 | struct sock *inet_csk_accept(struct sock *sk, int flags, int *err) |
| 299 | { |
| 300 | struct inet_connection_sock *icsk = inet_csk(sk); |
Jerry Chu | 8336886 | 2012-08-31 12:29:12 +0000 | [diff] [blame] | 301 | struct request_sock_queue *queue = &icsk->icsk_accept_queue; |
Jerry Chu | 8336886 | 2012-08-31 12:29:12 +0000 | [diff] [blame] | 302 | struct request_sock *req; |
Eric Dumazet | e3d95ad | 2015-03-17 18:32:30 -0700 | [diff] [blame] | 303 | struct sock *newsk; |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 304 | int error; |
| 305 | |
| 306 | lock_sock(sk); |
| 307 | |
| 308 | /* We need to make sure that this socket is listening, |
| 309 | * and that it has something pending. |
| 310 | */ |
| 311 | error = -EINVAL; |
| 312 | if (sk->sk_state != TCP_LISTEN) |
| 313 | goto out_err; |
| 314 | |
| 315 | /* Find already established connection */ |
Jerry Chu | 8336886 | 2012-08-31 12:29:12 +0000 | [diff] [blame] | 316 | if (reqsk_queue_empty(queue)) { |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 317 | long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK); |
| 318 | |
| 319 | /* If this is a non blocking socket don't sleep */ |
| 320 | error = -EAGAIN; |
| 321 | if (!timeo) |
| 322 | goto out_err; |
| 323 | |
| 324 | error = inet_csk_wait_for_connect(sk, timeo); |
| 325 | if (error) |
| 326 | goto out_err; |
| 327 | } |
Eric Dumazet | fff1f30 | 2015-10-02 11:43:23 -0700 | [diff] [blame] | 328 | req = reqsk_queue_remove(queue, sk); |
Jerry Chu | 8336886 | 2012-08-31 12:29:12 +0000 | [diff] [blame] | 329 | newsk = req->sk; |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 330 | |
Eric Dumazet | e3d95ad | 2015-03-17 18:32:30 -0700 | [diff] [blame] | 331 | if (sk->sk_protocol == IPPROTO_TCP && |
Eric Dumazet | 0536fcc | 2015-09-29 07:42:52 -0700 | [diff] [blame] | 332 | tcp_rsk(req)->tfo_listener) { |
| 333 | spin_lock_bh(&queue->fastopenq.lock); |
Eric Dumazet | 9439ce0 | 2015-03-17 18:32:29 -0700 | [diff] [blame] | 334 | if (tcp_rsk(req)->tfo_listener) { |
Jerry Chu | 8336886 | 2012-08-31 12:29:12 +0000 | [diff] [blame] | 335 | /* We are still waiting for the final ACK from 3WHS |
| 336 | * so can't free req now. Instead, we set req->sk to |
| 337 | * NULL to signify that the child socket is taken |
| 338 | * so reqsk_fastopen_remove() will free the req |
| 339 | * when 3WHS finishes (or is aborted). |
| 340 | */ |
| 341 | req->sk = NULL; |
| 342 | req = NULL; |
| 343 | } |
Eric Dumazet | 0536fcc | 2015-09-29 07:42:52 -0700 | [diff] [blame] | 344 | spin_unlock_bh(&queue->fastopenq.lock); |
Jerry Chu | 8336886 | 2012-08-31 12:29:12 +0000 | [diff] [blame] | 345 | } |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 346 | out: |
| 347 | release_sock(sk); |
Jerry Chu | 8336886 | 2012-08-31 12:29:12 +0000 | [diff] [blame] | 348 | if (req) |
Eric Dumazet | 13854e5 | 2015-03-15 21:12:16 -0700 | [diff] [blame] | 349 | reqsk_put(req); |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 350 | return newsk; |
| 351 | out_err: |
| 352 | newsk = NULL; |
Jerry Chu | 8336886 | 2012-08-31 12:29:12 +0000 | [diff] [blame] | 353 | req = NULL; |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 354 | *err = error; |
| 355 | goto out; |
| 356 | } |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 357 | EXPORT_SYMBOL(inet_csk_accept); |
| 358 | |
| 359 | /* |
| 360 | * Using different timers for retransmit, delayed acks and probes |
YOSHIFUJI Hideaki | e905a9e | 2007-02-09 23:24:47 +0900 | [diff] [blame] | 361 | * We may wish use just one timer maintaining a list of expire jiffies |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 362 | * to optimize. |
| 363 | */ |
| 364 | void inet_csk_init_xmit_timers(struct sock *sk, |
| 365 | void (*retransmit_handler)(unsigned long), |
| 366 | void (*delack_handler)(unsigned long), |
| 367 | void (*keepalive_handler)(unsigned long)) |
| 368 | { |
| 369 | struct inet_connection_sock *icsk = inet_csk(sk); |
| 370 | |
Pavel Emelyanov | b24b8a2 | 2008-01-23 21:20:07 -0800 | [diff] [blame] | 371 | setup_timer(&icsk->icsk_retransmit_timer, retransmit_handler, |
| 372 | (unsigned long)sk); |
| 373 | setup_timer(&icsk->icsk_delack_timer, delack_handler, |
| 374 | (unsigned long)sk); |
| 375 | setup_timer(&sk->sk_timer, keepalive_handler, (unsigned long)sk); |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 376 | icsk->icsk_pending = icsk->icsk_ack.pending = 0; |
| 377 | } |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 378 | EXPORT_SYMBOL(inet_csk_init_xmit_timers); |
| 379 | |
| 380 | void inet_csk_clear_xmit_timers(struct sock *sk) |
| 381 | { |
| 382 | struct inet_connection_sock *icsk = inet_csk(sk); |
| 383 | |
| 384 | icsk->icsk_pending = icsk->icsk_ack.pending = icsk->icsk_ack.blocked = 0; |
| 385 | |
| 386 | sk_stop_timer(sk, &icsk->icsk_retransmit_timer); |
| 387 | sk_stop_timer(sk, &icsk->icsk_delack_timer); |
| 388 | sk_stop_timer(sk, &sk->sk_timer); |
| 389 | } |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 390 | EXPORT_SYMBOL(inet_csk_clear_xmit_timers); |
| 391 | |
| 392 | void inet_csk_delete_keepalive_timer(struct sock *sk) |
| 393 | { |
| 394 | sk_stop_timer(sk, &sk->sk_timer); |
| 395 | } |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 396 | EXPORT_SYMBOL(inet_csk_delete_keepalive_timer); |
| 397 | |
| 398 | void inet_csk_reset_keepalive_timer(struct sock *sk, unsigned long len) |
| 399 | { |
| 400 | sk_reset_timer(sk, &sk->sk_timer, jiffies + len); |
| 401 | } |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 402 | EXPORT_SYMBOL(inet_csk_reset_keepalive_timer); |
| 403 | |
Eric Dumazet | e5895bc | 2015-09-25 07:39:11 -0700 | [diff] [blame] | 404 | struct dst_entry *inet_csk_route_req(const struct sock *sk, |
David S. Miller | 6bd023f | 2011-05-18 18:32:03 -0400 | [diff] [blame] | 405 | struct flowi4 *fl4, |
David S. Miller | ba3f7f0 | 2012-07-17 14:02:46 -0700 | [diff] [blame] | 406 | const struct request_sock *req) |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 407 | { |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 408 | const struct inet_request_sock *ireq = inet_rsk(req); |
Eric Dumazet | 8b929ab | 2015-03-22 10:22:20 -0700 | [diff] [blame] | 409 | struct net *net = read_pnet(&ireq->ireq_net); |
Eric Dumazet | 2ffd261 | 2017-10-20 09:04:13 -0700 | [diff] [blame] | 410 | struct ip_options_rcu *opt; |
Eric Dumazet | 8b929ab | 2015-03-22 10:22:20 -0700 | [diff] [blame] | 411 | struct rtable *rt; |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 412 | |
Eric Dumazet | 6b2f36b | 2018-10-02 12:35:05 -0700 | [diff] [blame] | 413 | rcu_read_lock(); |
| 414 | opt = rcu_dereference(ireq->ireq_opt); |
Eric Dumazet | 2af59c6 | 2017-10-24 08:20:31 -0700 | [diff] [blame] | 415 | |
Eric Dumazet | 8b929ab | 2015-03-22 10:22:20 -0700 | [diff] [blame] | 416 | flowi4_init_output(fl4, ireq->ir_iif, ireq->ir_mark, |
David S. Miller | e79d9bc | 2011-03-31 04:53:20 -0700 | [diff] [blame] | 417 | RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE, |
Eric Dumazet | 8b929ab | 2015-03-22 10:22:20 -0700 | [diff] [blame] | 418 | sk->sk_protocol, inet_sk_flowi_flags(sk), |
Eric Dumazet | 634fb979 | 2013-10-09 15:21:29 -0700 | [diff] [blame] | 419 | (opt && opt->opt.srr) ? opt->opt.faddr : ireq->ir_rmt_addr, |
Eric Dumazet | 8b929ab | 2015-03-22 10:22:20 -0700 | [diff] [blame] | 420 | ireq->ir_loc_addr, ireq->ir_rmt_port, |
| 421 | htons(ireq->ir_num)); |
David S. Miller | 6bd023f | 2011-05-18 18:32:03 -0400 | [diff] [blame] | 422 | security_req_classify_flow(req, flowi4_to_flowi(fl4)); |
| 423 | rt = ip_route_output_flow(net, fl4, sk); |
David S. Miller | b23dd4f | 2011-03-02 14:31:35 -0800 | [diff] [blame] | 424 | if (IS_ERR(rt)) |
Ilpo Järvinen | 857a6e0 | 2008-12-14 23:13:08 -0800 | [diff] [blame] | 425 | goto no_route; |
Julian Anastasov | 155e833 | 2012-10-08 11:41:18 +0000 | [diff] [blame] | 426 | if (opt && opt->opt.is_strictroute && rt->rt_uses_gateway) |
Ilpo Järvinen | 857a6e0 | 2008-12-14 23:13:08 -0800 | [diff] [blame] | 427 | goto route_err; |
Eric Dumazet | 6b2f36b | 2018-10-02 12:35:05 -0700 | [diff] [blame] | 428 | rcu_read_unlock(); |
Changli Gao | d8d1f30 | 2010-06-10 23:31:35 -0700 | [diff] [blame] | 429 | return &rt->dst; |
Ilpo Järvinen | 857a6e0 | 2008-12-14 23:13:08 -0800 | [diff] [blame] | 430 | |
| 431 | route_err: |
| 432 | ip_rt_put(rt); |
| 433 | no_route: |
Eric Dumazet | 6b2f36b | 2018-10-02 12:35:05 -0700 | [diff] [blame] | 434 | rcu_read_unlock(); |
Eric Dumazet | b45386e | 2016-04-27 16:44:35 -0700 | [diff] [blame] | 435 | __IP_INC_STATS(net, IPSTATS_MIB_OUTNOROUTES); |
Ilpo Järvinen | 857a6e0 | 2008-12-14 23:13:08 -0800 | [diff] [blame] | 436 | return NULL; |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 437 | } |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 438 | EXPORT_SYMBOL_GPL(inet_csk_route_req); |
| 439 | |
Eric Dumazet | a2432c4 | 2015-09-29 07:42:43 -0700 | [diff] [blame] | 440 | struct dst_entry *inet_csk_route_child_sock(const struct sock *sk, |
David S. Miller | 77357a9 | 2011-05-08 14:34:22 -0700 | [diff] [blame] | 441 | struct sock *newsk, |
| 442 | const struct request_sock *req) |
| 443 | { |
| 444 | const struct inet_request_sock *ireq = inet_rsk(req); |
Eric Dumazet | 8b929ab | 2015-03-22 10:22:20 -0700 | [diff] [blame] | 445 | struct net *net = read_pnet(&ireq->ireq_net); |
David S. Miller | 77357a9 | 2011-05-08 14:34:22 -0700 | [diff] [blame] | 446 | struct inet_sock *newinet = inet_sk(newsk); |
Christoph Paasch | 1a7b27c | 2012-08-20 02:52:09 +0000 | [diff] [blame] | 447 | struct ip_options_rcu *opt; |
David S. Miller | 77357a9 | 2011-05-08 14:34:22 -0700 | [diff] [blame] | 448 | struct flowi4 *fl4; |
| 449 | struct rtable *rt; |
| 450 | |
Eric Dumazet | 2ffd261 | 2017-10-20 09:04:13 -0700 | [diff] [blame] | 451 | opt = rcu_dereference(ireq->ireq_opt); |
David S. Miller | 77357a9 | 2011-05-08 14:34:22 -0700 | [diff] [blame] | 452 | fl4 = &newinet->cork.fl.u.ip4; |
Christoph Paasch | 1a7b27c | 2012-08-20 02:52:09 +0000 | [diff] [blame] | 453 | |
Eric Dumazet | 8b929ab | 2015-03-22 10:22:20 -0700 | [diff] [blame] | 454 | flowi4_init_output(fl4, ireq->ir_iif, ireq->ir_mark, |
David S. Miller | 77357a9 | 2011-05-08 14:34:22 -0700 | [diff] [blame] | 455 | RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE, |
| 456 | sk->sk_protocol, inet_sk_flowi_flags(sk), |
Eric Dumazet | 634fb979 | 2013-10-09 15:21:29 -0700 | [diff] [blame] | 457 | (opt && opt->opt.srr) ? opt->opt.faddr : ireq->ir_rmt_addr, |
Eric Dumazet | 8b929ab | 2015-03-22 10:22:20 -0700 | [diff] [blame] | 458 | ireq->ir_loc_addr, ireq->ir_rmt_port, |
| 459 | htons(ireq->ir_num)); |
David S. Miller | 77357a9 | 2011-05-08 14:34:22 -0700 | [diff] [blame] | 460 | security_req_classify_flow(req, flowi4_to_flowi(fl4)); |
| 461 | rt = ip_route_output_flow(net, fl4, sk); |
| 462 | if (IS_ERR(rt)) |
| 463 | goto no_route; |
Julian Anastasov | 155e833 | 2012-10-08 11:41:18 +0000 | [diff] [blame] | 464 | if (opt && opt->opt.is_strictroute && rt->rt_uses_gateway) |
David S. Miller | 77357a9 | 2011-05-08 14:34:22 -0700 | [diff] [blame] | 465 | goto route_err; |
| 466 | return &rt->dst; |
| 467 | |
| 468 | route_err: |
| 469 | ip_rt_put(rt); |
| 470 | no_route: |
Eric Dumazet | b45386e | 2016-04-27 16:44:35 -0700 | [diff] [blame] | 471 | __IP_INC_STATS(net, IPSTATS_MIB_OUTNOROUTES); |
David S. Miller | 77357a9 | 2011-05-08 14:34:22 -0700 | [diff] [blame] | 472 | return NULL; |
| 473 | } |
| 474 | EXPORT_SYMBOL_GPL(inet_csk_route_child_sock); |
| 475 | |
Eric Dumazet | dfd56b8 | 2011-12-10 09:48:31 +0000 | [diff] [blame] | 476 | #if IS_ENABLED(CONFIG_IPV6) |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 477 | #define AF_INET_FAMILY(fam) ((fam) == AF_INET) |
| 478 | #else |
Eric Dumazet | fa76ce73 | 2015-03-19 19:04:20 -0700 | [diff] [blame] | 479 | #define AF_INET_FAMILY(fam) true |
Arnaldo Carvalho de Melo | 3f421ba | 2005-08-09 20:11:08 -0700 | [diff] [blame] | 480 | #endif |
| 481 | |
Julian Anastasov | 0c3d79b | 2009-10-19 10:03:58 +0000 | [diff] [blame] | 482 | /* Decide when to expire the request and when to resend SYN-ACK */ |
| 483 | static inline void syn_ack_recalc(struct request_sock *req, const int thresh, |
| 484 | const int max_retries, |
| 485 | const u8 rskq_defer_accept, |
| 486 | int *expire, int *resend) |
| 487 | { |
| 488 | if (!rskq_defer_accept) { |
Eric Dumazet | e6c022a | 2012-10-27 23:16:46 +0000 | [diff] [blame] | 489 | *expire = req->num_timeout >= thresh; |
Julian Anastasov | 0c3d79b | 2009-10-19 10:03:58 +0000 | [diff] [blame] | 490 | *resend = 1; |
| 491 | return; |
| 492 | } |
Eric Dumazet | e6c022a | 2012-10-27 23:16:46 +0000 | [diff] [blame] | 493 | *expire = req->num_timeout >= thresh && |
| 494 | (!inet_rsk(req)->acked || req->num_timeout >= max_retries); |
Julian Anastasov | 0c3d79b | 2009-10-19 10:03:58 +0000 | [diff] [blame] | 495 | /* |
| 496 | * Do not resend while waiting for data after ACK, |
| 497 | * start to resend on end of deferring period to give |
| 498 | * last chance for data or ACK to create established socket. |
| 499 | */ |
| 500 | *resend = !inet_rsk(req)->acked || |
Eric Dumazet | e6c022a | 2012-10-27 23:16:46 +0000 | [diff] [blame] | 501 | req->num_timeout >= rskq_defer_accept - 1; |
Julian Anastasov | 0c3d79b | 2009-10-19 10:03:58 +0000 | [diff] [blame] | 502 | } |
| 503 | |
Eric Dumazet | 1b70e97 | 2015-09-25 07:39:24 -0700 | [diff] [blame] | 504 | int inet_rtx_syn_ack(const struct sock *parent, struct request_sock *req) |
Eric Dumazet | e6c022a | 2012-10-27 23:16:46 +0000 | [diff] [blame] | 505 | { |
Christoph Paasch | 1a2c618 | 2013-03-17 08:23:34 +0000 | [diff] [blame] | 506 | int err = req->rsk_ops->rtx_syn_ack(parent, req); |
Eric Dumazet | e6c022a | 2012-10-27 23:16:46 +0000 | [diff] [blame] | 507 | |
| 508 | if (!err) |
| 509 | req->num_retrans++; |
| 510 | return err; |
| 511 | } |
| 512 | EXPORT_SYMBOL(inet_rtx_syn_ack); |
| 513 | |
Eric Dumazet | 079096f | 2015-10-02 11:43:32 -0700 | [diff] [blame] | 514 | /* return true if req was found in the ehash table */ |
Eric Dumazet | b357a36 | 2015-04-23 18:03:44 -0700 | [diff] [blame] | 515 | static bool reqsk_queue_unlink(struct request_sock_queue *queue, |
| 516 | struct request_sock *req) |
| 517 | { |
Eric Dumazet | 079096f | 2015-10-02 11:43:32 -0700 | [diff] [blame] | 518 | struct inet_hashinfo *hashinfo = req_to_sk(req)->sk_prot->h.hashinfo; |
Eric Dumazet | 5e0724d | 2015-10-22 08:20:46 -0700 | [diff] [blame] | 519 | bool found = false; |
Eric Dumazet | b357a36 | 2015-04-23 18:03:44 -0700 | [diff] [blame] | 520 | |
Eric Dumazet | 5e0724d | 2015-10-22 08:20:46 -0700 | [diff] [blame] | 521 | if (sk_hashed(req_to_sk(req))) { |
| 522 | spinlock_t *lock = inet_ehash_lockp(hashinfo, req->rsk_hash); |
Eric Dumazet | b357a36 | 2015-04-23 18:03:44 -0700 | [diff] [blame] | 523 | |
Eric Dumazet | 5e0724d | 2015-10-22 08:20:46 -0700 | [diff] [blame] | 524 | spin_lock(lock); |
| 525 | found = __sk_nulls_del_node_init_rcu(req_to_sk(req)); |
| 526 | spin_unlock(lock); |
| 527 | } |
Eric Dumazet | 83fccfc | 2015-08-13 15:44:51 -0700 | [diff] [blame] | 528 | if (timer_pending(&req->rsk_timer) && del_timer_sync(&req->rsk_timer)) |
Eric Dumazet | b357a36 | 2015-04-23 18:03:44 -0700 | [diff] [blame] | 529 | reqsk_put(req); |
| 530 | return found; |
| 531 | } |
| 532 | |
| 533 | void inet_csk_reqsk_queue_drop(struct sock *sk, struct request_sock *req) |
| 534 | { |
| 535 | if (reqsk_queue_unlink(&inet_csk(sk)->icsk_accept_queue, req)) { |
| 536 | reqsk_queue_removed(&inet_csk(sk)->icsk_accept_queue, req); |
| 537 | reqsk_put(req); |
| 538 | } |
| 539 | } |
| 540 | EXPORT_SYMBOL(inet_csk_reqsk_queue_drop); |
| 541 | |
Eric Dumazet | f03f2e1 | 2015-10-14 11:16:27 -0700 | [diff] [blame] | 542 | void inet_csk_reqsk_queue_drop_and_put(struct sock *sk, struct request_sock *req) |
| 543 | { |
| 544 | inet_csk_reqsk_queue_drop(sk, req); |
| 545 | reqsk_put(req); |
| 546 | } |
| 547 | EXPORT_SYMBOL(inet_csk_reqsk_queue_drop_and_put); |
| 548 | |
Eric Dumazet | fa76ce73 | 2015-03-19 19:04:20 -0700 | [diff] [blame] | 549 | static void reqsk_timer_handler(unsigned long data) |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 550 | { |
Eric Dumazet | fa76ce73 | 2015-03-19 19:04:20 -0700 | [diff] [blame] | 551 | struct request_sock *req = (struct request_sock *)data; |
| 552 | struct sock *sk_listener = req->rsk_listener; |
Nikolay Borisov | 7c083ec | 2016-02-03 09:46:50 +0200 | [diff] [blame] | 553 | struct net *net = sock_net(sk_listener); |
Eric Dumazet | fa76ce73 | 2015-03-19 19:04:20 -0700 | [diff] [blame] | 554 | struct inet_connection_sock *icsk = inet_csk(sk_listener); |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 555 | struct request_sock_queue *queue = &icsk->icsk_accept_queue; |
Eric Dumazet | 2b41fab | 2015-03-22 10:22:18 -0700 | [diff] [blame] | 556 | int qlen, expire = 0, resend = 0; |
Eric Dumazet | fa76ce73 | 2015-03-19 19:04:20 -0700 | [diff] [blame] | 557 | int max_retries, thresh; |
Eric Dumazet | 2b41fab | 2015-03-22 10:22:18 -0700 | [diff] [blame] | 558 | u8 defer_accept; |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 559 | |
Eric Dumazet | 00fd38d | 2015-11-12 08:43:18 -0800 | [diff] [blame] | 560 | if (sk_state_load(sk_listener) != TCP_LISTEN) |
Eric Dumazet | 079096f | 2015-10-02 11:43:32 -0700 | [diff] [blame] | 561 | goto drop; |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 562 | |
Nikolay Borisov | 7c083ec | 2016-02-03 09:46:50 +0200 | [diff] [blame] | 563 | max_retries = icsk->icsk_syn_retries ? : net->ipv4.sysctl_tcp_synack_retries; |
Eric Dumazet | fa76ce73 | 2015-03-19 19:04:20 -0700 | [diff] [blame] | 564 | thresh = max_retries; |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 565 | /* Normally all the openreqs are young and become mature |
| 566 | * (i.e. converted to established socket) for first timeout. |
Eric Dumazet | fd4f2ce | 2012-04-12 19:48:40 +0000 | [diff] [blame] | 567 | * If synack was not acknowledged for 1 second, it means |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 568 | * one of the following things: synack was lost, ack was lost, |
| 569 | * rtt is high or nobody planned to ack (i.e. synflood). |
| 570 | * When server is a bit loaded, queue is populated with old |
| 571 | * open requests, reducing effective size of queue. |
| 572 | * When server is well loaded, queue size reduces to zero |
| 573 | * after several minutes of work. It is not synflood, |
| 574 | * it is normal operation. The solution is pruning |
| 575 | * too old entries overriding normal timeout, when |
| 576 | * situation becomes dangerous. |
| 577 | * |
| 578 | * Essentially, we reserve half of room for young |
| 579 | * embrions; and abort old ones without pity, if old |
| 580 | * ones are about to clog our table. |
| 581 | */ |
Eric Dumazet | aac065c | 2015-10-02 11:43:24 -0700 | [diff] [blame] | 582 | qlen = reqsk_queue_len(queue); |
Eric Dumazet | acb4a6b | 2015-10-06 14:49:58 -0700 | [diff] [blame] | 583 | if ((qlen << 1) > max(8U, sk_listener->sk_max_ack_backlog)) { |
Eric Dumazet | aac065c | 2015-10-02 11:43:24 -0700 | [diff] [blame] | 584 | int young = reqsk_queue_len_young(queue) << 1; |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 585 | |
| 586 | while (thresh > 2) { |
Eric Dumazet | 2b41fab | 2015-03-22 10:22:18 -0700 | [diff] [blame] | 587 | if (qlen < young) |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 588 | break; |
| 589 | thresh--; |
| 590 | young <<= 1; |
| 591 | } |
| 592 | } |
Eric Dumazet | 2b41fab | 2015-03-22 10:22:18 -0700 | [diff] [blame] | 593 | defer_accept = READ_ONCE(queue->rskq_defer_accept); |
| 594 | if (defer_accept) |
| 595 | max_retries = defer_accept; |
| 596 | syn_ack_recalc(req, thresh, max_retries, defer_accept, |
Eric Dumazet | fa76ce73 | 2015-03-19 19:04:20 -0700 | [diff] [blame] | 597 | &expire, &resend); |
Eric Dumazet | 42cb80a | 2015-03-22 10:22:19 -0700 | [diff] [blame] | 598 | req->rsk_ops->syn_ack_timeout(req); |
Eric Dumazet | fa76ce73 | 2015-03-19 19:04:20 -0700 | [diff] [blame] | 599 | if (!expire && |
| 600 | (!resend || |
| 601 | !inet_rtx_syn_ack(sk_listener, req) || |
| 602 | inet_rsk(req)->acked)) { |
| 603 | unsigned long timeo; |
David S. Miller | ec0a196 | 2008-06-12 16:31:35 -0700 | [diff] [blame] | 604 | |
Eric Dumazet | fa76ce73 | 2015-03-19 19:04:20 -0700 | [diff] [blame] | 605 | if (req->num_timeout++ == 0) |
Eric Dumazet | aac065c | 2015-10-02 11:43:24 -0700 | [diff] [blame] | 606 | atomic_dec(&queue->young); |
Eric Dumazet | fa76ce73 | 2015-03-19 19:04:20 -0700 | [diff] [blame] | 607 | timeo = min(TCP_TIMEOUT_INIT << req->num_timeout, TCP_RTO_MAX); |
Thomas Gleixner | f3438bc | 2016-07-04 09:50:23 +0000 | [diff] [blame] | 608 | mod_timer(&req->rsk_timer, jiffies + timeo); |
Eric Dumazet | fa76ce73 | 2015-03-19 19:04:20 -0700 | [diff] [blame] | 609 | return; |
| 610 | } |
Eric Dumazet | 079096f | 2015-10-02 11:43:32 -0700 | [diff] [blame] | 611 | drop: |
Eric Dumazet | f03f2e1 | 2015-10-14 11:16:27 -0700 | [diff] [blame] | 612 | inet_csk_reqsk_queue_drop_and_put(sk_listener, req); |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 613 | } |
Eric Dumazet | fa76ce73 | 2015-03-19 19:04:20 -0700 | [diff] [blame] | 614 | |
Eric Dumazet | 079096f | 2015-10-02 11:43:32 -0700 | [diff] [blame] | 615 | static void reqsk_queue_hash_req(struct request_sock *req, |
| 616 | unsigned long timeout) |
Eric Dumazet | fa76ce73 | 2015-03-19 19:04:20 -0700 | [diff] [blame] | 617 | { |
Eric Dumazet | fa76ce73 | 2015-03-19 19:04:20 -0700 | [diff] [blame] | 618 | req->num_retrans = 0; |
| 619 | req->num_timeout = 0; |
| 620 | req->sk = NULL; |
| 621 | |
Thomas Gleixner | f3438bc | 2016-07-04 09:50:23 +0000 | [diff] [blame] | 622 | setup_pinned_timer(&req->rsk_timer, reqsk_timer_handler, |
| 623 | (unsigned long)req); |
| 624 | mod_timer(&req->rsk_timer, jiffies + timeout); |
Eric Dumazet | 29c6852 | 2015-09-19 09:48:04 -0700 | [diff] [blame] | 625 | |
Eric Dumazet | 079096f | 2015-10-02 11:43:32 -0700 | [diff] [blame] | 626 | inet_ehash_insert(req_to_sk(req), NULL); |
Eric Dumazet | fa76ce73 | 2015-03-19 19:04:20 -0700 | [diff] [blame] | 627 | /* before letting lookups find us, make sure all req fields |
| 628 | * are committed to memory and refcnt initialized. |
| 629 | */ |
| 630 | smp_wmb(); |
Eric Dumazet | ca6fb06 | 2015-10-02 11:43:35 -0700 | [diff] [blame] | 631 | atomic_set(&req->rsk_refcnt, 2 + 1); |
Eric Dumazet | fa76ce73 | 2015-03-19 19:04:20 -0700 | [diff] [blame] | 632 | } |
Eric Dumazet | 079096f | 2015-10-02 11:43:32 -0700 | [diff] [blame] | 633 | |
| 634 | void inet_csk_reqsk_queue_hash_add(struct sock *sk, struct request_sock *req, |
| 635 | unsigned long timeout) |
| 636 | { |
| 637 | reqsk_queue_hash_req(req, timeout); |
| 638 | inet_csk_reqsk_queue_added(sk); |
| 639 | } |
| 640 | EXPORT_SYMBOL_GPL(inet_csk_reqsk_queue_hash_add); |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 641 | |
Eric Dumazet | e56c57d | 2011-11-08 17:07:07 -0500 | [diff] [blame] | 642 | /** |
| 643 | * inet_csk_clone_lock - clone an inet socket, and lock its clone |
| 644 | * @sk: the socket to clone |
| 645 | * @req: request_sock |
| 646 | * @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc) |
| 647 | * |
| 648 | * Caller must unlock socket even in error path (bh_unlock_sock(newsk)) |
| 649 | */ |
| 650 | struct sock *inet_csk_clone_lock(const struct sock *sk, |
| 651 | const struct request_sock *req, |
| 652 | const gfp_t priority) |
Arnaldo Carvalho de Melo | 9f1d260 | 2005-08-09 20:11:24 -0700 | [diff] [blame] | 653 | { |
Eric Dumazet | e56c57d | 2011-11-08 17:07:07 -0500 | [diff] [blame] | 654 | struct sock *newsk = sk_clone_lock(sk, priority); |
Arnaldo Carvalho de Melo | 9f1d260 | 2005-08-09 20:11:24 -0700 | [diff] [blame] | 655 | |
Ian Morris | 00db412 | 2015-04-03 09:17:27 +0100 | [diff] [blame] | 656 | if (newsk) { |
Arnaldo Carvalho de Melo | 9f1d260 | 2005-08-09 20:11:24 -0700 | [diff] [blame] | 657 | struct inet_connection_sock *newicsk = inet_csk(newsk); |
| 658 | |
| 659 | newsk->sk_state = TCP_SYN_RECV; |
| 660 | newicsk->icsk_bind_hash = NULL; |
| 661 | |
Eric Dumazet | 634fb979 | 2013-10-09 15:21:29 -0700 | [diff] [blame] | 662 | inet_sk(newsk)->inet_dport = inet_rsk(req)->ir_rmt_port; |
Eric Dumazet | b44084c | 2013-10-10 00:04:37 -0700 | [diff] [blame] | 663 | inet_sk(newsk)->inet_num = inet_rsk(req)->ir_num; |
| 664 | inet_sk(newsk)->inet_sport = htons(inet_rsk(req)->ir_num); |
Arnaldo Carvalho de Melo | 9f1d260 | 2005-08-09 20:11:24 -0700 | [diff] [blame] | 665 | newsk->sk_write_space = sk_stream_write_space; |
| 666 | |
Eric Dumazet | 8501786 | 2016-04-06 22:07:34 -0700 | [diff] [blame] | 667 | /* listeners have SOCK_RCU_FREE, not the children */ |
| 668 | sock_reset_flag(newsk, SOCK_RCU_FREE); |
| 669 | |
Eric Dumazet | 4eed440 | 2017-05-09 06:29:19 -0700 | [diff] [blame] | 670 | inet_sk(newsk)->mc_list = NULL; |
| 671 | |
Lorenzo Colitti | 84f39b0 | 2014-05-13 10:17:35 -0700 | [diff] [blame] | 672 | newsk->sk_mark = inet_rsk(req)->ir_mark; |
Eric Dumazet | 33cf7c9 | 2015-03-11 18:53:14 -0700 | [diff] [blame] | 673 | atomic64_set(&newsk->sk_cookie, |
| 674 | atomic64_read(&inet_rsk(req)->ir_cookie)); |
Lorenzo Colitti | 84f39b0 | 2014-05-13 10:17:35 -0700 | [diff] [blame] | 675 | |
Arnaldo Carvalho de Melo | 9f1d260 | 2005-08-09 20:11:24 -0700 | [diff] [blame] | 676 | newicsk->icsk_retransmits = 0; |
Arnaldo Carvalho de Melo | 6687e98 | 2005-08-10 04:03:31 -0300 | [diff] [blame] | 677 | newicsk->icsk_backoff = 0; |
| 678 | newicsk->icsk_probes_out = 0; |
Arnaldo Carvalho de Melo | 9f1d260 | 2005-08-09 20:11:24 -0700 | [diff] [blame] | 679 | |
| 680 | /* Deinitialize accept_queue to trap illegal accesses. */ |
| 681 | memset(&newicsk->icsk_accept_queue, 0, sizeof(newicsk->icsk_accept_queue)); |
Venkat Yekkirala | 4237c75 | 2006-07-24 23:32:50 -0700 | [diff] [blame] | 682 | |
| 683 | security_inet_csk_clone(newsk, req); |
Arnaldo Carvalho de Melo | 9f1d260 | 2005-08-09 20:11:24 -0700 | [diff] [blame] | 684 | } |
| 685 | return newsk; |
| 686 | } |
Eric Dumazet | e56c57d | 2011-11-08 17:07:07 -0500 | [diff] [blame] | 687 | EXPORT_SYMBOL_GPL(inet_csk_clone_lock); |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 688 | |
| 689 | /* |
| 690 | * At this point, there should be no process reference to this |
| 691 | * socket, and thus no user references at all. Therefore we |
| 692 | * can assume the socket waitqueue is inactive and nobody will |
| 693 | * try to jump onto it. |
| 694 | */ |
| 695 | void inet_csk_destroy_sock(struct sock *sk) |
| 696 | { |
Ilpo Järvinen | 547b792 | 2008-07-25 21:43:18 -0700 | [diff] [blame] | 697 | WARN_ON(sk->sk_state != TCP_CLOSE); |
| 698 | WARN_ON(!sock_flag(sk, SOCK_DEAD)); |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 699 | |
| 700 | /* It cannot be in hash table! */ |
Ilpo Järvinen | 547b792 | 2008-07-25 21:43:18 -0700 | [diff] [blame] | 701 | WARN_ON(!sk_unhashed(sk)); |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 702 | |
Eric Dumazet | c720c7e | 2009-10-15 06:30:45 +0000 | [diff] [blame] | 703 | /* If it has not 0 inet_sk(sk)->inet_num, it must be bound */ |
| 704 | WARN_ON(inet_sk(sk)->inet_num && !inet_csk(sk)->icsk_bind_hash); |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 705 | |
| 706 | sk->sk_prot->destroy(sk); |
| 707 | |
| 708 | sk_stream_kill_queues(sk); |
| 709 | |
| 710 | xfrm_sk_free_policy(sk); |
| 711 | |
| 712 | sk_refcnt_debug_release(sk); |
| 713 | |
Eric Dumazet | 777c6ae | 2016-05-04 15:27:29 -0700 | [diff] [blame] | 714 | local_bh_disable(); |
Eric Dumazet | dd24c00 | 2008-11-25 21:17:14 -0800 | [diff] [blame] | 715 | percpu_counter_dec(sk->sk_prot->orphan_count); |
Eric Dumazet | 777c6ae | 2016-05-04 15:27:29 -0700 | [diff] [blame] | 716 | local_bh_enable(); |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 717 | sock_put(sk); |
| 718 | } |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 719 | EXPORT_SYMBOL(inet_csk_destroy_sock); |
| 720 | |
Christoph Paasch | e337e24 | 2012-12-14 04:07:58 +0000 | [diff] [blame] | 721 | /* This function allows to force a closure of a socket after the call to |
| 722 | * tcp/dccp_create_openreq_child(). |
| 723 | */ |
| 724 | void inet_csk_prepare_forced_close(struct sock *sk) |
Christoph Paasch | c10cb5f | 2013-03-07 02:34:33 +0000 | [diff] [blame] | 725 | __releases(&sk->sk_lock.slock) |
Christoph Paasch | e337e24 | 2012-12-14 04:07:58 +0000 | [diff] [blame] | 726 | { |
| 727 | /* sk_clone_lock locked the socket and set refcnt to 2 */ |
| 728 | bh_unlock_sock(sk); |
| 729 | sock_put(sk); |
| 730 | |
| 731 | /* The below has to be done to allow calling inet_csk_destroy_sock */ |
| 732 | sock_set_flag(sk, SOCK_DEAD); |
| 733 | percpu_counter_inc(sk->sk_prot->orphan_count); |
| 734 | inet_sk(sk)->inet_num = 0; |
| 735 | } |
| 736 | EXPORT_SYMBOL(inet_csk_prepare_forced_close); |
| 737 | |
Eric Dumazet | f985c65 | 2015-10-14 06:16:49 -0700 | [diff] [blame] | 738 | int inet_csk_listen_start(struct sock *sk, int backlog) |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 739 | { |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 740 | struct inet_connection_sock *icsk = inet_csk(sk); |
Eric Dumazet | 10cbc8f | 2015-10-02 11:43:36 -0700 | [diff] [blame] | 741 | struct inet_sock *inet = inet_sk(sk); |
Craig Gallek | 086c653 | 2016-02-10 11:50:35 -0500 | [diff] [blame] | 742 | int err = -EADDRINUSE; |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 743 | |
Eric Dumazet | ef547f2 | 2015-10-02 11:43:37 -0700 | [diff] [blame] | 744 | reqsk_queue_alloc(&icsk->icsk_accept_queue); |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 745 | |
Eric Dumazet | f985c65 | 2015-10-14 06:16:49 -0700 | [diff] [blame] | 746 | sk->sk_max_ack_backlog = backlog; |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 747 | sk->sk_ack_backlog = 0; |
| 748 | inet_csk_delack_init(sk); |
| 749 | |
| 750 | /* There is race window here: we announce ourselves listening, |
| 751 | * but this transition is still not validated by get_port(). |
| 752 | * It is OK, because this socket enters to hash table only |
| 753 | * after validation is complete. |
| 754 | */ |
Eric Dumazet | 00fd38d | 2015-11-12 08:43:18 -0800 | [diff] [blame] | 755 | sk_state_store(sk, TCP_LISTEN); |
Eric Dumazet | c720c7e | 2009-10-15 06:30:45 +0000 | [diff] [blame] | 756 | if (!sk->sk_prot->get_port(sk, inet->inet_num)) { |
| 757 | inet->inet_sport = htons(inet->inet_num); |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 758 | |
| 759 | sk_dst_reset(sk); |
Craig Gallek | 086c653 | 2016-02-10 11:50:35 -0500 | [diff] [blame] | 760 | err = sk->sk_prot->hash(sk); |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 761 | |
Craig Gallek | 086c653 | 2016-02-10 11:50:35 -0500 | [diff] [blame] | 762 | if (likely(!err)) |
| 763 | return 0; |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 764 | } |
| 765 | |
| 766 | sk->sk_state = TCP_CLOSE; |
Craig Gallek | 086c653 | 2016-02-10 11:50:35 -0500 | [diff] [blame] | 767 | return err; |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 768 | } |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 769 | EXPORT_SYMBOL_GPL(inet_csk_listen_start); |
| 770 | |
Eric Dumazet | ebb516a | 2015-10-14 11:16:28 -0700 | [diff] [blame] | 771 | static void inet_child_forget(struct sock *sk, struct request_sock *req, |
| 772 | struct sock *child) |
| 773 | { |
| 774 | sk->sk_prot->disconnect(child, O_NONBLOCK); |
| 775 | |
| 776 | sock_orphan(child); |
| 777 | |
| 778 | percpu_counter_inc(sk->sk_prot->orphan_count); |
| 779 | |
| 780 | if (sk->sk_protocol == IPPROTO_TCP && tcp_rsk(req)->tfo_listener) { |
| 781 | BUG_ON(tcp_sk(child)->fastopen_rsk != req); |
| 782 | BUG_ON(sk != req->rsk_listener); |
| 783 | |
| 784 | /* Paranoid, to prevent race condition if |
| 785 | * an inbound pkt destined for child is |
| 786 | * blocked by sock lock in tcp_v4_rcv(). |
| 787 | * Also to satisfy an assertion in |
| 788 | * tcp_v4_destroy_sock(). |
| 789 | */ |
| 790 | tcp_sk(child)->fastopen_rsk = NULL; |
| 791 | } |
| 792 | inet_csk_destroy_sock(child); |
| 793 | reqsk_put(req); |
| 794 | } |
| 795 | |
Eric Dumazet | 7716682 | 2016-02-18 05:39:18 -0800 | [diff] [blame] | 796 | struct sock *inet_csk_reqsk_queue_add(struct sock *sk, |
| 797 | struct request_sock *req, |
| 798 | struct sock *child) |
Eric Dumazet | ebb516a | 2015-10-14 11:16:28 -0700 | [diff] [blame] | 799 | { |
| 800 | struct request_sock_queue *queue = &inet_csk(sk)->icsk_accept_queue; |
| 801 | |
| 802 | spin_lock(&queue->rskq_lock); |
| 803 | if (unlikely(sk->sk_state != TCP_LISTEN)) { |
| 804 | inet_child_forget(sk, req, child); |
Eric Dumazet | 7716682 | 2016-02-18 05:39:18 -0800 | [diff] [blame] | 805 | child = NULL; |
Eric Dumazet | ebb516a | 2015-10-14 11:16:28 -0700 | [diff] [blame] | 806 | } else { |
| 807 | req->sk = child; |
| 808 | req->dl_next = NULL; |
| 809 | if (queue->rskq_accept_head == NULL) |
| 810 | queue->rskq_accept_head = req; |
| 811 | else |
| 812 | queue->rskq_accept_tail->dl_next = req; |
| 813 | queue->rskq_accept_tail = req; |
| 814 | sk_acceptq_added(sk); |
| 815 | } |
| 816 | spin_unlock(&queue->rskq_lock); |
Eric Dumazet | 7716682 | 2016-02-18 05:39:18 -0800 | [diff] [blame] | 817 | return child; |
Eric Dumazet | ebb516a | 2015-10-14 11:16:28 -0700 | [diff] [blame] | 818 | } |
| 819 | EXPORT_SYMBOL(inet_csk_reqsk_queue_add); |
| 820 | |
Eric Dumazet | 5e0724d | 2015-10-22 08:20:46 -0700 | [diff] [blame] | 821 | struct sock *inet_csk_complete_hashdance(struct sock *sk, struct sock *child, |
| 822 | struct request_sock *req, bool own_req) |
| 823 | { |
| 824 | if (own_req) { |
| 825 | inet_csk_reqsk_queue_drop(sk, req); |
| 826 | reqsk_queue_removed(&inet_csk(sk)->icsk_accept_queue, req); |
Eric Dumazet | 7716682 | 2016-02-18 05:39:18 -0800 | [diff] [blame] | 827 | if (inet_csk_reqsk_queue_add(sk, req, child)) |
| 828 | return child; |
Eric Dumazet | 5e0724d | 2015-10-22 08:20:46 -0700 | [diff] [blame] | 829 | } |
| 830 | /* Too bad, another child took ownership of the request, undo. */ |
| 831 | bh_unlock_sock(child); |
| 832 | sock_put(child); |
| 833 | return NULL; |
| 834 | } |
| 835 | EXPORT_SYMBOL(inet_csk_complete_hashdance); |
| 836 | |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 837 | /* |
| 838 | * This routine closes sockets which have been at least partially |
| 839 | * opened, but not yet accepted. |
| 840 | */ |
| 841 | void inet_csk_listen_stop(struct sock *sk) |
| 842 | { |
| 843 | struct inet_connection_sock *icsk = inet_csk(sk); |
Jerry Chu | 8336886 | 2012-08-31 12:29:12 +0000 | [diff] [blame] | 844 | struct request_sock_queue *queue = &icsk->icsk_accept_queue; |
Eric Dumazet | fff1f30 | 2015-10-02 11:43:23 -0700 | [diff] [blame] | 845 | struct request_sock *next, *req; |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 846 | |
| 847 | /* Following specs, it would be better either to send FIN |
| 848 | * (and enter FIN-WAIT-1, it is normal close) |
| 849 | * or to send active reset (abort). |
| 850 | * Certainly, it is pretty dangerous while synflood, but it is |
| 851 | * bad justification for our negligence 8) |
| 852 | * To be honest, we are not able to make either |
| 853 | * of the variants now. --ANK |
| 854 | */ |
Eric Dumazet | fff1f30 | 2015-10-02 11:43:23 -0700 | [diff] [blame] | 855 | while ((req = reqsk_queue_remove(queue, sk)) != NULL) { |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 856 | struct sock *child = req->sk; |
| 857 | |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 858 | local_bh_disable(); |
| 859 | bh_lock_sock(child); |
Ilpo Järvinen | 547b792 | 2008-07-25 21:43:18 -0700 | [diff] [blame] | 860 | WARN_ON(sock_owned_by_user(child)); |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 861 | sock_hold(child); |
| 862 | |
Eric Dumazet | ebb516a | 2015-10-14 11:16:28 -0700 | [diff] [blame] | 863 | inet_child_forget(sk, req, child); |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 864 | bh_unlock_sock(child); |
| 865 | local_bh_enable(); |
| 866 | sock_put(child); |
| 867 | |
Eric Dumazet | 92d6f17 | 2015-10-02 11:43:38 -0700 | [diff] [blame] | 868 | cond_resched(); |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 869 | } |
Eric Dumazet | 0536fcc | 2015-09-29 07:42:52 -0700 | [diff] [blame] | 870 | if (queue->fastopenq.rskq_rst_head) { |
Jerry Chu | 8336886 | 2012-08-31 12:29:12 +0000 | [diff] [blame] | 871 | /* Free all the reqs queued in rskq_rst_head. */ |
Eric Dumazet | 0536fcc | 2015-09-29 07:42:52 -0700 | [diff] [blame] | 872 | spin_lock_bh(&queue->fastopenq.lock); |
Eric Dumazet | fff1f30 | 2015-10-02 11:43:23 -0700 | [diff] [blame] | 873 | req = queue->fastopenq.rskq_rst_head; |
Eric Dumazet | 0536fcc | 2015-09-29 07:42:52 -0700 | [diff] [blame] | 874 | queue->fastopenq.rskq_rst_head = NULL; |
| 875 | spin_unlock_bh(&queue->fastopenq.lock); |
Eric Dumazet | fff1f30 | 2015-10-02 11:43:23 -0700 | [diff] [blame] | 876 | while (req != NULL) { |
| 877 | next = req->dl_next; |
Eric Dumazet | 13854e5 | 2015-03-15 21:12:16 -0700 | [diff] [blame] | 878 | reqsk_put(req); |
Eric Dumazet | fff1f30 | 2015-10-02 11:43:23 -0700 | [diff] [blame] | 879 | req = next; |
Jerry Chu | 8336886 | 2012-08-31 12:29:12 +0000 | [diff] [blame] | 880 | } |
| 881 | } |
Eric Dumazet | ebb516a | 2015-10-14 11:16:28 -0700 | [diff] [blame] | 882 | WARN_ON_ONCE(sk->sk_ack_backlog); |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 883 | } |
Arnaldo Carvalho de Melo | a019d6f | 2005-08-09 20:15:09 -0700 | [diff] [blame] | 884 | EXPORT_SYMBOL_GPL(inet_csk_listen_stop); |
Arnaldo Carvalho de Melo | af05dc9 | 2005-12-13 23:16:04 -0800 | [diff] [blame] | 885 | |
| 886 | void inet_csk_addr2sockaddr(struct sock *sk, struct sockaddr *uaddr) |
| 887 | { |
| 888 | struct sockaddr_in *sin = (struct sockaddr_in *)uaddr; |
| 889 | const struct inet_sock *inet = inet_sk(sk); |
| 890 | |
| 891 | sin->sin_family = AF_INET; |
Eric Dumazet | c720c7e | 2009-10-15 06:30:45 +0000 | [diff] [blame] | 892 | sin->sin_addr.s_addr = inet->inet_daddr; |
| 893 | sin->sin_port = inet->inet_dport; |
Arnaldo Carvalho de Melo | af05dc9 | 2005-12-13 23:16:04 -0800 | [diff] [blame] | 894 | } |
Arnaldo Carvalho de Melo | af05dc9 | 2005-12-13 23:16:04 -0800 | [diff] [blame] | 895 | EXPORT_SYMBOL_GPL(inet_csk_addr2sockaddr); |
Arnaldo Carvalho de Melo | c4d9390 | 2006-03-20 22:01:03 -0800 | [diff] [blame] | 896 | |
Arnaldo Carvalho de Melo | dec73ff | 2006-03-20 22:46:16 -0800 | [diff] [blame] | 897 | #ifdef CONFIG_COMPAT |
| 898 | int inet_csk_compat_getsockopt(struct sock *sk, int level, int optname, |
| 899 | char __user *optval, int __user *optlen) |
| 900 | { |
David S. Miller | dbeff12 | 2006-03-20 22:52:32 -0800 | [diff] [blame] | 901 | const struct inet_connection_sock *icsk = inet_csk(sk); |
Arnaldo Carvalho de Melo | dec73ff | 2006-03-20 22:46:16 -0800 | [diff] [blame] | 902 | |
Ian Morris | 00db412 | 2015-04-03 09:17:27 +0100 | [diff] [blame] | 903 | if (icsk->icsk_af_ops->compat_getsockopt) |
Arnaldo Carvalho de Melo | dec73ff | 2006-03-20 22:46:16 -0800 | [diff] [blame] | 904 | return icsk->icsk_af_ops->compat_getsockopt(sk, level, optname, |
| 905 | optval, optlen); |
| 906 | return icsk->icsk_af_ops->getsockopt(sk, level, optname, |
| 907 | optval, optlen); |
| 908 | } |
Arnaldo Carvalho de Melo | dec73ff | 2006-03-20 22:46:16 -0800 | [diff] [blame] | 909 | EXPORT_SYMBOL_GPL(inet_csk_compat_getsockopt); |
| 910 | |
| 911 | int inet_csk_compat_setsockopt(struct sock *sk, int level, int optname, |
David S. Miller | b705884 | 2009-09-30 16:12:20 -0700 | [diff] [blame] | 912 | char __user *optval, unsigned int optlen) |
Arnaldo Carvalho de Melo | dec73ff | 2006-03-20 22:46:16 -0800 | [diff] [blame] | 913 | { |
David S. Miller | dbeff12 | 2006-03-20 22:52:32 -0800 | [diff] [blame] | 914 | const struct inet_connection_sock *icsk = inet_csk(sk); |
Arnaldo Carvalho de Melo | dec73ff | 2006-03-20 22:46:16 -0800 | [diff] [blame] | 915 | |
Ian Morris | 00db412 | 2015-04-03 09:17:27 +0100 | [diff] [blame] | 916 | if (icsk->icsk_af_ops->compat_setsockopt) |
Arnaldo Carvalho de Melo | dec73ff | 2006-03-20 22:46:16 -0800 | [diff] [blame] | 917 | return icsk->icsk_af_ops->compat_setsockopt(sk, level, optname, |
| 918 | optval, optlen); |
| 919 | return icsk->icsk_af_ops->setsockopt(sk, level, optname, |
| 920 | optval, optlen); |
| 921 | } |
Arnaldo Carvalho de Melo | dec73ff | 2006-03-20 22:46:16 -0800 | [diff] [blame] | 922 | EXPORT_SYMBOL_GPL(inet_csk_compat_setsockopt); |
| 923 | #endif |
David S. Miller | 80d0a69 | 2012-07-16 03:28:06 -0700 | [diff] [blame] | 924 | |
| 925 | static struct dst_entry *inet_csk_rebuild_route(struct sock *sk, struct flowi *fl) |
| 926 | { |
Eric Dumazet | 5abf7f7 | 2012-07-17 22:42:13 +0200 | [diff] [blame] | 927 | const struct inet_sock *inet = inet_sk(sk); |
| 928 | const struct ip_options_rcu *inet_opt; |
David S. Miller | 80d0a69 | 2012-07-16 03:28:06 -0700 | [diff] [blame] | 929 | __be32 daddr = inet->inet_daddr; |
| 930 | struct flowi4 *fl4; |
| 931 | struct rtable *rt; |
| 932 | |
| 933 | rcu_read_lock(); |
| 934 | inet_opt = rcu_dereference(inet->inet_opt); |
| 935 | if (inet_opt && inet_opt->opt.srr) |
| 936 | daddr = inet_opt->opt.faddr; |
| 937 | fl4 = &fl->u.ip4; |
| 938 | rt = ip_route_output_ports(sock_net(sk), fl4, sk, daddr, |
| 939 | inet->inet_saddr, inet->inet_dport, |
| 940 | inet->inet_sport, sk->sk_protocol, |
| 941 | RT_CONN_FLAGS(sk), sk->sk_bound_dev_if); |
| 942 | if (IS_ERR(rt)) |
| 943 | rt = NULL; |
| 944 | if (rt) |
| 945 | sk_setup_caps(sk, &rt->dst); |
| 946 | rcu_read_unlock(); |
| 947 | |
| 948 | return &rt->dst; |
| 949 | } |
| 950 | |
| 951 | struct dst_entry *inet_csk_update_pmtu(struct sock *sk, u32 mtu) |
| 952 | { |
| 953 | struct dst_entry *dst = __sk_dst_check(sk, 0); |
| 954 | struct inet_sock *inet = inet_sk(sk); |
| 955 | |
| 956 | if (!dst) { |
| 957 | dst = inet_csk_rebuild_route(sk, &inet->cork.fl); |
| 958 | if (!dst) |
| 959 | goto out; |
| 960 | } |
David S. Miller | 6700c27 | 2012-07-17 03:29:28 -0700 | [diff] [blame] | 961 | dst->ops->update_pmtu(dst, sk, NULL, mtu); |
David S. Miller | 80d0a69 | 2012-07-16 03:28:06 -0700 | [diff] [blame] | 962 | |
| 963 | dst = __sk_dst_check(sk, 0); |
| 964 | if (!dst) |
| 965 | dst = inet_csk_rebuild_route(sk, &inet->cork.fl); |
| 966 | out: |
| 967 | return dst; |
| 968 | } |
| 969 | EXPORT_SYMBOL_GPL(inet_csk_update_pmtu); |