One Level Up Top Level

src/core/ngx_connection.c - nginx

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_event_flags & NGX_USE_IOCP_EVENT)) {
  612.                 if (ngx_nonblocking(s) == -1) {
  613.                     ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  614.                                   ngx_nonblocking_n " %V failed",
  615.                                   &ls[i].addr_text);

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

  623.                     return NGX_ERROR;
  624.                 }
  625.             }

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

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

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

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

  644.                 if (err != NGX_EADDRINUSE) {
  645.                     return NGX_ERROR;
  646.                 }

  648.                 if (!ngx_test_config) {
  649.                     failed = 1;
  650.                 }

  652.                 continue;
  653.             }

  655. #if (NGX_HAVE_UNIX_DOMAIN)

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

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

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

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

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

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

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

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

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

  705.                 if (err != NGX_EADDRINUSE) {
  706.                     return NGX_ERROR;
  707.                 }

  709.                 if (!ngx_test_config) {
  710.                     failed = 1;
  711.                 }

  713.                 continue;
  714.             }

  716.             ls[i].listen = 1;

  718.             ls[i].fd = s;
  719.             ls[i].open = 1;
  720.         }

  722.         if (!failed) {
  723.             break;
  724.         }

  726.         /* TODO: delay configurable */

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

  731.         ngx_msleep(500);
  732.     }

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

  739.     return NGX_OK;
  740. }


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

  750. #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
  751.     struct accept_filter_arg   af;
  752. #endif

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

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

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

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

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

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

  794. #if (NGX_HAVE_KEEPALIVE_TUNABLE)

  796. #if !(NGX_DARWIN)

  798.         if (ls[i].keepidle) {
  799.             value = ls[i].keepidle;

  801. #if (NGX_KEEPALIVE_FACTOR)
  802.             value *= NGX_KEEPALIVE_FACTOR;
  803. #endif

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

  815. #endif

  817.         if (ls[i].keepintvl) {
  818.             value = ls[i].keepintvl;

  820. #if (NGX_KEEPALIVE_FACTOR)
  821.             value *= NGX_KEEPALIVE_FACTOR;
  822. #endif

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

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

  845. #endif

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

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

  873. #if 0
  874.         if (1) {
  875.             int tcp_nodelay = 1;

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

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

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

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

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

  904. #if (NGX_HAVE_DEFERRED_ACCEPT)

  906. #ifdef SO_ACCEPTFILTER

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

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

  924.                 continue;
  925.             }

  927.             ls[i].deferred_accept = 0;
  928.         }

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

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

  946.             ls[i].deferred_accept = 1;
  947.         }

  949. #endif

  951. #ifdef TCP_DEFER_ACCEPT

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

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

  964.             } else {
  965.                 value = 0;
  966.             }

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

  977.                 continue;
  978.             }
  979.         }

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

  985. #endif

  987. #endif /* NGX_HAVE_DEFERRED_ACCEPT */

  989. #if (NGX_HAVE_IP_RECVDSTADDR)

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

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

  1008. #elif (NGX_HAVE_IP_PKTINFO)

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

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

  1027. #endif

  1029. #if (NGX_HAVE_INET6 && NGX_HAVE_IPV6_RECVPKTINFO)

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

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

  1048. #endif

  1050. #if (NGX_HAVE_IP_MTU_DISCOVER)

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

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

  1066. #elif (NGX_HAVE_IP_DONTFRAG)

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

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

  1082. #endif

  1084. #if (NGX_HAVE_INET6)

  1086. #if (NGX_HAVE_IPV6_MTU_DISCOVER)

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

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

  1102. #elif (NGX_HAVE_IP_DONTFRAG)

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

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

  1118. #endif

  1120. #endif
  1121.     }

  1123.     return;
  1124. }


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

  1134.     if (ngx_event_flags & NGX_USE_IOCP_EVENT) {
  1135.         return;
  1136.     }

  1138.     ngx_accept_mutex_held = 0;
  1139.     ngx_use_accept_mutex = 0;

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

  1144. #if (NGX_QUIC)
  1145.         if (ls[i].quic) {
  1146.             continue;
  1147.         }
  1148. #endif

  1150.         c = ls[i].connection;

  1152.         if (c) {
  1153.             if (c->read->active) {
  1154.                 if (ngx_event_flags & NGX_USE_EPOLL_EVENT) {

  1156.                     /*
  1157.                      * it seems that Linux-2.6.x OpenVZ sends events
  1158.                      * for closed shared listening sockets unless
  1159.                      * the events was explicitly deleted
  1160.                      */

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

  1164.                 } else {
  1165.                     ngx_del_event(c->read, NGX_READ_EVENT, NGX_CLOSE_EVENT);
  1166.                 }
  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 (err == 0
  1623.         || err == NGX_ECONNRESET
  1624. #if (NGX_WIN32)
  1625.         || err == NGX_ECONNABORTED
  1626. #else
  1627.         || err == NGX_EPIPE
  1628. #endif
  1629.         || err == NGX_ENOTCONN
  1630.         || err == NGX_ETIMEDOUT
  1631.         || err == NGX_ECONNREFUSED
  1632.         || err == NGX_ENETDOWN
  1633.         || err == NGX_ENETUNREACH
  1634.         || err == NGX_EHOSTDOWN
  1635.         || err == NGX_EHOSTUNREACH)
  1636.     {
  1637.         switch (c->log_error) {

  1639.         case NGX_ERROR_IGNORE_EMSGSIZE:
  1640.         case NGX_ERROR_IGNORE_EINVAL:
  1641.         case NGX_ERROR_IGNORE_ECONNRESET:
  1642.         case NGX_ERROR_INFO:
  1643.             level = NGX_LOG_INFO;
  1644.             break;

  1646.         default:
  1647.             level = NGX_LOG_ERR;
  1648.         }

  1650.     } else {
  1651.         level = NGX_LOG_ALERT;
  1652.     }

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

  1656.     return NGX_ERROR;
  1657. }

One Level Up Top Level