mirror of https://github.com/F-Stack/f-stack.git
456 lines
11 KiB
C
456 lines
11 KiB
C
|
|
/*
|
|
* Copyright (C) Igor Sysoev
|
|
* Copyright (C) Nginx, Inc.
|
|
*/
|
|
|
|
|
|
#include <ngx_config.h>
|
|
#include <ngx_core.h>
|
|
#include <ngx_event.h>
|
|
#include <ngx_event_connect.h>
|
|
|
|
|
|
#if (NGX_HAVE_TRANSPARENT_PROXY)
|
|
static ngx_int_t ngx_event_connect_set_transparent(ngx_peer_connection_t *pc,
|
|
ngx_socket_t s);
|
|
#endif
|
|
|
|
|
|
ngx_int_t
|
|
ngx_event_connect_peer(ngx_peer_connection_t *pc)
|
|
{
|
|
int rc, type, value;
|
|
#if (NGX_HAVE_IP_BIND_ADDRESS_NO_PORT || NGX_LINUX)
|
|
in_port_t port;
|
|
#endif
|
|
ngx_int_t event;
|
|
ngx_err_t err;
|
|
ngx_uint_t level;
|
|
ngx_socket_t s;
|
|
ngx_event_t *rev, *wev;
|
|
ngx_connection_t *c;
|
|
|
|
rc = pc->get(pc, pc->data);
|
|
if (rc != NGX_OK) {
|
|
return rc;
|
|
}
|
|
|
|
type = (pc->type ? pc->type : SOCK_STREAM);
|
|
|
|
#if (NGX_HAVE_FSTACK)
|
|
/*
|
|
We use a creation flags created by fstack's adaptable layer to
|
|
to explicitly call the needed socket() function.
|
|
*/
|
|
if (!pc->belong_to_host) {
|
|
s = ngx_socket(pc->sockaddr->sa_family, type | SOCK_FSTACK, 0);
|
|
} else {
|
|
s = ngx_socket(pc->sockaddr->sa_family, type, 0);
|
|
}
|
|
#else
|
|
s = ngx_socket(pc->sockaddr->sa_family, type, 0);
|
|
#endif
|
|
|
|
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, pc->log, 0, "%s socket %d",
|
|
(type == SOCK_STREAM) ? "stream" : "dgram", s);
|
|
|
|
if (s == (ngx_socket_t) -1) {
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
|
ngx_socket_n " failed");
|
|
return NGX_ERROR;
|
|
}
|
|
|
|
|
|
c = ngx_get_connection(s, pc->log);
|
|
|
|
if (c == NULL) {
|
|
if (ngx_close_socket(s) == -1) {
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
|
ngx_close_socket_n " failed");
|
|
}
|
|
|
|
return NGX_ERROR;
|
|
}
|
|
|
|
c->type = type;
|
|
|
|
if (pc->rcvbuf) {
|
|
if (setsockopt(s, SOL_SOCKET, SO_RCVBUF,
|
|
(const void *) &pc->rcvbuf, sizeof(int)) == -1)
|
|
{
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
|
"setsockopt(SO_RCVBUF) failed");
|
|
goto failed;
|
|
}
|
|
}
|
|
|
|
if (pc->so_keepalive) {
|
|
value = 1;
|
|
|
|
if (setsockopt(s, SOL_SOCKET, SO_KEEPALIVE,
|
|
(const void *) &value, sizeof(int))
|
|
== -1)
|
|
{
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
|
"setsockopt(SO_KEEPALIVE) failed, ignored");
|
|
}
|
|
}
|
|
|
|
if (ngx_nonblocking(s) == -1) {
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
|
ngx_nonblocking_n " failed");
|
|
|
|
goto failed;
|
|
}
|
|
|
|
if (pc->local) {
|
|
|
|
#if (NGX_HAVE_TRANSPARENT_PROXY)
|
|
if (pc->transparent) {
|
|
if (ngx_event_connect_set_transparent(pc, s) != NGX_OK) {
|
|
goto failed;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if (NGX_HAVE_IP_BIND_ADDRESS_NO_PORT || NGX_LINUX)
|
|
port = ngx_inet_get_port(pc->local->sockaddr);
|
|
#endif
|
|
|
|
#if (NGX_HAVE_IP_BIND_ADDRESS_NO_PORT)
|
|
|
|
if (pc->sockaddr->sa_family != AF_UNIX && port == 0) {
|
|
static int bind_address_no_port = 1;
|
|
|
|
if (bind_address_no_port) {
|
|
if (setsockopt(s, IPPROTO_IP, IP_BIND_ADDRESS_NO_PORT,
|
|
(const void *) &bind_address_no_port,
|
|
sizeof(int)) == -1)
|
|
{
|
|
err = ngx_socket_errno;
|
|
|
|
if (err != NGX_EOPNOTSUPP && err != NGX_ENOPROTOOPT) {
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, err,
|
|
"setsockopt(IP_BIND_ADDRESS_NO_PORT) "
|
|
"failed, ignored");
|
|
|
|
} else {
|
|
bind_address_no_port = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
#if (NGX_LINUX)
|
|
|
|
if (pc->type == SOCK_DGRAM && port != 0) {
|
|
int reuse_addr = 1;
|
|
|
|
if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
|
|
(const void *) &reuse_addr, sizeof(int))
|
|
== -1)
|
|
{
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
|
"setsockopt(SO_REUSEADDR) failed");
|
|
goto failed;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
if (bind(s, pc->local->sockaddr, pc->local->socklen) == -1) {
|
|
ngx_log_error(NGX_LOG_CRIT, pc->log, ngx_socket_errno,
|
|
"bind(%V) failed", &pc->local->name);
|
|
|
|
goto failed;
|
|
}
|
|
}
|
|
|
|
if (type == SOCK_STREAM) {
|
|
c->recv = ngx_recv;
|
|
c->send = ngx_send;
|
|
c->recv_chain = ngx_recv_chain;
|
|
c->send_chain = ngx_send_chain;
|
|
|
|
c->sendfile = 1;
|
|
|
|
if (pc->sockaddr->sa_family == AF_UNIX) {
|
|
c->tcp_nopush = NGX_TCP_NOPUSH_DISABLED;
|
|
c->tcp_nodelay = NGX_TCP_NODELAY_DISABLED;
|
|
|
|
#if (NGX_SOLARIS)
|
|
/* Solaris's sendfilev() supports AF_NCA, AF_INET, and AF_INET6 */
|
|
c->sendfile = 0;
|
|
#endif
|
|
}
|
|
|
|
} else { /* type == SOCK_DGRAM */
|
|
c->recv = ngx_udp_recv;
|
|
c->send = ngx_send;
|
|
c->send_chain = ngx_udp_send_chain;
|
|
}
|
|
|
|
c->log_error = pc->log_error;
|
|
|
|
rev = c->read;
|
|
wev = c->write;
|
|
|
|
rev->log = pc->log;
|
|
wev->log = pc->log;
|
|
|
|
pc->connection = c;
|
|
|
|
c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1);
|
|
|
|
#if (NGX_HAVE_FSTACK)
|
|
if (ngx_event_actions.add_conn) {
|
|
#else
|
|
if (ngx_add_conn) {
|
|
|
|
#endif
|
|
if (ngx_add_conn(c) == NGX_ERROR) {
|
|
goto failed;
|
|
}
|
|
}
|
|
|
|
ngx_log_debug3(NGX_LOG_DEBUG_EVENT, pc->log, 0,
|
|
"connect to %V, fd:%d #%uA", pc->name, s, c->number);
|
|
|
|
rc = connect(s, pc->sockaddr, pc->socklen);
|
|
|
|
if (rc == -1) {
|
|
err = ngx_socket_errno;
|
|
|
|
|
|
if (err != NGX_EINPROGRESS
|
|
#if (NGX_WIN32)
|
|
/* Winsock returns WSAEWOULDBLOCK (NGX_EAGAIN) */
|
|
&& err != NGX_EAGAIN
|
|
#endif
|
|
)
|
|
{
|
|
if (err == NGX_ECONNREFUSED
|
|
#if (NGX_LINUX)
|
|
/*
|
|
* Linux returns EAGAIN instead of ECONNREFUSED
|
|
* for unix sockets if listen queue is full
|
|
*/
|
|
|| err == NGX_EAGAIN
|
|
#endif
|
|
|| err == NGX_ECONNRESET
|
|
|| err == NGX_ENETDOWN
|
|
|| err == NGX_ENETUNREACH
|
|
|| err == NGX_EHOSTDOWN
|
|
|| err == NGX_EHOSTUNREACH)
|
|
{
|
|
level = NGX_LOG_ERR;
|
|
|
|
} else {
|
|
level = NGX_LOG_CRIT;
|
|
}
|
|
|
|
ngx_log_error(level, c->log, err, "connect() to %V failed",
|
|
pc->name);
|
|
|
|
ngx_close_connection(c);
|
|
pc->connection = NULL;
|
|
|
|
return NGX_DECLINED;
|
|
}
|
|
}
|
|
|
|
#if (NGX_HAVE_FSTACK)
|
|
if (ngx_event_actions.add_conn) {
|
|
#else
|
|
if (ngx_add_conn) {
|
|
#endif
|
|
if (rc == -1) {
|
|
|
|
/* NGX_EINPROGRESS */
|
|
|
|
return NGX_AGAIN;
|
|
}
|
|
|
|
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, pc->log, 0, "connected");
|
|
|
|
wev->ready = 1;
|
|
|
|
return NGX_OK;
|
|
}
|
|
|
|
if (ngx_event_flags & NGX_USE_IOCP_EVENT) {
|
|
|
|
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, pc->log, ngx_socket_errno,
|
|
"connect(): %d", rc);
|
|
|
|
if (ngx_blocking(s) == -1) {
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
|
ngx_blocking_n " failed");
|
|
goto failed;
|
|
}
|
|
|
|
/*
|
|
* FreeBSD's aio allows to post an operation on non-connected socket.
|
|
* NT does not support it.
|
|
*
|
|
* TODO: check in Win32, etc. As workaround we can use NGX_ONESHOT_EVENT
|
|
*/
|
|
|
|
rev->ready = 1;
|
|
wev->ready = 1;
|
|
|
|
return NGX_OK;
|
|
}
|
|
|
|
if (ngx_event_flags & NGX_USE_CLEAR_EVENT) {
|
|
|
|
/* kqueue */
|
|
|
|
event = NGX_CLEAR_EVENT;
|
|
|
|
} else {
|
|
|
|
/* select, poll, /dev/poll */
|
|
|
|
event = NGX_LEVEL_EVENT;
|
|
}
|
|
|
|
if (ngx_add_event(rev, NGX_READ_EVENT, event) != NGX_OK) {
|
|
goto failed;
|
|
}
|
|
|
|
if (rc == -1) {
|
|
|
|
/* NGX_EINPROGRESS */
|
|
|
|
if (ngx_add_event(wev, NGX_WRITE_EVENT, event) != NGX_OK) {
|
|
goto failed;
|
|
}
|
|
|
|
return NGX_AGAIN;
|
|
}
|
|
|
|
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, pc->log, 0, "connected");
|
|
|
|
wev->ready = 1;
|
|
|
|
return NGX_OK;
|
|
|
|
failed:
|
|
|
|
ngx_close_connection(c);
|
|
pc->connection = NULL;
|
|
|
|
return NGX_ERROR;
|
|
}
|
|
|
|
|
|
#if (NGX_HAVE_TRANSPARENT_PROXY)
|
|
|
|
static ngx_int_t
|
|
ngx_event_connect_set_transparent(ngx_peer_connection_t *pc, ngx_socket_t s)
|
|
{
|
|
int value;
|
|
|
|
value = 1;
|
|
|
|
#if defined(SO_BINDANY)
|
|
|
|
if (setsockopt(s, SOL_SOCKET, SO_BINDANY,
|
|
(const void *) &value, sizeof(int)) == -1)
|
|
{
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
|
"setsockopt(SO_BINDANY) failed");
|
|
return NGX_ERROR;
|
|
}
|
|
|
|
#else
|
|
|
|
switch (pc->local->sockaddr->sa_family) {
|
|
|
|
case AF_INET:
|
|
|
|
#if defined(NGX_HAVE_FSTACK)
|
|
/****
|
|
FreeBSD define IP_BINDANY in freebsd/netinet/in.h
|
|
Fstack should only support IP_BINDANY.
|
|
****/
|
|
#define IP_BINDANY 24
|
|
if (setsockopt(s, IPPROTO_IP, IP_BINDANY,
|
|
(const void *) &value, sizeof(int)) == -1)
|
|
{
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
|
"setsockopt(IP_BINDANY) failed");
|
|
return NGX_ERROR;
|
|
}
|
|
|
|
#elif defined(IP_TRANSPARENT)
|
|
if (setsockopt(s, IPPROTO_IP, IP_TRANSPARENT,
|
|
(const void *) &value, sizeof(int)) == -1)
|
|
{
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
|
"setsockopt(IP_TRANSPARENT) failed");
|
|
return NGX_ERROR;
|
|
}
|
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
#if (NGX_HAVE_INET6)
|
|
|
|
case AF_INET6:
|
|
|
|
#if defined(IPV6_TRANSPARENT)
|
|
|
|
if (setsockopt(s, IPPROTO_IPV6, IPV6_TRANSPARENT,
|
|
(const void *) &value, sizeof(int)) == -1)
|
|
{
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
|
"setsockopt(IPV6_TRANSPARENT) failed");
|
|
return NGX_ERROR;
|
|
}
|
|
|
|
#elif defined(IPV6_BINDANY)
|
|
|
|
if (setsockopt(s, IPPROTO_IPV6, IPV6_BINDANY,
|
|
(const void *) &value, sizeof(int)) == -1)
|
|
{
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
|
"setsockopt(IPV6_BINDANY) failed");
|
|
return NGX_ERROR;
|
|
}
|
|
|
|
#else
|
|
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, 0,
|
|
"could not enable transparent proxying for IPv6 "
|
|
"on this platform");
|
|
|
|
return NGX_ERROR;
|
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
#endif /* NGX_HAVE_INET6 */
|
|
|
|
}
|
|
|
|
#endif /* SO_BINDANY */
|
|
|
|
return NGX_OK;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
ngx_int_t
|
|
ngx_event_get_peer(ngx_peer_connection_t *pc, void *data)
|
|
{
|
|
return NGX_OK;
|
|
}
|