One Level Up Top Level

src/core/ngx_connection.c - nginx source code

Global variables defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_event.h>


  13. ‌ngx_os_io_t  ngx_io;


  16. static void ngx_drain_connections(ngx_cycle_t *cycle);


  19. ngx_listening_t *
  20. ‌ngx_create_listening(ngx_conf_t *cf, struct sockaddr *sockaddr,
  21.     socklen_t socklen)
  22. {
  23.     size_t            len;
  24.     ngx_listening_t  *ls;
  25.     struct sockaddr  *sa;
  26.     u_char            text[NGX_SOCKADDR_STRLEN];

  28.     ls = ngx_array_push(&cf->cycle->listening);
  29.     if (ls == NULL) {
  30.         return NULL;
  31.     }

  33.     ngx_memzero(ls, sizeof(ngx_listening_t));

  35.     sa = ngx_palloc(cf->pool, socklen);
  36.     if (sa == NULL) {
  37.         return NULL;
  38.     }

  40.     ngx_memcpy(sa, sockaddr, socklen);

  42.     ls->sockaddr = sa;
  43.     ls->socklen = socklen;

  45.     len = ngx_sock_ntop(sa, socklen, text, NGX_SOCKADDR_STRLEN, 1);
  46.     ls->addr_text.len = len;

  48.     switch (ls->sockaddr->sa_family) {
  49. #if (NGX_HAVE_INET6)
  50.     case AF_INET6:
  51.         ls->addr_text_max_len = NGX_INET6_ADDRSTRLEN;
  52.         break;
  53. #endif
  54. #if (NGX_HAVE_UNIX_DOMAIN)
  55.     case AF_UNIX:
  56.         ls->addr_text_max_len = NGX_UNIX_ADDRSTRLEN;
  57.         len++;
  58.         break;
  59. #endif
  60.     case AF_INET:
  61.         ls->addr_text_max_len = NGX_INET_ADDRSTRLEN;
  62.         break;
  63.     default:
  64.         ls->addr_text_max_len = NGX_SOCKADDR_STRLEN;
  65.         break;
  66.     }

  68.     ls->addr_text.data = ngx_pnalloc(cf->pool, len);
  69.     if (ls->addr_text.data == NULL) {
  70.         return NULL;
  71.     }

  73.     ngx_memcpy(ls->addr_text.data, text, len);

  75. #if !(NGX_WIN32)
  76.     ngx_rbtree_init(&ls->rbtree, &ls->sentinel, ngx_udp_rbtree_insert_value);
  77. #endif

  79.     ls->fd = (ngx_socket_t) -1;
  80.     ls->type = SOCK_STREAM;

  82.     ls->backlog = NGX_LISTEN_BACKLOG;
  83.     ls->rcvbuf = -1;
  84.     ls->sndbuf = -1;

  86. #if (NGX_HAVE_SETFIB)
  87.     ls->setfib = -1;
  88. #endif

  90. #if (NGX_HAVE_TCP_FASTOPEN)
  91.     ls->fastopen = -1;
  92. #endif

  94.     return ls;
  95. }


  98. ngx_int_t
  99. ‌ngx_clone_listening(ngx_cycle_t *cycle, ngx_listening_t *ls)
  100. {
  101. #if (NGX_HAVE_REUSEPORT)

  103.     ngx_int_t         n;
  104.     ngx_core_conf_t  *ccf;
  105.     ngx_listening_t   ols;

  107.     if (!ls->reuseport || ls->worker != 0) {
  108.         return NGX_OK;
  109.     }

  111.     ols = *ls;

  113.     ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);

  115.     for (n = 1; n < ccf->worker_processes; n++) {

  117.         /* create a socket for each worker process */

  119.         ls = ngx_array_push(&cycle->listening);
  120.         if (ls == NULL) {
  121.             return NGX_ERROR;
  122.         }

  124.         *ls = ols;
  125.         ls->worker = n;
  126.     }

  128. #endif

  130.     return NGX_OK;
  131. }


  134. ngx_int_t
  135. ‌ngx_set_inherited_sockets(ngx_cycle_t *cycle)
  136. {
  137.     size_t                     len;
  138.     ngx_uint_t                 i;
  139.     ngx_listening_t           *ls;
  140.     socklen_t                  olen;
  141. #if (NGX_HAVE_DEFERRED_ACCEPT || NGX_HAVE_TCP_FASTOPEN)
  142.     ngx_err_t                  err;
  143. #endif
  144. #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
  145.     struct accept_filter_arg   af;
  146. #endif
  147. #if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
  148.     int                        timeout;
  149. #endif
  150. #if (NGX_HAVE_REUSEPORT)
  151.     int                        reuseport;
  152. #endif

  154.     ls = cycle->listening.elts;
  155.     for (i = 0; i < cycle->listening.nelts; i++) {

  157.         ls[i].sockaddr = ngx_palloc(cycle->pool, sizeof(ngx_sockaddr_t));
  158.         if (ls[i].sockaddr == NULL) {
  159.             return NGX_ERROR;
  160.         }

  162.         ls[i].socklen = sizeof(ngx_sockaddr_t);
  163.         if (getsockname(ls[i].fd, ls[i].sockaddr, &ls[i].socklen) == -1) {
  164.             ngx_log_error(NGX_LOG_CRIT, cycle->log, ngx_socket_errno,
  165.                           "getsockname() of the inherited "
  166.                           "socket #%d failed", ls[i].fd);
  167.             ls[i].ignore = 1;
  168.             continue;
  169.         }

  171.         if (ls[i].socklen > (socklen_t) sizeof(ngx_sockaddr_t)) {
  172.             ls[i].socklen = sizeof(ngx_sockaddr_t);
  173.         }

  175.         switch (ls[i].sockaddr->sa_family) {

  177. #if (NGX_HAVE_INET6)
  178.         case AF_INET6:
  179.             ls[i].addr_text_max_len = NGX_INET6_ADDRSTRLEN;
  180.             len = NGX_INET6_ADDRSTRLEN + sizeof("[]:65535") - 1;
  181.             break;
  182. #endif

  184. #if (NGX_HAVE_UNIX_DOMAIN)
  185.         case AF_UNIX:
  186.             ls[i].addr_text_max_len = NGX_UNIX_ADDRSTRLEN;
  187.             len = NGX_UNIX_ADDRSTRLEN;
  188.             break;
  189. #endif

  191.         case AF_INET:
  192.             ls[i].addr_text_max_len = NGX_INET_ADDRSTRLEN;
  193.             len = NGX_INET_ADDRSTRLEN + sizeof(":65535") - 1;
  194.             break;

  196.         default:
  197.             ngx_log_error(NGX_LOG_CRIT, cycle->log, ngx_socket_errno,
  198.                           "the inherited socket #%d has "
  199.                           "an unsupported protocol family", ls[i].fd);
  200.             ls[i].ignore = 1;
  201.             continue;
  202.         }

  204.         ls[i].addr_text.data = ngx_pnalloc(cycle->pool, len);
  205.         if (ls[i].addr_text.data == NULL) {
  206.             return NGX_ERROR;
  207.         }

  209.         len = ngx_sock_ntop(ls[i].sockaddr, ls[i].socklen,
  210.                             ls[i].addr_text.data, len, 1);
  211.         if (len == 0) {
  212.             return NGX_ERROR;
  213.         }

  215.         ls[i].addr_text.len = len;

  217.         ls[i].backlog = NGX_LISTEN_BACKLOG;

  219.         olen = sizeof(int);

  221.         if (getsockopt(ls[i].fd, SOL_SOCKET, SO_TYPE, (void *) &ls[i].type,
  222.                        &olen)
  223.             == -1)
  224.         {
  225.             ngx_log_error(NGX_LOG_CRIT, cycle->log, ngx_socket_errno,
  226.                           "getsockopt(SO_TYPE) %V failed", &ls[i].addr_text);
  227.             ls[i].ignore = 1;
  228.             continue;
  229.         }

  231.         olen = sizeof(int);

  233.         if (getsockopt(ls[i].fd, SOL_SOCKET, SO_RCVBUF, (void *) &ls[i].rcvbuf,
  234.                        &olen)
  235.             == -1)
  236.         {
  237.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  238.                           "getsockopt(SO_RCVBUF) %V failed, ignored",
  239.                           &ls[i].addr_text);

  241.             ls[i].rcvbuf = -1;
  242.         }

  244.         olen = sizeof(int);

  246.         if (getsockopt(ls[i].fd, SOL_SOCKET, SO_SNDBUF, (void *) &ls[i].sndbuf,
  247.                        &olen)
  248.             == -1)
  249.         {
  250.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  251.                           "getsockopt(SO_SNDBUF) %V failed, ignored",
  252.                           &ls[i].addr_text);

  254.             ls[i].sndbuf = -1;
  255.         }

  257. #if 0
  258.         /* SO_SETFIB is currently a set only option */

  260. #if (NGX_HAVE_SETFIB)

  262.         olen = sizeof(int);

  264.         if (getsockopt(ls[i].fd, SOL_SOCKET, SO_SETFIB,
  265.                        (void *) &ls[i].setfib, &olen)
  266.             == -1)
  267.         {
  268.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  269.                           "getsockopt(SO_SETFIB) %V failed, ignored",
  270.                           &ls[i].addr_text);

  272.             ls[i].setfib = -1;
  273.         }

  275. #endif
  276. #endif

  278. #if (NGX_HAVE_REUSEPORT)

  280.         reuseport = 0;
  281.         olen = sizeof(int);

  283. #ifdef SO_REUSEPORT_LB

  285.         if (getsockopt(ls[i].fd, SOL_SOCKET, SO_REUSEPORT_LB,
  286.                        (void *) &reuseport, &olen)
  287.             == -1)
  288.         {
  289.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  290.                           "getsockopt(SO_REUSEPORT_LB) %V failed, ignored",
  291.                           &ls[i].addr_text);

  293.         } else {
  294.             ls[i].reuseport = reuseport ? 1 : 0;
  295.         }

  297. #else

  299.         if (getsockopt(ls[i].fd, SOL_SOCKET, SO_REUSEPORT,
  300.                        (void *) &reuseport, &olen)
  301.             == -1)
  302.         {
  303.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  304.                           "getsockopt(SO_REUSEPORT) %V failed, ignored",
  305.                           &ls[i].addr_text);

  307.         } else {
  308.             ls[i].reuseport = reuseport ? 1 : 0;
  309.         }
  310. #endif

  312. #endif

  314.         if (ls[i].type != SOCK_STREAM) {
  315.             continue;
  316.         }

  318. #if (NGX_HAVE_TCP_FASTOPEN)

  320.         olen = sizeof(int);

  322.         if (getsockopt(ls[i].fd, IPPROTO_TCP, TCP_FASTOPEN,
  323.                        (void *) &ls[i].fastopen, &olen)
  324.             == -1)
  325.         {
  326.             err = ngx_socket_errno;

  328.             if (err != NGX_EOPNOTSUPP && err != NGX_ENOPROTOOPT
  329.                 && err != NGX_EINVAL)
  330.             {
  331.                 ngx_log_error(NGX_LOG_NOTICE, cycle->log, err,
  332.                               "getsockopt(TCP_FASTOPEN) %V failed, ignored",
  333.                               &ls[i].addr_text);
  334.             }

  336.             ls[i].fastopen = -1;
  337.         }

  339. #endif

  341. #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)

  343.         ngx_memzero(&af, sizeof(struct accept_filter_arg));
  344.         olen = sizeof(struct accept_filter_arg);

  346.         if (getsockopt(ls[i].fd, SOL_SOCKET, SO_ACCEPTFILTER, &af, &olen)
  347.             == -1)
  348.         {
  349.             err = ngx_socket_errno;

  351.             if (err == NGX_EINVAL) {
  352.                 continue;
  353.             }

  355.             ngx_log_error(NGX_LOG_NOTICE, cycle->log, err,
  356.                           "getsockopt(SO_ACCEPTFILTER) for %V failed, ignored",
  357.                           &ls[i].addr_text);
  358.             continue;
  359.         }

  361.         if (olen < sizeof(struct accept_filter_arg) || af.af_name[0] == '\0') {
  362.             continue;
  363.         }

  365.         ls[i].accept_filter = ngx_palloc(cycle->pool, 16);
  366.         if (ls[i].accept_filter == NULL) {
  367.             return NGX_ERROR;
  368.         }

  370.         (void) ngx_cpystrn((u_char *) ls[i].accept_filter,
  371.                            (u_char *) af.af_name, 16);
  372. #endif

  374. #if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)

  376.         timeout = 0;
  377.         olen = sizeof(int);

  379.         if (getsockopt(ls[i].fd, IPPROTO_TCP, TCP_DEFER_ACCEPT, &timeout, &olen)
  380.             == -1)
  381.         {
  382.             err = ngx_socket_errno;

  384.             if (err == NGX_EOPNOTSUPP) {
  385.                 continue;
  386.             }

  388.             ngx_log_error(NGX_LOG_NOTICE, cycle->log, err,
  389.                           "getsockopt(TCP_DEFER_ACCEPT) for %V failed, ignored",
  390.                           &ls[i].addr_text);
  391.             continue;
  392.         }

  394.         if (olen < sizeof(int) || timeout == 0) {
  395.             continue;
  396.         }

  398.         ls[i].deferred_accept = 1;
  399. #endif
  400.     }

  402.     return NGX_OK;
  403. }


  406. ngx_int_t
  407. ‌ngx_open_listening_sockets(ngx_cycle_t *cycle)
  408. {
  409.     int               reuseaddr;
  410.     ngx_uint_t        i, tries, failed;
  411.     ngx_err_t         err;
  412.     ngx_log_t        *log;
  413.     ngx_socket_t      s;
  414.     ngx_listening_t  *ls;

  416.     reuseaddr = 1;
  417. #if (NGX_SUPPRESS_WARN)
  418.     failed = 0;
  419. #endif

  421.     log = cycle->log;

  423.     /* TODO: configurable try number */

  425.     for (tries = 5; tries; tries--) {
  426.         failed = 0;

  428.         /* for each listening socket */

  430.         ls = cycle->listening.elts;
  431.         for (i = 0; i < cycle->listening.nelts; i++) {

  433.             if (ls[i].ignore) {
  434.                 continue;
  435.             }

  437. #if (NGX_HAVE_REUSEPORT)

  439.             if (ls[i].add_reuseport) {

  441.                 /*
  442.                  * to allow transition from a socket without SO_REUSEPORT
  443.                  * to multiple sockets with SO_REUSEPORT, we have to set
  444.                  * SO_REUSEPORT on the old socket before opening new ones
  445.                  */

  447.                 int  reuseport = 1;

  449. #ifdef SO_REUSEPORT_LB

  451.                 if (setsockopt(ls[i].fd, SOL_SOCKET, SO_REUSEPORT_LB,
  452.                                (const void *) &reuseport, sizeof(int))
  453.                     == -1)
  454.                 {
  455.                     ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  456.                                   "setsockopt(SO_REUSEPORT_LB) %V failed, "
  457.                                   "ignored",
  458.                                   &ls[i].addr_text);
  459.                 }

  461. #else

  463.                 if (setsockopt(ls[i].fd, SOL_SOCKET, SO_REUSEPORT,
  464.                                (const void *) &reuseport, sizeof(int))
  465.                     == -1)
  466.                 {
  467.                     ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  468.                                   "setsockopt(SO_REUSEPORT) %V failed, ignored",
  469.                                   &ls[i].addr_text);
  470.                 }
  471. #endif

  473.                 ls[i].add_reuseport = 0;
  474.             }
  475. #endif

  477.             if (ls[i].fd != (ngx_socket_t) -1) {
  478.                 continue;
  479.             }

  481.             if (ls[i].inherited) {

  483.                 /* TODO: close on exit */
  484.                 /* TODO: nonblocking */
  485.                 /* TODO: deferred accept */

  487.                 continue;
  488.             }

  490.             s = ngx_socket(ls[i].sockaddr->sa_family, ls[i].type, 0);

  492.             if (s == (ngx_socket_t) -1) {
  493.                 ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  494.                               ngx_socket_n " %V failed", &ls[i].addr_text);
  495.                 return NGX_ERROR;
  496.             }

  498.             if (ls[i].type != SOCK_DGRAM || !ngx_test_config) {

  500.                 if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
  501.                                (const void *) &reuseaddr, sizeof(int))
  502.                     == -1)
  503.                 {
  504.                     ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  505.                                   "setsockopt(SO_REUSEADDR) %V failed",
  506.                                   &ls[i].addr_text);

  508.                     if (ngx_close_socket(s) == -1) {
  509.                         ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  510.                                       ngx_close_socket_n " %V failed",
  511.                                       &ls[i].addr_text);
  512.                     }

  514.                     return NGX_ERROR;
  515.                 }
  516.             }

  518. #if (NGX_HAVE_REUSEPORT)

  520.             if (ls[i].reuseport && !ngx_test_config) {
  521.                 int  reuseport;

  523.                 reuseport = 1;

  525. #ifdef SO_REUSEPORT_LB

  527.                 if (setsockopt(s, SOL_SOCKET, SO_REUSEPORT_LB,
  528.                                (const void *) &reuseport, sizeof(int))
  529.                     == -1)
  530.                 {
  531.                     ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  532.                                   "setsockopt(SO_REUSEPORT_LB) %V failed",
  533.                                   &ls[i].addr_text);

  535.                     if (ngx_close_socket(s) == -1) {
  536.                         ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  537.                                       ngx_close_socket_n " %V failed",
  538.                                       &ls[i].addr_text);
  539.                     }

  541.                     return NGX_ERROR;
  542.                 }

  544. #else

  546.                 if (setsockopt(s, SOL_SOCKET, SO_REUSEPORT,
  547.                                (const void *) &reuseport, sizeof(int))
  548.                     == -1)
  549.                 {
  550.                     ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  551.                                   "setsockopt(SO_REUSEPORT) %V failed",
  552.                                   &ls[i].addr_text);

  554.                     if (ngx_close_socket(s) == -1) {
  555.                         ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  556.                                       ngx_close_socket_n " %V failed",
  557.                                       &ls[i].addr_text);
  558.                     }

  560.                     return NGX_ERROR;
  561.                 }
  562. #endif
  563.             }
  564. #endif

  566. #if (NGX_HAVE_INET6 && defined IPV6_V6ONLY)

  568.             if (ls[i].sockaddr->sa_family == AF_INET6) {
  569.                 int  ipv6only;

  571.                 ipv6only = ls[i].ipv6only;

  573.                 if (setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY,
  574.                                (const void *) &ipv6only, sizeof(int))
  575.                     == -1)
  576.                 {
  577.                     ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  578.                                   "setsockopt(IPV6_V6ONLY) %V failed, ignored",
  579.                                   &ls[i].addr_text);
  580.                 }
  581.             }
  582. #endif
  583.             /* TODO: close on exit */

  585.             if (!(ngx_event_flags & NGX_USE_IOCP_EVENT)) {
  586.                 if (ngx_nonblocking(s) == -1) {
  587.                     ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  588.                                   ngx_nonblocking_n " %V failed",
  589.                                   &ls[i].addr_text);

  591.                     if (ngx_close_socket(s) == -1) {
  592.                         ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  593.                                       ngx_close_socket_n " %V failed",
  594.                                       &ls[i].addr_text);
  595.                     }

  597.                     return NGX_ERROR;
  598.                 }
  599.             }

  601.             ngx_log_debug2(NGX_LOG_DEBUG_CORE, log, 0,
  602.                            "bind() %V #%d ", &ls[i].addr_text, s);

  604.             if (bind(s, ls[i].sockaddr, ls[i].socklen) == -1) {
  605.                 err = ngx_socket_errno;

  607.                 if (err != NGX_EADDRINUSE || !ngx_test_config) {
  608.                     ngx_log_error(NGX_LOG_EMERG, log, err,
  609.                                   "bind() to %V failed", &ls[i].addr_text);
  610.                 }

  612.                 if (ngx_close_socket(s) == -1) {
  613.                     ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  614.                                   ngx_close_socket_n " %V failed",
  615.                                   &ls[i].addr_text);
  616.                 }

  618.                 if (err != NGX_EADDRINUSE) {
  619.                     return NGX_ERROR;
  620.                 }

  622.                 if (!ngx_test_config) {
  623.                     failed = 1;
  624.                 }

  626.                 continue;
  627.             }

  629. #if (NGX_HAVE_UNIX_DOMAIN)

  631.             if (ls[i].sockaddr->sa_family == AF_UNIX) {
  632.                 mode_t   mode;
  633.                 u_char  *name;

  635.                 name = ls[i].addr_text.data + sizeof("unix:") - 1;
  636.                 mode = (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);

  638.                 if (chmod((char *) name, mode) == -1) {
  639.                     ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  640.                                   "chmod() \"%s\" failed", name);
  641.                 }

  643.                 if (ngx_test_config) {
  644.                     if (ngx_delete_file(name) == NGX_FILE_ERROR) {
  645.                         ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  646.                                       ngx_delete_file_n " %s failed", name);
  647.                     }
  648.                 }
  649.             }
  650. #endif

  652.             if (ls[i].type != SOCK_STREAM) {
  653.                 ls[i].fd = s;
  654.                 continue;
  655.             }

  657.             if (listen(s, ls[i].backlog) == -1) {
  658.                 err = ngx_socket_errno;

  660.                 /*
  661.                  * on OpenVZ after suspend/resume EADDRINUSE
  662.                  * may be returned by listen() instead of bind(), see
  663.                  * https://bugs.openvz.org/browse/OVZ-5587
  664.                  */

  666.                 if (err != NGX_EADDRINUSE || !ngx_test_config) {
  667.                     ngx_log_error(NGX_LOG_EMERG, log, err,
  668.                                   "listen() to %V, backlog %d failed",
  669.                                   &ls[i].addr_text, ls[i].backlog);
  670.                 }

  672.                 if (ngx_close_socket(s) == -1) {
  673.                     ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  674.                                   ngx_close_socket_n " %V failed",
  675.                                   &ls[i].addr_text);
  676.                 }

  678.                 if (err != NGX_EADDRINUSE) {
  679.                     return NGX_ERROR;
  680.                 }

  682.                 if (!ngx_test_config) {
  683.                     failed = 1;
  684.                 }

  686.                 continue;
  687.             }

  689.             ls[i].listen = 1;

  691.             ls[i].fd = s;
  692.         }

  694.         if (!failed) {
  695.             break;
  696.         }

  698.         /* TODO: delay configurable */

  700.         ngx_log_error(NGX_LOG_NOTICE, log, 0,
  701.                       "try again to bind() after 500ms");

  703.         ngx_msleep(500);
  704.     }

  706.     if (failed) {
  707.         ngx_log_error(NGX_LOG_EMERG, log, 0, "still could not bind()");
  708.         return NGX_ERROR;
  709.     }

  711.     return NGX_OK;
  712. }


  715. void
  716. ‌ngx_configure_listening_sockets(ngx_cycle_t *cycle)
  717. {
  718.     int                        value;
  719.     ngx_uint_t                 i;
  720.     ngx_listening_t           *ls;

  722. #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
  723.     struct accept_filter_arg   af;
  724. #endif

  726.     ls = cycle->listening.elts;
  727.     for (i = 0; i < cycle->listening.nelts; i++) {

  729.         ls[i].log = *ls[i].logp;

  731.         if (ls[i].rcvbuf != -1) {
  732.             if (setsockopt(ls[i].fd, SOL_SOCKET, SO_RCVBUF,
  733.                            (const void *) &ls[i].rcvbuf, sizeof(int))
  734.                 == -1)
  735.             {
  736.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  737.                               "setsockopt(SO_RCVBUF, %d) %V failed, ignored",
  738.                               ls[i].rcvbuf, &ls[i].addr_text);
  739.             }
  740.         }

  742.         if (ls[i].sndbuf != -1) {
  743.             if (setsockopt(ls[i].fd, SOL_SOCKET, SO_SNDBUF,
  744.                            (const void *) &ls[i].sndbuf, sizeof(int))
  745.                 == -1)
  746.             {
  747.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  748.                               "setsockopt(SO_SNDBUF, %d) %V failed, ignored",
  749.                               ls[i].sndbuf, &ls[i].addr_text);
  750.             }
  751.         }

  753.         if (ls[i].keepalive) {
  754.             value = (ls[i].keepalive == 1) ? 1 : 0;

  756.             if (setsockopt(ls[i].fd, SOL_SOCKET, SO_KEEPALIVE,
  757.                            (const void *) &value, sizeof(int))
  758.                 == -1)
  759.             {
  760.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  761.                               "setsockopt(SO_KEEPALIVE, %d) %V failed, ignored",
  762.                               value, &ls[i].addr_text);
  763.             }
  764.         }

  766. #if (NGX_HAVE_KEEPALIVE_TUNABLE)

  768.         if (ls[i].keepidle) {
  769.             value = ls[i].keepidle;

  771. #if (NGX_KEEPALIVE_FACTOR)
  772.             value *= NGX_KEEPALIVE_FACTOR;
  773. #endif

  775.             if (setsockopt(ls[i].fd, IPPROTO_TCP, TCP_KEEPIDLE,
  776.                            (const void *) &value, sizeof(int))
  777.                 == -1)
  778.             {
  779.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  780.                               "setsockopt(TCP_KEEPIDLE, %d) %V failed, ignored",
  781.                               value, &ls[i].addr_text);
  782.             }
  783.         }

  785.         if (ls[i].keepintvl) {
  786.             value = ls[i].keepintvl;

  788. #if (NGX_KEEPALIVE_FACTOR)
  789.             value *= NGX_KEEPALIVE_FACTOR;
  790. #endif

  792.             if (setsockopt(ls[i].fd, IPPROTO_TCP, TCP_KEEPINTVL,
  793.                            (const void *) &value, sizeof(int))
  794.                 == -1)
  795.             {
  796.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  797.                              "setsockopt(TCP_KEEPINTVL, %d) %V failed, ignored",
  798.                              value, &ls[i].addr_text);
  799.             }
  800.         }

  802.         if (ls[i].keepcnt) {
  803.             if (setsockopt(ls[i].fd, IPPROTO_TCP, TCP_KEEPCNT,
  804.                            (const void *) &ls[i].keepcnt, sizeof(int))
  805.                 == -1)
  806.             {
  807.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  808.                               "setsockopt(TCP_KEEPCNT, %d) %V failed, ignored",
  809.                               ls[i].keepcnt, &ls[i].addr_text);
  810.             }
  811.         }

  813. #endif

  815. #if (NGX_HAVE_SETFIB)
  816.         if (ls[i].setfib != -1) {
  817.             if (setsockopt(ls[i].fd, SOL_SOCKET, SO_SETFIB,
  818.                            (const void *) &ls[i].setfib, sizeof(int))
  819.                 == -1)
  820.             {
  821.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  822.                               "setsockopt(SO_SETFIB, %d) %V failed, ignored",
  823.                               ls[i].setfib, &ls[i].addr_text);
  824.             }
  825.         }
  826. #endif

  828. #if (NGX_HAVE_TCP_FASTOPEN)
  829.         if (ls[i].fastopen != -1) {
  830.             if (setsockopt(ls[i].fd, IPPROTO_TCP, TCP_FASTOPEN,
  831.                            (const void *) &ls[i].fastopen, sizeof(int))
  832.                 == -1)
  833.             {
  834.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  835.                               "setsockopt(TCP_FASTOPEN, %d) %V failed, ignored",
  836.                               ls[i].fastopen, &ls[i].addr_text);
  837.             }
  838.         }
  839. #endif

  841. #if 0
  842.         if (1) {
  843.             int tcp_nodelay = 1;

  845.             if (setsockopt(ls[i].fd, IPPROTO_TCP, TCP_NODELAY,
  846.                        (const void *) &tcp_nodelay, sizeof(int))
  847.                 == -1)
  848.             {
  849.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  850.                               "setsockopt(TCP_NODELAY) %V failed, ignored",
  851.                               &ls[i].addr_text);
  852.             }
  853.         }
  854. #endif

  856.         if (ls[i].listen) {

  858.             /* change backlog via listen() */

  860.             if (listen(ls[i].fd, ls[i].backlog) == -1) {
  861.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  862.                               "listen() to %V, backlog %d failed, ignored",
  863.                               &ls[i].addr_text, ls[i].backlog);
  864.             }
  865.         }

  867.         /*
  868.          * setting deferred mode should be last operation on socket,
  869.          * because code may prematurely continue cycle on failure
  870.          */

  872. #if (NGX_HAVE_DEFERRED_ACCEPT)

  874. #ifdef SO_ACCEPTFILTER

  876.         if (ls[i].delete_deferred) {
  877.             if (setsockopt(ls[i].fd, SOL_SOCKET, SO_ACCEPTFILTER, NULL, 0)
  878.                 == -1)
  879.             {
  880.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  881.                               "setsockopt(SO_ACCEPTFILTER, NULL) "
  882.                               "for %V failed, ignored",
  883.                               &ls[i].addr_text);

  885.                 if (ls[i].accept_filter) {
  886.                     ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  887.                                   "could not change the accept filter "
  888.                                   "to \"%s\" for %V, ignored",
  889.                                   ls[i].accept_filter, &ls[i].addr_text);
  890.                 }

  892.                 continue;
  893.             }

  895.             ls[i].deferred_accept = 0;
  896.         }

  898.         if (ls[i].add_deferred) {
  899.             ngx_memzero(&af, sizeof(struct accept_filter_arg));
  900.             (void) ngx_cpystrn((u_char *) af.af_name,
  901.                                (u_char *) ls[i].accept_filter, 16);

  903.             if (setsockopt(ls[i].fd, SOL_SOCKET, SO_ACCEPTFILTER,
  904.                            &af, sizeof(struct accept_filter_arg))
  905.                 == -1)
  906.             {
  907.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  908.                               "setsockopt(SO_ACCEPTFILTER, \"%s\") "
  909.                               "for %V failed, ignored",
  910.                               ls[i].accept_filter, &ls[i].addr_text);
  911.                 continue;
  912.             }

  914.             ls[i].deferred_accept = 1;
  915.         }

  917. #endif

  919. #ifdef TCP_DEFER_ACCEPT

  921.         if (ls[i].add_deferred || ls[i].delete_deferred) {

  923.             if (ls[i].add_deferred) {
  924.                 /*
  925.                  * There is no way to find out how long a connection was
  926.                  * in queue (and a connection may bypass deferred queue at all
  927.                  * if syncookies were used), hence we use 1 second timeout
  928.                  * here.
  929.                  */
  930.                 value = 1;

  932.             } else {
  933.                 value = 0;
  934.             }

  936.             if (setsockopt(ls[i].fd, IPPROTO_TCP, TCP_DEFER_ACCEPT,
  937.                            &value, sizeof(int))
  938.                 == -1)
  939.             {
  940.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  941.                               "setsockopt(TCP_DEFER_ACCEPT, %d) for %V failed, "
  942.                               "ignored",
  943.                               value, &ls[i].addr_text);

  945.                 continue;
  946.             }
  947.         }

  949.         if (ls[i].add_deferred) {
  950.             ls[i].deferred_accept = 1;
  951.         }

  953. #endif

  955. #endif /* NGX_HAVE_DEFERRED_ACCEPT */

  957. #if (NGX_HAVE_IP_RECVDSTADDR)

  959.         if (ls[i].wildcard
  960.             && ls[i].type == SOCK_DGRAM
  961.             && ls[i].sockaddr->sa_family == AF_INET)
  962.         {
  963.             value = 1;

  965.             if (setsockopt(ls[i].fd, IPPROTO_IP, IP_RECVDSTADDR,
  966.                            (const void *) &value, sizeof(int))
  967.                 == -1)
  968.             {
  969.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  970.                               "setsockopt(IP_RECVDSTADDR) "
  971.                               "for %V failed, ignored",
  972.                               &ls[i].addr_text);
  973.             }
  974.         }

  976. #elif (NGX_HAVE_IP_PKTINFO)

  978.         if (ls[i].wildcard
  979.             && ls[i].type == SOCK_DGRAM
  980.             && ls[i].sockaddr->sa_family == AF_INET)
  981.         {
  982.             value = 1;

  984.             if (setsockopt(ls[i].fd, IPPROTO_IP, IP_PKTINFO,
  985.                            (const void *) &value, sizeof(int))
  986.                 == -1)
  987.             {
  988.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  989.                               "setsockopt(IP_PKTINFO) "
  990.                               "for %V failed, ignored",
  991.                               &ls[i].addr_text);
  992.             }
  993.         }

  995. #endif

  997. #if (NGX_HAVE_INET6 && NGX_HAVE_IPV6_RECVPKTINFO)

  999.         if (ls[i].wildcard
  1000.             && ls[i].type == SOCK_DGRAM
  1001.             && ls[i].sockaddr->sa_family == AF_INET6)
  1002.         {
  1003.             value = 1;

  1005.             if (setsockopt(ls[i].fd, IPPROTO_IPV6, IPV6_RECVPKTINFO,
  1006.                            (const void *) &value, sizeof(int))
  1007.                 == -1)
  1008.             {
  1009.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  1010.                               "setsockopt(IPV6_RECVPKTINFO) "
  1011.                               "for %V failed, ignored",
  1012.                               &ls[i].addr_text);
  1013.             }
  1014.         }

  1016. #endif

  1018. #if (NGX_HAVE_IP_MTU_DISCOVER)

  1020.         if (ls[i].quic && ls[i].sockaddr->sa_family == AF_INET) {
  1021.             value = IP_PMTUDISC_DO;

  1023.             if (setsockopt(ls[i].fd, IPPROTO_IP, IP_MTU_DISCOVER,
  1024.                            (const void *) &value, sizeof(int))
  1025.                 == -1)
  1026.             {
  1027.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  1028.                               "setsockopt(IP_MTU_DISCOVER) "
  1029.                               "for %V failed, ignored",
  1030.                               &ls[i].addr_text);
  1031.             }
  1032.         }

  1034. #elif (NGX_HAVE_IP_DONTFRAG)

  1036.         if (ls[i].quic && ls[i].sockaddr->sa_family == AF_INET) {
  1037.             value = 1;

  1039.             if (setsockopt(ls[i].fd, IPPROTO_IP, IP_DONTFRAG,
  1040.                            (const void *) &value, sizeof(int))
  1041.                 == -1)
  1042.             {
  1043.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  1044.                               "setsockopt(IP_DONTFRAG) "
  1045.                               "for %V failed, ignored",
  1046.                               &ls[i].addr_text);
  1047.             }
  1048.         }

  1050. #endif

  1052. #if (NGX_HAVE_INET6)

  1054. #if (NGX_HAVE_IPV6_MTU_DISCOVER)

  1056.         if (ls[i].quic && ls[i].sockaddr->sa_family == AF_INET6) {
  1057.             value = IPV6_PMTUDISC_DO;

  1059.             if (setsockopt(ls[i].fd, IPPROTO_IPV6, IPV6_MTU_DISCOVER,
  1060.                            (const void *) &value, sizeof(int))
  1061.                 == -1)
  1062.             {
  1063.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  1064.                               "setsockopt(IPV6_MTU_DISCOVER) "
  1065.                               "for %V failed, ignored",
  1066.                               &ls[i].addr_text);
  1067.             }
  1068.         }

  1070. #elif (NGX_HAVE_IP_DONTFRAG)

  1072.         if (ls[i].quic && ls[i].sockaddr->sa_family == AF_INET6) {
  1073.             value = 1;

  1075.             if (setsockopt(ls[i].fd, IPPROTO_IPV6, IPV6_DONTFRAG,
  1076.                            (const void *) &value, sizeof(int))
  1077.                 == -1)
  1078.             {
  1079.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  1080.                               "setsockopt(IPV6_DONTFRAG) "
  1081.                               "for %V failed, ignored",
  1082.                               &ls[i].addr_text);
  1083.             }
  1084.         }

  1086. #endif

  1088. #endif
  1089.     }

  1091.     return;
  1092. }


  1095. void
  1096. ‌ngx_close_listening_sockets(ngx_cycle_t *cycle)
  1097. {
  1098.     ngx_uint_t         i;
  1099.     ngx_listening_t   *ls;
  1100.     ngx_connection_t  *c;

  1102.     if (ngx_event_flags & NGX_USE_IOCP_EVENT) {
  1103.         return;
  1104.     }

  1106.     ngx_accept_mutex_held = 0;
  1107.     ngx_use_accept_mutex = 0;

  1109.     ls = cycle->listening.elts;
  1110.     for (i = 0; i < cycle->listening.nelts; i++) {

  1112. #if (NGX_QUIC)
  1113.         if (ls[i].quic) {
  1114.             continue;
  1115.         }
  1116. #endif

  1118.         c = ls[i].connection;

  1120.         if (c) {
  1121.             if (c->read->active) {
  1122.                 if (ngx_event_flags & NGX_USE_EPOLL_EVENT) {

  1124.                     /*
  1125.                      * it seems that Linux-2.6.x OpenVZ sends events
  1126.                      * for closed shared listening sockets unless
  1127.                      * the events was explicitly deleted
  1128.                      */

  1130.                     ngx_del_event(c->read, NGX_READ_EVENT, 0);

  1132.                 } else {
  1133.                     ngx_del_event(c->read, NGX_READ_EVENT, NGX_CLOSE_EVENT);
  1134.                 }
  1135.             }

  1137.             ngx_free_connection(c);

  1139.             c->fd = (ngx_socket_t) -1;
  1140.         }

  1142.         ngx_log_debug2(NGX_LOG_DEBUG_CORE, cycle->log, 0,
  1143.                        "close listening %V #%d ", &ls[i].addr_text, ls[i].fd);

  1145.         if (ngx_close_socket(ls[i].fd) == -1) {
  1146.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_socket_errno,
  1147.                           ngx_close_socket_n " %V failed", &ls[i].addr_text);
  1148.         }

  1150. #if (NGX_HAVE_UNIX_DOMAIN)

  1152.         if (ls[i].sockaddr->sa_family == AF_UNIX
  1153.             && ngx_process <= NGX_PROCESS_MASTER
  1154.             && ngx_new_binary == 0
  1155.             && (!ls[i].inherited || ngx_getppid() != ngx_parent))
  1156.         {
  1157.             u_char *name = ls[i].addr_text.data + sizeof("unix:") - 1;

  1159.             if (ngx_delete_file(name) == NGX_FILE_ERROR) {
  1160.                 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_socket_errno,
  1161.                               ngx_delete_file_n " %s failed", name);
  1162.             }
  1163.         }

  1165. #endif

  1167.         ls[i].fd = (ngx_socket_t) -1;
  1168.     }

  1170.     cycle->listening.nelts = 0;
  1171. }


  1174. ngx_connection_t *
  1175. ‌ngx_get_connection(ngx_socket_t s, ngx_log_t *log)
  1176. {
  1177.     ngx_uint_t         instance;
  1178.     ngx_event_t       *rev, *wev;
  1179.     ngx_connection_t  *c;

  1181.     /* disable warning: Win32 SOCKET is u_int while UNIX socket is int */

  1183.     if (ngx_cycle->files && (ngx_uint_t) s >= ngx_cycle->files_n) {
  1184.         ngx_log_error(NGX_LOG_ALERT, log, 0,
  1185.                       "the new socket has number %d, "
  1186.                       "but only %ui files are available",
  1187.                       s, ngx_cycle->files_n);
  1188.         return NULL;
  1189.     }

  1191.     ngx_drain_connections((ngx_cycle_t *) ngx_cycle);

  1193.     c = ngx_cycle->free_connections;

  1195.     if (c == NULL) {
  1196.         ngx_log_error(NGX_LOG_ALERT, log, 0,
  1197.                       "%ui worker_connections are not enough",
  1198.                       ngx_cycle->connection_n);

  1200.         return NULL;
  1201.     }

  1203.     ngx_cycle->free_connections = c->data;
  1204.     ngx_cycle->free_connection_n--;

  1206.     if (ngx_cycle->files && ngx_cycle->files[s] == NULL) {
  1207.         ngx_cycle->files[s] = c;
  1208.     }

  1210.     rev = c->read;
  1211.     wev = c->write;

  1213.     ngx_memzero(c, sizeof(ngx_connection_t));

  1215.     c->read = rev;
  1216.     c->write = wev;
  1217.     c->fd = s;
  1218.     c->log = log;

  1220.     instance = rev->instance;

  1222.     ngx_memzero(rev, sizeof(ngx_event_t));
  1223.     ngx_memzero(wev, sizeof(ngx_event_t));

  1225.     rev->instance = !instance;
  1226.     wev->instance = !instance;

  1228.     rev->index = NGX_INVALID_INDEX;
  1229.     wev->index = NGX_INVALID_INDEX;

  1231.     rev->data = c;
  1232.     wev->data = c;

  1234.     wev->write = 1;

  1236.     return c;
  1237. }


  1240. void
  1241. ‌ngx_free_connection(ngx_connection_t *c)
  1242. {
  1243.     c->data = ngx_cycle->free_connections;
  1244.     ngx_cycle->free_connections = c;
  1245.     ngx_cycle->free_connection_n++;

  1247.     if (ngx_cycle->files && ngx_cycle->files[c->fd] == c) {
  1248.         ngx_cycle->files[c->fd] = NULL;
  1249.     }
  1250. }


  1253. void
  1254. ‌ngx_close_connection(ngx_connection_t *c)
  1255. {
  1256.     ngx_err_t     err;
  1257.     ngx_uint_t    log_error, level;
  1258.     ngx_socket_t  fd;

  1260.     if (c->fd == (ngx_socket_t) -1) {
  1261.         ngx_log_error(NGX_LOG_ALERT, c->log, 0, "connection already closed");
  1262.         return;
  1263.     }

  1265.     if (c->read->timer_set) {
  1266.         ngx_del_timer(c->read);
  1267.     }

  1269.     if (c->write->timer_set) {
  1270.         ngx_del_timer(c->write);
  1271.     }

  1273.     if (!c->shared) {
  1274.         if (ngx_del_conn) {
  1275.             ngx_del_conn(c, NGX_CLOSE_EVENT);

  1277.         } else {
  1278.             if (c->read->active || c->read->disabled) {
  1279.                 ngx_del_event(c->read, NGX_READ_EVENT, NGX_CLOSE_EVENT);
  1280.             }

  1282.             if (c->write->active || c->write->disabled) {
  1283.                 ngx_del_event(c->write, NGX_WRITE_EVENT, NGX_CLOSE_EVENT);
  1284.             }
  1285.         }
  1286.     }

  1288.     if (c->read->posted) {
  1289.         ngx_delete_posted_event(c->read);
  1290.     }

  1292.     if (c->write->posted) {
  1293.         ngx_delete_posted_event(c->write);
  1294.     }

  1296.     c->read->closed = 1;
  1297.     c->write->closed = 1;

  1299.     ngx_reusable_connection(c, 0);

  1301.     log_error = c->log_error;

  1303.     ngx_free_connection(c);

  1305.     fd = c->fd;
  1306.     c->fd = (ngx_socket_t) -1;

  1308.     if (c->shared) {
  1309.         return;
  1310.     }

  1312.     if (ngx_close_socket(fd) == -1) {

  1314.         err = ngx_socket_errno;

  1316.         if (err == NGX_ECONNRESET || err == NGX_ENOTCONN) {

  1318.             switch (log_error) {

  1320.             case NGX_ERROR_INFO:
  1321.                 level = NGX_LOG_INFO;
  1322.                 break;

  1324.             case NGX_ERROR_ERR:
  1325.                 level = NGX_LOG_ERR;
  1326.                 break;

  1328.             default:
  1329.                 level = NGX_LOG_CRIT;
  1330.             }

  1332.         } else {
  1333.             level = NGX_LOG_CRIT;
  1334.         }

  1336.         ngx_log_error(level, c->log, err, ngx_close_socket_n " %d failed", fd);
  1337.     }
  1338. }


  1341. void
  1342. ‌ngx_reusable_connection(ngx_connection_t *c, ngx_uint_t reusable)
  1343. {
  1344.     ngx_log_debug1(NGX_LOG_DEBUG_CORE, c->log, 0,
  1345.                    "reusable connection: %ui", reusable);

  1347.     if (c->reusable) {
  1348.         ngx_queue_remove(&c->queue);
  1349.         ngx_cycle->reusable_connections_n--;

  1351. #if (NGX_STAT_STUB)
  1352.         (void) ngx_atomic_fetch_add(ngx_stat_waiting, -1);
  1353. #endif
  1354.     }

  1356.     c->reusable = reusable;

  1358.     if (reusable) {
  1359.         /* need cast as ngx_cycle is volatile */

  1361.         ngx_queue_insert_head(
  1362.             (ngx_queue_t *) &ngx_cycle->reusable_connections_queue, &c->queue);
  1363.         ngx_cycle->reusable_connections_n++;

  1365. #if (NGX_STAT_STUB)
  1366.         (void) ngx_atomic_fetch_add(ngx_stat_waiting, 1);
  1367. #endif
  1368.     }
  1369. }


  1372. static void
  1373. ‌ngx_drain_connections(ngx_cycle_t *cycle)
  1374. {
  1375.     ngx_uint_t         i, n;
  1376.     ngx_queue_t       *q;
  1377.     ngx_connection_t  *c;

  1379.     if (cycle->free_connection_n > cycle->connection_n / 16
  1380.         || cycle->reusable_connections_n == 0)
  1381.     {
  1382.         return;
  1383.     }

  1385.     if (cycle->connections_reuse_time != ngx_time()) {
  1386.         cycle->connections_reuse_time = ngx_time();

  1388.         ngx_log_error(NGX_LOG_WARN, cycle->log, 0,
  1389.                       "%ui worker_connections are not enough, "
  1390.                       "reusing connections",
  1391.                       cycle->connection_n);
  1392.     }

  1394.     c = NULL;
  1395.     n = ngx_max(ngx_min(32, cycle->reusable_connections_n / 8), 1);

  1397.     for (i = 0; i < n; i++) {
  1398.         if (ngx_queue_empty(&cycle->reusable_connections_queue)) {
  1399.             break;
  1400.         }

  1402.         q = ngx_queue_last(&cycle->reusable_connections_queue);
  1403.         c = ngx_queue_data(q, ngx_connection_t, queue);

  1405.         ngx_log_debug0(NGX_LOG_DEBUG_CORE, c->log, 0,
  1406.                        "reusing connection");

  1408.         c->close = 1;
  1409.         c->read->handler(c->read);
  1410.     }

  1412.     if (cycle->free_connection_n == 0 && c && c->reusable) {

  1414.         /*
  1415.          * if no connections were freed, try to reuse the last
  1416.          * connection again: this should free it as long as
  1417.          * previous reuse moved it to lingering close
  1418.          */

  1420.         ngx_log_debug0(NGX_LOG_DEBUG_CORE, c->log, 0,
  1421.                        "reusing connection again");

  1423.         c->close = 1;
  1424.         c->read->handler(c->read);
  1425.     }
  1426. }


  1429. void
  1430. ‌ngx_close_idle_connections(ngx_cycle_t *cycle)
  1431. {
  1432.     ngx_uint_t         i;
  1433.     ngx_connection_t  *c;

  1435.     c = cycle->connections;

  1437.     for (i = 0; i < cycle->connection_n; i++) {

  1439.         /* THREAD: lock */

  1441.         if (c[i].fd != (ngx_socket_t) -1 && c[i].idle) {
  1442.             c[i].close = 1;
  1443.             c[i].read->handler(c[i].read);
  1444.         }
  1445.     }
  1446. }


  1449. ngx_int_t
  1450. ‌ngx_connection_local_sockaddr(ngx_connection_t *c, ngx_str_t *s,
  1451.     ngx_uint_t port)
  1452. {
  1453.     socklen_t             len;
  1454.     ngx_uint_t            addr;
  1455.     ngx_sockaddr_t        sa;
  1456.     struct sockaddr_in   *sin;
  1457. #if (NGX_HAVE_INET6)
  1458.     ngx_uint_t            i;
  1459.     struct sockaddr_in6  *sin6;
  1460. #endif

  1462.     addr = 0;

  1464.     if (c->local_socklen) {
  1465.         switch (c->local_sockaddr->sa_family) {

  1467. #if (NGX_HAVE_INET6)
  1468.         case AF_INET6:
  1469.             sin6 = (struct sockaddr_in6 *) c->local_sockaddr;

  1471.             for (i = 0; addr == 0 && i < 16; i++) {
  1472.                 addr |= sin6->sin6_addr.s6_addr[i];
  1473.             }

  1475.             break;
  1476. #endif

  1478. #if (NGX_HAVE_UNIX_DOMAIN)
  1479.         case AF_UNIX:
  1480.             addr = 1;
  1481.             break;
  1482. #endif

  1484.         default: /* AF_INET */
  1485.             sin = (struct sockaddr_in *) c->local_sockaddr;
  1486.             addr = sin->sin_addr.s_addr;
  1487.             break;
  1488.         }
  1489.     }

  1491.     if (addr == 0) {

  1493.         len = sizeof(ngx_sockaddr_t);

  1495.         if (getsockname(c->fd, &sa.sockaddr, &len) == -1) {
  1496.             ngx_connection_error(c, ngx_socket_errno, "getsockname() failed");
  1497.             return NGX_ERROR;
  1498.         }

  1500.         c->local_sockaddr = ngx_palloc(c->pool, len);
  1501.         if (c->local_sockaddr == NULL) {
  1502.             return NGX_ERROR;
  1503.         }

  1505.         ngx_memcpy(c->local_sockaddr, &sa, len);

  1507.         c->local_socklen = len;
  1508.     }

  1510.     if (s == NULL) {
  1511.         return NGX_OK;
  1512.     }

  1514.     s->len = ngx_sock_ntop(c->local_sockaddr, c->local_socklen,
  1515.                            s->data, s->len, port);

  1517.     return NGX_OK;
  1518. }


  1521. ngx_int_t
  1522. ‌ngx_tcp_nodelay(ngx_connection_t *c)
  1523. {
  1524.     int  tcp_nodelay;

  1526.     if (c->tcp_nodelay != NGX_TCP_NODELAY_UNSET) {
  1527.         return NGX_OK;
  1528.     }

  1530.     ngx_log_debug0(NGX_LOG_DEBUG_CORE, c->log, 0, "tcp_nodelay");

  1532.     tcp_nodelay = 1;

  1534.     if (setsockopt(c->fd, IPPROTO_TCP, TCP_NODELAY,
  1535.                    (const void *) &tcp_nodelay, sizeof(int))
  1536.         == -1)
  1537.     {
  1538. #if (NGX_SOLARIS)
  1539.         if (c->log_error == NGX_ERROR_INFO) {

  1541.             /* Solaris returns EINVAL if a socket has been shut down */
  1542.             c->log_error = NGX_ERROR_IGNORE_EINVAL;

  1544.             ngx_connection_error(c, ngx_socket_errno,
  1545.                                  "setsockopt(TCP_NODELAY) failed");

  1547.             c->log_error = NGX_ERROR_INFO;

  1549.             return NGX_ERROR;
  1550.         }
  1551. #endif

  1553.         ngx_connection_error(c, ngx_socket_errno,
  1554.                              "setsockopt(TCP_NODELAY) failed");
  1555.         return NGX_ERROR;
  1556.     }

  1558.     c->tcp_nodelay = NGX_TCP_NODELAY_SET;

  1560.     return NGX_OK;
  1561. }


  1564. ngx_int_t
  1565. ‌ngx_connection_error(ngx_connection_t *c, ngx_err_t err, char *text)
  1566. {
  1567.     ngx_uint_t  level;

  1569.     /* Winsock may return NGX_ECONNABORTED instead of NGX_ECONNRESET */

  1571.     if ((err == NGX_ECONNRESET
  1572. #if (NGX_WIN32)
  1573.          || err == NGX_ECONNABORTED
  1574. #endif
  1575.         ) && c->log_error == NGX_ERROR_IGNORE_ECONNRESET)
  1576.     {
  1577.         return 0;
  1578.     }

  1580. #if (NGX_SOLARIS)
  1581.     if (err == NGX_EINVAL && c->log_error == NGX_ERROR_IGNORE_EINVAL) {
  1582.         return 0;
  1583.     }
  1584. #endif

  1586.     if (err == NGX_EMSGSIZE && c->log_error == NGX_ERROR_IGNORE_EMSGSIZE) {
  1587.         return 0;
  1588.     }

  1590.     if (err == 0
  1591.         || err == NGX_ECONNRESET
  1592. #if (NGX_WIN32)
  1593.         || err == NGX_ECONNABORTED
  1594. #else
  1595.         || err == NGX_EPIPE
  1596. #endif
  1597.         || err == NGX_ENOTCONN
  1598.         || err == NGX_ETIMEDOUT
  1599.         || err == NGX_ECONNREFUSED
  1600.         || err == NGX_ENETDOWN
  1601.         || err == NGX_ENETUNREACH
  1602.         || err == NGX_EHOSTDOWN
  1603.         || err == NGX_EHOSTUNREACH)
  1604.     {
  1605.         switch (c->log_error) {

  1607.         case NGX_ERROR_IGNORE_EMSGSIZE:
  1608.         case NGX_ERROR_IGNORE_EINVAL:
  1609.         case NGX_ERROR_IGNORE_ECONNRESET:
  1610.         case NGX_ERROR_INFO:
  1611.             level = NGX_LOG_INFO;
  1612.             break;

  1614.         default:
  1615.             level = NGX_LOG_ERR;
  1616.         }

  1618.     } else {
  1619.         level = NGX_LOG_ALERT;
  1620.     }

  1622.     ngx_log_error(level, c->log, err, text);

  1624.     return NGX_ERROR;
  1625. }

One Level Up Top Level