2003-05-12 23:52:24 +08:00
|
|
|
|
2004-09-28 16:34:51 +08:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2002-2004 Igor Sysoev
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
2003-10-02 13:39:37 +08:00
|
|
|
#include <ngx_config.h>
|
|
|
|
#include <ngx_core.h>
|
|
|
|
#include <ngx_event.h>
|
2003-05-12 23:52:24 +08:00
|
|
|
#include <ngx_event_connect.h>
|
2004-02-12 01:08:49 +08:00
|
|
|
#include <nginx.h>
|
2003-05-12 23:52:24 +08:00
|
|
|
|
2003-08-14 14:00:28 +08:00
|
|
|
|
2003-07-23 21:10:12 +08:00
|
|
|
/* AF_INET only */
|
2003-05-12 23:52:24 +08:00
|
|
|
|
2003-08-01 22:56:33 +08:00
|
|
|
int ngx_event_connect_peer(ngx_peer_connection_t *pc)
|
2003-05-12 23:52:24 +08:00
|
|
|
{
|
2004-03-16 15:10:12 +08:00
|
|
|
int rc;
|
2004-07-07 23:01:00 +08:00
|
|
|
ngx_uint_t instance;
|
2003-11-21 14:30:49 +08:00
|
|
|
u_int event;
|
2003-07-23 21:10:12 +08:00
|
|
|
time_t now;
|
2003-10-02 13:39:37 +08:00
|
|
|
ngx_err_t err;
|
|
|
|
ngx_peer_t *peer;
|
2003-07-23 21:10:12 +08:00
|
|
|
ngx_socket_t s;
|
2003-10-02 13:39:37 +08:00
|
|
|
ngx_event_t *rev, *wev;
|
|
|
|
ngx_connection_t *c;
|
2004-04-22 02:54:33 +08:00
|
|
|
ngx_event_conf_t *ecf;
|
2003-10-02 13:39:37 +08:00
|
|
|
struct sockaddr_in addr;
|
2003-07-23 21:10:12 +08:00
|
|
|
|
|
|
|
now = ngx_time();
|
2003-05-12 23:52:24 +08:00
|
|
|
|
2003-07-23 03:53:10 +08:00
|
|
|
/* ngx_lock_mutex(pc->peers->mutex); */
|
|
|
|
|
|
|
|
if (pc->peers->last_cached) {
|
|
|
|
|
|
|
|
/* cached connection */
|
|
|
|
|
2004-07-07 23:01:00 +08:00
|
|
|
c = pc->peers->cached[pc->peers->last_cached];
|
2003-07-23 03:53:10 +08:00
|
|
|
pc->peers->last_cached--;
|
|
|
|
|
|
|
|
/* ngx_unlock_mutex(pc->peers->mutex); */
|
|
|
|
|
2004-07-07 23:01:00 +08:00
|
|
|
#if (NGX_THREADS)
|
|
|
|
c->read->lock = c->read->own_lock;
|
|
|
|
c->write->lock = c->write->own_lock;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
pc->connection = c;
|
2003-07-23 03:53:10 +08:00
|
|
|
pc->cached = 1;
|
|
|
|
return NGX_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
pc->cached = 0;
|
2003-08-01 22:56:33 +08:00
|
|
|
pc->connection = NULL;
|
2003-07-21 05:15:59 +08:00
|
|
|
|
2003-10-31 15:10:36 +08:00
|
|
|
if (pc->peers->number == 1) {
|
|
|
|
peer = &pc->peers->peers[0];
|
|
|
|
|
|
|
|
} else {
|
2003-05-12 23:52:24 +08:00
|
|
|
|
2003-07-21 05:15:59 +08:00
|
|
|
/* there are several peers */
|
2003-05-12 23:52:24 +08:00
|
|
|
|
2003-07-22 00:24:25 +08:00
|
|
|
if (pc->tries == pc->peers->number) {
|
2003-05-12 23:52:24 +08:00
|
|
|
|
2003-07-21 05:15:59 +08:00
|
|
|
/* it's a first try - get a current peer */
|
|
|
|
|
2003-07-22 00:24:25 +08:00
|
|
|
pc->cur_peer = pc->peers->current++;
|
2003-05-12 23:52:24 +08:00
|
|
|
|
2003-10-02 13:39:37 +08:00
|
|
|
if (pc->peers->current >= pc->peers->number) {
|
2003-07-22 00:24:25 +08:00
|
|
|
pc->peers->current = 0;
|
2003-05-12 23:52:24 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-10-31 15:10:36 +08:00
|
|
|
if (pc->peers->max_fails == 0) {
|
|
|
|
peer = &pc->peers->peers[pc->cur_peer];
|
|
|
|
|
|
|
|
} else {
|
2003-05-12 23:52:24 +08:00
|
|
|
|
2003-07-21 05:15:59 +08:00
|
|
|
/* the peers support a fault tolerance */
|
|
|
|
|
2003-05-12 23:52:24 +08:00
|
|
|
for ( ;; ) {
|
2003-07-22 00:24:25 +08:00
|
|
|
peer = &pc->peers->peers[pc->cur_peer];
|
2003-05-12 23:52:24 +08:00
|
|
|
|
2003-07-22 00:24:25 +08:00
|
|
|
if (peer->fails <= pc->peers->max_fails
|
|
|
|
|| (now - peer->accessed > pc->peers->fail_timeout))
|
2003-05-12 23:52:24 +08:00
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2003-07-22 00:24:25 +08:00
|
|
|
pc->cur_peer++;
|
2003-05-12 23:52:24 +08:00
|
|
|
|
2003-07-22 00:24:25 +08:00
|
|
|
if (pc->cur_peer >= pc->peers->number) {
|
|
|
|
pc->cur_peer = 0;
|
2003-05-12 23:52:24 +08:00
|
|
|
}
|
|
|
|
|
2003-07-22 00:24:25 +08:00
|
|
|
pc->tries--;
|
2003-05-12 23:52:24 +08:00
|
|
|
|
2003-07-22 00:24:25 +08:00
|
|
|
if (pc->tries == 0) {
|
2003-07-23 21:10:12 +08:00
|
|
|
/* ngx_unlock_mutex(pc->peers->mutex); */
|
2003-10-02 13:39:37 +08:00
|
|
|
|
2003-05-12 23:52:24 +08:00
|
|
|
return NGX_ERROR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-07-23 21:10:12 +08:00
|
|
|
/* ngx_unlock_mutex(pc->peers->mutex); */
|
|
|
|
|
2003-05-12 23:52:24 +08:00
|
|
|
|
|
|
|
s = ngx_socket(AF_INET, SOCK_STREAM, IPPROTO_IP, 0);
|
|
|
|
|
|
|
|
if (s == -1) {
|
2003-07-23 03:53:10 +08:00
|
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
2003-05-12 23:52:24 +08:00
|
|
|
ngx_socket_n " failed");
|
2003-07-21 05:15:59 +08:00
|
|
|
return NGX_ERROR;
|
2003-05-12 23:52:24 +08:00
|
|
|
}
|
|
|
|
|
2004-04-22 02:54:33 +08:00
|
|
|
|
|
|
|
ecf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_event_core_module);
|
|
|
|
|
|
|
|
/* disable warning: Win32 SOCKET is u_int while UNIX socket is int */
|
|
|
|
|
|
|
|
if ((ngx_uint_t) s >= ecf->connections) {
|
|
|
|
|
|
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, 0,
|
|
|
|
"socket() returned socket #%d while only %d "
|
|
|
|
"connections was configured, closing the socket",
|
|
|
|
s, ecf->connections);
|
|
|
|
|
|
|
|
if (ngx_close_socket(s) == -1) {
|
|
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
|
|
|
ngx_close_socket_n "failed");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* TODO: sleep for some time */
|
|
|
|
|
|
|
|
return NGX_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-07-23 03:53:10 +08:00
|
|
|
if (pc->rcvbuf) {
|
2003-05-12 23:52:24 +08:00
|
|
|
if (setsockopt(s, SOL_SOCKET, SO_RCVBUF,
|
2003-07-23 03:53:10 +08:00
|
|
|
(const void *) &pc->rcvbuf, sizeof(int)) == -1) {
|
|
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
2003-05-12 23:52:24 +08:00
|
|
|
"setsockopt(SO_RCVBUF) failed");
|
|
|
|
|
|
|
|
if (ngx_close_socket(s) == -1) {
|
2003-07-23 03:53:10 +08:00
|
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
2003-05-12 23:52:24 +08:00
|
|
|
ngx_close_socket_n " failed");
|
|
|
|
}
|
|
|
|
|
2003-07-21 05:15:59 +08:00
|
|
|
return NGX_ERROR;
|
2003-05-12 23:52:24 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ngx_nonblocking(s) == -1) {
|
2003-07-23 03:53:10 +08:00
|
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
2003-05-12 23:52:24 +08:00
|
|
|
ngx_nonblocking_n " failed");
|
|
|
|
|
|
|
|
if (ngx_close_socket(s) == -1) {
|
2003-07-23 03:53:10 +08:00
|
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
2003-05-12 23:52:24 +08:00
|
|
|
ngx_close_socket_n " failed");
|
|
|
|
}
|
|
|
|
|
2003-07-21 05:15:59 +08:00
|
|
|
return NGX_ERROR;
|
2003-05-12 23:52:24 +08:00
|
|
|
}
|
|
|
|
|
2003-07-21 05:15:59 +08:00
|
|
|
#if (WIN32)
|
2003-07-23 03:53:10 +08:00
|
|
|
/*
|
|
|
|
* Winsock assignes a socket number divisible by 4
|
|
|
|
* so to find a connection we divide a socket number by 4.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (s % 4) {
|
|
|
|
ngx_log_error(NGX_LOG_EMERG, pc->log, 0,
|
|
|
|
ngx_socket_n
|
|
|
|
" created socket %d, not divisible by 4", s);
|
|
|
|
exit(1);
|
|
|
|
}
|
2003-07-21 05:15:59 +08:00
|
|
|
|
|
|
|
c = &ngx_cycle->connections[s / 4];
|
|
|
|
rev = &ngx_cycle->read_events[s / 4];
|
|
|
|
wev = &ngx_cycle->write_events[s / 4];
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
c = &ngx_cycle->connections[s];
|
|
|
|
rev = &ngx_cycle->read_events[s];
|
|
|
|
wev = &ngx_cycle->write_events[s];
|
|
|
|
|
|
|
|
#endif
|
2003-05-12 23:52:24 +08:00
|
|
|
|
|
|
|
instance = rev->instance;
|
|
|
|
|
2004-07-07 00:12:16 +08:00
|
|
|
#if (NGX_THREADS)
|
2004-07-07 14:15:04 +08:00
|
|
|
|
|
|
|
if (*(&c->lock)) {
|
2004-07-07 00:12:16 +08:00
|
|
|
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, pc->log, 0,
|
2004-07-07 14:15:04 +08:00
|
|
|
"spinlock in connect, fd:%d", s);
|
|
|
|
ngx_spinlock(&c->lock, 1000);
|
|
|
|
ngx_unlock(&c->lock);
|
2004-07-07 00:12:16 +08:00
|
|
|
}
|
2004-07-07 14:15:04 +08:00
|
|
|
|
2004-07-07 00:12:16 +08:00
|
|
|
#endif
|
|
|
|
|
2003-05-12 23:52:24 +08:00
|
|
|
ngx_memzero(c, sizeof(ngx_connection_t));
|
|
|
|
ngx_memzero(rev, sizeof(ngx_event_t));
|
|
|
|
ngx_memzero(wev, sizeof(ngx_event_t));
|
|
|
|
|
2004-07-07 23:01:00 +08:00
|
|
|
rev->instance = !instance;
|
|
|
|
wev->instance = !instance;
|
2004-04-05 04:32:09 +08:00
|
|
|
|
2003-11-20 00:26:41 +08:00
|
|
|
rev->index = NGX_INVALID_INDEX;
|
|
|
|
wev->index = NGX_INVALID_INDEX;
|
|
|
|
|
|
|
|
rev->data = c;
|
|
|
|
wev->data = c;
|
|
|
|
|
2003-05-12 23:52:24 +08:00
|
|
|
c->read = rev;
|
|
|
|
c->write = wev;
|
2003-10-08 12:34:07 +08:00
|
|
|
wev->write = 1;
|
2003-05-12 23:52:24 +08:00
|
|
|
|
2003-11-20 00:26:41 +08:00
|
|
|
c->log = pc->log;
|
|
|
|
rev->log = pc->log;
|
|
|
|
wev->log = pc->log;
|
2003-05-12 23:52:24 +08:00
|
|
|
|
|
|
|
c->fd = s;
|
2003-07-23 03:53:10 +08:00
|
|
|
|
2004-03-15 04:46:25 +08:00
|
|
|
c->log_error = pc->log_error;
|
|
|
|
|
2003-07-23 03:53:10 +08:00
|
|
|
pc->connection = c;
|
|
|
|
|
2004-02-12 01:08:49 +08:00
|
|
|
/*
|
|
|
|
* TODO: MT: - atomic increment (x86: lock xadd)
|
|
|
|
* or protection by critical section or mutex
|
|
|
|
*
|
|
|
|
* TODO: MP: - allocated in a shared memory
|
|
|
|
* - atomic increment (x86: lock xadd)
|
|
|
|
* or protection by critical section or mutex
|
|
|
|
*/
|
|
|
|
|
2004-04-10 00:03:04 +08:00
|
|
|
c->number = ngx_atomic_inc(ngx_connection_counter);
|
2004-02-12 01:08:49 +08:00
|
|
|
|
2004-07-05 23:08:23 +08:00
|
|
|
#if (NGX_THREADS)
|
|
|
|
rev->lock = pc->lock;
|
|
|
|
wev->lock = pc->lock;
|
2004-07-07 14:15:04 +08:00
|
|
|
rev->own_lock = &c->lock;
|
|
|
|
wev->own_lock = &c->lock;
|
2004-07-05 23:08:23 +08:00
|
|
|
#endif
|
|
|
|
|
2003-07-23 03:53:10 +08:00
|
|
|
if (ngx_add_conn) {
|
|
|
|
if (ngx_add_conn(c) == NGX_ERROR) {
|
|
|
|
return NGX_ERROR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-10-03 23:50:53 +08:00
|
|
|
ngx_memzero(&addr, sizeof(struct sockaddr_in));
|
|
|
|
|
2003-10-02 13:39:37 +08:00
|
|
|
addr.sin_family = AF_INET;
|
2004-09-07 23:29:22 +08:00
|
|
|
addr.sin_port = peer->port;
|
2003-11-17 05:49:42 +08:00
|
|
|
addr.sin_addr.s_addr = peer->addr;
|
2003-07-23 21:10:12 +08:00
|
|
|
|
2004-03-16 21:35:20 +08:00
|
|
|
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, pc->log, 0,
|
|
|
|
"connect to %s, #%d", peer->addr_port_text.data, c->number);
|
2003-10-28 00:16:17 +08:00
|
|
|
|
2003-10-02 13:39:37 +08:00
|
|
|
rc = connect(s, (struct sockaddr *) &addr, sizeof(struct sockaddr_in));
|
2003-07-23 21:10:12 +08:00
|
|
|
|
|
|
|
if (rc == -1) {
|
|
|
|
err = ngx_socket_errno;
|
2003-11-17 05:49:42 +08:00
|
|
|
|
2004-03-15 04:46:25 +08:00
|
|
|
/* Winsock returns WSAEWOULDBLOCK (NGX_EAGAIN) */
|
2003-11-17 05:49:42 +08:00
|
|
|
|
|
|
|
if (err != NGX_EINPROGRESS && err != NGX_EAGAIN) {
|
2004-03-15 04:46:25 +08:00
|
|
|
ngx_connection_error(c, err, "connect() failed");
|
2003-07-23 21:10:12 +08:00
|
|
|
|
|
|
|
if (ngx_close_socket(s) == -1) {
|
|
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
|
|
|
ngx_close_socket_n " failed");
|
|
|
|
}
|
|
|
|
|
2004-03-16 15:10:12 +08:00
|
|
|
c->fd = (ngx_socket_t) -1;
|
2003-10-07 23:30:05 +08:00
|
|
|
|
2003-07-23 21:10:12 +08:00
|
|
|
return NGX_CONNECT_ERROR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-06-01 14:04:46 +08:00
|
|
|
if (ngx_add_conn) {
|
|
|
|
if (rc == -1) {
|
|
|
|
/* NGX_EINPROGRESS */
|
|
|
|
return NGX_AGAIN;
|
|
|
|
}
|
|
|
|
|
|
|
|
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, pc->log, 0, "connected");
|
|
|
|
return NGX_OK;
|
|
|
|
}
|
|
|
|
|
2003-10-29 16:30:44 +08:00
|
|
|
if (ngx_event_flags & NGX_USE_AIO_EVENT) {
|
2003-10-31 00:51:33 +08:00
|
|
|
|
2003-10-29 16:30:44 +08:00
|
|
|
/* aio, iocp */
|
|
|
|
|
2003-10-31 00:51:33 +08:00
|
|
|
if (ngx_blocking(s) == -1) {
|
|
|
|
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
|
|
|
ngx_blocking_n " failed");
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* aio allows to post operation on non-connected socket
|
2003-11-17 05:49:42 +08:00
|
|
|
* at least in FreeBSD.
|
|
|
|
* NT does not support it.
|
2003-10-31 00:51:33 +08:00
|
|
|
*
|
2003-11-01 00:05:33 +08:00
|
|
|
* TODO: check in Win32, etc. As workaround we can use NGX_ONESHOT_EVENT
|
2003-10-31 00:51:33 +08:00
|
|
|
*/
|
|
|
|
|
2003-10-30 16:51:06 +08:00
|
|
|
rev->ready = 1;
|
2003-10-29 16:30:44 +08:00
|
|
|
wev->ready = 1;
|
2003-10-30 16:51:06 +08:00
|
|
|
|
2003-10-29 16:30:44 +08:00
|
|
|
return NGX_OK;
|
|
|
|
}
|
|
|
|
|
2003-10-13 00:49:16 +08:00
|
|
|
if (ngx_event_flags & NGX_USE_CLEAR_EVENT) { /* kqueue */
|
2003-10-03 23:50:53 +08:00
|
|
|
event = NGX_CLEAR_EVENT;
|
|
|
|
|
|
|
|
} else { /* select, poll, /dev/poll */
|
|
|
|
event = NGX_LEVEL_EVENT;
|
|
|
|
}
|
|
|
|
|
2003-10-28 05:01:00 +08:00
|
|
|
if (ngx_add_event(rev, NGX_READ_EVENT, event) != NGX_OK) {
|
|
|
|
return NGX_ERROR;
|
|
|
|
}
|
|
|
|
|
2003-10-03 23:50:53 +08:00
|
|
|
if (rc == -1) {
|
|
|
|
|
|
|
|
/* NGX_EINPROGRESS */
|
|
|
|
|
|
|
|
if (ngx_add_event(wev, NGX_WRITE_EVENT, event) != NGX_OK) {
|
|
|
|
return NGX_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NGX_AGAIN;
|
|
|
|
}
|
|
|
|
|
2004-02-12 01:08:49 +08:00
|
|
|
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, pc->log, 0, "connected");
|
2003-11-19 00:49:00 +08:00
|
|
|
|
2003-10-17 04:19:16 +08:00
|
|
|
wev->ready = 1;
|
|
|
|
|
2003-10-02 13:39:37 +08:00
|
|
|
return NGX_OK;
|
2003-07-21 05:15:59 +08:00
|
|
|
}
|
2003-08-14 14:00:28 +08:00
|
|
|
|
|
|
|
|
|
|
|
void ngx_event_connect_peer_failed(ngx_peer_connection_t *pc)
|
|
|
|
{
|
2003-10-31 15:10:36 +08:00
|
|
|
time_t now;
|
|
|
|
|
|
|
|
now = ngx_time();
|
|
|
|
|
|
|
|
/* ngx_lock_mutex(pc->peers->mutex); */
|
|
|
|
|
|
|
|
pc->peers->peers[pc->cur_peer].fails++;
|
|
|
|
pc->peers->peers[pc->cur_peer].accessed = now;
|
|
|
|
|
|
|
|
/* ngx_unlock_mutex(pc->peers->mutex); */
|
|
|
|
|
2003-10-28 00:16:17 +08:00
|
|
|
pc->cur_peer++;
|
|
|
|
|
|
|
|
if (pc->cur_peer >= pc->peers->number) {
|
|
|
|
pc->cur_peer = 0;
|
|
|
|
}
|
|
|
|
|
2003-10-03 23:50:53 +08:00
|
|
|
pc->tries--;
|
|
|
|
|
2003-08-14 14:00:28 +08:00
|
|
|
return;
|
|
|
|
}
|