One Level Up Top Level

src/event/ngx_event_connect.c - nginx source code

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)) == -1)
  69.         {
  70.             ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
  71.                           "setsockopt(SO_RCVBUF) failed");
  72.             goto failed;
  73.         }
  74.     }

  76.     if (pc->so_keepalive) {
  77.         value = 1;

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

  88.     if (ngx_nonblocking(s) == -1) {
  89.         ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
  90.                       ngx_nonblocking_n " failed");

  92.         goto failed;
  93.     }

  95.     if (pc->local) {

  97. #if (NGX_HAVE_TRANSPARENT_PROXY)
  98.         if (pc->transparent) {
  99.             if (ngx_event_connect_set_transparent(pc, s) != NGX_OK) {
  100.                 goto failed;
  101.             }
  102.         }
  103. #endif

  105. #if (NGX_HAVE_IP_BIND_ADDRESS_NO_PORT || NGX_LINUX)
  106.         port = ngx_inet_get_port(pc->local->sockaddr);
  107. #endif

  109. #if (NGX_HAVE_IP_BIND_ADDRESS_NO_PORT)

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

  114.             if (bind_address_no_port) {
  115.                 if (setsockopt(s, IPPROTO_IP, IP_BIND_ADDRESS_NO_PORT,
  116.                                (const void *) &bind_address_no_port,
  117.                                sizeof(int)) == -1)
  118.                 {
  119.                     err = ngx_socket_errno;

  121.                     if (err != NGX_EOPNOTSUPP && err != NGX_ENOPROTOOPT) {
  122.                         ngx_log_error(NGX_LOG_ALERT, pc->log, err,
  123.                                       "setsockopt(IP_BIND_ADDRESS_NO_PORT) "
  124.                                       "failed, ignored");

  126.                     } else {
  127.                         bind_address_no_port = 0;
  128.                     }
  129.                 }
  130.             }
  131.         }

  133. #endif

  135. #if (NGX_LINUX)

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

  140.             if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
  141.                            (const void *) &reuse_addr, sizeof(int))
  142.                  == -1)
  143.             {
  144.                 ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
  145.                               "setsockopt(SO_REUSEADDR) failed");
  146.                 goto failed;
  147.             }
  148.         }

  150. #endif

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

  156.             goto failed;
  157.         }
  158.     }

  160.     if (type == SOCK_STREAM) {
  161.         c->recv = ngx_recv;
  162.         c->send = ngx_send;
  163.         c->recv_chain = ngx_recv_chain;
  164.         c->send_chain = ngx_send_chain;

  166.         c->sendfile = 1;

  168.         if (pc->sockaddr->sa_family == AF_UNIX) {
  169.             c->tcp_nopush = NGX_TCP_NOPUSH_DISABLED;
  170.             c->tcp_nodelay = NGX_TCP_NODELAY_DISABLED;

  172. #if (NGX_SOLARIS)
  173.             /* Solaris's sendfilev() supports AF_NCA, AF_INET, and AF_INET6 */
  174.             c->sendfile = 0;
  175. #endif
  176.         }

  178.     } else { /* type == SOCK_DGRAM */
  179.         c->recv = ngx_udp_recv;
  180.         c->send = ngx_send;
  181.         c->send_chain = ngx_udp_send_chain;

  183.         c->need_flush_buf = 1;
  184.     }

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

  188.     rev = c->read;
  189.     wev = c->write;

  191.     rev->log = pc->log;
  192.     wev->log = pc->log;

  194.     pc->connection = c;

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

  198.     c->start_time = ngx_current_msec;

  200.     if (ngx_add_conn) {
  201.         if (ngx_add_conn(c) == NGX_ERROR) {
  202.             goto failed;
  203.         }
  204.     }

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

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

  211.     if (rc == -1) {
  212.         err = ngx_socket_errno;


  215.         if (err != NGX_EINPROGRESS
  216. #if (NGX_WIN32)
  217.             /* Winsock returns WSAEWOULDBLOCK (NGX_EAGAIN) */
  218.             && err != NGX_EAGAIN
  219. #endif
  220.             )
  221.         {
  222.             if (err == NGX_ECONNREFUSED
  223. #if (NGX_LINUX)
  224.                 /*
  225.                  * Linux returns EAGAIN instead of ECONNREFUSED
  226.                  * for unix sockets if listen queue is full
  227.                  */
  228.                 || err == NGX_EAGAIN
  229. #endif
  230.                 || err == NGX_ECONNRESET
  231.                 || err == NGX_ENETDOWN
  232.                 || err == NGX_ENETUNREACH
  233.                 || err == NGX_EHOSTDOWN
  234.                 || err == NGX_EHOSTUNREACH)
  235.             {
  236.                 level = NGX_LOG_ERR;

  238.             } else {
  239.                 level = NGX_LOG_CRIT;
  240.             }

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

  245.             ngx_close_connection(c);
  246.             pc->connection = NULL;

  248.             return NGX_DECLINED;
  249.         }
  250.     }

  252.     if (ngx_add_conn) {
  253.         if (rc == -1) {

  255.             /* NGX_EINPROGRESS */

  257.             return NGX_AGAIN;
  258.         }

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

  262.         wev->ready = 1;

  264.         return NGX_OK;
  265.     }

  267.     if (ngx_event_flags & NGX_USE_IOCP_EVENT) {

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

  272.         if (ngx_blocking(s) == -1) {
  273.             ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
  274.                           ngx_blocking_n " failed");
  275.             goto failed;
  276.         }

  278.         /*
  279.          * FreeBSD's aio allows to post an operation on non-connected socket.
  280.          * NT does not support it.
  281.          *
  282.          * TODO: check in Win32, etc. As workaround we can use NGX_ONESHOT_EVENT
  283.          */

  285.         rev->ready = 1;
  286.         wev->ready = 1;

  288.         return NGX_OK;
  289.     }

  291.     if (ngx_event_flags & NGX_USE_CLEAR_EVENT) {

  293.         /* kqueue */

  295.         event = NGX_CLEAR_EVENT;

  297.     } else {

  299.         /* select, poll, /dev/poll */

  301.         event = NGX_LEVEL_EVENT;
  302.     }

  304.     if (ngx_add_event(rev, NGX_READ_EVENT, event) != NGX_OK) {
  305.         goto failed;
  306.     }

  308.     if (rc == -1) {

  310.         /* NGX_EINPROGRESS */

  312.         if (ngx_add_event(wev, NGX_WRITE_EVENT, event) != NGX_OK) {
  313.             goto failed;
  314.         }

  316.         return NGX_AGAIN;
  317.     }

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

  321.     wev->ready = 1;

  323.     return NGX_OK;

  325. failed:

  327.     ngx_close_connection(c);
  328.     pc->connection = NULL;

  330.     return NGX_ERROR;
  331. }


  334. #if (NGX_HAVE_TRANSPARENT_PROXY)

  336. static ngx_int_t
  337. ‌ngx_event_connect_set_transparent(ngx_peer_connection_t *pc, ngx_socket_t s)
  338. {
  339.     int  value;

  341.     value = 1;

  343. #if defined(SO_BINDANY)

  345.     if (setsockopt(s, SOL_SOCKET, SO_BINDANY,
  346.                    (const void *) &value, sizeof(int)) == -1)
  347.     {
  348.         ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
  349.                       "setsockopt(SO_BINDANY) failed");
  350.         return NGX_ERROR;
  351.     }

  353. #else

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

  357.     case AF_INET:

  359. #if defined(IP_TRANSPARENT)

  361.         if (setsockopt(s, IPPROTO_IP, IP_TRANSPARENT,
  362.                        (const void *) &value, sizeof(int)) == -1)
  363.         {
  364.             ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
  365.                           "setsockopt(IP_TRANSPARENT) failed");
  366.             return NGX_ERROR;
  367.         }

  369. #elif defined(IP_BINDANY)

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

  379. #endif

  381.         break;

  383. #if (NGX_HAVE_INET6)

  385.     case AF_INET6:

  387. #if defined(IPV6_TRANSPARENT)

  389.         if (setsockopt(s, IPPROTO_IPV6, IPV6_TRANSPARENT,
  390.                        (const void *) &value, sizeof(int)) == -1)
  391.         {
  392.             ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
  393.                           "setsockopt(IPV6_TRANSPARENT) failed");
  394.             return NGX_ERROR;
  395.         }

  397. #elif defined(IPV6_BINDANY)

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

  407. #else

  409.         ngx_log_error(NGX_LOG_ALERT, pc->log, 0,
  410.                       "could not enable transparent proxying for IPv6 "
  411.                       "on this platform");

  413.         return NGX_ERROR;

  415. #endif

  417.         break;

  419. #endif /* NGX_HAVE_INET6 */

  421.     }

  423. #endif /* SO_BINDANY */

  425.     return NGX_OK;
  426. }

  428. #endif


  431. ngx_int_t
  432. ‌ngx_event_get_peer(ngx_peer_connection_t *pc, void *data)
  433. {
  434.     return NGX_OK;
  435. }

One Level Up Top Level