ngx_int_t
ngx_http_oauth_service_test_connect(ngx_connection_t *c)
{
int err;
socklen_t len;
#if (NGX_HAVE_KQUEUE)
if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
if (c->write->pending_eof || c->read->pending_eof) {
if (c->write->pending_eof) {
err = c->write->kq_errno;
} else {
err = c->read->kq_errno;
}
c->log->action = "oauth service connecting to upstream";
(void) ngx_connection_error(c, err,
"kevent() reported that connect() failed");
return NGX_ERROR;
}
} else
#endif
{
err = 0;
len = sizeof(int);
/*
* BSDs and Linux return 0 and set a pending error in err
* Solaris returns -1 and sets errno
*/
if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len)
== -1)
{
err = ngx_errno;
}
if (err) {
c->log->action = "oauth_service_test_connect: connecting to memcache";
(void) ngx_connection_error(c, err, "oauth_service_test_connect() failed");
return NGX_ERROR;
}
}
return NGX_OK;
}
ngx_int_t
ngx_postgres_upstream_test_connect(ngx_connection_t *c)
{
int err;
socklen_t len;
dd("entering");
#if (NGX_HAVE_KQUEUE)
if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
if (c->write->pending_eof) {
c->log->action = "connecting to upstream";
(void) ngx_connection_error(c, c->write->kq_errno,
"kevent() reported that connect() failed");
dd("returning NGX_ERROR");
return NGX_ERROR;
}
} else
#endif
{
err = 0;
len = sizeof(int);
/*
* BSDs and Linux return 0 and set a pending error in err
* Solaris returns -1 and sets errno
*/
if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len) == -1)
{
err = ngx_errno;
}
if (err) {
c->log->action = "connecting to upstream";
(void) ngx_connection_error(c, err, "connect() failed");
dd("returning NGX_ERROR");
return NGX_ERROR;
}
}
dd("returning NGX_OK");
return NGX_OK;
}
ngx_int_t
ngx_send_lowat(ngx_connection_t *c, size_t lowat)
{
int sndlowat;
#if (NGX_HAVE_LOWAT_EVENT)
if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
c->write->available = lowat;
return NGX_OK;
}
#endif
if (lowat == 0 || c->sndlowat) {
return NGX_OK;
}
sndlowat = (int) lowat;
if (setsockopt(c->fd, SOL_SOCKET, SO_SNDLOWAT,
(const void *) &sndlowat, sizeof(int))
== -1)
{
ngx_connection_error(c, ngx_socket_errno,
"setsockopt(SO_SNDLOWAT) failed");
return NGX_ERROR;
}
c->sndlowat = 1;
return NGX_OK;
}
ssize_t
ngx_udp_wsarecv(ngx_connection_t *c, u_char *buf, size_t size)
{
int rc;
u_long bytes, flags;
WSABUF wsabuf[1];
ngx_err_t err;
ngx_event_t *rev;
wsabuf[0].buf = (char *) buf;
wsabuf[0].len = size;
flags = 0;
bytes = 0;
rc = WSARecv(c->fd, wsabuf, 1, &bytes, &flags, NULL, NULL);
ngx_log_debug4(NGX_LOG_DEBUG_EVENT, c->log, 0,
"WSARecv: fd:%d rc:%d %ul of %z", c->fd, rc, bytes, size);
rev = c->read;
if (rc == -1)
{
rev->ready = 0;
err = ngx_socket_errno;
if (err == WSAEWOULDBLOCK)
{
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
"WSARecv() not ready");
return NGX_AGAIN;
}
rev->error = 1;
ngx_connection_error(c, err, "WSARecv() failed");
return NGX_ERROR;
}
return bytes;
}
static void
ngx_stream_proxy_downstream_handler(ngx_event_t *ev)
{
ngx_connection_t *c;
ngx_stream_session_t *s;
ngx_stream_upstream_t *u;
c = ev->data;
s = c->data;
if (ev->timedout) {
ngx_connection_error(c, NGX_ETIMEDOUT, "connection timed out");
ngx_stream_proxy_finalize(s, NGX_DECLINED);
return;
}
u = s->upstream;
if (!ev->write) {
ngx_stream_proxy_process(s, 0, 0);
} else if (u->upstream_buf.start) {
ngx_stream_proxy_process(s, 1, 1);
}
}
static void
ngx_http_proxy_connect_read_hello_data(ngx_http_request_t *r)
{
ngx_int_t n;
ngx_buf_t *buf;
ngx_connection_t *c;
ngx_http_core_srv_conf_t *cscf;
ngx_http_proxy_connect_ctx_t *ctx;
c = r->connection;
ctx = ngx_http_get_module_ctx(r,ngx_http_proxy_connect_module);
buf = ctx->client_hello;
if (c->read->timedout) {
c->timedout = 1;
ngx_connection_error(c, NGX_ETIMEDOUT, "client timed out");
ngx_http_finalize_request(r, NGX_HTTP_REQUEST_TIME_OUT);
return;
}
if (c->read->ready) {
n = c->recv(c, buf->start, 4096);
} else {
return;
}
if (n == NGX_AGAIN) {
if (!c->read->timer_set) {
cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
ngx_add_timer(c->read, cscf->client_header_timeout);
}
if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
return;
}
return;
}
if (n == 0) {
ngx_log_error(NGX_LOG_INFO, c->log, 0,
"client prematurely closed connection");
}
if (n == 0 || n == NGX_ERROR) {
c->error = 1;
c->log->action = "reading https client hello data";
ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
return;
}
if (c->read->timer_set) {
ngx_del_timer(c->read);
}
buf->last = buf->pos + n;
ngx_http_proxy_connect_upstream(r);
}
ngx_int_t
ngx_connection_local_sockaddr(ngx_connection_t *c, ngx_str_t *s,
ngx_uint_t port)
{
socklen_t len;
ngx_uint_t addr;
u_char sa[NGX_SOCKADDRLEN];
struct sockaddr_in *sin;
#if (NGX_HAVE_INET6)
ngx_uint_t i;
struct sockaddr_in6 *sin6;
#endif
switch (c->local_sockaddr->sa_family) {
#if (NGX_HAVE_INET6)
case AF_INET6:
sin6 = (struct sockaddr_in6 *) c->local_sockaddr;
for (addr = 0, i = 0; addr == 0 && i < 16; i++) {
addr |= sin6->sin6_addr.s6_addr[i];
}
break;
#endif
default: /* AF_INET */
sin = (struct sockaddr_in *) c->local_sockaddr;
addr = sin->sin_addr.s_addr;
break;
}
if (addr == 0) {
len = NGX_SOCKADDRLEN;
if (getsockname(c->fd, (struct sockaddr *) &sa, &len) == -1) {
ngx_connection_error(c, ngx_socket_errno, "getsockname() failed");
return NGX_ERROR;
}
c->local_sockaddr = ngx_palloc(c->pool, len);
if (c->local_sockaddr == NULL) {
return NGX_ERROR;
}
ngx_memcpy(c->local_sockaddr, &sa, len);
}
if (s == NULL) {
return NGX_OK;
}
s->len = ngx_sock_ntop(c->local_sockaddr, s->data, s->len, port);
return NGX_OK;
}
static ngx_int_t
ngx_stream_proxy_test_connect(ngx_connection_t *c)
{
int err;
socklen_t len;
#if (NGX_HAVE_KQUEUE)
if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
err = c->write->kq_errno ? c->write->kq_errno : c->read->kq_errno;
if (err) {
(void) ngx_connection_error(c, err,
"kevent() reported that connect() failed");
return NGX_ERROR;
}
} else
#endif
{
err = 0;
len = sizeof(int);
/*
* BSDs and Linux return 0 and set a pending error in err
* Solaris returns -1 and sets errno
*/
if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len)
== -1)
{
err = ngx_socket_errno;
}
if (err) {
(void) ngx_connection_error(c, err, "connect() failed");
return NGX_ERROR;
}
}
return NGX_OK;
}
ssize_t
ngx_unix_recv(ngx_connection_t *c, u_char *buf, size_t size)
{
ssize_t n;
ngx_err_t err;
ngx_event_t *rev;
rev = c->read;
do {
n = recv(c->fd, buf, size, 0);
ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
"recv: fd:%d %d of %d", c->fd, n, size);
if (n == 0) { // 返回0，对方已经关闭
rev->ready = 0;
rev->eof = 1;
return n;
} else if (n > 0) {
if ((size_t) n < size
&& !(ngx_event_flags & NGX_USE_GREEDY_EVENT))
{
rev->ready = 0; // ????
}
return n;
}
err = ngx_socket_errno;
if (err == NGX_EAGAIN || err == NGX_EINTR) {
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
"recv() not ready");
n = NGX_AGAIN;
} else {
n = ngx_connection_error(c, err, "recv() failed");
break;
}
} while (err == NGX_EINTR);
rev->ready = 0;
if (n == NGX_ERROR) {
rev->error = 1;
}
return n;
}
ssize_t
ngx_udp_wsasend(ngx_connection_t *c, u_char *buf, size_t size)
{
int n;
u_long sent;
ngx_err_t err;
ngx_event_t *wev;
WSABUF wsabuf;
wev = c->write;
if (!wev->ready) {
return NGX_AGAIN;
}
/*
* WSABUF must be 4-byte aligned otherwise
* WSASend() will return undocumented WSAEINVAL error.
*/
wsabuf.buf = (char *) buf;
wsabuf.len = size;
sent = 0;
n = WSASendTo(c->fd,&wsabuf,1,&sent,0,c->sockaddr, c->socklen,NULL,NULL);
ngx_log_debug4(NGX_LOG_DEBUG_EVENT, c->log, 0,
"WSASend: fd:%d, %d, %ul of %uz", c->fd, n, sent, size);
if (n == 0) {
if (sent < size) {
wev->ready = 0;
}
c->sent += sent;
return sent;
}
err = ngx_socket_errno;
if (err == WSAEWOULDBLOCK) {
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err, "WSASend() not ready");
wev->ready = 0;
return NGX_AGAIN;
}
wev->error = 1;
ngx_connection_error(c, err, "WSASend() failed");
return NGX_ERROR;
}
static ssize_t
ngx_linux_sendfile(ngx_connection_t *c, ngx_buf_t *file, size_t size)
{
#if (NGX_HAVE_SENDFILE64)
off_t offset;
#else
int32_t offset;
#endif
ssize_t n;
ngx_err_t err;
#if (NGX_HAVE_SENDFILE64)
offset = file->file_pos;
#else
offset = (int32_t) file->file_pos;
#endif
eintr:
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
"sendfile: @%O %uz", file->file_pos, size);
n = sendfile(c->fd, file->file->fd, &offset, size);
if (n == -1) {
err = ngx_errno;
switch (err) {
case NGX_EAGAIN:
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
"sendfile() is not ready");
return NGX_AGAIN;
case NGX_EINTR:
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
"sendfile() was interrupted");
goto eintr;
default:
c->write->error = 1;
ngx_connection_error(c, err, "sendfile() failed");
return NGX_ERROR;
}
}
ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0, "sendfile: %z of %uz @%O",
n, size, file->file_pos);
return n;
}
static ssize_t
ngx_sendmsg(ngx_connection_t *c, ngx_iovec_t *vec)
{
ssize_t n;
ngx_err_t err;
struct msghdr msg;
ngx_memzero(&msg, sizeof(struct msghdr));
if (c->socklen) {
msg.msg_name = c->sockaddr;
msg.msg_namelen = c->socklen;
}
msg.msg_iov = vec->iovs;
msg.msg_iovlen = vec->count;
eintr:
n = sendmsg(c->fd, &msg, 0);
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
"sendmsg: %z of %uz", n, vec->size);
if (n == -1) {
err = ngx_errno;
switch (err) {
case NGX_EAGAIN:
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
"sendmsg() not ready");
return NGX_AGAIN;
case NGX_EINTR:
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
"sendmsg() was interrupted");
goto eintr;
default:
c->write->error = 1;
ngx_connection_error(c, err, "sendmsg() failed");
return NGX_ERROR;
}
}
return n;
}
static void
ngx_stream_return_write_handler(ngx_event_t *ev)
{
ssize_t n;
ngx_buf_t *b;
ngx_connection_t *c;
ngx_stream_session_t *s;
ngx_stream_return_ctx_t *ctx;
c = ev->data;
s = c->data;
if (ev->timedout) {
ngx_connection_error(c, NGX_ETIMEDOUT, "connection timed out");
ngx_stream_close_connection(c);
return;
}
if (ev->ready) {
ctx = ngx_stream_get_module_ctx(s, ngx_stream_return_module);
b = &ctx->buf;
n = c->send(c, b->pos, b->last - b->pos);
if (n == NGX_ERROR) {
ngx_stream_close_connection(c);
return;
}
if (n > 0) {
b->pos += n;
if (b->pos == b->last) {
ngx_stream_close_connection(c);
return;
}
}
}
if (ngx_handle_write_event(ev, 0) != NGX_OK) {
ngx_stream_close_connection(c);
return;
}
ngx_add_timer(ev, 5000);
}
// 封装系统调用writev，发送多个内存块
// again，暂时不可写，需要等待事件可写再重试，返回again
// 被中断，需要立即重试，可能就成功了
// 其他的就是错误
ssize_t
ngx_writev(ngx_connection_t *c, ngx_iovec_t *vec)
{
ssize_t n;
ngx_err_t err;
// 这个goto标签可以改用for+continue来实现
// 即发生EINTR错误就重试发送数据
eintr:
// 系统调用writev，发送多个内存块
n = writev(c->fd, vec->iovs, vec->count);
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
"writev: %z of %uz", n, vec->size);
// n < 0 出错，检查errno
if (n == -1) {
err = ngx_errno;
switch (err) {
// again，暂时不可写，需要等待事件可写再重试，返回again
case NGX_EAGAIN:
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
"writev() not ready");
return NGX_AGAIN;
// 被中断，需要立即重试，可能就成功了
case NGX_EINTR:
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
"writev() was interrupted");
goto eintr;
// 其他的就是错误
default:
c->write->error = 1;
ngx_connection_error(c, err, "writev() failed");
return NGX_ERROR;
}
}
return n;
}
static void
ngx_stream_return_write_handler(ngx_event_t *ev)
{
ngx_connection_t *c;
ngx_stream_session_t *s;
ngx_stream_return_ctx_t *ctx;
c = ev->data;
s = c->data;
if (ev->timedout) {
ngx_connection_error(c, NGX_ETIMEDOUT, "connection timed out");
ngx_stream_finalize_session(s, NGX_STREAM_OK);
return;
}
ctx = ngx_stream_get_module_ctx(s, ngx_stream_return_module);
if (ngx_stream_top_filter(s, ctx->out, 1) == NGX_ERROR) {
ngx_stream_finalize_session(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
return;
}
ctx->out = NULL;
if (!c->buffered) {
ngx_log_debug0(NGX_LOG_DEBUG_STREAM, c->log, 0,
"stream return done sending");
ngx_stream_finalize_session(s, NGX_STREAM_OK);
return;
}
if (ngx_handle_write_event(ev, 0) != NGX_OK) {
ngx_stream_finalize_session(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
return;
}
ngx_add_timer(ev, 5000);
}
ngx_int_t
ngx_send_lowat(ngx_connection_t *c, size_t lowat)
{
int sndlowat;
#if (NGX_HAVE_LOWAT_EVENT)
if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
c->write->available = lowat;
return NGX_OK;
}
#endif
if (lowat == 0 || c->sndlowat) {
return NGX_OK;
}
sndlowat = (int) lowat;
/*
SO_RCVLOWAT SO_SNDLOWAT
每个套接口都有一个接收低潮限度和一个发送低潮限度。
接收低潮限度：对于TCP套接口而言，接收缓冲区中的数据必须达到规定数量，内核才通知进程“可读”。比如触发select或者epoll，返回“套接口可读”。
发送低潮限度：对于TCP套接口而言，和接收低潮限度一个道理。
*/
if (setsockopt(c->fd, SOL_SOCKET, SO_SNDLOWAT,
(const void *) &sndlowat, sizeof(int))
== -1)
{
ngx_connection_error(c, ngx_socket_errno,
"setsockopt(SO_SNDLOWAT) failed");
return NGX_ERROR;
}
c->sndlowat = 1;
return NGX_OK;
}
ngx_int_t
ngx_stream_core_content_phase(ngx_stream_session_t *s,
ngx_stream_phase_handler_t *ph)
{
int tcp_nodelay;
ngx_connection_t *c;
ngx_stream_core_srv_conf_t *cscf;
c = s->connection;
c->log->action = NULL;
cscf = ngx_stream_get_module_srv_conf(s, ngx_stream_core_module);
if (c->type == SOCK_STREAM
&& cscf->tcp_nodelay
&& c->tcp_nodelay == NGX_TCP_NODELAY_UNSET)
{
ngx_log_debug0(NGX_LOG_DEBUG_STREAM, c->log, 0, "tcp_nodelay");
tcp_nodelay = 1;
if (setsockopt(c->fd, IPPROTO_TCP, TCP_NODELAY,
(const void *) &tcp_nodelay, sizeof(int)) == -1)
{
ngx_connection_error(c, ngx_socket_errno,
"setsockopt(TCP_NODELAY) failed");
ngx_stream_finalize_session(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
return NGX_OK;
}
c->tcp_nodelay = NGX_TCP_NODELAY_SET;
}
cscf->handler(s);
return NGX_OK;
}
ngx_chain_t *
ngx_darwin_sendfile_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
{
int rc;
off_t send, prev_send, sent;
off_t file_size;
ssize_t n;
ngx_uint_t eintr;
ngx_err_t err;
ngx_buf_t *file;
ngx_event_t *wev;
ngx_chain_t *cl;
ngx_iovec_t header, trailer;
struct sf_hdtr hdtr;
struct iovec headers[NGX_IOVS_PREALLOCATE];
struct iovec trailers[NGX_IOVS_PREALLOCATE];
wev = c->write;
if (!wev->ready) {
return in;
}
#if (NGX_HAVE_KQUEUE)
if ((ngx_event_flags & NGX_USE_KQUEUE_EVENT) && wev->pending_eof) {
(void) ngx_connection_error(c, wev->kq_errno,
"kevent() reported about an closed connection");
wev->error = 1;
return NGX_CHAIN_ERROR;
}
#endif
/* the maximum limit size is the maximum size_t value - the page size */
if (limit == 0 || limit > (off_t) (NGX_MAX_SIZE_T_VALUE - ngx_pagesize)) {
limit = NGX_MAX_SIZE_T_VALUE - ngx_pagesize;
}
send = 0;
header.iovs = headers;
header.nalloc = NGX_IOVS_PREALLOCATE;
trailer.iovs = trailers;
trailer.nalloc = NGX_IOVS_PREALLOCATE;
for ( ;; ) {
eintr = 0;
prev_send = send;
/* create the header iovec and coalesce the neighbouring bufs */
cl = ngx_output_chain_to_iovec(&header, in, limit - send, c->log);
if (cl == NGX_CHAIN_ERROR) {
return NGX_CHAIN_ERROR;
}
send += header.size;
if (cl && cl->buf->in_file && send < limit) {
file = cl->buf;
/* coalesce the neighbouring file bufs */
file_size = ngx_chain_coalesce_file(&cl, limit - send);
send += file_size;
if (header.count == 0) {
/*
* create the trailer iovec and coalesce the neighbouring bufs
*/
cl = ngx_output_chain_to_iovec(&trailer, cl, limit - send,
c->log);
if (cl == NGX_CHAIN_ERROR) {
return NGX_CHAIN_ERROR;
}
send += trailer.size;
} else {
trailer.count = 0;
}
/*
* sendfile() returns EINVAL if sf_hdtr's count is 0,
* but corresponding pointer is not NULL
*/
hdtr.headers = header.count ? header.iovs : NULL;
hdtr.hdr_cnt = header.count;
hdtr.trailers = trailer.count ? trailer.iovs : NULL;
hdtr.trl_cnt = trailer.count;
sent = header.size + file_size;
ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
"sendfile: @%O %O h:%uz",
file->file_pos, sent, header.size);
/* 这里开始真正的发送文件，
* 当输入localhost的时候默认的是index.html
* 那么此时这里的file->file->name就是xxxx/html/index.html ,
* 发送过去之后，客户端页面就可以正常显示了。
*/
rc = sendfile(file->file->fd, c->fd, file->file_pos,
&sent, &hdtr, 0);
if (rc == -1) {
err = ngx_errno;
switch (err) {
case NGX_EAGAIN:
break;
case NGX_EINTR:
eintr = 1;
break;
default:
wev->error = 1;
(void) ngx_connection_error(c, err, "sendfile() failed");
return NGX_CHAIN_ERROR;
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, err,
"sendfile() sent only %O bytes", sent);
}
if (rc == 0 && sent == 0) {
/*
* if rc and sent equal to zero, then someone
* has truncated the file, so the offset became beyond
* the end of the file
*/
ngx_log_error(NGX_LOG_ALERT, c->log, 0,
"sendfile() reported that \"%s\" was truncated",
file->file->name.data);
return NGX_CHAIN_ERROR;
}
ngx_log_debug4(NGX_LOG_DEBUG_EVENT, c->log, 0,
"sendfile: %d, @%O %O:%O",
rc, file->file_pos, sent, file_size + header.size);
} else {
n = ngx_writev(c, &header);
if (n == NGX_ERROR) {
return NGX_CHAIN_ERROR;
}
sent = (n == NGX_AGAIN) ? 0 : n;
}
c->sent += sent;
in = ngx_chain_update_sent(in, sent);
if (eintr) {
send = prev_send + sent;
continue;
}
if (send - prev_send != sent) {
wev->ready = 0;
return in;
}
if (send >= limit || in == NULL) {
return in;
}
}
}
ngx_chain_t *
ngx_linux_sendfile_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
{
int rc, tcp_nodelay;
off_t size, send, prev_send, aligned, sent, fprev;
u_char *prev;
size_t file_size;
ngx_err_t err;
ngx_buf_t *file;
ngx_uint_t eintr, complete;
ngx_array_t header;
ngx_event_t *wev;
ngx_chain_t *cl;
struct iovec *iov, headers[NGX_HEADERS];
#if (NGX_HAVE_SENDFILE64)
off_t offset;
#else
int32_t offset;
#endif
wev = c->write;
if (!wev->ready) {
return in;
}
/* the maximum limit size is 2G-1 - the page size */
if (limit == 0 || limit > (off_t) (NGX_SENDFILE_LIMIT - ngx_pagesize)) {
limit = NGX_SENDFILE_LIMIT - ngx_pagesize;
}
send = 0;
header.elts = headers;
header.size = sizeof(struct iovec);
header.nalloc = NGX_HEADERS;
header.pool = c->pool;
for ( ;; ) {
file = NULL;
file_size = 0;
eintr = 0;
complete = 0;
prev_send = send;
header.nelts = 0;
prev = NULL;
iov = NULL;
/* create the iovec and coalesce the neighbouring bufs */
for (cl = in;
cl && header.nelts < IOV_MAX && send < limit;
cl = cl->next)
{
if (ngx_buf_special(cl->buf)) {
continue;
}
#if 1
if (!ngx_buf_in_memory(cl->buf) && !cl->buf->in_file) {
ngx_log_error(NGX_LOG_ALERT, c->log, 0,
"zero size buf in sendfile "
"t:%d r:%d f:%d %p %p-%p %p %O-%O",
cl->buf->temporary,
cl->buf->recycled,
cl->buf->in_file,
cl->buf->start,
cl->buf->pos,
cl->buf->last,
cl->buf->file,
cl->buf->file_pos,
cl->buf->file_last);
ngx_debug_point();
return NGX_CHAIN_ERROR;
}
#endif
if (!ngx_buf_in_memory_only(cl->buf)) {
break;
}
size = cl->buf->last - cl->buf->pos;
if (send + size > limit) {
size = limit - send;
}
if (prev == cl->buf->pos) {
iov->iov_len += (size_t) size;
} else {
iov = ngx_array_push(&header);
if (iov == NULL) {
return NGX_CHAIN_ERROR;
}
iov->iov_base = (void *) cl->buf->pos;
iov->iov_len = (size_t) size;
}
prev = cl->buf->pos + (size_t) size;
send += size;
}
/* set TCP_CORK if there is a header before a file */
if (c->tcp_nopush == NGX_TCP_NOPUSH_UNSET
&& header.nelts != 0
&& cl
&& cl->buf->in_file)
{
/* the TCP_CORK and TCP_NODELAY are mutually exclusive */
if (c->tcp_nodelay == NGX_TCP_NODELAY_SET) {
tcp_nodelay = 0;
if (setsockopt(c->fd, IPPROTO_TCP, TCP_NODELAY,
(const void *) &tcp_nodelay, sizeof(int)) == -1)
{
err = ngx_errno;
/*
* there is a tiny chance to be interrupted, however,
* we continue a processing with the TCP_NODELAY
* and without the TCP_CORK
*/
if (err != NGX_EINTR) {
wev->error = 1;
ngx_connection_error(c, err,
"setsockopt(TCP_NODELAY) failed");
return NGX_CHAIN_ERROR;
}
} else {
c->tcp_nodelay = NGX_TCP_NODELAY_UNSET;
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
"no tcp_nodelay");
}
}
if (c->tcp_nodelay == NGX_TCP_NODELAY_UNSET) {
if (ngx_tcp_nopush(c->fd) == NGX_ERROR) {
err = ngx_errno;
/*
* there is a tiny chance to be interrupted, however,
* we continue a processing without the TCP_CORK
*/
if (err != NGX_EINTR) {
wev->error = 1;
ngx_connection_error(c, err,
ngx_tcp_nopush_n " failed");
return NGX_CHAIN_ERROR;
}
} else {
c->tcp_nopush = NGX_TCP_NOPUSH_SET;
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
"tcp_nopush");
}
}
}
/* get the file buf */
if (header.nelts == 0 && cl && cl->buf->in_file && send < limit) {
file = cl->buf;
/* coalesce the neighbouring file bufs */
do {
size = cl->buf->file_last - cl->buf->file_pos;
if (send + size > limit) {
size = limit - send;
aligned = (cl->buf->file_pos + size + ngx_pagesize - 1)
& ~((off_t) ngx_pagesize - 1);
if (aligned <= cl->buf->file_last) {
size = aligned - cl->buf->file_pos;
}
}
file_size += (size_t) size;
send += size;
fprev = cl->buf->file_pos + size;
cl = cl->next;
} while (cl
&& cl->buf->in_file
&& send < limit
&& file->file->fd == cl->buf->file->fd
&& fprev == cl->buf->file_pos);
}
if (file) {
#if 1
if (file_size == 0) {
ngx_debug_point();
return NGX_CHAIN_ERROR;
}
#endif
#if (NGX_HAVE_SENDFILE64)
offset = file->file_pos;
#else
offset = (int32_t) file->file_pos;
#endif
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
"sendfile: @%O %uz", file->file_pos, file_size);
rc = sendfile(c->fd, file->file->fd, &offset, file_size);
if (rc == -1) {
err = ngx_errno;
switch (err) {
case NGX_EAGAIN:
break;
case NGX_EINTR:
eintr = 1;
break;
default:
wev->error = 1;
ngx_connection_error(c, err, "sendfile() failed");
return NGX_CHAIN_ERROR;
}
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
"sendfile() is not ready");
}
sent = rc > 0 ? rc : 0;
ngx_log_debug4(NGX_LOG_DEBUG_EVENT, c->log, 0,
"sendfile: %d, @%O %O:%uz",
rc, file->file_pos, sent, file_size);
} else {
rc = writev(c->fd, header.elts, header.nelts);
if (rc == -1) {
err = ngx_errno;
switch (err) {
case NGX_EAGAIN:
break;
case NGX_EINTR:
eintr = 1;
break;
default:
wev->error = 1;
ngx_connection_error(c, err, "writev() failed");
return NGX_CHAIN_ERROR;
}
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
"writev() not ready");
}
sent = rc > 0 ? rc : 0;
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "writev: %O", sent);
}
if (send - prev_send == sent) {
complete = 1;
}
c->sent += sent;
for (cl = in; cl; cl = cl->next) {
if (ngx_buf_special(cl->buf)) {
continue;
}
if (sent == 0) {
break;
}
size = ngx_buf_size(cl->buf);
if (sent >= size) {
sent -= size;
if (ngx_buf_in_memory(cl->buf)) {
cl->buf->pos = cl->buf->last;
}
if (cl->buf->in_file) {
cl->buf->file_pos = cl->buf->file_last;
}
continue;
}
if (ngx_buf_in_memory(cl->buf)) {
cl->buf->pos += (size_t) sent;
}
if (cl->buf->in_file) {
cl->buf->file_pos += sent;
}
break;
}
if (eintr) {
continue;
}
if (!complete) {
wev->ready = 0;
return cl;
}
if (send >= limit || cl == NULL) {
return cl;
}
in = cl;
}
}
ngx_int_t
ngx_connection_local_sockaddr(ngx_connection_t *c, ngx_str_t *s,
ngx_uint_t port)
{
socklen_t len;
ngx_uint_t addr;
ngx_sockaddr_t sa;
struct sockaddr_in *sin;
#if (NGX_HAVE_INET6)
ngx_uint_t i;
struct sockaddr_in6 *sin6;
#endif
addr = 0;
if (c->local_socklen) {
switch (c->local_sockaddr->sa_family) {
#if (NGX_HAVE_INET6)
case AF_INET6:
sin6 = (struct sockaddr_in6 *) c->local_sockaddr;
for (i = 0; addr == 0 && i < 16; i++) {
addr |= sin6->sin6_addr.s6_addr[i];
}
break;
#endif
#if (NGX_HAVE_UNIX_DOMAIN)
case AF_UNIX:
addr = 1;
break;
#endif
default: /* AF_INET */
sin = (struct sockaddr_in *) c->local_sockaddr;
addr = sin->sin_addr.s_addr;
break;
}
}
if (addr == 0) {
len = sizeof(ngx_sockaddr_t);
if (getsockname(c->fd, &sa.sockaddr, &len) == -1) {
ngx_connection_error(c, ngx_socket_errno, "getsockname() failed");
return NGX_ERROR;
}
c->local_sockaddr = ngx_palloc(c->pool, len);
if (c->local_sockaddr == NULL) {
return NGX_ERROR;
}
ngx_memcpy(c->local_sockaddr, &sa, len);
c->local_socklen = len;
}
if (s == NULL) {
return NGX_OK;
}
s->len = ngx_sock_ntop(c->local_sockaddr, c->local_socklen,
s->data, s->len, port);
return NGX_OK;
}
ssize_t
ngx_unix_recv(ngx_connection_t *c, u_char *buf, size_t size)
{
ssize_t n;
ngx_err_t err;
ngx_event_t *rev;
rev = c->read;
if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
"recv: eof:%d, avail:%d, err:%d",
rev->pending_eof, rev->available, rev->kq_errno);
if (rev->available == 0) {
if (rev->pending_eof) {
rev->ready = 0;
rev->eof = 1;
if (rev->kq_errno) {
rev->error = 1;
ngx_set_socket_errno(rev->kq_errno);
return ngx_connection_error(c, rev->kq_errno,
"kevent() reported about an closed connection");
}
return 0;
} else {
rev->ready = 0;
return NGX_AGAIN;
}
}
}
do {
n = recv(c->fd, buf, size, 0);
ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
"recv: fd:%d %d of %d", c->fd, n, size);
if (n >= 0) {
if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
rev->available -= n;
/*
* rev->available may be negative here because some additional
* bytes may be received between kevent() and recv()
*/
if (rev->available <= 0) {
if (!rev->pending_eof) {
rev->ready = 0;
}
if (rev->available < 0) {
rev->available = 0;
}
}
if (n == 0) {
/*
* on FreeBSD recv() may return 0 on closed socket
* even if kqueue reported about available data
*/
rev->eof = 1;
rev->available = 0;
}
return n;
}
if ((size_t) n < size) {
rev->ready = 0;
}
if (n == 0) {
rev->eof = 1;
}
return n;
}
err = ngx_socket_errno;
if (err == NGX_EAGAIN || err == NGX_EINTR) {
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
"recv() not ready");
n = NGX_AGAIN;
} else {
n = ngx_connection_error(c, err, "recv() failed");
break;
}
} while (err == NGX_EINTR);
rev->ready = 0;
if (n == NGX_ERROR) {
rev->error = 1;
}
return n;
}
ssize_t
ngx_wsasend(ngx_connection_t *c, u_char *buf, size_t size)
{
int rc;
WSABUF wsabuf;
ssize_t n;
ngx_err_t err;
ngx_event_t *wev;
WSAOVERLAPPED *ovlp;
wev = c->write;
if (wev->closed) {
return 0;
}
if (wev->error) {
return NGX_ERROR;
}
#if (NGX_HAVE_IOCP)
if (ngx_event_flags & NGX_USE_IOCP_EVENT) {
n = wev->available;
if (wev->ready && n > 0) {
wev->available = 0;
return n;
}
wev->ovlp.event = wev;
ovlp = (WSAOVERLAPPED *) &wev->ovlp;
} else {
ovlp = NULL;
}
#else
ovlp = NULL;
#endif
wsabuf.buf = buf;
wsabuf.len = (DWORD) size;
n = 0;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
"WSASend() fd:%d, size:%uz", c->fd, size);
rc = WSASend(c->fd, &wsabuf, 1, (DWORD *) &n, 0, ovlp, NULL);
err = ngx_socket_errno;
if (rc == 0) {
if (ngx_event_flags & NGX_USE_IOCP_EVENT) {
wev->ready = 0;
return NGX_AGAIN;
}
if ((size_t) n < size) {
wev->ready = 0;
}
if (n == 0) {
wev->eof = 1;
}
return n;
}
if (err == WSA_IO_PENDING || err == WSAEWOULDBLOCK) {
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err, "WSASend() not ready");
wev->ready = 0;
return NGX_AGAIN;
}
ngx_connection_error(c, err, "WSASend() failed");
wev->ready = 0;
wev->error = 1;
return NGX_ERROR;
}
ngx_chain_t *
ngx_solaris_sendfilev_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
{
int fd;
u_char *prev;
off_t size, send, prev_send, aligned, fprev;
size_t sent;
ssize_t n;
ngx_int_t eintr;
ngx_err_t err;
ngx_uint_t nsfv;
sendfilevec_t *sfv, sfvs[NGX_SENDFILEVECS];
ngx_event_t *wev;
ngx_chain_t *cl;
wev = c->write;
if (!wev->ready) {
return in;
}
if (!c->sendfile) {
return ngx_writev_chain(c, in, limit);
}
/* the maximum limit size is the maximum size_t value - the page size */
if (limit == 0 || limit > (off_t) (NGX_MAX_SIZE_T_VALUE - ngx_pagesize)) {
limit = NGX_MAX_SIZE_T_VALUE - ngx_pagesize;
}
send = 0;
for ( ;; ) {
fd = SFV_FD_SELF;
prev = NULL;
fprev = 0;
sfv = NULL;
eintr = 0;
sent = 0;
prev_send = send;
nsfv = 0;
/* create the sendfilevec and coalesce the neighbouring bufs */
for (cl = in; cl && send < limit; cl = cl->next) {
if (ngx_buf_special(cl->buf)) {
continue;
}
if (ngx_buf_in_memory_only(cl->buf)) {
fd = SFV_FD_SELF;
size = cl->buf->last - cl->buf->pos;
if (send + size > limit) {
size = limit - send;
}
if (prev == cl->buf->pos) {
sfv->sfv_len += (size_t) size;
} else {
if (nsfv == NGX_SENDFILEVECS) {
break;
}
sfv = &sfvs[nsfv++];
sfv->sfv_fd = SFV_FD_SELF;
sfv->sfv_flag = 0;
sfv->sfv_off = (off_t) (uintptr_t) cl->buf->pos;
sfv->sfv_len = (size_t) size;
}
prev = cl->buf->pos + (size_t) size;
send += size;
} else {
prev = NULL;
size = cl->buf->file_last - cl->buf->file_pos;
if (send + size > limit) {
size = limit - send;
aligned = (cl->buf->file_pos + size + ngx_pagesize - 1)
& ~((off_t) ngx_pagesize - 1);
if (aligned <= cl->buf->file_last) {
size = aligned - cl->buf->file_pos;
}
}
if (fd == cl->buf->file->fd && fprev == cl->buf->file_pos) {
sfv->sfv_len += (size_t) size;
} else {
if (nsfv == NGX_SENDFILEVECS) {
break;
}
sfv = &sfvs[nsfv++];
fd = cl->buf->file->fd;
sfv->sfv_fd = fd;
sfv->sfv_flag = 0;
sfv->sfv_off = cl->buf->file_pos;
sfv->sfv_len = (size_t) size;
}
fprev = cl->buf->file_pos + size;
send += size;
}
}
n = sendfilev(c->fd, sfvs, nsfv, &sent);
if (n == -1) {
err = ngx_errno;
switch (err) {
case NGX_EAGAIN:
break;
case NGX_EINTR:
eintr = 1;
break;
default:
wev->error = 1;
ngx_connection_error(c, err, "sendfilev() failed");
return NGX_CHAIN_ERROR;
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, err,
"sendfilev() sent only %uz bytes", sent);
}
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
"sendfilev: %z %z", n, sent);
c->sent += sent;
in = ngx_chain_update_sent(in, sent);
if (eintr) {
send = prev_send + sent;
continue;
}
if (send - prev_send != (off_t) sent) {
wev->ready = 0;
return in;
}
if (send >= limit || in == NULL) {
return in;
}
}
}
static void
ngx_stream_proxy_process_connection(ngx_event_t *ev, ngx_uint_t from_upstream)
{
ngx_connection_t *c, *pc;
ngx_stream_session_t *s;
ngx_stream_upstream_t *u;
ngx_stream_proxy_srv_conf_t *pscf;
c = ev->data;
s = c->data;
u = s->upstream;
if (ev->timedout) {
if (ev->delayed) {
ev->timedout = 0;
ev->delayed = 0;
if (!ev->ready) {
if (ngx_handle_read_event(ev, 0) != NGX_OK) {
ngx_stream_proxy_finalize(s, NGX_ERROR);
return;
}
if (u->connected) {
pc = u->peer.connection;
if (!c->read->delayed && !pc->read->delayed) {
pscf = ngx_stream_get_module_srv_conf(s,
ngx_stream_proxy_module);
ngx_add_timer(c->write, pscf->timeout);
}
}
return;
}
} else {
ngx_connection_error(c, NGX_ETIMEDOUT, "connection timed out");
ngx_stream_proxy_finalize(s, NGX_DECLINED);
return;
}
} else if (ev->delayed) {
ngx_log_debug0(NGX_LOG_DEBUG_STREAM, c->log, 0,
"stream connection delayed");
if (ngx_handle_read_event(ev, 0) != NGX_OK) {
ngx_stream_proxy_finalize(s, NGX_ERROR);
}
return;
}
if (from_upstream && !u->connected) {
return;
}
ngx_stream_proxy_process(s, from_upstream, ev->write);
}
ssize_t
ngx_overlapped_wsarecv(ngx_connection_t *c, u_char *buf, size_t size)
{
int rc;
u_long bytes, flags;
WSABUF wsabuf[1];
ngx_err_t err;
ngx_int_t n;
ngx_event_t *rev;
LPWSAOVERLAPPED ovlp;
rev = c->read;
if (!rev->ready) {
ngx_log_error(NGX_LOG_ALERT, c->log, 0, "second wsa post");
return NGX_AGAIN;
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
"rev->complete: %d", rev->complete);
if (rev->complete) {
rev->complete = 0;
if (ngx_event_flags & NGX_USE_IOCP_EVENT) {
if (rev->ovlp.error) {
ngx_connection_error(c, rev->ovlp.error, "WSARecv() failed");
return NGX_ERROR;
}
ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
"WSARecv ovlp: fd:%d %ul of %z",
c->fd, rev->available, size);
return rev->available;
}
if (WSAGetOverlappedResult(c->fd, (LPWSAOVERLAPPED) &rev->ovlp,
&bytes, 0, NULL)
== 0)
{
ngx_connection_error(c, ngx_socket_errno,
"WSARecv() or WSAGetOverlappedResult() failed");
return NGX_ERROR;
}
ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
"WSARecv: fd:%d %ul of %z", c->fd, bytes, size);
return bytes;
}
ovlp = (LPWSAOVERLAPPED) &rev->ovlp;
ngx_memzero(ovlp, sizeof(WSAOVERLAPPED));
wsabuf[0].buf = (char *) buf;
wsabuf[0].len = size;
flags = 0;
bytes = 0;
rc = WSARecv(c->fd, wsabuf, 1, &bytes, &flags, ovlp, NULL);
rev->complete = 0;
ngx_log_debug4(NGX_LOG_DEBUG_EVENT, c->log, 0,
"WSARecv ovlp: fd:%d rc:%d %ul of %z",
c->fd, rc, bytes, size);
if (rc == -1) {
err = ngx_socket_errno;
if (err == WSA_IO_PENDING) {
rev->active = 1;
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
"WSARecv() posted");
return NGX_AGAIN;
}
n = ngx_connection_error(c, err, "WSARecv() failed");
if (n == NGX_ERROR) {
rev->error = 1;
}
return n;
}
if (ngx_event_flags & NGX_USE_IOCP_EVENT) {
/*
* if a socket was bound with I/O completion port
* then GetQueuedCompletionStatus() would anyway return its status
* despite that WSARecv() was already complete
*/
rev->active = 1;
return NGX_AGAIN;
}
if (bytes == 0) {
rev->eof = 1;
rev->ready = 0;
} else {
rev->ready = 1;
}
rev->active = 0;
return bytes;
}
ngx_chain_t *
ngx_writev_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
{
u_char *prev;
ssize_t n, size, sent;
off_t send, prev_send;
ngx_uint_t eintr, complete;
ngx_err_t err;
ngx_array_t vec;
ngx_chain_t *cl;
ngx_event_t *wev;
struct iovec *iov, iovs[NGX_IOVS];
wev = c->write;
if (!wev->ready) {
return in;
}
#if (NGX_HAVE_KQUEUE)
if ((ngx_event_flags & NGX_USE_KQUEUE_EVENT) && wev->pending_eof) {
(void) ngx_connection_error(c, wev->kq_errno,
"kevent() reported about an closed connection");
wev->error = 1;
return NGX_CHAIN_ERROR;
}
#endif
/* the maximum limit size is the maximum size_t value - the page size */
if (limit == 0 || limit > (off_t) (NGX_MAX_SIZE_T_VALUE - ngx_pagesize)) {
limit = NGX_MAX_SIZE_T_VALUE - ngx_pagesize;
}
send = 0;
vec.elts = iovs;
vec.size = sizeof(struct iovec);
vec.nalloc = NGX_IOVS;
vec.pool = c->pool;
for ( ;; ) {
prev = NULL;
iov = NULL;
eintr = 0;
complete = 0;
prev_send = send;
vec.nelts = 0;
/* create the iovec and coalesce the neighbouring bufs */
for (cl = in; cl && send < limit; cl = cl->next) {
if (ngx_buf_special(cl->buf)) {
continue;
}
#if 1
if (!ngx_buf_in_memory(cl->buf)) {
ngx_debug_point();
}
#endif
size = cl->buf->last - cl->buf->pos;
if (send + size > limit) {
size = (ssize_t) (limit - send);
}
if (prev == cl->buf->pos) {
iov->iov_len += size;
} else {
if (vec.nelts >= IOV_MAX) {
break;
}
iov = ngx_array_push(&vec);
if (iov == NULL) {
return NGX_CHAIN_ERROR;
}
iov->iov_base = (void *) cl->buf->pos;
iov->iov_len = size;
}
prev = cl->buf->pos + size;
send += size;
}
n = writev(c->fd, vec.elts, vec.nelts);
if (n == -1) {
err = ngx_errno;
switch (err) {
case NGX_EAGAIN:
break;
case NGX_EINTR:
eintr = 1;
break;
default:
wev->error = 1;
(void) ngx_connection_error(c, err, "writev() failed (in writev_chain.c)");
return NGX_CHAIN_ERROR;
}
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
"writev() not ready");
}
sent = n > 0 ? n : 0;
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "writev: %z", sent);
if (send - prev_send == sent) {
complete = 1;
}
c->sent += sent;
for (cl = in; cl; cl = cl->next) {
if (ngx_buf_special(cl->buf)) {
continue;
}
if (sent == 0) {
break;
}
size = cl->buf->last - cl->buf->pos;
if (sent >= size) {
sent -= size;
cl->buf->pos = cl->buf->last;
continue;
}
cl->buf->pos += sent;
break;
}
if (eintr) {
continue;
}
if (!complete) {
wev->ready = 0;
return cl;
}
if (send >= limit || cl == NULL) {
return cl;
}
in = cl;
}
}
ssize_t
ngx_wsasend(ngx_connection_t *c, u_char *buf, size_t size)
{
int rc;
WSABUF wsabuf;
ssize_t n;
ngx_err_t err;
ngx_event_t *wev;
WSAOVERLAPPED *ovlp;
wev = c->write;
if (wev->closed) {
return 0;
}
if (wev->error) {
return NGX_ERROR;
}
retry:
if (ngx_event_flags & NGX_USE_IOCP_EVENT && !wev->ovlp.posted_zero_byte) {
ovlp = (WSAOVERLAPPED *) &wev->ovlp;
/* overlapped io */
wsabuf.buf = NULL;
wsabuf.len = 0;
} else {
ovlp = NULL;
/* non-blocking io */
wsabuf.buf = (CHAR *) buf;
wsabuf.len = (ULONG) size;
}
n = 0;
rc = WSASend(c->fd, &wsabuf, 1, (DWORD *) &n, 0, ovlp, NULL);
err = ngx_socket_errno;
if (rc == 0) {
if (ovlp != NULL) {
wev->ovlp.posted_zero_byte = 1;
wev->ready = 0;
return NGX_AGAIN;
}
#if 0
if ((size_t) n < size) {
wev->ready = 0;
}
#endif
wev->ovlp.posted_zero_byte = 0;
return n;
}
if (err == WSA_IO_PENDING) {
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err, "WSASend() not ready");
wev->ovlp.posted_zero_byte = 1;
wev->ready = 0;
return NGX_AGAIN;
}
if (err == WSAEWOULDBLOCK) {
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err, "WSASend() not ready");
if ((ngx_event_flags & NGX_USE_IOCP_EVENT) == 0) {
wev->ready = 0;
return NGX_AGAIN;
}
/* post another overlapped-io WSASend() */
wev->ovlp.posted_zero_byte = 0;
goto retry;
}
ngx_connection_error(c, err, "WSASend() failed");
wev->ready = 0;
wev->error = 1;
return NGX_ERROR;
}
ngx_chain_t *
ngx_freebsd_sendfile_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
{
int rc, flags;
u_char *prev;
off_t size, send, prev_send, aligned, sent, fprev;
size_t header_size, file_size;
ngx_uint_t eintr, eagain, complete;
ngx_err_t err;
ngx_buf_t *file;
ngx_array_t header, trailer;
ngx_event_t *wev;
ngx_chain_t *cl;
struct sf_hdtr hdtr;
struct iovec *iov, headers[NGX_HEADERS], trailers[NGX_TRAILERS];
wev = c->write;
if (!wev->ready) {
return in;
}
#if (NGX_HAVE_KQUEUE)
if ((ngx_event_flags & NGX_USE_KQUEUE_EVENT) && wev->pending_eof) {
(void) ngx_connection_error(c, wev->kq_errno,
"kevent() reported about an closed connection");
wev->error = 1;
return NGX_CHAIN_ERROR;
}
#endif
/* the maximum limit size is the maximum size_t value - the page size */
if (limit == 0 || limit > (off_t) (NGX_MAX_SIZE_T_VALUE - ngx_pagesize)) {
limit = NGX_MAX_SIZE_T_VALUE - ngx_pagesize;
}
send = 0;
eagain = 0;
flags = 0;
header.elts = headers;
header.size = sizeof(struct iovec);
header.nalloc = NGX_HEADERS;
header.pool = c->pool;
trailer.elts = trailers;
trailer.size = sizeof(struct iovec);
trailer.nalloc = NGX_TRAILERS;
trailer.pool = c->pool;
for ( ;; ) {
file = NULL;
file_size = 0;
header_size = 0;
eintr = 0;
complete = 0;
prev_send = send;
header.nelts = 0;
trailer.nelts = 0;
/* create the header iovec and coalesce the neighbouring bufs */
prev = NULL;
iov = NULL;
for (cl = in; cl && send < limit; cl = cl->next) {
if (ngx_buf_special(cl->buf)) {
continue;
}
if (!ngx_buf_in_memory_only(cl->buf)) {
break;
}
size = cl->buf->last - cl->buf->pos;
if (send + size > limit) {
size = limit - send;
}
if (prev == cl->buf->pos) {
iov->iov_len += (size_t) size;
} else {
if (header.nelts >= IOV_MAX){
break;
}
iov = ngx_array_push(&header);
if (iov == NULL) {
return NGX_CHAIN_ERROR;
}
iov->iov_base = (void *) cl->buf->pos;
iov->iov_len = (size_t) size;
}
prev = cl->buf->pos + (size_t) size;
header_size += (size_t) size;
send += size;
}
if (cl && cl->buf->in_file && send < limit) {
file = cl->buf;
/* coalesce the neighbouring file bufs */
do {
size = cl->buf->file_last - cl->buf->file_pos;
if (send + size > limit) {
size = limit - send;
aligned = (cl->buf->file_pos + size + ngx_pagesize - 1)
& ~((off_t) ngx_pagesize - 1);
if (aligned <= cl->buf->file_last) {
size = aligned - cl->buf->file_pos;
}
}
file_size += (size_t) size;
send += size;
fprev = cl->buf->file_pos + size;
cl = cl->next;
} while (cl
&& cl->buf->in_file
&& send < limit
&& file->file->fd == cl->buf->file->fd
&& fprev == cl->buf->file_pos);
}
if (file) {
/* create the trailer iovec and coalesce the neighbouring bufs */
prev = NULL;
iov = NULL;
while (cl && send < limit) {
if (ngx_buf_special(cl->buf)) {
cl = cl->next;
continue;
}
if (!ngx_buf_in_memory_only(cl->buf)) {
break;
}
size = cl->buf->last - cl->buf->pos;
if (send + size > limit) {
size = limit - send;
}
if (prev == cl->buf->pos) {
iov->iov_len += (size_t) size;
} else {
if (trailer.nelts >= IOV_MAX){
break;
}
iov = ngx_array_push(&trailer);
if (iov == NULL) {
return NGX_CHAIN_ERROR;
}
iov->iov_base = (void *) cl->buf->pos;
iov->iov_len = (size_t) size;
}
prev = cl->buf->pos + (size_t) size;
send += size;
cl = cl->next;
}
}
if (file) {
if (ngx_freebsd_use_tcp_nopush
&& c->tcp_nopush == NGX_TCP_NOPUSH_UNSET)
{
if (ngx_tcp_nopush(c->fd) == NGX_ERROR) {
err = ngx_socket_errno;
/*
* there is a tiny chance to be interrupted, however,
* we continue a processing without the TCP_NOPUSH
*/
if (err != NGX_EINTR) {
wev->error = 1;
(void) ngx_connection_error(c, err,
ngx_tcp_nopush_n " failed");
return NGX_CHAIN_ERROR;
}
} else {
c->tcp_nopush = NGX_TCP_NOPUSH_SET;
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
"tcp_nopush");
}
}
/*
* sendfile() does unneeded work if sf_hdtr's count is 0,
* but corresponding pointer is not NULL
*/
hdtr.headers = header.nelts ? (struct iovec *) header.elts: NULL;
hdtr.hdr_cnt = header.nelts;
hdtr.trailers = trailer.nelts ? (struct iovec *) trailer.elts: NULL;
hdtr.trl_cnt = trailer.nelts;
/*
* the "nbytes bug" of the old sendfile() syscall:
* http://bugs.freebsd.org/33771
*/
if (!ngx_freebsd_sendfile_nbytes_bug) {
header_size = 0;
}
sent = 0;
#if (NGX_HAVE_AIO_SENDFILE)
flags = c->aio_sendfile ? SF_NODISKIO : 0;
#endif
rc = sendfile(file->file->fd, c->fd, file->file_pos,
file_size + header_size, &hdtr, &sent, flags);
if (rc == -1) {
err = ngx_errno;
switch (err) {
case NGX_EAGAIN:
eagain = 1;
break;
case NGX_EINTR:
eintr = 1;
break;
#if (NGX_HAVE_AIO_SENDFILE)
case NGX_EBUSY:
c->busy_sendfile = file;
break;
#endif
default:
wev->error = 1;
(void) ngx_connection_error(c, err, "sendfile() failed");
return NGX_CHAIN_ERROR;
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, err,
"sendfile() sent only %O bytes", sent);
/*
* sendfile() in FreeBSD 3.x-4.x may return value >= 0
* on success, although only 0 is documented
*/
} else if (rc >= 0 && sent == 0) {
/*
* if rc is OK and sent equal to zero, then someone
* has truncated the file, so the offset became beyond
* the end of the file
*/
ngx_log_error(NGX_LOG_ALERT, c->log, 0,
"sendfile() reported that \"%s\" was truncated at %O",
file->file->name.data, file->file_pos);
return NGX_CHAIN_ERROR;
}
ngx_log_debug4(NGX_LOG_DEBUG_EVENT, c->log, 0,
"sendfile: %d, @%O %O:%uz",
rc, file->file_pos, sent, file_size + header_size);
} else {
rc = writev(c->fd, header.elts, header.nelts);
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
"writev: %d of %uz", rc, header_size);
if (rc == -1) {
err = ngx_errno;
switch (err) {
case NGX_EAGAIN:
break;
case NGX_EINTR:
eintr = 1;
break;
default:
wev->error = 1;
ngx_connection_error(c, err, "writev() failed");
return NGX_CHAIN_ERROR;
}
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
"writev() not ready");
}
sent = rc > 0 ? rc : 0;
}
if (send - prev_send == sent) {
complete = 1;
}
c->sent += sent;
for ( /* void */ ; in; in = in->next) {
if (ngx_buf_special(in->buf)) {
continue;
}
if (sent == 0) {
break;
}
size = ngx_buf_size(in->buf);
if (sent >= size) {
sent -= size;
if (ngx_buf_in_memory(in->buf)) {
in->buf->pos = in->buf->last;
}
if (in->buf->in_file) {
in->buf->file_pos = in->buf->file_last;
}
continue;
}
if (ngx_buf_in_memory(in->buf)) {
in->buf->pos += (size_t) sent;
}
if (in->buf->in_file) {
in->buf->file_pos += sent;
}
break;
}
#if (NGX_HAVE_AIO_SENDFILE)
if (c->busy_sendfile) {
return in;
}
#endif
if (eagain) {
/*
* sendfile() may return EAGAIN, even if it has sent a whole file
* part, it indicates that the successive sendfile() call would
* return EAGAIN right away and would not send anything.
* We use it as a hint.
*/
wev->ready = 0;
return in;
}
if (eintr) {
continue;
}
if (!complete) {
wev->ready = 0;
return in;
}
if (send >= limit || in == NULL) {
return in;
}
}
}
void
ngx_mail_init_connection(ngx_connection_t *c)
{
in_addr_t in_addr;
socklen_t len;
ngx_uint_t i;
struct sockaddr_in sin;
ngx_mail_log_ctx_t *ctx;
ngx_mail_in_port_t *imip;
ngx_mail_in_addr_t *imia;
ngx_mail_session_t *s;
/* find the server configuration for the address:port */
/* AF_INET only */
imip = c->listening->servers;
imia = imip->addrs;
i = 0;
if (imip->naddrs > 1) {
/*
* There are several addresses on this port and one of them
* is the "*:port" wildcard so getsockname() is needed to determine
* the server address.
*
* AcceptEx() already gave this address.
*/
#if (NGX_WIN32)
if (c->local_sockaddr) {
in_addr =
((struct sockaddr_in *) c->local_sockaddr)->sin_addr.s_addr;
} else
#endif
{
len = sizeof(struct sockaddr_in);
if (getsockname(c->fd, (struct sockaddr *) &sin, &len) == -1) {
ngx_connection_error(c, ngx_socket_errno,
"getsockname() failed");
ngx_mail_close_connection(c);
return;
}
in_addr = sin.sin_addr.s_addr;
}
/* the last address is "*" */
for ( /* void */ ; i < imip->naddrs - 1; i++) {
if (in_addr == imia[i].addr) {
break;
}
}
}
s = ngx_pcalloc(c->pool, sizeof(ngx_mail_session_t));
if (s == NULL) {
ngx_mail_close_connection(c);
return;
}
s->main_conf = imia[i].ctx->main_conf;
s->srv_conf = imia[i].ctx->srv_conf;
s->addr_text = &imia[i].addr_text;
c->data = s;
s->connection = c;
ngx_log_error(NGX_LOG_INFO, c->log, 0, "*%ui client %V connected to %V",
c->number, &c->addr_text, s->addr_text);
ctx = ngx_palloc(c->pool, sizeof(ngx_mail_log_ctx_t));
if (ctx == NULL) {
ngx_mail_close_connection(c);
return;
}
ctx->client = &c->addr_text;
ctx->session = s;
c->log->connection = c->number;
c->log->handler = ngx_mail_log_error;
c->log->data = ctx;
c->log->action = "sending client greeting line";
c->log_error = NGX_ERROR_INFO;
#if (NGX_MAIL_SSL)
{
ngx_mail_ssl_conf_t *sslcf;
sslcf = ngx_mail_get_module_srv_conf(s, ngx_mail_ssl_module);
if (sslcf->enable) {
ngx_mail_ssl_init_connection(&sslcf->ssl, c);
return;
}
}
#endif
ngx_mail_init_session(c);
}
// 在ngx_stream_optimize_servers里设置有连接发生时的回调函数
// 调用发生在ngx_event_accept.c:ngx_event_accept()
//
// 创建一个处理tcp的会话对象
// 要先检查限速和访问限制这两个功能模块
// 最后调用ngx_stream_init_session
// 创建ctx数组，用于存储模块的ctx数据
// 调用handler，处理tcp数据，收发等等
void
ngx_stream_init_connection(ngx_connection_t *c)
{
int tcp_nodelay;
u_char text[NGX_SOCKADDR_STRLEN];
size_t len;
ngx_int_t rc;
ngx_uint_t i;
struct sockaddr *sa;
ngx_stream_port_t *port;
struct sockaddr_in *sin;
ngx_stream_in_addr_t *addr;
ngx_stream_session_t *s;
ngx_stream_addr_conf_t *addr_conf;
#if (NGX_HAVE_INET6)
struct sockaddr_in6 *sin6;
ngx_stream_in6_addr_t *addr6;
#endif
ngx_stream_core_srv_conf_t *cscf;
ngx_stream_core_main_conf_t *cmcf;
/* find the server configuration for the address:port */
// 取监听同一端口的server信息
port = c->listening->servers;
if (port->naddrs > 1) {
/*
* There are several addresses on this port and one of them
* is the "*:port" wildcard so getsockname() is needed to determine
* the server address.
*
* AcceptEx() already gave this address.
*/
if (ngx_connection_local_sockaddr(c, NULL, 0) != NGX_OK) {
ngx_stream_close_connection(c);
return;
}
sa = c->local_sockaddr;
switch (sa->sa_family) {
#if (NGX_HAVE_INET6)
case AF_INET6:
sin6 = (struct sockaddr_in6 *) sa;
addr6 = port->addrs;
/* the last address is "*" */
for (i = 0; i < port->naddrs - 1; i++) {
if (ngx_memcmp(&addr6[i].addr6, &sin6->sin6_addr, 16) == 0) {
break;
}
}
addr_conf = &addr6[i].conf;
break;
#endif
default: /* AF_INET */
sin = (struct sockaddr_in *) sa;
addr = port->addrs;
/* the last address is "*" */
for (i = 0; i < port->naddrs - 1; i++) {
if (addr[i].addr == sin->sin_addr.s_addr) {
break;
}
}
addr_conf = &addr[i].conf;
break;
}
} else {
// 唯一监听端口的server
// addr_conf就是端口所在的server的配置数组
switch (c->local_sockaddr->sa_family) {
#if (NGX_HAVE_INET6)
case AF_INET6:
addr6 = port->addrs;
addr_conf = &addr6[0].conf;
break;
#endif
default: /* AF_INET */
addr = port->addrs;
addr_conf = &addr[0].conf;
break;
}
}
// 创建一个处理tcp的会话对象
s = ngx_pcalloc(c->pool, sizeof(ngx_stream_session_t));
if (s == NULL) {
ngx_stream_close_connection(c);
return;
}
// 设置会话对象的标志
s->signature = NGX_STREAM_MODULE;
//设置会话正确的配置结构体
// addr_conf就是端口所在的server的配置数组
// 之后就可以用宏正确地获取模块的配置信息
s->main_conf = addr_conf->ctx->main_conf;
s->srv_conf = addr_conf->ctx->srv_conf;
// 设置会话关联的连接对象
s->connection = c;
// 连接的data指针指向会话对象
c->data = s;
// 获取相关的core配置
cscf = ngx_stream_get_module_srv_conf(s, ngx_stream_core_module);
ngx_set_connection_log(c, cscf->error_log);
len = ngx_sock_ntop(c->sockaddr, c->socklen, text, NGX_SOCKADDR_STRLEN, 1);
ngx_log_error(NGX_LOG_INFO, c->log, 0, "*%uA client %*s connected to %V",
c->number, len, text, &addr_conf->addr_text);
// log的一些参数
c->log->connection = c->number;
c->log->handler = ngx_stream_log_error;
c->log->data = s;
c->log->action = "initializing connection";
c->log_error = NGX_ERROR_INFO;
// 一个stream{}块只能有一个main conf
// 所以连接限速、访问限制的处理函数是相同的
// 但配置参数每个server可以不同
cmcf = ngx_stream_get_module_main_conf(s, ngx_stream_core_module);
// 是否有连接限速设置，在ngx_stream_limit_conn_module.c里设置
if (cmcf->limit_conn_handler) {
rc = cmcf->limit_conn_handler(s);
if (rc != NGX_DECLINED) {
ngx_stream_close_connection(c);
return;
}
}
// 是否有访问限制
if (cmcf->access_handler) {
rc = cmcf->access_handler(s);
if (rc != NGX_OK && rc != NGX_DECLINED) {
ngx_stream_close_connection(c);
return;
}
}
// 设置TCP_NODELAY，默认启用
if (cscf->tcp_nodelay && c->tcp_nodelay == NGX_TCP_NODELAY_UNSET) {
ngx_log_debug0(NGX_LOG_DEBUG_STREAM, c->log, 0, "tcp_nodelay");
tcp_nodelay = 1;
if (setsockopt(c->fd, IPPROTO_TCP, TCP_NODELAY,
(const void *) &tcp_nodelay, sizeof(int)) == -1)
{
ngx_connection_error(c, ngx_socket_errno,
"setsockopt(TCP_NODELAY) failed");
ngx_stream_close_connection(c);
return;
}
c->tcp_nodelay = NGX_TCP_NODELAY_SET;
}
#if (NGX_STREAM_SSL)
{
ngx_stream_ssl_conf_t *sslcf;
sslcf = ngx_stream_get_module_srv_conf(s, ngx_stream_ssl_module);
if (addr_conf->ssl) {
c->log->action = "SSL handshaking";
if (sslcf->ssl.ctx == NULL) {
ngx_log_error(NGX_LOG_ERR, c->log, 0,
"no \"ssl_certificate\" is defined "
"in server listening on SSL port");
ngx_stream_close_connection(c);
return;
}
ngx_stream_ssl_init_connection(&sslcf->ssl, c);
return;
}
}
#endif
// 创建ctx数组，用于存储模块的ctx数据
// 调用handler，处理tcp数据，收发等等
ngx_stream_init_session(c);
}
