One Level Up Top Level

src/core/ngx_connection.c - nginx-1.7.10

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(void);


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

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

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

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

  39.     ngx_memcpy(sa, sockaddr, socklen);

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

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

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

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

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

  74.     ls->fd = (ngx_socket_t) -1;
  75.     ls->type = SOCK_STREAM;

  77.     ls->backlog = NGX_LISTEN_BACKLOG;
  78.     ls->rcvbuf = -1;
  79.     ls->sndbuf = -1;

  81. #if (NGX_HAVE_SETFIB)
  82.     ls->setfib = -1;
  83. #endif

  85. #if (NGX_HAVE_TCP_FASTOPEN)
  86.     ls->fastopen = -1;
  87. #endif

  89.     return ls;
  90. }


  93. ngx_int_t
  94. ‌ngx_set_inherited_sockets(ngx_cycle_t *cycle)
  95. {
  96.     size_t                     len;
  97.     ngx_uint_t                 i;
  98.     ngx_listening_t           *ls;
  99.     socklen_t                  olen;
  100. #if (NGX_HAVE_DEFERRED_ACCEPT || NGX_HAVE_TCP_FASTOPEN)
  101.     ngx_err_t                  err;
  102. #endif
  103. #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
  104.     struct accept_filter_arg   af;
  105. #endif
  106. #if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
  107.     int                        timeout;
  108. #endif

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

  113.         ls[i].sockaddr = ngx_palloc(cycle->pool, NGX_SOCKADDRLEN);
  114.         if (ls[i].sockaddr == NULL) {
  115.             return NGX_ERROR;
  116.         }

  118.         ls[i].socklen = NGX_SOCKADDRLEN;
  119.         if (getsockname(ls[i].fd, ls[i].sockaddr, &ls[i].socklen) == -1) {
  120.             ngx_log_error(NGX_LOG_CRIT, cycle->log, ngx_socket_errno,
  121.                           "getsockname() of the inherited "
  122.                           "socket #%d failed", ls[i].fd);
  123.             ls[i].ignore = 1;
  124.             continue;
  125.         }

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

  129. #if (NGX_HAVE_INET6)
  130.         case AF_INET6:
  131.              ls[i].addr_text_max_len = NGX_INET6_ADDRSTRLEN;
  132.              len = NGX_INET6_ADDRSTRLEN + sizeof("[]:65535") - 1;
  133.              break;
  134. #endif

  136. #if (NGX_HAVE_UNIX_DOMAIN)
  137.         case AF_UNIX:
  138.              ls[i].addr_text_max_len = NGX_UNIX_ADDRSTRLEN;
  139.              len = NGX_UNIX_ADDRSTRLEN;
  140.              break;
  141. #endif

  143.         case AF_INET:
  144.              ls[i].addr_text_max_len = NGX_INET_ADDRSTRLEN;
  145.              len = NGX_INET_ADDRSTRLEN + sizeof(":65535") - 1;
  146.              break;

  148.         default:
  149.             ngx_log_error(NGX_LOG_CRIT, cycle->log, ngx_socket_errno,
  150.                           "the inherited socket #%d has "
  151.                           "an unsupported protocol family", ls[i].fd);
  152.             ls[i].ignore = 1;
  153.             continue;
  154.         }

  156.         ls[i].addr_text.data = ngx_pnalloc(cycle->pool, len);
  157.         if (ls[i].addr_text.data == NULL) {
  158.             return NGX_ERROR;
  159.         }

  161.         len = ngx_sock_ntop(ls[i].sockaddr, ls[i].socklen,
  162.                             ls[i].addr_text.data, len, 1);
  163.         if (len == 0) {
  164.             return NGX_ERROR;
  165.         }

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

  169.         ls[i].backlog = NGX_LISTEN_BACKLOG;

  171.         olen = sizeof(int);

  173.         if (getsockopt(ls[i].fd, SOL_SOCKET, SO_RCVBUF, (void *) &ls[i].rcvbuf,
  174.                        &olen)
  175.             == -1)
  176.         {
  177.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  178.                           "getsockopt(SO_RCVBUF) %V failed, ignored",
  179.                           &ls[i].addr_text);

  181.             ls[i].rcvbuf = -1;
  182.         }

  184.         olen = sizeof(int);

  186.         if (getsockopt(ls[i].fd, SOL_SOCKET, SO_SNDBUF, (void *) &ls[i].sndbuf,
  187.                        &olen)
  188.             == -1)
  189.         {
  190.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  191.                           "getsockopt(SO_SNDBUF) %V failed, ignored",
  192.                           &ls[i].addr_text);

  194.             ls[i].sndbuf = -1;
  195.         }

  197. #if 0
  198.         /* SO_SETFIB is currently a set only option */

  200. #if (NGX_HAVE_SETFIB)

  202.         olen = sizeof(int);

  204.         if (getsockopt(ls[i].fd, SOL_SOCKET, SO_SETFIB,
  205.                        (void *) &ls[i].setfib, &olen)
  206.             == -1)
  207.         {
  208.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  209.                           "getsockopt(SO_SETFIB) %V failed, ignored",
  210.                           &ls[i].addr_text);

  212.             ls[i].setfib = -1;
  213.         }

  215. #endif
  216. #endif

  218. #if (NGX_HAVE_TCP_FASTOPEN)

  220.         olen = sizeof(int);

  222.         if (getsockopt(ls[i].fd, IPPROTO_TCP, TCP_FASTOPEN,
  223.                        (void *) &ls[i].fastopen, &olen)
  224.             == -1)
  225.         {
  226.             err = ngx_socket_errno;

  228.             if (err != NGX_EOPNOTSUPP && err != NGX_ENOPROTOOPT) {
  229.                 ngx_log_error(NGX_LOG_NOTICE, cycle->log, err,
  230.                               "getsockopt(TCP_FASTOPEN) %V failed, ignored",
  231.                               &ls[i].addr_text);
  232.             }

  234.             ls[i].fastopen = -1;
  235.         }

  237. #endif

  239. #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)

  241.         ngx_memzero(&af, sizeof(struct accept_filter_arg));
  242.         olen = sizeof(struct accept_filter_arg);

  244.         if (getsockopt(ls[i].fd, SOL_SOCKET, SO_ACCEPTFILTER, &af, &olen)
  245.             == -1)
  246.         {
  247.             err = ngx_socket_errno;

  249.             if (err == NGX_EINVAL) {
  250.                 continue;
  251.             }

  253.             ngx_log_error(NGX_LOG_NOTICE, cycle->log, err,
  254.                           "getsockopt(SO_ACCEPTFILTER) for %V failed, ignored",
  255.                           &ls[i].addr_text);
  256.             continue;
  257.         }

  259.         if (olen < sizeof(struct accept_filter_arg) || af.af_name[0] == '\0') {
  260.             continue;
  261.         }

  263.         ls[i].accept_filter = ngx_palloc(cycle->pool, 16);
  264.         if (ls[i].accept_filter == NULL) {
  265.             return NGX_ERROR;
  266.         }

  268.         (void) ngx_cpystrn((u_char *) ls[i].accept_filter,
  269.                            (u_char *) af.af_name, 16);
  270. #endif

  272. #if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)

  274.         timeout = 0;
  275.         olen = sizeof(int);

  277.         if (getsockopt(ls[i].fd, IPPROTO_TCP, TCP_DEFER_ACCEPT, &timeout, &olen)
  278.             == -1)
  279.         {
  280.             err = ngx_socket_errno;

  282.             if (err == NGX_EOPNOTSUPP) {
  283.                 continue;
  284.             }

  286.             ngx_log_error(NGX_LOG_NOTICE, cycle->log, err,
  287.                           "getsockopt(TCP_DEFER_ACCEPT) for %V failed, ignored",
  288.                           &ls[i].addr_text);
  289.             continue;
  290.         }

  292.         if (olen < sizeof(int) || timeout == 0) {
  293.             continue;
  294.         }

  296.         ls[i].deferred_accept = 1;
  297. #endif
  298.     }

  300.     return NGX_OK;
  301. }


  304. ngx_int_t
  305. ‌ngx_open_listening_sockets(ngx_cycle_t *cycle)
  306. {
  307.     int               reuseaddr;
  308.     ngx_uint_t        i, tries, failed;
  309.     ngx_err_t         err;
  310.     ngx_log_t        *log;
  311.     ngx_socket_t      s;
  312.     ngx_listening_t  *ls;

  314.     reuseaddr = 1;
  315. #if (NGX_SUPPRESS_WARN)
  316.     failed = 0;
  317. #endif

  319.     log = cycle->log;

  321.     /* TODO: configurable try number */

  323.     for (tries = 5; tries; tries--) {
  324.         failed = 0;

  326.         /* for each listening socket */

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

  331.             if (ls[i].ignore) {
  332.                 continue;
  333.             }

  335.             if (ls[i].fd != (ngx_socket_t) -1) {
  336.                 continue;
  337.             }

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

  341.                 /* TODO: close on exit */
  342.                 /* TODO: nonblocking */
  343.                 /* TODO: deferred accept */

  345.                 continue;
  346.             }

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

  350.             if (s == (ngx_socket_t) -1) {
  351.                 ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  352.                               ngx_socket_n " %V failed", &ls[i].addr_text);
  353.                 return NGX_ERROR;
  354.             }

  356.             if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
  357.                            (const void *) &reuseaddr, sizeof(int))
  358.                 == -1)
  359.             {
  360.                 ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  361.                               "setsockopt(SO_REUSEADDR) %V failed",
  362.                               &ls[i].addr_text);

  364.                 if (ngx_close_socket(s) == -1) {
  365.                     ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  366.                                   ngx_close_socket_n " %V failed",
  367.                                   &ls[i].addr_text);
  368.                 }

  370.                 return NGX_ERROR;
  371.             }

  373. #if (NGX_HAVE_INET6 && defined IPV6_V6ONLY)

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

  378.                 ipv6only = ls[i].ipv6only;

  380.                 if (setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY,
  381.                                (const void *) &ipv6only, sizeof(int))
  382.                     == -1)
  383.                 {
  384.                     ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  385.                                   "setsockopt(IPV6_V6ONLY) %V failed, ignored",
  386.                                   &ls[i].addr_text);
  387.                 }
  388.             }
  389. #endif
  390.             /* TODO: close on exit */

  392.             if (!(ngx_event_flags & NGX_USE_AIO_EVENT)) {
  393.                 if (ngx_nonblocking(s) == -1) {
  394.                     ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  395.                                   ngx_nonblocking_n " %V failed",
  396.                                   &ls[i].addr_text);

  398.                     if (ngx_close_socket(s) == -1) {
  399.                         ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  400.                                       ngx_close_socket_n " %V failed",
  401.                                       &ls[i].addr_text);
  402.                     }

  404.                     return NGX_ERROR;
  405.                 }
  406.             }

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

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

  414.                 if (err != NGX_EADDRINUSE || !ngx_test_config) {
  415.                     ngx_log_error(NGX_LOG_EMERG, log, err,
  416.                                   "bind() to %V failed", &ls[i].addr_text);
  417.                 }

  419.                 if (ngx_close_socket(s) == -1) {
  420.                     ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  421.                                   ngx_close_socket_n " %V failed",
  422.                                   &ls[i].addr_text);
  423.                 }

  425.                 if (err != NGX_EADDRINUSE) {
  426.                     return NGX_ERROR;
  427.                 }

  429.                 if (!ngx_test_config) {
  430.                     failed = 1;
  431.                 }

  433.                 continue;
  434.             }

  436. #if (NGX_HAVE_UNIX_DOMAIN)

  438.             if (ls[i].sockaddr->sa_family == AF_UNIX) {
  439.                 mode_t   mode;
  440.                 u_char  *name;

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

  445.                 if (chmod((char *) name, mode) == -1) {
  446.                     ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  447.                                   "chmod() \"%s\" failed", name);
  448.                 }

  450.                 if (ngx_test_config) {
  451.                     if (ngx_delete_file(name) == NGX_FILE_ERROR) {
  452.                         ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  453.                                       ngx_delete_file_n " %s failed", name);
  454.                     }
  455.                 }
  456.             }
  457. #endif

  459.             if (listen(s, ls[i].backlog) == -1) {
  460.                 ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  461.                               "listen() to %V, backlog %d failed",
  462.                               &ls[i].addr_text, ls[i].backlog);

  464.                 if (ngx_close_socket(s) == -1) {
  465.                     ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
  466.                                   ngx_close_socket_n " %V failed",
  467.                                   &ls[i].addr_text);
  468.                 }

  470.                 return NGX_ERROR;
  471.             }

  473.             ls[i].listen = 1;

  475.             ls[i].fd = s;
  476.         }

  478.         if (!failed) {
  479.             break;
  480.         }

  482.         /* TODO: delay configurable */

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

  487.         ngx_msleep(500);
  488.     }

  490.     if (failed) {
  491.         ngx_log_error(NGX_LOG_EMERG, log, 0, "still could not bind()");
  492.         return NGX_ERROR;
  493.     }

  495.     return NGX_OK;
  496. }


  499. void
  500. ‌ngx_configure_listening_sockets(ngx_cycle_t *cycle)
  501. {
  502.     int                        value;
  503.     ngx_uint_t                 i;
  504.     ngx_listening_t           *ls;

  506. #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
  507.     struct accept_filter_arg   af;
  508. #endif

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

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

  515.         if (ls[i].rcvbuf != -1) {
  516.             if (setsockopt(ls[i].fd, SOL_SOCKET, SO_RCVBUF,
  517.                            (const void *) &ls[i].rcvbuf, sizeof(int))
  518.                 == -1)
  519.             {
  520.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  521.                               "setsockopt(SO_RCVBUF, %d) %V failed, ignored",
  522.                               ls[i].rcvbuf, &ls[i].addr_text);
  523.             }
  524.         }

  526.         if (ls[i].sndbuf != -1) {
  527.             if (setsockopt(ls[i].fd, SOL_SOCKET, SO_SNDBUF,
  528.                            (const void *) &ls[i].sndbuf, sizeof(int))
  529.                 == -1)
  530.             {
  531.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  532.                               "setsockopt(SO_SNDBUF, %d) %V failed, ignored",
  533.                               ls[i].sndbuf, &ls[i].addr_text);
  534.             }
  535.         }

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

  540.             if (setsockopt(ls[i].fd, SOL_SOCKET, SO_KEEPALIVE,
  541.                            (const void *) &value, sizeof(int))
  542.                 == -1)
  543.             {
  544.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  545.                               "setsockopt(SO_KEEPALIVE, %d) %V failed, ignored",
  546.                               value, &ls[i].addr_text);
  547.             }
  548.         }

  550. #if (NGX_HAVE_KEEPALIVE_TUNABLE)

  552.         if (ls[i].keepidle) {
  553.             value = ls[i].keepidle;

  555. #if (NGX_KEEPALIVE_FACTOR)
  556.             value *= NGX_KEEPALIVE_FACTOR;
  557. #endif

  559.             if (setsockopt(ls[i].fd, IPPROTO_TCP, TCP_KEEPIDLE,
  560.                            (const void *) &value, sizeof(int))
  561.                 == -1)
  562.             {
  563.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  564.                               "setsockopt(TCP_KEEPIDLE, %d) %V failed, ignored",
  565.                               value, &ls[i].addr_text);
  566.             }
  567.         }

  569.         if (ls[i].keepintvl) {
  570.             value = ls[i].keepintvl;

  572. #if (NGX_KEEPALIVE_FACTOR)
  573.             value *= NGX_KEEPALIVE_FACTOR;
  574. #endif

  576.             if (setsockopt(ls[i].fd, IPPROTO_TCP, TCP_KEEPINTVL,
  577.                            (const void *) &value, sizeof(int))
  578.                 == -1)
  579.             {
  580.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  581.                              "setsockopt(TCP_KEEPINTVL, %d) %V failed, ignored",
  582.                              value, &ls[i].addr_text);
  583.             }
  584.         }

  586.         if (ls[i].keepcnt) {
  587.             if (setsockopt(ls[i].fd, IPPROTO_TCP, TCP_KEEPCNT,
  588.                            (const void *) &ls[i].keepcnt, sizeof(int))
  589.                 == -1)
  590.             {
  591.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  592.                               "setsockopt(TCP_KEEPCNT, %d) %V failed, ignored",
  593.                               ls[i].keepcnt, &ls[i].addr_text);
  594.             }
  595.         }

  597. #endif

  599. #if (NGX_HAVE_SETFIB)
  600.         if (ls[i].setfib != -1) {
  601.             if (setsockopt(ls[i].fd, SOL_SOCKET, SO_SETFIB,
  602.                            (const void *) &ls[i].setfib, sizeof(int))
  603.                 == -1)
  604.             {
  605.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  606.                               "setsockopt(SO_SETFIB, %d) %V failed, ignored",
  607.                               ls[i].setfib, &ls[i].addr_text);
  608.             }
  609.         }
  610. #endif

  612. #if (NGX_HAVE_TCP_FASTOPEN)
  613.         if (ls[i].fastopen != -1) {
  614.             if (setsockopt(ls[i].fd, IPPROTO_TCP, TCP_FASTOPEN,
  615.                            (const void *) &ls[i].fastopen, sizeof(int))
  616.                 == -1)
  617.             {
  618.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  619.                               "setsockopt(TCP_FASTOPEN, %d) %V failed, ignored",
  620.                               ls[i].fastopen, &ls[i].addr_text);
  621.             }
  622.         }
  623. #endif

  625. #if 0
  626.         if (1) {
  627.             int tcp_nodelay = 1;

  629.             if (setsockopt(ls[i].fd, IPPROTO_TCP, TCP_NODELAY,
  630.                        (const void *) &tcp_nodelay, sizeof(int))
  631.                 == -1)
  632.             {
  633.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  634.                               "setsockopt(TCP_NODELAY) %V failed, ignored",
  635.                               &ls[i].addr_text);
  636.             }
  637.         }
  638. #endif

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

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

  644.             if (listen(ls[i].fd, ls[i].backlog) == -1) {
  645.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  646.                               "listen() to %V, backlog %d failed, ignored",
  647.                               &ls[i].addr_text, ls[i].backlog);
  648.             }
  649.         }

  651.         /*
  652.          * setting deferred mode should be last operation on socket,
  653.          * because code may prematurely continue cycle on failure
  654.          */

  656. #if (NGX_HAVE_DEFERRED_ACCEPT)

  658. #ifdef SO_ACCEPTFILTER

  660.         if (ls[i].delete_deferred) {
  661.             if (setsockopt(ls[i].fd, SOL_SOCKET, SO_ACCEPTFILTER, NULL, 0)
  662.                 == -1)
  663.             {
  664.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  665.                               "setsockopt(SO_ACCEPTFILTER, NULL) "
  666.                               "for %V failed, ignored",
  667.                               &ls[i].addr_text);

  669.                 if (ls[i].accept_filter) {
  670.                     ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  671.                                   "could not change the accept filter "
  672.                                   "to \"%s\" for %V, ignored",
  673.                                   ls[i].accept_filter, &ls[i].addr_text);
  674.                 }

  676.                 continue;
  677.             }

  679.             ls[i].deferred_accept = 0;
  680.         }

  682.         if (ls[i].add_deferred) {
  683.             ngx_memzero(&af, sizeof(struct accept_filter_arg));
  684.             (void) ngx_cpystrn((u_char *) af.af_name,
  685.                                (u_char *) ls[i].accept_filter, 16);

  687.             if (setsockopt(ls[i].fd, SOL_SOCKET, SO_ACCEPTFILTER,
  688.                            &af, sizeof(struct accept_filter_arg))
  689.                 == -1)
  690.             {
  691.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  692.                               "setsockopt(SO_ACCEPTFILTER, \"%s\") "
  693.                               "for %V failed, ignored",
  694.                               ls[i].accept_filter, &ls[i].addr_text);
  695.                 continue;
  696.             }

  698.             ls[i].deferred_accept = 1;
  699.         }

  701. #endif

  703. #ifdef TCP_DEFER_ACCEPT

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

  707.             if (ls[i].add_deferred) {
  708.                 /*
  709.                  * There is no way to find out how long a connection was
  710.                  * in queue (and a connection may bypass deferred queue at all
  711.                  * if syncookies were used), hence we use 1 second timeout
  712.                  * here.
  713.                  */
  714.                 value = 1;

  716.             } else {
  717.                 value = 0;
  718.             }

  720.             if (setsockopt(ls[i].fd, IPPROTO_TCP, TCP_DEFER_ACCEPT,
  721.                            &value, sizeof(int))
  722.                 == -1)
  723.             {
  724.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  725.                               "setsockopt(TCP_DEFER_ACCEPT, %d) for %V failed, "
  726.                               "ignored",
  727.                               value, &ls[i].addr_text);

  729.                 continue;
  730.             }
  731.         }

  733.         if (ls[i].add_deferred) {
  734.             ls[i].deferred_accept = 1;
  735.         }

  737. #endif

  739. #endif /* NGX_HAVE_DEFERRED_ACCEPT */
  740.     }

  742.     return;
  743. }


  746. void
  747. ‌ngx_close_listening_sockets(ngx_cycle_t *cycle)
  748. {
  749.     ngx_uint_t         i;
  750.     ngx_listening_t   *ls;
  751.     ngx_connection_t  *c;

  753.     if (ngx_event_flags & NGX_USE_IOCP_EVENT) {
  754.         return;
  755.     }

  757.     ngx_accept_mutex_held = 0;
  758.     ngx_use_accept_mutex = 0;

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

  763.         c = ls[i].connection;

  765.         if (c) {
  766.             if (c->read->active) {
  767.                 if (ngx_event_flags & NGX_USE_RTSIG_EVENT) {
  768.                     ngx_del_conn(c, NGX_CLOSE_EVENT);

  770.                 } else if (ngx_event_flags & NGX_USE_EPOLL_EVENT) {

  772.                     /*
  773.                      * it seems that Linux-2.6.x OpenVZ sends events
  774.                      * for closed shared listening sockets unless
  775.                      * the events was explicitly deleted
  776.                      */

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

  780.                 } else {
  781.                     ngx_del_event(c->read, NGX_READ_EVENT, NGX_CLOSE_EVENT);
  782.                 }
  783.             }

  785.             ngx_free_connection(c);

  787.             c->fd = (ngx_socket_t) -1;
  788.         }

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

  793.         if (ngx_close_socket(ls[i].fd) == -1) {
  794.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_socket_errno,
  795.                           ngx_close_socket_n " %V failed", &ls[i].addr_text);
  796.         }

  798. #if (NGX_HAVE_UNIX_DOMAIN)

  800.         if (ls[i].sockaddr->sa_family == AF_UNIX
  801.             && ngx_process <= NGX_PROCESS_MASTER
  802.             && ngx_new_binary == 0)
  803.         {
  804.             u_char *name = ls[i].addr_text.data + sizeof("unix:") - 1;

  806.             if (ngx_delete_file(name) == NGX_FILE_ERROR) {
  807.                 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_socket_errno,
  808.                               ngx_delete_file_n " %s failed", name);
  809.             }
  810.         }

  812. #endif

  814.         ls[i].fd = (ngx_socket_t) -1;
  815.     }

  817.     cycle->listening.nelts = 0;
  818. }


  821. ngx_connection_t *
  822. ‌ngx_get_connection(ngx_socket_t s, ngx_log_t *log)
  823. {
  824.     ngx_uint_t         instance;
  825.     ngx_event_t       *rev, *wev;
  826.     ngx_connection_t  *c;

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

  830.     if (ngx_cycle->files && (ngx_uint_t) s >= ngx_cycle->files_n) {
  831.         ngx_log_error(NGX_LOG_ALERT, log, 0,
  832.                       "the new socket has number %d, "
  833.                       "but only %ui files are available",
  834.                       s, ngx_cycle->files_n);
  835.         return NULL;
  836.     }

  838.     /* ngx_mutex_lock */

  840.     c = ngx_cycle->free_connections;

  842.     if (c == NULL) {
  843.         ngx_drain_connections();
  844.         c = ngx_cycle->free_connections;
  845.     }

  847.     if (c == NULL) {
  848.         ngx_log_error(NGX_LOG_ALERT, log, 0,
  849.                       "%ui worker_connections are not enough",
  850.                       ngx_cycle->connection_n);

  852.         /* ngx_mutex_unlock */

  854.         return NULL;
  855.     }

  857.     ngx_cycle->free_connections = c->data;
  858.     ngx_cycle->free_connection_n--;

  860.     /* ngx_mutex_unlock */

  862.     if (ngx_cycle->files) {
  863.         ngx_cycle->files[s] = c;
  864.     }

  866.     rev = c->read;
  867.     wev = c->write;

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

  871.     c->read = rev;
  872.     c->write = wev;
  873.     c->fd = s;
  874.     c->log = log;

  876.     instance = rev->instance;

  878.     ngx_memzero(rev, sizeof(ngx_event_t));
  879.     ngx_memzero(wev, sizeof(ngx_event_t));

  881.     rev->instance = !instance;
  882.     wev->instance = !instance;

  884.     rev->index = NGX_INVALID_INDEX;
  885.     wev->index = NGX_INVALID_INDEX;

  887.     rev->data = c;
  888.     wev->data = c;

  890.     wev->write = 1;

  892.     return c;
  893. }


  896. void
  897. ‌ngx_free_connection(ngx_connection_t *c)
  898. {
  899.     /* ngx_mutex_lock */

  901.     c->data = ngx_cycle->free_connections;
  902.     ngx_cycle->free_connections = c;
  903.     ngx_cycle->free_connection_n++;

  905.     /* ngx_mutex_unlock */

  907.     if (ngx_cycle->files) {
  908.         ngx_cycle->files[c->fd] = NULL;
  909.     }
  910. }


  913. void
  914. ‌ngx_close_connection(ngx_connection_t *c)
  915. {
  916.     ngx_err_t     err;
  917.     ngx_uint_t    log_error, level;
  918.     ngx_socket_t  fd;

  920.     if (c->fd == (ngx_socket_t) -1) {
  921.         ngx_log_error(NGX_LOG_ALERT, c->log, 0, "connection already closed");
  922.         return;
  923.     }

  925.     if (c->read->timer_set) {
  926.         ngx_del_timer(c->read);
  927.     }

  929.     if (c->write->timer_set) {
  930.         ngx_del_timer(c->write);
  931.     }

  933.     if (ngx_del_conn) {
  934.         ngx_del_conn(c, NGX_CLOSE_EVENT);

  936.     } else {
  937.         if (c->read->active || c->read->disabled) {
  938.             ngx_del_event(c->read, NGX_READ_EVENT, NGX_CLOSE_EVENT);
  939.         }

  941.         if (c->write->active || c->write->disabled) {
  942.             ngx_del_event(c->write, NGX_WRITE_EVENT, NGX_CLOSE_EVENT);
  943.         }
  944.     }

  946. #if (NGX_THREADS)

  948.     /*
  949.      * we have to clean the connection information before the closing
  950.      * because another thread may reopen the same file descriptor
  951.      * before we clean the connection
  952.      */

  954.     ngx_unlock(&c->lock);

  956. #endif

  958.     if (c->read->posted) {
  959.         ngx_delete_posted_event(c->read);
  960.     }

  962.     if (c->write->posted) {
  963.         ngx_delete_posted_event(c->write);
  964.     }

  966.     c->read->closed = 1;
  967.     c->write->closed = 1;

  969.     ngx_reusable_connection(c, 0);

  971.     log_error = c->log_error;

  973.     ngx_free_connection(c);

  975.     fd = c->fd;
  976.     c->fd = (ngx_socket_t) -1;

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

  980.         err = ngx_socket_errno;

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

  984.             switch (log_error) {

  986.             case NGX_ERROR_INFO:
  987.                 level = NGX_LOG_INFO;
  988.                 break;

  990.             case NGX_ERROR_ERR:
  991.                 level = NGX_LOG_ERR;
  992.                 break;

  994.             default:
  995.                 level = NGX_LOG_CRIT;
  996.             }

  998.         } else {
  999.             level = NGX_LOG_CRIT;
  1000.         }

  1002.         /* we use ngx_cycle->log because c->log was in c->pool */

  1004.         ngx_log_error(level, ngx_cycle->log, err,
  1005.                       ngx_close_socket_n " %d failed", fd);
  1006.     }
  1007. }


  1010. void
  1011. ‌ngx_reusable_connection(ngx_connection_t *c, ngx_uint_t reusable)
  1012. {
  1013.     ngx_log_debug1(NGX_LOG_DEBUG_CORE, c->log, 0,
  1014.                    "reusable connection: %ui", reusable);

  1016.     if (c->reusable) {
  1017.         ngx_queue_remove(&c->queue);

  1019. #if (NGX_STAT_STUB)
  1020.         (void) ngx_atomic_fetch_add(ngx_stat_waiting, -1);
  1021. #endif
  1022.     }

  1024.     c->reusable = reusable;

  1026.     if (reusable) {
  1027.         /* need cast as ngx_cycle is volatile */

  1029.         ngx_queue_insert_head(
  1030.             (ngx_queue_t *) &ngx_cycle->reusable_connections_queue, &c->queue);

  1032. #if (NGX_STAT_STUB)
  1033.         (void) ngx_atomic_fetch_add(ngx_stat_waiting, 1);
  1034. #endif
  1035.     }
  1036. }


  1039. static void
  1040. ‌ngx_drain_connections(void)
  1041. {
  1042.     ngx_int_t          i;
  1043.     ngx_queue_t       *q;
  1044.     ngx_connection_t  *c;

  1046.     for (i = 0; i < 32; i++) {
  1047.         if (ngx_queue_empty(&ngx_cycle->reusable_connections_queue)) {
  1048.             break;
  1049.         }

  1051.         q = ngx_queue_last(&ngx_cycle->reusable_connections_queue);
  1052.         c = ngx_queue_data(q, ngx_connection_t, queue);

  1054.         ngx_log_debug0(NGX_LOG_DEBUG_CORE, c->log, 0,
  1055.                        "reusing connection");

  1057.         c->close = 1;
  1058.         c->read->handler(c->read);
  1059.     }
  1060. }


  1063. ngx_int_t
  1064. ‌ngx_connection_local_sockaddr(ngx_connection_t *c, ngx_str_t *s,
  1065.     ngx_uint_t port)
  1066. {
  1067.     socklen_t             len;
  1068.     ngx_uint_t            addr;
  1069.     u_char                sa[NGX_SOCKADDRLEN];
  1070.     struct sockaddr_in   *sin;
  1071. #if (NGX_HAVE_INET6)
  1072.     ngx_uint_t            i;
  1073.     struct sockaddr_in6  *sin6;
  1074. #endif

  1076.     if (c->local_socklen == 0) {
  1077.         return NGX_ERROR;
  1078.     }

  1080.     switch (c->local_sockaddr->sa_family) {

  1082. #if (NGX_HAVE_INET6)
  1083.     case AF_INET6:
  1084.         sin6 = (struct sockaddr_in6 *) c->local_sockaddr;

  1086.         for (addr = 0, i = 0; addr == 0 && i < 16; i++) {
  1087.             addr |= sin6->sin6_addr.s6_addr[i];
  1088.         }

  1090.         break;
  1091. #endif

  1093. #if (NGX_HAVE_UNIX_DOMAIN)
  1094.     case AF_UNIX:
  1095.         addr = 1;
  1096.         break;
  1097. #endif

  1099.     default: /* AF_INET */
  1100.         sin = (struct sockaddr_in *) c->local_sockaddr;
  1101.         addr = sin->sin_addr.s_addr;
  1102.         break;
  1103.     }

  1105.     if (addr == 0) {

  1107.         len = NGX_SOCKADDRLEN;

  1109.         if (getsockname(c->fd, (struct sockaddr *) &sa, &len) == -1) {
  1110.             ngx_connection_error(c, ngx_socket_errno, "getsockname() failed");
  1111.             return NGX_ERROR;
  1112.         }

  1114.         c->local_sockaddr = ngx_palloc(c->pool, len);
  1115.         if (c->local_sockaddr == NULL) {
  1116.             return NGX_ERROR;
  1117.         }

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

  1121.         c->local_socklen = len;
  1122.     }

  1124.     if (s == NULL) {
  1125.         return NGX_OK;
  1126.     }

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

  1131.     return NGX_OK;
  1132. }


  1135. ngx_int_t
  1136. ‌ngx_connection_error(ngx_connection_t *c, ngx_err_t err, char *text)
  1137. {
  1138.     ngx_uint_t  level;

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

  1142.     if ((err == NGX_ECONNRESET
  1143. #if (NGX_WIN32)
  1144.          || err == NGX_ECONNABORTED
  1145. #endif
  1146.         ) && c->log_error == NGX_ERROR_IGNORE_ECONNRESET)
  1147.     {
  1148.         return 0;
  1149.     }

  1151. #if (NGX_SOLARIS)
  1152.     if (err == NGX_EINVAL && c->log_error == NGX_ERROR_IGNORE_EINVAL) {
  1153.         return 0;
  1154.     }
  1155. #endif

  1157.     if (err == 0
  1158.         || err == NGX_ECONNRESET
  1159. #if (NGX_WIN32)
  1160.         || err == NGX_ECONNABORTED
  1161. #else
  1162.         || err == NGX_EPIPE
  1163. #endif
  1164.         || err == NGX_ENOTCONN
  1165.         || err == NGX_ETIMEDOUT
  1166.         || err == NGX_ECONNREFUSED
  1167.         || err == NGX_ENETDOWN
  1168.         || err == NGX_ENETUNREACH
  1169.         || err == NGX_EHOSTDOWN
  1170.         || err == NGX_EHOSTUNREACH)
  1171.     {
  1172.         switch (c->log_error) {

  1174.         case NGX_ERROR_IGNORE_EINVAL:
  1175.         case NGX_ERROR_IGNORE_ECONNRESET:
  1176.         case NGX_ERROR_INFO:
  1177.             level = NGX_LOG_INFO;
  1178.             break;

  1180.         default:
  1181.             level = NGX_LOG_ERR;
  1182.         }

  1184.     } else {
  1185.         level = NGX_LOG_ALERT;
  1186.     }

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

  1190.     return NGX_ERROR;
  1191. }

One Level Up Top Level