One Level Up Top Level

src/event/ngx_event_connect.c - nginx-1.31.4 nginx/ @ 8d9666701

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>
  11. #include <ngx_event_connect.h>


  14. #if (NGX_HAVE_TRANSPARENT_PROXY)
  15. static ngx_int_t ngx_event_connect_set_transparent(ngx_peer_connection_t *pc,
  16.     ngx_socket_t s);
  17. #endif


  20. ngx_int_t
  21. ‌ngx_event_connect_peer(ngx_peer_connection_t *pc)
  22. {
  23.     int                rc, type, value;
  24. #if (NGX_HAVE_IP_BIND_ADDRESS_NO_PORT || NGX_LINUX)
  25.     in_port_t          port;
  26. #endif
  27.     ngx_int_t          event;
  28.     ngx_err_t          err;
  29.     ngx_uint_t         level;
  30.     ngx_socket_t       s;
  31.     ngx_event_t       *rev, *wev;
  32.     ngx_connection_t  *c;

  34.     rc = pc->get(pc, pc->data);
  35.     if (rc != NGX_OK) {
  36.         return rc;
  37.     }

  39.     type = (pc->type ? pc->type : SOCK_STREAM);

  41.     s = ngx_socket(pc->sockaddr->sa_family, type, 0);

  43.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, pc->log, 0, "%s socket %d",
  44.                    (type == SOCK_STREAM) ? "stream" : "dgram", s);

  46.     if (s == (ngx_socket_t) -1) {
  47.         ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
  48.                       ngx_socket_n " failed");
  49.         return NGX_ERROR;
  50.     }


  53.     c = ngx_get_connection(s, pc->log);

  55.     if (c == NULL) {
  56.         if (ngx_close_socket(s) == -1) {
  57.             ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
  58.                           ngx_close_socket_n " failed");
  59.         }

  61.         return NGX_ERROR;
  62.     }

  64.     c->type = type;

  66.     if (pc->rcvbuf) {
  67.         if (setsockopt(s, SOL_SOCKET, SO_RCVBUF,
  68.                        (const void *) &pc->rcvbuf, sizeof(int))
  69.             == -1)
  70.         {
  71.             ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
  72.                           "setsockopt(SO_RCVBUF, %d) failed, ignored",
  73.                           pc->rcvbuf);
  74.         }
  75.     }

  77.     if (pc->sndbuf) {
  78.         if (setsockopt(s, SOL_SOCKET, SO_SNDBUF,
  79.                        (const void *) &pc->sndbuf, sizeof(int))
  80.             == -1)
  81.         {
  82.             ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
  83.                           "setsockopt(SO_SNDBUF, %d) failed, ignored",
  84.                           pc->sndbuf);
  85.         }
  86.     }

  88.     if (pc->so_keepalive) {
  89.         value = 1;

  91.         if (setsockopt(s, SOL_SOCKET, SO_KEEPALIVE,
  92.                        (const void *) &value, sizeof(int))
  93.             == -1)
  94.         {
  95.             ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
  96.                           "setsockopt(SO_KEEPALIVE) failed, ignored");
  97.         }
  98.     }

  100.     if (ngx_nonblocking(s) == -1) {
  101.         ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
  102.                       ngx_nonblocking_n " failed");

  104.         goto failed;
  105.     }

  107.     if (pc->local) {

  109. #if (NGX_HAVE_TRANSPARENT_PROXY)
  110.         if (pc->transparent) {
  111.             if (ngx_event_connect_set_transparent(pc, s) != NGX_OK) {
  112.                 goto failed;
  113.             }
  114.         }
  115. #endif

  117. #if (NGX_HAVE_IP_BIND_ADDRESS_NO_PORT || NGX_LINUX)
  118.         port = ngx_inet_get_port(pc->local->sockaddr);
  119. #endif

  121. #if (NGX_HAVE_IP_BIND_ADDRESS_NO_PORT)

  123.         if (pc->sockaddr->sa_family != AF_UNIX && port == 0) {
  124.             static int  bind_address_no_port = 1;

  126.             if (bind_address_no_port) {
  127.                 if (setsockopt(s, IPPROTO_IP, IP_BIND_ADDRESS_NO_PORT,
  128.                                (const void *) &bind_address_no_port,
  129.                                sizeof(int)) == -1)
  130.                 {
  131.                     err = ngx_socket_errno;

  133.                     if (err != NGX_EOPNOTSUPP && err != NGX_ENOPROTOOPT) {
  134.                         ngx_log_error(NGX_LOG_ALERT, pc->log, err,
  135.                                       "setsockopt(IP_BIND_ADDRESS_NO_PORT) "
  136.                                       "failed, ignored");

  138.                     } else {
  139.                         bind_address_no_port = 0;
  140.                     }
  141.                 }
  142.             }
  143.         }

  145. #endif

  147. #if (NGX_LINUX)

  149.         if (pc->type == SOCK_DGRAM && port != 0) {
  150.             int  reuse_addr = 1;

  152.             if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
  153.                            (const void *) &reuse_addr, sizeof(int))
  154.                  == -1)
  155.             {
  156.                 ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
  157.                               "setsockopt(SO_REUSEADDR) failed");
  158.                 goto failed;
  159.             }
  160.         }

  162. #endif

  164.         if (bind(s, pc->local->sockaddr, pc->local->socklen) == -1) {
  165.             ngx_log_error(NGX_LOG_CRIT, pc->log, ngx_socket_errno,
  166.                           "bind(%V) failed", &pc->local->name);

  168.             goto failed;
  169.         }
  170.     }

  172.     if (type == SOCK_STREAM) {
  173.         c->recv = ngx_recv;
  174.         c->send = ngx_send;
  175.         c->recv_chain = ngx_recv_chain;
  176.         c->send_chain = ngx_send_chain;

  178.         c->sendfile = 1;

  180.         if (pc->sockaddr->sa_family == AF_UNIX) {
  181.             c->tcp_nopush = NGX_TCP_NOPUSH_DISABLED;
  182.             c->tcp_nodelay = NGX_TCP_NODELAY_DISABLED;

  184. #if (NGX_SOLARIS)
  185.             /* Solaris's sendfilev() supports AF_NCA, AF_INET, and AF_INET6 */
  186.             c->sendfile = 0;
  187. #endif
  188.         }

  190.     } else { /* type == SOCK_DGRAM */
  191.         c->recv = ngx_udp_recv;
  192.         c->send = ngx_send;
  193.         c->send_chain = ngx_udp_send_chain;

  195.         c->need_flush_buf = 1;
  196.     }

  198.     c->log_error = pc->log_error;

  200.     rev = c->read;
  201.     wev = c->write;

  203.     rev->log = pc->log;
  204.     wev->log = pc->log;

  206.     pc->connection = c;

  208.     c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1);

  210.     c->start_time = ngx_current_msec;

  212.     if (ngx_add_conn) {
  213.         if (ngx_add_conn(c) == NGX_ERROR) {
  214.             goto failed;
  215.         }
  216.     }

  218.     ngx_log_debug3(NGX_LOG_DEBUG_EVENT, pc->log, 0,
  219.                    "connect to %V, fd:%d #%uA", pc->name, s, c->number);

  221.     rc = connect(s, pc->sockaddr, pc->socklen);

  223.     if (rc == -1) {
  224.         err = ngx_socket_errno;


  227.         if (err != NGX_EINPROGRESS
  228. #if (NGX_WIN32)
  229.             /* Winsock returns WSAEWOULDBLOCK (NGX_EAGAIN) */
  230.             && err != NGX_EAGAIN
  231. #endif
  232.             )
  233.         {
  234.             if (err == NGX_ECONNREFUSED
  235. #if (NGX_LINUX)
  236.                 /*
  237.                  * Linux returns EAGAIN instead of ECONNREFUSED
  238.                  * for unix sockets if listen queue is full
  239.                  */
  240.                 || err == NGX_EAGAIN
  241. #endif
  242.                 || err == NGX_ECONNRESET
  243.                 || err == NGX_ENETDOWN
  244.                 || err == NGX_ENETUNREACH
  245.                 || err == NGX_EHOSTDOWN
  246.                 || err == NGX_EHOSTUNREACH)
  247.             {
  248.                 level = NGX_LOG_ERR;

  250.             } else {
  251.                 level = NGX_LOG_CRIT;
  252.             }

  254.             ngx_log_error(level, c->log, err, "connect() to %V failed",
  255.                           pc->name);

  257.             ngx_close_connection(c);
  258.             pc->connection = NULL;

  260.             return NGX_DECLINED;
  261.         }
  262.     }

  264.     if (ngx_add_conn) {
  265.         if (rc == -1) {

  267.             /* NGX_EINPROGRESS */

  269.             return NGX_AGAIN;
  270.         }

  272.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, pc->log, 0, "connected");

  274.         wev->ready = 1;

  276.         return NGX_OK;
  277.     }

  279.     if (ngx_event_flags & NGX_USE_IOCP_EVENT) {

  281.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, pc->log, ngx_socket_errno,
  282.                        "connect(): %d", rc);

  284.         if (ngx_blocking(s) == -1) {
  285.             ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
  286.                           ngx_blocking_n " failed");
  287.             goto failed;
  288.         }

  290.         /*
  291.          * FreeBSD's aio allows to post an operation on non-connected socket.
  292.          * NT does not support it.
  293.          *
  294.          * TODO: check in Win32, etc. As workaround we can use NGX_ONESHOT_EVENT
  295.          */

  297.         rev->ready = 1;
  298.         wev->ready = 1;

  300.         return NGX_OK;
  301.     }

  303.     if (ngx_event_flags & NGX_USE_CLEAR_EVENT) {

  305.         /* kqueue */

  307.         event = NGX_CLEAR_EVENT;

  309.     } else {

  311.         /* select, poll, /dev/poll */

  313.         event = NGX_LEVEL_EVENT;
  314.     }

  316.     if (ngx_add_event(rev, NGX_READ_EVENT, event) != NGX_OK) {
  317.         goto failed;
  318.     }

  320.     if (rc == -1) {

  322.         /* NGX_EINPROGRESS */

  324.         if (ngx_add_event(wev, NGX_WRITE_EVENT, event) != NGX_OK) {
  325.             goto failed;
  326.         }

  328.         return NGX_AGAIN;
  329.     }

  331.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, pc->log, 0, "connected");

  333.     wev->ready = 1;

  335.     return NGX_OK;

  337. failed:

  339.     ngx_close_connection(c);
  340.     pc->connection = NULL;

  342.     return NGX_ERROR;
  343. }


  346. #if (NGX_HAVE_TRANSPARENT_PROXY)

  348. static ngx_int_t
  349. ‌ngx_event_connect_set_transparent(ngx_peer_connection_t *pc, ngx_socket_t s)
  350. {
  351.     int  value;

  353.     value = 1;

  355. #if defined(SO_BINDANY)

  357.     if (setsockopt(s, SOL_SOCKET, SO_BINDANY,
  358.                    (const void *) &value, sizeof(int)) == -1)
  359.     {
  360.         ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
  361.                       "setsockopt(SO_BINDANY) failed");
  362.         return NGX_ERROR;
  363.     }

  365. #else

  367.     switch (pc->local->sockaddr->sa_family) {

  369.     case AF_INET:

  371. #if defined(IP_TRANSPARENT)

  373.         if (setsockopt(s, IPPROTO_IP, IP_TRANSPARENT,
  374.                        (const void *) &value, sizeof(int)) == -1)
  375.         {
  376.             ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
  377.                           "setsockopt(IP_TRANSPARENT) failed");
  378.             return NGX_ERROR;
  379.         }

  381. #elif defined(IP_BINDANY)

  383.         if (setsockopt(s, IPPROTO_IP, IP_BINDANY,
  384.                        (const void *) &value, sizeof(int)) == -1)
  385.         {
  386.             ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
  387.                           "setsockopt(IP_BINDANY) failed");
  388.             return NGX_ERROR;
  389.         }

  391. #endif

  393.         break;

  395. #if (NGX_HAVE_INET6)

  397.     case AF_INET6:

  399. #if defined(IPV6_TRANSPARENT)

  401.         if (setsockopt(s, IPPROTO_IPV6, IPV6_TRANSPARENT,
  402.                        (const void *) &value, sizeof(int)) == -1)
  403.         {
  404.             ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
  405.                           "setsockopt(IPV6_TRANSPARENT) failed");
  406.             return NGX_ERROR;
  407.         }

  409. #elif defined(IPV6_BINDANY)

  411.         if (setsockopt(s, IPPROTO_IPV6, IPV6_BINDANY,
  412.                        (const void *) &value, sizeof(int)) == -1)
  413.         {
  414.             ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
  415.                           "setsockopt(IPV6_BINDANY) failed");
  416.             return NGX_ERROR;
  417.         }

  419. #else

  421.         ngx_log_error(NGX_LOG_ALERT, pc->log, 0,
  422.                       "could not enable transparent proxying for IPv6 "
  423.                       "on this platform");

  425.         return NGX_ERROR;

  427. #endif

  429.         break;

  431. #endif /* NGX_HAVE_INET6 */

  433.     }

  435. #endif /* SO_BINDANY */

  437.     return NGX_OK;
  438. }

  440. #endif


  443. ngx_int_t
  444. ‌ngx_event_get_peer(ngx_peer_connection_t *pc, void *data)
  445. {
  446.     return NGX_OK;
  447. }

One Level Up Top Level