One Level Up Top Level

src/core/ngx_connection.c - nginx-1.31.9 nginx/ @ 2a3a19c6f

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. #ifdef SO_PROTOCOL

  320.         olen = sizeof(int);

  322.         if (getsockopt(ls[i].fd, SOL_SOCKET, SO_PROTOCOL,
  323.                        (void *) &ls[i].protocol, &olen)
  324.             == -1)
  325.         {
  326.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  327.                           "getsockopt(SO_PROTOCOL) %V failed, ignored",
  328.                           &ls[i].addr_text);
  329.             ls[i].protocol = 0;

  331.         } else if (ls[i].protocol == IPPROTO_TCP) {
  332.             ls[i].protocol = 0;
  333.         }

  335. #endif

  337. #if (NGX_HAVE_TCP_FASTOPEN)

  339.         olen = sizeof(int);

  341.         if (getsockopt(ls[i].fd, IPPROTO_TCP, TCP_FASTOPEN,
  342.                        (void *) &ls[i].fastopen, &olen)
  343.             == -1)
  344.         {
  345.             err = ngx_socket_errno;

  347.             if (err != NGX_EOPNOTSUPP && err != NGX_ENOPROTOOPT
  348.                 && err != NGX_EINVAL)
  349.             {
  350.                 ngx_log_error(NGX_LOG_NOTICE, cycle->log, err,
  351.                               "getsockopt(TCP_FASTOPEN) %V failed, ignored",
  352.                               &ls[i].addr_text);
  353.             }

  355.             ls[i].fastopen = -1;
  356.         }

  358. #endif

  360. #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)

  362.         ngx_memzero(&af, sizeof(struct accept_filter_arg));
  363.         olen = sizeof(struct accept_filter_arg);

  365.         if (getsockopt(ls[i].fd, SOL_SOCKET, SO_ACCEPTFILTER, &af, &olen)
  366.             == -1)
  367.         {
  368.             err = ngx_socket_errno;

  370.             if (err == NGX_EINVAL) {
  371.                 continue;
  372.             }

  374.             ngx_log_error(NGX_LOG_NOTICE, cycle->log, err,
  375.                           "getsockopt(SO_ACCEPTFILTER) for %V failed, ignored",
  376.                           &ls[i].addr_text);
  377.             continue;
  378.         }

  380.         if (olen < sizeof(struct accept_filter_arg) || af.af_name[0] == '\0') {
  381.             continue;
  382.         }

  384.         ls[i].accept_filter = ngx_palloc(cycle->pool, 16);
  385.         if (ls[i].accept_filter == NULL) {
  386.             return NGX_ERROR;
  387.         }

  389.         (void) ngx_cpystrn((u_char *) ls[i].accept_filter,
  390.                            (u_char *) af.af_name, 16);
  391. #endif

  393. #if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)

  395.         timeout = 0;
  396.         olen = sizeof(int);

  398.         if (getsockopt(ls[i].fd, IPPROTO_TCP, TCP_DEFER_ACCEPT, &timeout, &olen)
  399.             == -1)
  400.         {
  401.             err = ngx_socket_errno;

  403.             if (err == NGX_EOPNOTSUPP) {
  404.                 continue;
  405.             }

  407.             ngx_log_error(NGX_LOG_NOTICE, cycle->log, err,
  408.                           "getsockopt(TCP_DEFER_ACCEPT) for %V failed, ignored",
  409.                           &ls[i].addr_text);
  410.             continue;
  411.         }

  413.         if (olen < sizeof(int) || timeout == 0) {
  414.             continue;
  415.         }

  417.         ls[i].deferred_accept = 1;
  418. #endif
  419.     }

  421.     return NGX_OK;
  422. }


  425. ngx_int_t
  426. ‌ngx_open_listening_sockets(ngx_cycle_t *cycle)
  427. {
  428.     int               reuseaddr;
  429.     ngx_uint_t        i, tries, failed;
  430.     ngx_err_t         err;
  431.     ngx_log_t        *log;
  432.     ngx_socket_t      s;
  433.     ngx_listening_t  *ls;

  435.     reuseaddr = 1;
  436. #if (NGX_SUPPRESS_WARN)
  437.     failed = 0;
  438. #endif

  440.     log = cycle->log;

  442.     /* TODO: configurable try number */

  444.     for (tries = 5; tries; tries--) {
  445.         failed = 0;

  447.         /* for each listening socket */

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

  452.             if (ls[i].ignore) {
  453.                 continue;
  454.             }

  456. #if (NGX_HAVE_REUSEPORT)

  458.             if (ls[i].add_reuseport || ls[i].change_protocol) {

  460.                 /*
  461.                  * to allow transition from a socket without SO_REUSEPORT
  462.                  * to multiple sockets with SO_REUSEPORT, we have to set
  463.                  * SO_REUSEPORT on the old socket before opening new ones
  464.                  *
  465.                  * to allow transition between different socket protocols
  466.                  * (e.g. IPPROTO_MPTCP), SO_REUSEPORT is set on both old
  467.                  * and new sockets
  468.                  */

  470.                 int  reuseport = 1;

  472. #ifdef SO_REUSEPORT_LB

  474.                 if (setsockopt(ls[i].fd, SOL_SOCKET, SO_REUSEPORT_LB,
  475.                                (const void *) &reuseport, sizeof(int))
  476.                     == -1)
  477.                 {
  478.                     ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  479.                                   "setsockopt(SO_REUSEPORT_LB) %V failed, "
  480.                                   "ignored",
  481.                                   &ls[i].addr_text);
  482.                 }

  484. #else

  486.                 if (setsockopt(ls[i].fd, SOL_SOCKET, SO_REUSEPORT,
  487.                                (const void *) &reuseport, sizeof(int))
  488.                     == -1)
  489.                 {
  490.                     ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  491.                                   "setsockopt(SO_REUSEPORT) %V failed, ignored",
  492.                                   &ls[i].addr_text);
  493.                 }
  494. #endif

  496.                 ls[i].add_reuseport = 0;
  497.             }
  498. #endif

  500.             if (ls[i].fd != (ngx_socket_t) -1 && !ls[i].change_protocol) {
  501.                 continue;
  502.             }

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

  506.                 /* TODO: close on exit */
  507.                 /* TODO: nonblocking */
  508.                 /* TODO: deferred accept */

  510.                 continue;
  511.             }

  513.             s = ngx_socket(ls[i].sockaddr->sa_family, ls[i].type,
  514.                            ls[i].protocol);

  516.             if (s == (ngx_socket_t) -1) {
  517.                 ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  518.                               ngx_socket_n " %V failed", &ls[i].addr_text);
  519.                 return NGX_ERROR;
  520.             }

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

  524.                 if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
  525.                                (const void *) &reuseaddr, sizeof(int))
  526.                     == -1)
  527.                 {
  528.                     ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  529.                                   "setsockopt(SO_REUSEADDR) %V failed",
  530.                                   &ls[i].addr_text);

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

  538.                     return NGX_ERROR;
  539.                 }
  540.             }

  542. #if (NGX_HAVE_REUSEPORT)

  544.             if ((ls[i].reuseport || ls[i].change_protocol)
  545.                 && !ngx_test_config)
  546.             {
  547.                 int  reuseport;

  549.                 reuseport = 1;

  551. #ifdef SO_REUSEPORT_LB

  553.                 if (setsockopt(s, SOL_SOCKET, SO_REUSEPORT_LB,
  554.                                (const void *) &reuseport, sizeof(int))
  555.                     == -1)
  556.                 {
  557.                     ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  558.                                   "setsockopt(SO_REUSEPORT_LB) %V failed",
  559.                                   &ls[i].addr_text);

  561.                     if (ngx_close_socket(s) == -1) {
  562.                         ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  563.                                       ngx_close_socket_n " %V failed",
  564.                                       &ls[i].addr_text);
  565.                     }

  567.                     return NGX_ERROR;
  568.                 }

  570. #else

  572.                 if (setsockopt(s, SOL_SOCKET, SO_REUSEPORT,
  573.                                (const void *) &reuseport, sizeof(int))
  574.                     == -1)
  575.                 {
  576.                     ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  577.                                   "setsockopt(SO_REUSEPORT) %V failed",
  578.                                   &ls[i].addr_text);

  580.                     if (ngx_close_socket(s) == -1) {
  581.                         ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  582.                                       ngx_close_socket_n " %V failed",
  583.                                       &ls[i].addr_text);
  584.                     }

  586.                     return NGX_ERROR;
  587.                 }
  588. #endif
  589.             }
  590. #endif

  592. #if (NGX_HAVE_INET6 && defined IPV6_V6ONLY)

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

  597.                 ipv6only = ls[i].ipv6only;

  599.                 if (setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY,
  600.                                (const void *) &ipv6only, sizeof(int))
  601.                     == -1)
  602.                 {
  603.                     ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  604.                                   "setsockopt(IPV6_V6ONLY) %V failed, ignored",
  605.                                   &ls[i].addr_text);
  606.                 }
  607.             }
  608. #endif
  609.             /* TODO: close on exit */

  611.             if (ngx_nonblocking(s) == -1) {
  612.                 ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  613.                               ngx_nonblocking_n " %V failed",
  614.                               &ls[i].addr_text);

  616.                 if (ngx_close_socket(s) == -1) {
  617.                     ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  618.                                   ngx_close_socket_n " %V failed",
  619.                                   &ls[i].addr_text);
  620.                 }

  622.                 return NGX_ERROR;
  623.             }

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

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

  631.                 if (err != NGX_EADDRINUSE || !ngx_test_config) {
  632.                     ngx_log_error(NGX_LOG_EMERG, log, err,
  633.                                   "bind() to %V failed", &ls[i].addr_text);
  634.                 }

  636.                 if (ngx_close_socket(s) == -1) {
  637.                     ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  638.                                   ngx_close_socket_n " %V failed",
  639.                                   &ls[i].addr_text);
  640.                 }

  642.                 if (err != NGX_EADDRINUSE) {
  643.                     return NGX_ERROR;
  644.                 }

  646.                 if (!ngx_test_config) {
  647.                     failed = 1;
  648.                 }

  650.                 continue;
  651.             }

  653. #if (NGX_HAVE_UNIX_DOMAIN)

  655.             if (ls[i].sockaddr->sa_family == AF_UNIX) {
  656.                 mode_t   mode;
  657.                 u_char  *name;

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

  662.                 if (chmod((char *) name, mode) == -1) {
  663.                     ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  664.                                   "chmod() \"%s\" failed", name);
  665.                 }

  667.                 if (ngx_test_config) {
  668.                     if (ngx_delete_file(name) == NGX_FILE_ERROR) {
  669.                         ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  670.                                       ngx_delete_file_n " %s failed", name);
  671.                     }
  672.                 }
  673.             }
  674. #endif

  676.             if (ls[i].type != SOCK_STREAM) {
  677.                 ls[i].fd = s;
  678.                 ls[i].open = 1;
  679.                 continue;
  680.             }

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

  685.                 /*
  686.                  * on OpenVZ after suspend/resume EADDRINUSE
  687.                  * may be returned by listen() instead of bind(), see
  688.                  * https://bugs.openvz.org/browse/OVZ-5587
  689.                  */

  691.                 if (err != NGX_EADDRINUSE || !ngx_test_config) {
  692.                     ngx_log_error(NGX_LOG_EMERG, log, err,
  693.                                   "listen() to %V, backlog %d failed",
  694.                                   &ls[i].addr_text, ls[i].backlog);
  695.                 }

  697.                 if (ngx_close_socket(s) == -1) {
  698.                     ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  699.                                   ngx_close_socket_n " %V failed",
  700.                                   &ls[i].addr_text);
  701.                 }

  703.                 if (err != NGX_EADDRINUSE) {
  704.                     return NGX_ERROR;
  705.                 }

  707.                 if (!ngx_test_config) {
  708.                     failed = 1;
  709.                 }

  711.                 continue;
  712.             }

  714.             ls[i].listen = 1;

  716.             ls[i].fd = s;
  717.             ls[i].open = 1;
  718.         }

  720.         if (!failed) {
  721.             break;
  722.         }

  724.         /* TODO: delay configurable */

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

  729.         ngx_msleep(500);
  730.     }

  732.     if (failed) {
  733.         ngx_log_error(NGX_LOG_EMERG, log, 0, "still could not bind()");
  734.         return NGX_ERROR;
  735.     }

  737.     return NGX_OK;
  738. }


  741. void
  742. ‌ngx_configure_listening_sockets(ngx_cycle_t *cycle)
  743. {
  744.     int                        value;
  745.     ngx_uint_t                 i;
  746.     ngx_listening_t           *ls;

  748. #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
  749.     struct accept_filter_arg   af;
  750. #endif

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

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

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

  768.         if (ls[i].sndbuf != -1) {
  769.             if (setsockopt(ls[i].fd, SOL_SOCKET, SO_SNDBUF,
  770.                            (const void *) &ls[i].sndbuf, sizeof(int))
  771.                 == -1)
  772.             {
  773.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  774.                               "setsockopt(SO_SNDBUF, %d) %V failed, ignored",
  775.                               ls[i].sndbuf, &ls[i].addr_text);
  776.             }
  777.         }

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

  782.             if (setsockopt(ls[i].fd, SOL_SOCKET, SO_KEEPALIVE,
  783.                            (const void *) &value, sizeof(int))
  784.                 == -1)
  785.             {
  786.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  787.                               "setsockopt(SO_KEEPALIVE, %d) %V failed, ignored",
  788.                               value, &ls[i].addr_text);
  789.             }
  790.         }

  792. #if (NGX_HAVE_KEEPALIVE_TUNABLE)

  794. #if !(NGX_DARWIN)

  796.         if (ls[i].keepidle) {
  797.             value = ls[i].keepidle;

  799. #if (NGX_KEEPALIVE_FACTOR)
  800.             value *= NGX_KEEPALIVE_FACTOR;
  801. #endif

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

  813. #endif

  815.         if (ls[i].keepintvl) {
  816.             value = ls[i].keepintvl;

  818. #if (NGX_KEEPALIVE_FACTOR)
  819.             value *= NGX_KEEPALIVE_FACTOR;
  820. #endif

  822.             if (setsockopt(ls[i].fd, IPPROTO_TCP, TCP_KEEPINTVL,
  823.                            (const void *) &value, sizeof(int))
  824.                 == -1)
  825.             {
  826.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  827.                              "setsockopt(TCP_KEEPINTVL, %d) %V failed, ignored",
  828.                              value, &ls[i].addr_text);
  829.             }
  830.         }

  832.         if (ls[i].keepcnt) {
  833.             if (setsockopt(ls[i].fd, IPPROTO_TCP, TCP_KEEPCNT,
  834.                            (const void *) &ls[i].keepcnt, sizeof(int))
  835.                 == -1)
  836.             {
  837.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  838.                               "setsockopt(TCP_KEEPCNT, %d) %V failed, ignored",
  839.                               ls[i].keepcnt, &ls[i].addr_text);
  840.             }
  841.         }

  843. #endif

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

  858. #if (NGX_HAVE_TCP_FASTOPEN)
  859.         if (ls[i].fastopen != -1) {
  860.             if (setsockopt(ls[i].fd, IPPROTO_TCP, TCP_FASTOPEN,
  861.                            (const void *) &ls[i].fastopen, sizeof(int))
  862.                 == -1)
  863.             {
  864.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  865.                               "setsockopt(TCP_FASTOPEN, %d) %V failed, ignored",
  866.                               ls[i].fastopen, &ls[i].addr_text);
  867.             }
  868.         }
  869. #endif

  871. #if 0
  872.         if (1) {
  873.             int tcp_nodelay = 1;

  875.             if (setsockopt(ls[i].fd, IPPROTO_TCP, TCP_NODELAY,
  876.                        (const void *) &tcp_nodelay, sizeof(int))
  877.                 == -1)
  878.             {
  879.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  880.                               "setsockopt(TCP_NODELAY) %V failed, ignored",
  881.                               &ls[i].addr_text);
  882.             }
  883.         }
  884. #endif

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

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

  890.             if (listen(ls[i].fd, ls[i].backlog) == -1) {
  891.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  892.                               "listen() to %V, backlog %d failed, ignored",
  893.                               &ls[i].addr_text, ls[i].backlog);
  894.             }
  895.         }

  897.         /*
  898.          * setting deferred mode should be last operation on socket,
  899.          * because code may prematurely continue cycle on failure
  900.          */

  902. #if (NGX_HAVE_DEFERRED_ACCEPT)

  904. #ifdef SO_ACCEPTFILTER

  906.         if (ls[i].delete_deferred) {
  907.             if (setsockopt(ls[i].fd, SOL_SOCKET, SO_ACCEPTFILTER, NULL, 0)
  908.                 == -1)
  909.             {
  910.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  911.                               "setsockopt(SO_ACCEPTFILTER, NULL) "
  912.                               "for %V failed, ignored",
  913.                               &ls[i].addr_text);

  915.                 if (ls[i].accept_filter) {
  916.                     ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  917.                                   "could not change the accept filter "
  918.                                   "to \"%s\" for %V, ignored",
  919.                                   ls[i].accept_filter, &ls[i].addr_text);
  920.                 }

  922.                 continue;
  923.             }

  925.             ls[i].deferred_accept = 0;
  926.         }

  928.         if (ls[i].add_deferred) {
  929.             ngx_memzero(&af, sizeof(struct accept_filter_arg));
  930.             (void) ngx_cpystrn((u_char *) af.af_name,
  931.                                (u_char *) ls[i].accept_filter, 16);

  933.             if (setsockopt(ls[i].fd, SOL_SOCKET, SO_ACCEPTFILTER,
  934.                            &af, sizeof(struct accept_filter_arg))
  935.                 == -1)
  936.             {
  937.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  938.                               "setsockopt(SO_ACCEPTFILTER, \"%s\") "
  939.                               "for %V failed, ignored",
  940.                               ls[i].accept_filter, &ls[i].addr_text);
  941.                 continue;
  942.             }

  944.             ls[i].deferred_accept = 1;
  945.         }

  947. #endif

  949. #ifdef TCP_DEFER_ACCEPT

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

  953.             if (ls[i].add_deferred) {
  954.                 /*
  955.                  * There is no way to find out how long a connection was
  956.                  * in queue (and a connection may bypass deferred queue at all
  957.                  * if syncookies were used), hence we use 1 second timeout
  958.                  * here.
  959.                  */
  960.                 value = 1;

  962.             } else {
  963.                 value = 0;
  964.             }

  966.             if (setsockopt(ls[i].fd, IPPROTO_TCP, TCP_DEFER_ACCEPT,
  967.                            &value, sizeof(int))
  968.                 == -1)
  969.             {
  970.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  971.                               "setsockopt(TCP_DEFER_ACCEPT, %d) for %V failed, "
  972.                               "ignored",
  973.                               value, &ls[i].addr_text);

  975.                 continue;
  976.             }
  977.         }

  979.         if (ls[i].add_deferred) {
  980.             ls[i].deferred_accept = 1;
  981.         }

  983. #endif

  985. #endif /* NGX_HAVE_DEFERRED_ACCEPT */

  987. #if (NGX_HAVE_IP_RECVDSTADDR)

  989.         if (ls[i].wildcard
  990.             && ls[i].type == SOCK_DGRAM
  991.             && ls[i].sockaddr->sa_family == AF_INET)
  992.         {
  993.             value = 1;

  995.             if (setsockopt(ls[i].fd, IPPROTO_IP, IP_RECVDSTADDR,
  996.                            (const void *) &value, sizeof(int))
  997.                 == -1)
  998.             {
  999.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  1000.                               "setsockopt(IP_RECVDSTADDR) "
  1001.                               "for %V failed, ignored",
  1002.                               &ls[i].addr_text);
  1003.             }
  1004.         }

  1006. #elif (NGX_HAVE_IP_PKTINFO)

  1008.         if (ls[i].wildcard
  1009.             && ls[i].type == SOCK_DGRAM
  1010.             && ls[i].sockaddr->sa_family == AF_INET)
  1011.         {
  1012.             value = 1;

  1014.             if (setsockopt(ls[i].fd, IPPROTO_IP, IP_PKTINFO,
  1015.                            (const void *) &value, sizeof(int))
  1016.                 == -1)
  1017.             {
  1018.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  1019.                               "setsockopt(IP_PKTINFO) "
  1020.                               "for %V failed, ignored",
  1021.                               &ls[i].addr_text);
  1022.             }
  1023.         }

  1025. #endif

  1027. #if (NGX_HAVE_INET6 && NGX_HAVE_IPV6_RECVPKTINFO)

  1029.         if (ls[i].wildcard
  1030.             && ls[i].type == SOCK_DGRAM
  1031.             && ls[i].sockaddr->sa_family == AF_INET6)
  1032.         {
  1033.             value = 1;

  1035.             if (setsockopt(ls[i].fd, IPPROTO_IPV6, IPV6_RECVPKTINFO,
  1036.                            (const void *) &value, sizeof(int))
  1037.                 == -1)
  1038.             {
  1039.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  1040.                               "setsockopt(IPV6_RECVPKTINFO) "
  1041.                               "for %V failed, ignored",
  1042.                               &ls[i].addr_text);
  1043.             }
  1044.         }

  1046. #endif

  1048. #if (NGX_HAVE_IP_MTU_DISCOVER)

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

  1053.             if (setsockopt(ls[i].fd, IPPROTO_IP, IP_MTU_DISCOVER,
  1054.                            (const void *) &value, sizeof(int))
  1055.                 == -1)
  1056.             {
  1057.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  1058.                               "setsockopt(IP_MTU_DISCOVER) "
  1059.                               "for %V failed, ignored",
  1060.                               &ls[i].addr_text);
  1061.             }
  1062.         }

  1064. #elif (NGX_HAVE_IP_DONTFRAG)

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

  1069.             if (setsockopt(ls[i].fd, IPPROTO_IP, IP_DONTFRAG,
  1070.                            (const void *) &value, sizeof(int))
  1071.                 == -1)
  1072.             {
  1073.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  1074.                               "setsockopt(IP_DONTFRAG) "
  1075.                               "for %V failed, ignored",
  1076.                               &ls[i].addr_text);
  1077.             }
  1078.         }

  1080. #endif

  1082. #if (NGX_HAVE_INET6)

  1084. #if (NGX_HAVE_IPV6_MTU_DISCOVER)

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

  1089.             if (setsockopt(ls[i].fd, IPPROTO_IPV6, IPV6_MTU_DISCOVER,
  1090.                            (const void *) &value, sizeof(int))
  1091.                 == -1)
  1092.             {
  1093.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  1094.                               "setsockopt(IPV6_MTU_DISCOVER) "
  1095.                               "for %V failed, ignored",
  1096.                               &ls[i].addr_text);
  1097.             }
  1098.         }

  1100. #elif (NGX_HAVE_IPV6_DONTFRAG)

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

  1105.             if (setsockopt(ls[i].fd, IPPROTO_IPV6, IPV6_DONTFRAG,
  1106.                            (const void *) &value, sizeof(int))
  1107.                 == -1)
  1108.             {
  1109.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  1110.                               "setsockopt(IPV6_DONTFRAG) "
  1111.                               "for %V failed, ignored",
  1112.                               &ls[i].addr_text);
  1113.             }
  1114.         }

  1116. #endif

  1118. #endif
  1119.     }

  1121.     return;
  1122. }


  1125. void
  1126. ‌ngx_close_listening_sockets(ngx_cycle_t *cycle)
  1127. {
  1128.     ngx_uint_t         i;
  1129.     ngx_listening_t   *ls;
  1130.     ngx_connection_t  *c;

  1132.     ngx_accept_mutex_held = 0;
  1133.     ngx_use_accept_mutex = 0;

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

  1138. #if (NGX_QUIC)
  1139.         if (ls[i].quic
  1140.             && (!ls[i].reuseport || !ngx_quic_bpf_enabled(cycle)))
  1141.         {
  1142.             continue;
  1143.         }
  1144. #endif

  1146.         c = ls[i].connection;

  1148.         if (c) {
  1149.             if (c->read->active) {
  1150.                 if (ngx_event_flags & NGX_USE_EPOLL_EVENT) {

  1152.                     /*
  1153.                      * it seems that Linux-2.6.x OpenVZ sends events
  1154.                      * for closed shared listening sockets unless
  1155.                      * the events was explicitly deleted
  1156.                      */

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

  1160.                 } else {
  1161.                     ngx_del_event(c->read, NGX_READ_EVENT, NGX_CLOSE_EVENT);
  1162.                 }
  1163.             }

  1165.             if (c->read->timer_set) {
  1166.                 ngx_del_timer(c->read);
  1167.             }

  1169.             ngx_free_connection(c);

  1171.             c->fd = (ngx_socket_t) -1;
  1172.         }

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

  1177.         if (ngx_close_socket(ls[i].fd) == -1) {
  1178.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_socket_errno,
  1179.                           ngx_close_socket_n " %V failed", &ls[i].addr_text);
  1180.         }

  1182. #if (NGX_HAVE_UNIX_DOMAIN)

  1184.         if (ls[i].sockaddr->sa_family == AF_UNIX
  1185.             && ngx_process <= NGX_PROCESS_MASTER
  1186.             && ngx_new_binary == 0
  1187.             && (!ls[i].inherited || ngx_getppid() != ngx_parent))
  1188.         {
  1189.             u_char *name = ls[i].addr_text.data + sizeof("unix:") - 1;

  1191.             if (ngx_delete_file(name) == NGX_FILE_ERROR) {
  1192.                 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_socket_errno,
  1193.                               ngx_delete_file_n " %s failed", name);
  1194.             }
  1195.         }

  1197. #endif

  1199.         ls[i].fd = (ngx_socket_t) -1;
  1200.     }

  1202.     cycle->listening.nelts = 0;
  1203. }


  1206. ngx_connection_t *
  1207. ‌ngx_get_connection(ngx_socket_t s, ngx_log_t *log)
  1208. {
  1209.     ngx_uint_t         instance;
  1210.     ngx_event_t       *rev, *wev;
  1211.     ngx_connection_t  *c;

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

  1215.     if (ngx_cycle->files && (ngx_uint_t) s >= ngx_cycle->files_n) {
  1216.         ngx_log_error(NGX_LOG_ALERT, log, 0,
  1217.                       "the new socket has number %d, "
  1218.                       "but only %ui files are available",
  1219.                       s, ngx_cycle->files_n);
  1220.         return NULL;
  1221.     }

  1223.     ngx_drain_connections((ngx_cycle_t *) ngx_cycle);

  1225.     c = ngx_cycle->free_connections;

  1227.     if (c == NULL) {
  1228.         ngx_log_error(NGX_LOG_ALERT, log, 0,
  1229.                       "%ui worker_connections are not enough",
  1230.                       ngx_cycle->connection_n);

  1232.         return NULL;
  1233.     }

  1235.     ngx_cycle->free_connections = c->data;
  1236.     ngx_cycle->free_connection_n--;

  1238.     if (ngx_cycle->files && ngx_cycle->files[s] == NULL) {
  1239.         ngx_cycle->files[s] = c;
  1240.     }

  1242.     rev = c->read;
  1243.     wev = c->write;

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

  1247.     c->read = rev;
  1248.     c->write = wev;
  1249.     c->fd = s;
  1250.     c->log = log;

  1252.     instance = rev->instance;

  1254.     ngx_memzero(rev, sizeof(ngx_event_t));
  1255.     ngx_memzero(wev, sizeof(ngx_event_t));

  1257.     rev->instance = !instance;
  1258.     wev->instance = !instance;

  1260.     rev->index = NGX_INVALID_INDEX;
  1261.     wev->index = NGX_INVALID_INDEX;

  1263.     rev->data = c;
  1264.     wev->data = c;

  1266.     wev->write = 1;

  1268.     return c;
  1269. }


  1272. void
  1273. ‌ngx_free_connection(ngx_connection_t *c)
  1274. {
  1275.     c->data = ngx_cycle->free_connections;
  1276.     ngx_cycle->free_connections = c;
  1277.     ngx_cycle->free_connection_n++;

  1279.     if (ngx_cycle->files && ngx_cycle->files[c->fd] == c) {
  1280.         ngx_cycle->files[c->fd] = NULL;
  1281.     }
  1282. }


  1285. void
  1286. ‌ngx_close_connection(ngx_connection_t *c)
  1287. {
  1288.     ngx_err_t     err;
  1289.     ngx_uint_t    log_error, level;
  1290.     ngx_socket_t  fd;

  1292.     if (c->fd == (ngx_socket_t) -1) {
  1293.         ngx_log_error(NGX_LOG_ALERT, c->log, 0, "connection already closed");
  1294.         return;
  1295.     }

  1297.     if (c->read->timer_set) {
  1298.         ngx_del_timer(c->read);
  1299.     }

  1301.     if (c->write->timer_set) {
  1302.         ngx_del_timer(c->write);
  1303.     }

  1305.     if (!c->shared) {
  1306.         if (ngx_del_conn) {
  1307.             ngx_del_conn(c, NGX_CLOSE_EVENT);

  1309.         } else {
  1310.             if (c->read->active || c->read->disabled) {
  1311.                 ngx_del_event(c->read, NGX_READ_EVENT, NGX_CLOSE_EVENT);
  1312.             }

  1314.             if (c->write->active || c->write->disabled) {
  1315.                 ngx_del_event(c->write, NGX_WRITE_EVENT, NGX_CLOSE_EVENT);
  1316.             }
  1317.         }
  1318.     }

  1320.     if (c->read->posted) {
  1321.         ngx_delete_posted_event(c->read);
  1322.     }

  1324.     if (c->write->posted) {
  1325.         ngx_delete_posted_event(c->write);
  1326.     }

  1328.     c->read->closed = 1;
  1329.     c->write->closed = 1;

  1331.     ngx_reusable_connection(c, 0);

  1333.     log_error = c->log_error;

  1335.     ngx_free_connection(c);

  1337.     fd = c->fd;
  1338.     c->fd = (ngx_socket_t) -1;

  1340.     if (c->shared) {
  1341.         return;
  1342.     }

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

  1346.         err = ngx_socket_errno;

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

  1350.             switch (log_error) {

  1352.             case NGX_ERROR_INFO:
  1353.                 level = NGX_LOG_INFO;
  1354.                 break;

  1356.             case NGX_ERROR_ERR:
  1357.                 level = NGX_LOG_ERR;
  1358.                 break;

  1360.             default:
  1361.                 level = NGX_LOG_CRIT;
  1362.             }

  1364.         } else {
  1365.             level = NGX_LOG_CRIT;
  1366.         }

  1368.         ngx_log_error(level, c->log, err, ngx_close_socket_n " %d failed", fd);
  1369.     }
  1370. }


  1373. void
  1374. ‌ngx_reusable_connection(ngx_connection_t *c, ngx_uint_t reusable)
  1375. {
  1376.     ngx_log_debug1(NGX_LOG_DEBUG_CORE, c->log, 0,
  1377.                    "reusable connection: %ui", reusable);

  1379.     if (c->reusable) {
  1380.         ngx_queue_remove(&c->queue);
  1381.         ngx_cycle->reusable_connections_n--;

  1383. #if (NGX_STAT_STUB)
  1384.         (void) ngx_atomic_fetch_add(ngx_stat_waiting, -1);
  1385. #endif
  1386.     }

  1388.     c->reusable = reusable;

  1390.     if (reusable) {
  1391.         /* need cast as ngx_cycle is volatile */

  1393.         ngx_queue_insert_head(
  1394.             (ngx_queue_t *) &ngx_cycle->reusable_connections_queue, &c->queue);
  1395.         ngx_cycle->reusable_connections_n++;

  1397. #if (NGX_STAT_STUB)
  1398.         (void) ngx_atomic_fetch_add(ngx_stat_waiting, 1);
  1399. #endif
  1400.     }
  1401. }


  1404. static void
  1405. ‌ngx_drain_connections(ngx_cycle_t *cycle)
  1406. {
  1407.     ngx_uint_t         i, n;
  1408.     ngx_queue_t       *q;
  1409.     ngx_connection_t  *c;

  1411.     if (cycle->free_connection_n > cycle->connection_n / 16
  1412.         || cycle->reusable_connections_n == 0)
  1413.     {
  1414.         return;
  1415.     }

  1417.     if (cycle->connections_reuse_time != ngx_time()) {
  1418.         cycle->connections_reuse_time = ngx_time();

  1420.         ngx_log_error(NGX_LOG_WARN, cycle->log, 0,
  1421.                       "%ui worker_connections are not enough, "
  1422.                       "reusing connections",
  1423.                       cycle->connection_n);
  1424.     }

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

  1429.     for (i = 0; i < n; i++) {
  1430.         if (ngx_queue_empty(&cycle->reusable_connections_queue)) {
  1431.             break;
  1432.         }

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

  1437.         ngx_log_debug0(NGX_LOG_DEBUG_CORE, c->log, 0,
  1438.                        "reusing connection");

  1440.         c->close = 1;
  1441.         c->read->handler(c->read);
  1442.     }

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

  1446.         /*
  1447.          * if no connections were freed, try to reuse the last
  1448.          * connection again: this should free it as long as
  1449.          * previous reuse moved it to lingering close
  1450.          */

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

  1455.         c->close = 1;
  1456.         c->read->handler(c->read);
  1457.     }
  1458. }


  1461. void
  1462. ‌ngx_close_idle_connections(ngx_cycle_t *cycle)
  1463. {
  1464.     ngx_uint_t         i;
  1465.     ngx_connection_t  *c;

  1467.     c = cycle->connections;

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

  1471.         /* THREAD: lock */

  1473.         if (c[i].fd != (ngx_socket_t) -1 && c[i].idle) {
  1474.             c[i].close = 1;
  1475.             c[i].read->handler(c[i].read);
  1476.         }
  1477.     }
  1478. }


  1481. ngx_int_t
  1482. ‌ngx_connection_local_sockaddr(ngx_connection_t *c, ngx_str_t *s,
  1483.     ngx_uint_t port)
  1484. {
  1485.     socklen_t             len;
  1486.     ngx_uint_t            addr;
  1487.     ngx_sockaddr_t        sa;
  1488.     struct sockaddr_in   *sin;
  1489. #if (NGX_HAVE_INET6)
  1490.     ngx_uint_t            i;
  1491.     struct sockaddr_in6  *sin6;
  1492. #endif

  1494.     addr = 0;

  1496.     if (c->local_socklen) {
  1497.         switch (c->local_sockaddr->sa_family) {

  1499. #if (NGX_HAVE_INET6)
  1500.         case AF_INET6:
  1501.             sin6 = (struct sockaddr_in6 *) c->local_sockaddr;

  1503.             for (i = 0; addr == 0 && i < 16; i++) {
  1504.                 addr |= sin6->sin6_addr.s6_addr[i];
  1505.             }

  1507.             break;
  1508. #endif

  1510. #if (NGX_HAVE_UNIX_DOMAIN)
  1511.         case AF_UNIX:
  1512.             addr = 1;
  1513.             break;
  1514. #endif

  1516.         default: /* AF_INET */
  1517.             sin = (struct sockaddr_in *) c->local_sockaddr;
  1518.             addr = sin->sin_addr.s_addr;
  1519.             break;
  1520.         }
  1521.     }

  1523.     if (addr == 0) {

  1525.         len = sizeof(ngx_sockaddr_t);

  1527.         if (getsockname(c->fd, &sa.sockaddr, &len) == -1) {
  1528.             ngx_connection_error(c, ngx_socket_errno, "getsockname() failed");
  1529.             return NGX_ERROR;
  1530.         }

  1532.         c->local_sockaddr = ngx_palloc(c->pool, len);
  1533.         if (c->local_sockaddr == NULL) {
  1534.             return NGX_ERROR;
  1535.         }

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

  1539.         c->local_socklen = len;
  1540.     }

  1542.     if (s == NULL) {
  1543.         return NGX_OK;
  1544.     }

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

  1549.     return NGX_OK;
  1550. }


  1553. ngx_int_t
  1554. ‌ngx_tcp_nodelay(ngx_connection_t *c)
  1555. {
  1556.     int  tcp_nodelay;

  1558.     if (c->tcp_nodelay != NGX_TCP_NODELAY_UNSET) {
  1559.         return NGX_OK;
  1560.     }

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

  1564.     tcp_nodelay = 1;

  1566.     if (setsockopt(c->fd, IPPROTO_TCP, TCP_NODELAY,
  1567.                    (const void *) &tcp_nodelay, sizeof(int))
  1568.         == -1)
  1569.     {
  1570. #if (NGX_SOLARIS)
  1571.         if (c->log_error == NGX_ERROR_INFO) {

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

  1576.             ngx_connection_error(c, ngx_socket_errno,
  1577.                                  "setsockopt(TCP_NODELAY) failed");

  1579.             c->log_error = NGX_ERROR_INFO;

  1581.             return NGX_ERROR;
  1582.         }
  1583. #endif

  1585.         ngx_connection_error(c, ngx_socket_errno,
  1586.                              "setsockopt(TCP_NODELAY) failed");
  1587.         return NGX_ERROR;
  1588.     }

  1590.     c->tcp_nodelay = NGX_TCP_NODELAY_SET;

  1592.     return NGX_OK;
  1593. }


  1596. ngx_int_t
  1597. ‌ngx_connection_error(ngx_connection_t *c, ngx_err_t err, char *text)
  1598. {
  1599.     ngx_uint_t  level;

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

  1603.     if ((err == NGX_ECONNRESET
  1604. #if (NGX_WIN32)
  1605.          || err == NGX_ECONNABORTED
  1606. #endif
  1607.         ) && c->log_error == NGX_ERROR_IGNORE_ECONNRESET)
  1608.     {
  1609.         return 0;
  1610.     }

  1612. #if (NGX_SOLARIS)
  1613.     if (err == NGX_EINVAL && c->log_error == NGX_ERROR_IGNORE_EINVAL) {
  1614.         return 0;
  1615.     }
  1616. #endif

  1618.     if (err == NGX_EMSGSIZE && c->log_error == NGX_ERROR_IGNORE_EMSGSIZE) {
  1619.         return 0;
  1620.     }

  1622. #if (NGX_LINUX)
  1623.     if (err == NGX_EIO && c->ktls_recv) {
  1624.         return 0;
  1625.     }
  1626. #endif

  1628.     if (err == 0
  1629.         || err == NGX_ECONNRESET
  1630. #if (NGX_WIN32)
  1631.         || err == NGX_ECONNABORTED
  1632. #else
  1633.         || err == NGX_EPIPE
  1634. #endif
  1635.         || err == NGX_ENOTCONN
  1636.         || err == NGX_ETIMEDOUT
  1637.         || err == NGX_ECONNREFUSED
  1638.         || err == NGX_ENETDOWN
  1639.         || err == NGX_ENETUNREACH
  1640.         || err == NGX_EHOSTDOWN
  1641.         || err == NGX_EHOSTUNREACH)
  1642.     {
  1643.         switch (c->log_error) {

  1645.         case NGX_ERROR_IGNORE_EMSGSIZE:
  1646.         case NGX_ERROR_IGNORE_EINVAL:
  1647.         case NGX_ERROR_IGNORE_ECONNRESET:
  1648.         case NGX_ERROR_INFO:
  1649.             level = NGX_LOG_INFO;
  1650.             break;

  1652.         default:
  1653.             level = NGX_LOG_ERR;
  1654.         }

  1656.     } else {
  1657.         level = NGX_LOG_ALERT;
  1658.     }

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

  1662.     return NGX_ERROR;
  1663. }

One Level Up Top Level