static void
ngx_mail_auth_sleep_handler(ngx_event_t *rev)
{
ngx_connection_t *c;
ngx_mail_session_t *s;
ngx_mail_core_srv_conf_t *cscf;
ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0, "mail auth sleep handler");
c = rev->data;
s = c->data;
if (rev->timedout) {
rev->timedout = 0;
if (s->auth_wait) {
s->auth_wait = 0;
ngx_mail_auth_http_init(s);
return;
}
cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);
rev->handler = cscf->protocol->auth_state;
s->mail_state = 0;
s->auth_method = NGX_MAIL_AUTH_PLAIN;
c->log->action = "in auth state";
ngx_mail_send(c->write);
if (c->destroyed) {
return;
}
ngx_add_timer(rev, cscf->timeout);
if (rev->ready) {
rev->handler(rev);
return;
}
if (ngx_handle_read_event(rev, 0) == NGX_ERROR) {
ngx_mail_close_connection(c);
}
return;
}
if (rev->active) {
if (ngx_handle_read_event(rev, 0) == NGX_ERROR) {
ngx_mail_close_connection(c);
}
}
}
static void
oc_smtp_greeting(oc_smtp_session_t *s, ngx_connection_t *c)
{
ngx_msec_t timeout;
oc_smtp_core_srv_conf_t *cscf;
ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
"smtp greeting for \"%V\"", &s->host);
cscf = oc_smtp_get_module_srv_conf(s, oc_smtp_core_module);
//sscf = oc_smtp_get_module_srv_conf(s, oc_smtp_module);
timeout = cscf->timeout;
ngx_add_timer(c->read, timeout);
if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
oc_smtp_close_connection(c);
}
c->read->handler = oc_smtp_init_protocol;
s->out = cscf->greeting;
//测试用途，完成greeting后就关闭连接
//s->quit = 1;
oc_smtp_send(c->write);
}
static void
ngx_mail_zmauth_wait_handler(ngx_event_t *ev) {
ngx_connection_t *c;
ngx_mail_session_t *s;
ngx_mail_zmauth_ctx_t *ctx;
ngx_log_debug0(NGX_LOG_DEBUG_MAIL, ev->log, 0, "mail zmauth wait handler");
c = ev->data;
s = c->data;
ctx = ngx_mail_get_module_ctx(s, ngx_mail_zmauth_module);
if (ev->timedout) {
/* we need to close the connection immediately */
ngx_destroy_pool(ctx->pool);
ngx_mail_set_ctx(s, NULL, ngx_mail_zmauth_module);
s->quit = 1;
ngx_mail_send(c->write);
return;
}
if (ev->active) {
if (ngx_handle_read_event(ev, 0) != NGX_OK) {
ngx_mail_close_connection(c);
}
}
}
void
ngx_mail_smtp_init_session(ngx_mail_session_t *s, ngx_connection_t *c)
{
ngx_msec_t timeout;
ngx_mail_core_srv_conf_t *cscf;
ngx_mail_smtp_srv_conf_t *sscf;
cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);
sscf = ngx_mail_get_module_srv_conf(s, ngx_mail_smtp_module);
timeout = sscf->greeting_delay ? sscf->greeting_delay : cscf->timeout;
ngx_add_timer(c->read, timeout);
if (ngx_handle_read_event(c->read, 0) == NGX_ERROR) {
ngx_mail_close_connection(c);
}
if (sscf->greeting_delay) {
c->read->handler = ngx_mail_smtp_invalid_pipelining;
return;
}
c->read->handler = ngx_mail_smtp_init_protocol;
s->out = sscf->greeting;
ngx_mail_send(c->write);
}
static void
ngx_mail_smtp_greeting(ngx_mail_session_t *s, ngx_connection_t *c)
{
ngx_msec_t timeout;
ngx_mail_core_srv_conf_t *cscf;
ngx_mail_smtp_srv_conf_t *sscf;
ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
"smtp greeting for \"%V\"", &s->host);
cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);
sscf = ngx_mail_get_module_srv_conf(s, ngx_mail_smtp_module);
timeout = sscf->greeting_delay ? sscf->greeting_delay : cscf->timeout;
ngx_add_timer(c->read, timeout);
if (ngx_handle_read_event(c->read, 0) == NGX_ERROR) {
ngx_mail_close_connection(c);
}
if (sscf->greeting_delay) {
c->read->handler = ngx_mail_smtp_invalid_pipelining;
return;
}
c->read->handler = ngx_mail_smtp_init_protocol;
s->out = sscf->greeting;
ngx_mail_send(c->write);
}
static ngx_int_t
ngx_mail_smtp_discard_command(ngx_mail_session_t *s, ngx_connection_t *c,
char *err)
{
ssize_t n;
n = c->recv(c, s->buffer->last, s->buffer->end - s->buffer->last);
if (n == NGX_ERROR || n == 0) {
ngx_mail_close_connection(c);
return NGX_ERROR;
}
if (n > 0) {
s->buffer->last += n;
}
if (n == NGX_AGAIN) {
if (ngx_handle_read_event(c->read, 0) == NGX_ERROR) {
ngx_mail_session_internal_server_error(s);
return NGX_ERROR;
}
return NGX_AGAIN;
}
ngx_mail_smtp_log_rejected_command(s, c, err);
s->buffer->pos = s->buffer->start;
s->buffer->last = s->buffer->start;
return NGX_OK;
}
static void
ngx_http_limit_req_delay(ngx_http_request_t *r)
{
ngx_event_t *wev;
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"limit_req delay");
wev = r->connection->write;
if (wev->delayed) {
if (ngx_handle_write_event(wev, 0) != NGX_OK) {
ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
}
return;
}
if (ngx_handle_read_event(r->connection->read, 0) != NGX_OK) {
ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
return;
}
r->read_event_handler = ngx_http_block_reading;
r->write_event_handler = ngx_http_core_run_phases;
ngx_http_core_run_phases(r);
}
void
ngx_pmap_client_init_connection(ngx_connection_t *c)
{
ngx_pmap_client_hub_t *hub;
ngx_event_t *rev, *wev;
hub = ngx_pcalloc(c->pool, sizeof(ngx_pmap_client_hub_t));
if (NULL == hub) {
ngx_pmap_close_connection(c);
return;
}
c->data = hub;
/* todo: set c->log */
rev = c->read;
wev = c->write;
rev->handler = ngx_pmap_client_on_recv;
wev->handler = ngx_pmap_empty_write_handler;
if (ngx_handle_read_event(rev, 0) != NGX_OK) {
ngx_pmap_close_connection(c);
return;
}
}
ngx_int_t
ngx_mail_read_command(ngx_mail_session_t *s, ngx_connection_t *c)
{
ssize_t n;
ngx_int_t rc;
ngx_str_t l;
ngx_mail_core_srv_conf_t *cscf;
n = c->recv(c, s->buffer->last, s->buffer->end - s->buffer->last);
if (n == NGX_ERROR || n == 0) {
ngx_mail_close_connection(c);
return NGX_ERROR;
}
if (n > 0) {
s->buffer->last += n;
}
if (n == NGX_AGAIN) {
if (ngx_handle_read_event(c->read, 0) == NGX_ERROR) {
ngx_mail_session_internal_server_error(s);
return NGX_ERROR;
}
return NGX_AGAIN;
}
cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);
rc = cscf->protocol->parse_command(s);
if (rc == NGX_AGAIN) {
if (s->buffer->last < s->buffer->end) {
return rc;
}
l.len = s->buffer->last - s->buffer->start;
l.data = s->buffer->start;
ngx_log_error(NGX_LOG_INFO, c->log, 0,
"client sent too long command \"%V\"", &l);
s->quit = 1;
return NGX_MAIL_PARSE_INVALID_COMMAND;
}
if (rc == NGX_IMAP_NEXT || rc == NGX_MAIL_PARSE_INVALID_COMMAND) {
return rc;
}
if (rc == NGX_ERROR) {
ngx_mail_close_connection(c);
return NGX_ERROR;
}
return NGX_OK;
}
void
ngx_rtmp_proxy_protocol(ngx_rtmp_session_t *s)
{
ngx_event_t *rev;
ngx_connection_t *c;
c = s->connection;
rev = c->read;
rev->handler = ngx_rtmp_proxy_protocol_recv;
ngx_log_debug0(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"proxy_protocol: start");
if (rev->ready) {
/* the deferred accept(), rtsig, aio, iocp */
if (ngx_use_accept_mutex) {
ngx_post_event(rev, &ngx_posted_events);
return;
}
rev->handler(rev);
return;
}
ngx_add_timer(rev, s->timeout);
if (ngx_handle_read_event(rev, 0) != NGX_OK) {
ngx_rtmp_finalize_session(s);
return;
}
}
static void
ngx_tcp_websocket_init_session(ngx_tcp_session_t *s)
{
ngx_connection_t *c;
ngx_tcp_websocket_ctx_t *wctx;
ngx_tcp_core_srv_conf_t *cscf;
ngx_tcp_websocket_conf_t *wcf;
c = s->connection;
ngx_log_debug0(NGX_LOG_DEBUG_TCP, c->log, 0, "tcp websocket init session");
cscf = ngx_tcp_get_module_srv_conf(s, ngx_tcp_core_module);
wcf = ngx_tcp_get_module_srv_conf(s, ngx_tcp_websocket_module);
wctx = ngx_pcalloc(s->connection->pool, sizeof(ngx_tcp_websocket_ctx_t));
if (wctx == NULL) {
ngx_tcp_finalize_session(s);
return;
}
ngx_tcp_set_ctx(s, wctx, ngx_tcp_websocket_module);
s->out.len = 0;
s->buffer = ngx_create_temp_buf(s->connection->pool, wcf->buffer_size);
if (s->buffer == NULL) {
ngx_tcp_finalize_session(s);
return;
}
c->write->handler = ngx_tcp_websocket_dummy_write_handler;
c->read->handler = ngx_tcp_websocket_init_protocol;
ngx_add_timer(c->read, cscf->timeout);
if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
ngx_tcp_finalize_session(s);
}
#if (NGX_TCP_SSL)
/*
* The ssl connection with client may not trigger the read event again,
* So I trigger it in this function.
* */
if (c->ssl) {
ngx_tcp_websocket_init_protocol(c->read);
return;
}
#endif
if (c->read->ready) {
ngx_tcp_websocket_init_protocol(c->read);
}
return;
}
ngx_int_t
ngx_stream_upm_read_and_parse_response(ngx_stream_session_t *s)
{
ngx_int_t n, rc;
ngx_buf_t *b;
ngx_connection_t *pc;
ngx_stream_upm_ctx_t *ctx;
ngx_stream_upstream_t *u;
ngx_stream_upm_main_conf_t *ummcf;
ctx = ngx_stream_get_module_ctx(s, ngx_stream_upm_module);
ummcf = ngx_stream_get_module_srv_conf(s, ngx_stream_upm_module);
u = s->upstream;
pc = u->peer.connection;
//Allocate big enough buffer
//Must be assure the content_length_n big than 2 * ummcf->buffer_size;
b = ctx->resp_body;
if (b->start == NULL) {
b->start = ngx_pcalloc(ctx->pool, 2 * ummcf->buffer_size);
b->pos = b->start;
b->last = b->start;
b->end = b->start + 2 * ummcf->buffer_size;
}
for (;;) {
n = pc->recv(pc, b->last, b->end - b->last);
if (n == NGX_AGAIN) {
if (ngx_handle_read_event(pc->read, 0) != NGX_OK) {
return NGX_ERROR;
}
return NGX_AGAIN;
}
if (n == 0) {
ngx_log_error(NGX_LOG_ERR, pc->log, 0,
"upm upstream prematurely closed connection while read the body");
}
if (n == NGX_ERROR || n == 0) {
return NGX_ERROR;
}
b->last += n;
if (b->last - b->pos == ctx->content_length_n) {
rc = ngx_stream_upm_parse_resp_body(s);
} else if (b->last - b->pos < ctx->content_length_n) {
continue;
} else {
ngx_log_error(NGX_LOG_ERR, pc->log, 0,
"upm upstream send a response body more than the content_length");
return NGX_ERROR;
}
}
return rc;
}
ngx_int_t
ngx_http_discard_request_body(ngx_http_request_t *r)
{
syslog(LOG_INFO, "[%s:%s:%d]", __FILE__, __func__, __LINE__);
ssize_t size;
ngx_event_t *rev;
if (r != r->main || r->discard_body) {
return NGX_OK;
}
if (ngx_http_test_expect(r) != NGX_OK) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
rev = r->connection->read;
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, rev->log, 0, "http set discard body");
if (rev->timer_set) {
ngx_del_timer(rev);
}
if (r->headers_in.content_length_n <= 0 || r->request_body) {
return NGX_OK;
}
size = r->header_in->last - r->header_in->pos;
if (size) {
if (r->headers_in.content_length_n > size) {
r->header_in->pos += size;
r->headers_in.content_length_n -= size;
} else {
r->header_in->pos += (size_t) r->headers_in.content_length_n;
r->headers_in.content_length_n = 0;
return NGX_OK;
}
}
if (ngx_http_read_discarded_request_body(r) == NGX_OK) {
r->lingering_close = 0;
return NGX_OK;
}
/* == NGX_AGAIN */
r->read_event_handler = ngx_http_discarded_request_body_handler;
if (ngx_handle_read_event(rev, 0) != NGX_OK) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
r->count++;
r->discard_body = 1;
return NGX_OK;
}
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);
}
static void
ngx_mail_smtp_invalid_pipelining(ngx_event_t *rev)
{
ngx_connection_t *c;
ngx_mail_session_t *s;
ngx_mail_core_srv_conf_t *cscf;
ngx_mail_smtp_srv_conf_t *sscf;
c = rev->data;
s = c->data;
c->log->action = "in delay pipelining state";
if (rev->timedout) {
ngx_log_debug0(NGX_LOG_DEBUG_MAIL, c->log, 0, "delay greeting");
rev->timedout = 0;
cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);
c->read->handler = ngx_mail_smtp_init_protocol;
ngx_add_timer(c->read, cscf->timeout);
if (ngx_handle_read_event(c->read, 0) == NGX_ERROR) {
ngx_mail_close_connection(c);
return;
}
sscf = ngx_mail_get_module_srv_conf(s, ngx_mail_smtp_module);
s->out = sscf->greeting;
} else {
ngx_log_debug0(NGX_LOG_DEBUG_MAIL, c->log, 0, "invalid pipelining");
if (s->buffer == NULL) {
if (ngx_mail_smtp_create_buffer(s, c) != NGX_OK) {
return;
}
}
if (ngx_mail_smtp_discard_command(s, c,
"client was rejected before greeting: \"%V\"")
!= NGX_OK)
{
return;
}
s->out.len = sizeof(smtp_invalid_pipelining) - 1;
s->out.data = smtp_invalid_pipelining;
}
ngx_mail_send(c->write);
}
void
ngx_tcp_init_connection(ngx_connection_t *c)
{
ngx_event_t *rev;
ngx_tcp_log_ctx_t *ctx;
ctx = ngx_palloc(c->pool, sizeof(ngx_tcp_log_ctx_t));
if (ctx == NULL) {
ngx_tcp_close_connection(c);
return;
}
ctx->client = NULL;
ctx->session = NULL;
c->log->connection = c->number;
c->log->handler = ngx_tcp_log_error;
c->log->data = ctx;
c->log->action = "client init tcp connection";
c->log_error = NGX_ERROR_INFO;
rev = c->read;
rev->handler = ngx_tcp_init_session;
c->write->handler = ngx_tcp_empty_handler;
/*
#if (NGX_STAT_STUB)
(void) ngx_atomic_fetch_add(ngx_stat_reading, 1);
#endif
*/
if (rev->ready) {
/* the deferred accept(), rtsig, aio, iocp */
if (ngx_use_accept_mutex) {
ngx_post_event(rev, &ngx_posted_events);
return;
}
ngx_tcp_init_session(rev);
return;
}
ngx_add_timer(rev, c->listening->post_accept_timeout);
if (ngx_handle_read_event(rev, 0) != NGX_OK) {
/*
#if (NGX_STAT_STUB)
(void) ngx_atomic_fetch_add(ngx_stat_reading, -1);
#endif
*/
ngx_tcp_close_connection(c);
return;
}
}
static ngx_int_t
ngx_stream_lua_socket_udp_read(ngx_stream_session_t *s,
ngx_stream_lua_socket_udp_upstream_t *u)
{
ngx_connection_t *c;
ngx_event_t *rev;
ssize_t n;
c = u->udp_connection.connection;
rev = c->read;
ngx_log_debug1(NGX_LOG_DEBUG_STREAM, c->log, 0,
"stream lua udp socket read data: waiting: %d",
(int) u->waiting);
n = ngx_udp_recv(u->udp_connection.connection,
ngx_stream_lua_socket_udp_buffer, u->recv_buf_size);
ngx_log_debug1(NGX_LOG_DEBUG_STREAM, c->log, 0,
"stream lua udp recv returned %z", n);
if (n >= 0) {
u->received = n;
ngx_stream_lua_socket_udp_handle_success(s, u);
return NGX_OK;
}
if (n == NGX_ERROR) {
u->socket_errno = ngx_socket_errno;
ngx_stream_lua_socket_udp_handle_error(s, u,
NGX_STREAM_LUA_SOCKET_FT_ERROR);
return NGX_ERROR;
}
/* n == NGX_AGAIN */
#if 1
if (ngx_handle_read_event(rev, 0) != NGX_OK) {
ngx_stream_lua_socket_udp_handle_error(s, u,
NGX_STREAM_LUA_SOCKET_FT_ERROR);
return NGX_ERROR;
}
#endif
if (rev->active) {
ngx_add_timer(rev, u->read_timeout);
} else if (rev->timer_set) {
ngx_del_timer(rev);
}
return NGX_AGAIN;
}
static void
ngx_nats_read_from_nats(ngx_connection_t *c)
{
ngx_nats_connection_t *nc = c->data;
ngx_nats_buf_t *rbuf = nc->read_buf;
ngx_nats_buf_t *wbuf = nc->write_buf;
ssize_t n;
size_t wlen;
ngx_int_t rc;
wlen = wbuf->end - wbuf->pos;
for ( ;; ) {
n = c->recv(c, (u_char *) (rbuf->buf + rbuf->end),
rbuf->cap - rbuf->end - 1);
if (n == NGX_AGAIN) {
if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
ngx_nats_close_connection(nc,
NGX_NATS_REASON_INTERNAL_ERROR, 1);
return;
}
break;
}
if (n == NGX_ERROR || n <= 0) {
ngx_nats_close_connection(nc, NGX_NATS_REASON_DISCONNECTED, 1);
return;
}
ngx_nats_check_connected(nc);
rbuf->end += n;
rc = ngx_nats_process_buffer(nc, rbuf);
if (rc != NGX_OK) {
ngx_nats_close_connection(nc, NGX_NATS_REASON_BAD_PROTOCOL, 1);
return;
}
}
/*
* Processing could add messages into write buffer.
*/
if (wlen < (wbuf->end - wbuf->pos)) {
ngx_nats_flush(nc);
}
}
ngx_int_t
ngx_http_discard_request_body(ngx_http_request_t *r)
{
ssize_t size;
ngx_event_t *rev;
if (r != r->main || r->discard_body) {
return NGX_OK;
}
if (ngx_http_test_expect(r) != NGX_OK) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
rev = r->connection->read;
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, rev->log, 0, "http set discard body");
if (rev->timer_set) {
ngx_del_timer(rev);
}
if (r->headers_in.content_length_n <= 0 || r->request_body) {
return NGX_OK;
}
size = r->header_in->last - r->header_in->pos;
if (size) {
if (r->headers_in.content_length_n > size) {
r->headers_in.content_length_n -= size;
} else {
r->header_in->pos += (size_t) r->headers_in.content_length_n;
r->headers_in.content_length_n = 0;
return NGX_OK;
}
}
r->discard_body = 1;
r->read_event_handler = ngx_http_read_discarded_request_body_handler;
if (ngx_handle_read_event(rev, 0) != NGX_OK) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
r->count++;
(void) ngx_http_read_discarded_request_body(r);
return NGX_OK;
}
static void ngx_imap_proxy_block_read(ngx_event_t *rev)
{
ngx_connection_t *c;
ngx_imap_session_t *s;
ngx_log_debug0(NGX_LOG_DEBUG_IMAP, rev->log, 0, "imap proxy block read");
if (ngx_handle_read_event(rev, 0) == NGX_ERROR) {
c = rev->data;
s = c->data;
ngx_imap_proxy_close_session(s);
}
}
ngx_int_t
ngx_ssl_shutdown(ngx_connection_t *c)
{
int sslerr;
if (c->timedout || c->ssl->no_send_shutdown || c->ssl->no_wait_shutdown) {
ssl_free(c->ssl->connection);
c->ssl = NULL;
return NGX_OK;
}
sslerr = ssl_close_notify(c->ssl->connection);
if (sslerr == 0 || sslerr == MBEDTLS_ERR_SSL_CONN_EOF) {
ssl_free(c->ssl->connection);
c->ssl = NULL;
return NGX_OK;
}
if (sslerr == MBEDTLS_ERR_NET_WANT_READ ||
sslerr == MBEDTLS_ERR_NET_WANT_WRITE) {
c->read->handler = ngx_ssl_shutdown_handler;
c->write->handler = ngx_ssl_shutdown_handler;
if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
return NGX_ERROR;
}
if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
return NGX_ERROR;
}
if (sslerr == MBEDTLS_ERR_NET_WANT_READ) {
ngx_add_timer(c->read, 300000);
}
return NGX_AGAIN;
}
ngx_mbedtls_error(NGX_LOG_ERR, c->log, 0, sslerr,
"ssl_close_notify() failed");
ssl_free(c->ssl->connection);
c->ssl = NULL;
return NGX_ERROR;
}
static void
ngx_mail_proxy_block_read(ngx_event_t *rev)
{
ngx_connection_t *c;
ngx_mail_session_t *s;
ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0, "mail proxy block read");
if (ngx_handle_read_event(rev, 0) != NGX_OK) {
c = rev->data;
s = c->data;
ngx_mail_proxy_close_session(s);
}
}
void
ngx_http_memcachep_read_line(ngx_event_t *wev)
{
ngx_int_t rc;
ssize_t n;
ngx_buf_t *buffer;
ngx_connection_t *c;
ngx_http_memcachedp_session_t *s;
c = wev->data;
s = c->data;
buffer = s->buffer;
n = c->recv(c, buffer->last, buffer->end - buffer->last);
// バッファのサイズ以上の読み込みはソケット閉じる そんなにぉっきぃのはぃらなぃょぉ
if (n == NGX_ERROR || n == 0) {
ngx_http_memcachep_close_connection(c);
return;
}
if (n > 0) {
buffer->last += n;
}
if (n == NGX_AGAIN) {
if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
ngx_http_memcachep_close_connection(c);
return;
}
return;
}
rc = ngx_http_memcachep_parse_command(wev);
// パースに失敗したので ERROR を返す
if (rc == NGX_ERROR) {
buffer->last = buffer->pos;
ngx_http_memcachep_send_error(wev);
return;
}
// パース成功して処理終わってる
if (rc == NGX_AGAIN) {
buffer->last = buffer->pos;
return;
}
}
static void
ngx_mail_zmauth_block_read(ngx_event_t *ev)
{
ngx_connection_t *c;
ngx_mail_session_t *s;
ngx_log_debug0(NGX_LOG_DEBUG_MAIL, ev->log, 0,
"mail zmauth block read");
if (ngx_handle_read_event(ev, 0) != NGX_OK) {
c = ev->data;
s = c->data;
ngx_mail_session_internal_server_error(s);
}
}
static void
ngx_tcp_lua_dummy_read_handler(ngx_tcp_session_t *s)
{
ngx_connection_t *c;
ngx_event_t *rev;
c = s->connection;
rev = c->write;
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, rev->log, 0,
"tcp lua dummy read handler: %d", c->fd);
if (ngx_handle_read_event(rev, 0) != NGX_OK) {
ngx_tcp_finalize_session(s);
}
}
static void
ngx_tcp_proxy_dummy_read_handler(ngx_event_t *rev)
{
ngx_connection_t *c;
ngx_tcp_session_t *s;
c = rev->data;
s = c->data;
ngx_log_debug1(NGX_LOG_DEBUG_TCP, rev->log, 0,
"tcp proxy dummy read handler: %d", c->fd);
if (ngx_handle_read_event(rev, 0) != NGX_OK) {
ngx_tcp_finalize_session(s);
}
}
static void
ngx_http_upstream_keepalive_close_handler(ngx_event_t *ev)
{
ngx_http_upstream_keepalive_srv_conf_t *conf;
ngx_http_upstream_keepalive_cache_t *item;
int n;
char buf[1];
ngx_connection_t *c;
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ev->log, 0,
"keepalive close handler");
c = ev->data;
if (c->close) {
goto close;
}
if (c->read->timedout) {
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ev->log, 0,
"keepalive max idle timeout");
goto close;
}
n = recv(c->fd, buf, 1, MSG_PEEK);
if (n == -1 && ngx_socket_errno == NGX_EAGAIN) {
ev->ready = 0;
if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
goto close;
}
return;
}
close:
item = c->data;
conf = item->conf;
ngx_http_upstream_keepalive_close(c);
ngx_queue_remove(&item->queue);
ngx_queue_insert_head(&conf->free, &item->queue);
}
static int init_conn_node_data(conn_node_data *data, ngx_stream_session_t *s)
{
ngx_connection_t *c;
c = s->connection;
c->data = data;
if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
ngx_log_error(NGX_LOG_ERR, c->log, 0, "%s %d: fail", __FUNCTION__, __LINE__);
return -1;
}
memset(data, 0, sizeof(*data));
add_list_buf(&data->send, 0);
add_list_buf(&data->recv, 0);
data->session = s;
return (0);
}
static void
ngx_http_drizzle_keepalive_close_handler(ngx_event_t *ev)
{
ngx_http_upstream_drizzle_srv_conf_t *dscf;
ngx_http_drizzle_keepalive_cache_t *item;
int n;
char buf[1];
ngx_connection_t *c;
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ev->log, 0,
"drizzle: keepalive close handler");
c = ev->data;
if (c->close) {
goto close;
}
n = recv(c->fd, buf, 1, MSG_PEEK);
if (n == -1 && ngx_socket_errno == NGX_EAGAIN) {
/* stale event */
#if 0
if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
goto close;
}
#endif
return;
}
close:
item = c->data;
dscf = item->srv_conf;
dd("closing fd %d", c->fd);
ngx_http_upstream_drizzle_free_connection(ev->log, c, item->drizzle_con,
dscf);
ngx_queue_remove(&item->queue);
ngx_queue_insert_head(&dscf->free, &item->queue);
}
void
ngx_mail_pop3_init_session(ngx_mail_session_t *s, ngx_connection_t *c)
{
u_char *p;
ngx_mail_core_srv_conf_t *cscf;
ngx_mail_pop3_srv_conf_t *pscf;
pscf = ngx_mail_get_module_srv_conf(s, ngx_mail_pop3_module);
cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);
if (pscf->auth_methods
& (NGX_MAIL_AUTH_APOP_ENABLED|NGX_MAIL_AUTH_CRAM_MD5_ENABLED))
{
if (ngx_mail_salt(s, c, cscf) != NGX_OK) {
ngx_mail_session_internal_server_error(s);
return;
}
s->out.data = ngx_pnalloc(c->pool, sizeof(pop3_greeting) + s->salt.len);
if (s->out.data == NULL) {
ngx_mail_session_internal_server_error(s);
return;
}
p = ngx_cpymem(s->out.data, pop3_greeting, sizeof(pop3_greeting) - 3);
*p++ = ' ';
p = ngx_cpymem(p, s->salt.data, s->salt.len);
s->out.len = p - s->out.data;
} else {
ngx_str_set(&s->out, pop3_greeting);
}
c->read->handler = ngx_mail_pop3_init_protocol;
ngx_add_timer(c->read, cscf->timeout);
if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
ngx_mail_close_connection(c);
}
ngx_mail_send(c->write);
}
