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

TOMOYO Linux Cross Reference
Linux/net/ipv4/inet_connection_sock.c

Version: ~ [ linux-5.12-rc1 ] ~ [ linux-5.11.2 ] ~ [ linux-5.10.19 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.101 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.177 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.222 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.258 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.258 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * INET         An implementation of the TCP/IP protocol suite for the LINUX
  3  *              operating system.  INET is implemented using the  BSD Socket
  4  *              interface as the means of communication with the user level.
  5  *
  6  *              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 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                 *low = net->ipv4.sysctl_local_ports.range[0];
 43                 *high = net->ipv4.sysctl_local_ports.range[1];
 44         } while (read_seqretry(&net->ipv4.sysctl_local_ports.lock, seq));
 45 }
 46 EXPORT_SYMBOL(inet_get_local_port_range);
 47 
 48 int inet_csk_bind_conflict(const struct sock *sk,
 49                            const struct inet_bind_bucket *tb, bool relax)
 50 {
 51         struct sock *sk2;
 52         int reuse = sk->sk_reuse;
 53         int reuseport = sk->sk_reuseport;
 54         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         sk_for_each_bound(sk2, &tb->owners) {
 64                 if (sk != sk2 &&
 65                     !inet_v6_ipv6only(sk2) &&
 66                     (!sk->sk_bound_dev_if ||
 67                      !sk2->sk_bound_dev_if ||
 68                      sk->sk_bound_dev_if == sk2->sk_bound_dev_if)) {
 69                         if ((!reuse || !sk2->sk_reuse ||
 70                             sk2->sk_state == TCP_LISTEN) &&
 71                             (!reuseport || !sk2->sk_reuseport ||
 72                             (sk2->sk_state != TCP_TIME_WAIT &&
 73                              !uid_eq(uid, sock_i_uid(sk2))))) {
 74 
 75                                 if (!sk2->sk_rcv_saddr || !sk->sk_rcv_saddr ||
 76                                     sk2->sk_rcv_saddr == sk->sk_rcv_saddr)
 77                                         break;
 78                         }
 79                         if (!relax && reuse && sk2->sk_reuse &&
 80                             sk2->sk_state != TCP_LISTEN) {
 81 
 82                                 if (!sk2->sk_rcv_saddr || !sk->sk_rcv_saddr ||
 83                                     sk2->sk_rcv_saddr == sk->sk_rcv_saddr)
 84                                         break;
 85                         }
 86                 }
 87         }
 88         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 int inet_csk_get_port(struct sock *sk, unsigned short snum)
 96 {
 97         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         kuid_t uid = sock_i_uid(sk);
104 
105         local_bh_disable();
106         if (!snum) {
107                 int remaining, rover, low, high;
108 
109 again:
110                 inet_get_local_port_range(net, &low, &high);
111                 remaining = (high - low) + 1;
112                 smallest_rover = rover = prandom_u32() % remaining + low;
113 
114                 smallest_size = -1;
115                 do {
116                         if (inet_is_reserved_local_port(rover))
117                                 goto next_nolock;
118                         head = &hashinfo->bhash[inet_bhashfn(net, rover,
119                                         hashinfo->bhash_size)];
120                         spin_lock(&head->lock);
121                         inet_bind_bucket_for_each(tb, &head->chain)
122                                 if (net_eq(ib_net(tb), net) && tb->port == rover) {
123                                         if (((tb->fastreuse > 0 &&
124                                               sk->sk_reuse &&
125                                               sk->sk_state != TCP_LISTEN) ||
126                                              (tb->fastreuseport > 0 &&
127                                               sk->sk_reuseport &&
128                                               uid_eq(tb->fastuid, uid))) &&
129                                             (tb->num_owners < smallest_size || smallest_size == -1)) {
130                                                 smallest_size = tb->num_owners;
131                                                 smallest_rover = rover;
132                                                 if (atomic_read(&hashinfo->bsockets) > (high - low) + 1 &&
133                                                     !inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, false)) {
134                                                         snum = smallest_rover;
135                                                         goto tb_found;
136                                                 }
137                                         }
138                                         if (!inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, false)) {
139                                                 snum = rover;
140                                                 goto tb_found;
141                                         }
142                                         goto next;
143                                 }
144                         break;
145                 next:
146                         spin_unlock(&head->lock);
147                 next_nolock:
148                         if (++rover > high)
149                                 rover = low;
150                 } 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                 if (remaining <= 0) {
160                         if (smallest_size != -1) {
161                                 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                 snum = rover;
170         } else {
171 have_snum:
172                 head = &hashinfo->bhash[inet_bhashfn(net, snum,
173                                 hashinfo->bhash_size)];
174                 spin_lock(&head->lock);
175                 inet_bind_bucket_for_each(tb, &head->chain)
176                         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         if (!hlist_empty(&tb->owners)) {
183                 if (sk->sk_reuse == SK_FORCE_REUSE)
184                         goto success;
185 
186                 if (((tb->fastreuse > 0 &&
187                       sk->sk_reuse && sk->sk_state != TCP_LISTEN) ||
188                      (tb->fastreuseport > 0 &&
189                       sk->sk_reuseport && uid_eq(tb->fastuid, uid))) &&
190                     smallest_size == -1) {
191                         goto success;
192                 } else {
193                         ret = 1;
194                         if (inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, true)) {
195                                 if (((sk->sk_reuse && sk->sk_state != TCP_LISTEN) ||
196                                      (tb->fastreuseport > 0 &&
197                                       sk->sk_reuseport && uid_eq(tb->fastuid, uid))) &&
198                                     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         if (!tb && (tb = inet_bind_bucket_create(hashinfo->bind_bucket_cachep,
210                                         net, head, snum)) == NULL)
211                 goto fail_unlock;
212         if (hlist_empty(&tb->owners)) {
213                 if (sk->sk_reuse && sk->sk_state != TCP_LISTEN)
214                         tb->fastreuse = 1;
215                 else
216                         tb->fastreuse = 0;
217                 if (sk->sk_reuseport) {
218                         tb->fastreuseport = 1;
219                         tb->fastuid = uid;
220                 } else
221                         tb->fastreuseport = 0;
222         } else {
223                 if (tb->fastreuse &&
224                     (!sk->sk_reuse || sk->sk_state == TCP_LISTEN))
225                         tb->fastreuse = 0;
226                 if (tb->fastreuseport &&
227                     (!sk->sk_reuseport || !uid_eq(tb->fastuid, uid)))
228                         tb->fastreuseport = 0;
229         }
230 success:
231         if (!inet_csk(sk)->icsk_bind_hash)
232                 inet_bind_hash(sk, tb, snum);
233         WARN_ON(inet_csk(sk)->icsk_bind_hash != tb);
234         ret = 0;
235 
236 fail_unlock:
237         spin_unlock(&head->lock);
238 fail:
239         local_bh_enable();
240         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 static int inet_csk_wait_for_connect(struct sock *sk, long timeo)
249 {
250         struct inet_connection_sock *icsk = inet_csk(sk);
251         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                 prepare_to_wait_exclusive(sk_sleep(sk), &wait,
270                                           TASK_INTERRUPTIBLE);
271                 release_sock(sk);
272                 if (reqsk_queue_empty(&icsk->icsk_accept_queue))
273                         timeo = schedule_timeout(timeo);
274                 lock_sock(sk);
275                 err = 0;
276                 if (!reqsk_queue_empty(&icsk->icsk_accept_queue))
277                         break;
278                 err = -EINVAL;
279                 if (sk->sk_state != TCP_LISTEN)
280                         break;
281                 err = sock_intr_errno(timeo);
282                 if (signal_pending(current))
283                         break;
284                 err = -EAGAIN;
285                 if (!timeo)
286                         break;
287         }
288         finish_wait(sk_sleep(sk), &wait);
289         return err;
290 }
291 
292 /*
293  * This will accept the next outstanding connection.
294  */
295 struct sock *inet_csk_accept(struct sock *sk, int flags, int *err)
296 {
297         struct inet_connection_sock *icsk = inet_csk(sk);
298         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         if (sk->sk_state != TCP_LISTEN)
310                 goto out_err;
311 
312         /* Find already established connection */
313         if (reqsk_queue_empty(queue)) {
314                 long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
315 
316                 /* If this is a non blocking socket don't sleep */
317                 error = -EAGAIN;
318                 if (!timeo)
319                         goto out_err;
320 
321                 error = inet_csk_wait_for_connect(sk, timeo);
322                 if (error)
323                         goto out_err;
324         }
325         req = reqsk_queue_remove(queue);
326         newsk = req->sk;
327 
328         sk_acceptq_removed(sk);
329         if (sk->sk_protocol == IPPROTO_TCP && queue->fastopenq != NULL) {
330                 spin_lock_bh(&queue->fastopenq->lock);
331                 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                         req->sk = NULL;
339                         req = NULL;
340                 }
341                 spin_unlock_bh(&queue->fastopenq->lock);
342         }
343 out:
344         release_sock(sk);
345         if (req)
346                 __reqsk_free(req);
347         return newsk;
348 out_err:
349         newsk = NULL;
350         req = NULL;
351         *err = error;
352         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 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         setup_timer(&icsk->icsk_retransmit_timer, retransmit_handler,
369                         (unsigned long)sk);
370         setup_timer(&icsk->icsk_delack_timer, delack_handler,
371                         (unsigned long)sk);
372         setup_timer(&sk->sk_timer, keepalive_handler, (unsigned long)sk);
373         icsk->icsk_pending = icsk->icsk_ack.pending = 0;
374 }
375 EXPORT_SYMBOL(inet_csk_init_xmit_timers);
376 
377 void inet_csk_clear_xmit_timers(struct sock *sk)
378 {
379         struct inet_connection_sock *icsk = inet_csk(sk);
380 
381         icsk->icsk_pending = icsk->icsk_ack.pending = icsk->icsk_ack.blocked = 0;
382 
383         sk_stop_timer(sk, &icsk->icsk_retransmit_timer);
384         sk_stop_timer(sk, &icsk->icsk_delack_timer);
385         sk_stop_timer(sk, &sk->sk_timer);
386 }
387 EXPORT_SYMBOL(inet_csk_clear_xmit_timers);
388 
389 void inet_csk_delete_keepalive_timer(struct sock *sk)
390 {
391         sk_stop_timer(sk, &sk->sk_timer);
392 }
393 EXPORT_SYMBOL(inet_csk_delete_keepalive_timer);
394 
395 void inet_csk_reset_keepalive_timer(struct sock *sk, unsigned long len)
396 {
397         sk_reset_timer(sk, &sk->sk_timer, jiffies + len);
398 }
399 EXPORT_SYMBOL(inet_csk_reset_keepalive_timer);
400 
401 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         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         flowi4_init_output(fl4, sk->sk_bound_dev_if, sk->sk_mark,
412                            RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE,
413                            sk->sk_protocol,
414                            flags,
415                            (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         security_req_classify_flow(req, flowi4_to_flowi(fl4));
418         rt = ip_route_output_flow(net, fl4, sk);
419         if (IS_ERR(rt))
420                 goto no_route;
421         if (opt && opt->opt.is_strictroute && rt->rt_uses_gateway)
422                 goto route_err;
423         return &rt->dst;
424 
425 route_err:
426         ip_rt_put(rt);
427 no_route:
428         IP_INC_STATS_BH(net, IPSTATS_MIB_OUTNOROUTES);
429         return NULL;
430 }
431 EXPORT_SYMBOL_GPL(inet_csk_route_req);
432 
433 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         fl4 = &newinet->cork.fl.u.ip4;
445 
446         rcu_read_lock();
447         opt = rcu_dereference(newinet->inet_opt);
448         flowi4_init_output(fl4, sk->sk_bound_dev_if, sk->sk_mark,
449                            RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE,
450                            sk->sk_protocol, inet_sk_flowi_flags(sk),
451                            (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         security_req_classify_flow(req, flowi4_to_flowi(fl4));
454         rt = ip_route_output_flow(net, fl4, sk);
455         if (IS_ERR(rt))
456                 goto no_route;
457         if (opt && opt->opt.is_strictroute && rt->rt_uses_gateway)
458                 goto route_err;
459         rcu_read_unlock();
460         return &rt->dst;
461 
462 route_err:
463         ip_rt_put(rt);
464 no_route:
465         rcu_read_unlock();
466         IP_INC_STATS_BH(net, IPSTATS_MIB_OUTNOROUTES);
467         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         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 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         struct listen_sock *lopt = icsk->icsk_accept_queue.listen_opt;
490         struct request_sock *req, **prev;
491 
492         for (prev = &lopt->syn_table[inet_synq_hash(raddr, rport, lopt->hash_rnd,
493                                                     lopt->nr_table_entries)];
494              (req = *prev) != NULL;
495              prev = &req->dl_next) {
496                 const struct inet_request_sock *ireq = inet_rsk(req);
497 
498                 if (ireq->ir_rmt_port == rport &&
499                     ireq->ir_rmt_addr == raddr &&
500                     ireq->ir_loc_addr == laddr &&
501                     AF_INET_FAMILY(req->rsk_ops->family)) {
502                         WARN_ON(req->sk);
503                         *prevp = prev;
504                         break;
505                 }
506         }
507 
508         return req;
509 }
510 EXPORT_SYMBOL_GPL(inet_csk_search_req);
511 
512 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         struct listen_sock *lopt = icsk->icsk_accept_queue.listen_opt;
517         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 }
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         if (!rskq_defer_accept) {
537                 *expire = req->num_timeout >= thresh;
538                 *resend = 1;
539                 return;
540         }
541         *expire = req->num_timeout >= thresh &&
542                   (!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         *resend = !inet_rsk(req)->acked ||
549                   req->num_timeout >= rskq_defer_accept - 1;
550 }
551 
552 int inet_rtx_syn_ack(struct sock *parent, struct request_sock *req)
553 {
554         int err = req->rsk_ops->rtx_syn_ack(parent, req);
555 
556         if (!err)
557                 req->num_retrans++;
558         return err;
559 }
560 EXPORT_SYMBOL(inet_rtx_syn_ack);
561 
562 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         struct request_sock_queue *queue = &icsk->icsk_accept_queue;
569         struct listen_sock *lopt = queue->listen_opt;
570         int max_retries = icsk->icsk_syn_retries ? : sysctl_tcp_synack_retries;
571         int thresh = max_retries;
572         unsigned long now = jiffies;
573         struct request_sock **reqp, *req;
574         int i, budget;
575 
576         if (lopt == NULL || lopt->qlen == 0)
577                 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         if (lopt->qlen>>(lopt->max_qlen_log-1)) {
597                 int young = (lopt->qlen_young<<1);
598 
599                 while (thresh > 2) {
600                         if (lopt->qlen < young)
601                                 break;
602                         thresh--;
603                         young <<= 1;
604                 }
605         }
606 
607         if (queue->rskq_defer_accept)
608                 max_retries = queue->rskq_defer_accept;
609 
610         budget = 2 * (lopt->nr_table_entries / (timeout / interval));
611         i = lopt->clock_hand;
612 
613         do {
614                 reqp=&lopt->syn_table[i];
615                 while ((req = *reqp) != NULL) {
616                         if (time_after_eq(now, req->expires)) {
617                                 int expire = 0, resend = 0;
618 
619                                 syn_ack_recalc(req, thresh, max_retries,
620                                                queue->rskq_defer_accept,
621                                                &expire, &resend);
622                                 req->rsk_ops->syn_ack_timeout(parent, req);
623                                 if (!expire &&
624                                     (!resend ||
625                                      !inet_rtx_syn_ack(parent, req) ||
626                                      inet_rsk(req)->acked)) {
627                                         unsigned long timeo;
628 
629                                         if (req->num_timeout++ == 0)
630                                                 lopt->qlen_young--;
631                                         timeo = min(timeout << req->num_timeout,
632                                                     max_rto);
633                                         req->expires = now + timeo;
634                                         reqp = &req->dl_next;
635                                         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                                 continue;
643                         }
644                         reqp = &req->dl_next;
645                 }
646 
647                 i = (i + 1) & (lopt->nr_table_entries - 1);
648 
649         } while (--budget > 0);
650 
651         lopt->clock_hand = i;
652 
653         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 struct sock *inet_csk_clone_lock(const struct sock *sk,
667                                  const struct request_sock *req,
668                                  const gfp_t priority)
669 {
670         struct sock *newsk = sk_clone_lock(sk, priority);
671 
672         if (newsk != NULL) {
673                 struct inet_connection_sock *newicsk = inet_csk(newsk);
674 
675                 newsk->sk_state = TCP_SYN_RECV;
676                 newicsk->icsk_bind_hash = NULL;
677 
678                 inet_sk(newsk)->inet_dport = inet_rsk(req)->ir_rmt_port;
679                 inet_sk(newsk)->inet_num = inet_rsk(req)->ir_num;
680                 inet_sk(newsk)->inet_sport = htons(inet_rsk(req)->ir_num);
681                 newsk->sk_write_space = sk_stream_write_space;
682 
683                 newicsk->icsk_retransmits = 0;
684                 newicsk->icsk_backoff     = 0;
685                 newicsk->icsk_probes_out  = 0;
686 
687                 /* Deinitialize accept_queue to trap illegal accesses. */
688                 memset(&newicsk->icsk_accept_queue, 0, sizeof(newicsk->icsk_accept_queue));
689 
690                 security_inet_csk_clone(newsk, req);
691         }
692         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 void inet_csk_destroy_sock(struct sock *sk)
703 {
704         WARN_ON(sk->sk_state != TCP_CLOSE);
705         WARN_ON(!sock_flag(sk, SOCK_DEAD));
706 
707         /* It cannot be in hash table! */
708         WARN_ON(!sk_unhashed(sk));
709 
710         /* If it has not 0 inet_sk(sk)->inet_num, it must be bound */
711         WARN_ON(inet_sk(sk)->inet_num && !inet_csk(sk)->icsk_bind_hash);
712 
713         sk->sk_prot->destroy(sk);
714 
715         sk_stream_kill_queues(sk);
716 
717         xfrm_sk_free_policy(sk);
718 
719         sk_refcnt_debug_release(sk);
720 
721         percpu_counter_dec(sk->sk_prot->orphan_count);
722         sock_put(sk);
723 }
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 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         percpu_counter_inc(sk->sk_prot->orphan_count);
739         inet_sk(sk)->inet_num = 0;
740 }
741 EXPORT_SYMBOL(inet_csk_prepare_forced_close);
742 
743 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         int rc = reqsk_queue_alloc(&icsk->icsk_accept_queue, nr_table_entries);
748 
749         if (rc != 0)
750                 return rc;
751 
752         sk->sk_max_ack_backlog = 0;
753         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         sk->sk_state = TCP_LISTEN;
762         if (!sk->sk_prot->get_port(sk, inet->inet_num)) {
763                 inet->inet_sport = htons(inet->inet_num);
764 
765                 sk_dst_reset(sk);
766                 sk->sk_prot->hash(sk);
767 
768                 return 0;
769         }
770 
771         sk->sk_state = TCP_CLOSE;
772         __reqsk_queue_destroy(&icsk->icsk_accept_queue);
773         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 void inet_csk_listen_stop(struct sock *sk)
782 {
783         struct inet_connection_sock *icsk = inet_csk(sk);
784         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         reqsk_queue_destroy(queue);
802 
803         while ((req = acc_req) != NULL) {
804                 struct sock *child = req->sk;
805 
806                 acc_req = req->dl_next;
807 
808                 local_bh_disable();
809                 bh_lock_sock(child);
810                 WARN_ON(sock_owned_by_user(child));
811                 sock_hold(child);
812 
813                 sk->sk_prot->disconnect(child, O_NONBLOCK);
814 
815                 sock_orphan(child);
816 
817                 percpu_counter_inc(sk->sk_prot->orphan_count);
818 
819                 if (sk->sk_protocol == IPPROTO_TCP && tcp_rsk(req)->listener) {
820                         BUG_ON(tcp_sk(child)->fastopen_rsk != req);
821                         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                         tcp_sk(child)->fastopen_rsk = NULL;
830                         sock_put(sk);
831                 }
832                 inet_csk_destroy_sock(child);
833 
834                 bh_unlock_sock(child);
835                 local_bh_enable();
836                 sock_put(child);
837 
838                 sk_acceptq_removed(sk);
839                 __reqsk_free(req);
840         }
841         if (queue->fastopenq != NULL) {
842                 /* Free all the reqs queued in rskq_rst_head. */
843                 spin_lock_bh(&queue->fastopenq->lock);
844                 acc_req = queue->fastopenq->rskq_rst_head;
845                 queue->fastopenq->rskq_rst_head = NULL;
846                 spin_unlock_bh(&queue->fastopenq->lock);
847                 while ((req = acc_req) != NULL) {
848                         acc_req = req->dl_next;
849                         __reqsk_free(req);
850                 }
851         }
852         WARN_ON(sk->sk_ack_backlog);
853 }
854 EXPORT_SYMBOL_GPL(inet_csk_listen_stop);
855 
856 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         sin->sin_family         = AF_INET;
862         sin->sin_addr.s_addr    = inet->inet_daddr;
863         sin->sin_port           = inet->inet_dport;
864 }
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 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         __be32 daddr = inet->inet_daddr;
900         struct flowi4 *fl4;
901         struct rtable *rt;
902 
903         rcu_read_lock();
904         inet_opt = rcu_dereference(inet->inet_opt);
905         if (inet_opt && inet_opt->opt.srr)
906                 daddr = inet_opt->opt.faddr;
907         fl4 = &fl->u.ip4;
908         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                                    RT_CONN_FLAGS(sk), sk->sk_bound_dev_if);
912         if (IS_ERR(rt))
913                 rt = NULL;
914         if (rt)
915                 sk_setup_caps(sk, &rt->dst);
916         rcu_read_unlock();
917 
918         return &rt->dst;
919 }
920 
921 struct dst_entry *inet_csk_update_pmtu(struct sock *sk, u32 mtu)
922 {
923         struct dst_entry *dst = __sk_dst_check(sk, 0);
924         struct inet_sock *inet = inet_sk(sk);
925 
926         if (!dst) {
927                 dst = inet_csk_rebuild_route(sk, &inet->cork.fl);
928                 if (!dst)
929                         goto out;
930         }
931         dst->ops->update_pmtu(dst, sk, NULL, mtu);
932 
933         dst = __sk_dst_check(sk, 0);
934         if (!dst)
935                 dst = inet_csk_rebuild_route(sk, &inet->cork.fl);
936 out:
937         return dst;
938 }
939 EXPORT_SYMBOL_GPL(inet_csk_update_pmtu);
940 

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

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

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

osdn.jp