static void
ngx_mail_proxy_dummy_handler(ngx_event_t *wev)
{
ngx_connection_t *c;
ngx_mail_session_t *s;
ngx_log_debug0(NGX_LOG_DEBUG_MAIL, wev->log, 0, "mail proxy dummy handler");
if (ngx_handle_write_event(wev, 0) != NGX_OK) {
c = wev->data;
s = c->data;
ngx_mail_proxy_close_session(s);
}
}
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);
}
}
static void
ngx_mail_proxy_handler(ngx_event_t *ev)
{
char *action, *recv_action, *send_action;
size_t size;
ssize_t n;
ngx_buf_t *b;
ngx_uint_t do_write;
ngx_connection_t *c, *src, *dst;
ngx_mail_session_t *s;
ngx_mail_proxy_conf_t *pcf;
c = ev->data;
s = c->data;
if (ev->timedout) {
c->log->action = "proxying";
if (c == s->connection) {
ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
"client timed out");
c->timedout = 1;
} else {
ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
"upstream timed out");
}
ngx_mail_proxy_close_session(s);
return;
}
if (c == s->connection) {
if (ev->write) {
recv_action = "proxying and reading from upstream";
send_action = "proxying and sending to client";
src = s->proxy->upstream.connection;
dst = c;
b = s->proxy->buffer;
} else {
recv_action = "proxying and reading from client";
send_action = "proxying and sending to upstream";
src = c;
dst = s->proxy->upstream.connection;
b = s->buffer;
}
} else {
if (ev->write) {
recv_action = "proxying and reading from client";
send_action = "proxying and sending to upstream";
src = s->connection;
dst = c;
b = s->buffer;
} else {
recv_action = "proxying and reading from upstream";
send_action = "proxying and sending to client";
src = c;
dst = s->connection;
b = s->proxy->buffer;
}
}
do_write = ev->write ? 1 : 0;
ngx_log_debug3(NGX_LOG_DEBUG_MAIL, ev->log, 0,
"mail proxy handler: %d, #%d > #%d",
do_write, src->fd, dst->fd);
for ( ;; ) {
if (do_write) {
size = b->last - b->pos;
if (size && dst->write->ready) {
c->log->action = send_action;
n = dst->send(dst, b->pos, size);
if (n == NGX_ERROR) {
ngx_mail_proxy_close_session(s);
return;
}
if (n > 0) {
b->pos += n;
if (b->pos == b->last) {
b->pos = b->start;
b->last = b->start;
}
}
}
}
size = b->end - b->last;
if (size && src->read->ready) {
c->log->action = recv_action;
n = src->recv(src, b->last, size);
if (n == NGX_AGAIN || n == 0) {
break;
}
if (n > 0) {
do_write = 1;
b->last += n;
continue;
}
if (n == NGX_ERROR) {
src->read->eof = 1;
}
}
break;
}
c->log->action = "proxying";
if ((s->connection->read->eof && s->buffer->pos == s->buffer->last)
|| (s->proxy->upstream.connection->read->eof
&& s->proxy->buffer->pos == s->proxy->buffer->last)
|| (s->connection->read->eof
&& s->proxy->upstream.connection->read->eof))
{
action = c->log->action;
c->log->action = NULL;
ngx_log_error(NGX_LOG_INFO, c->log, 0, "proxied session done");
c->log->action = action;
ngx_mail_proxy_close_session(s);
return;
}
if (ngx_handle_write_event(dst->write, 0) != NGX_OK) {
ngx_mail_proxy_close_session(s);
return;
}
if (ngx_handle_read_event(dst->read, 0) != NGX_OK) {
ngx_mail_proxy_close_session(s);
return;
}
if (ngx_handle_write_event(src->write, 0) != NGX_OK) {
ngx_mail_proxy_close_session(s);
return;
}
if (ngx_handle_read_event(src->read, 0) != NGX_OK) {
ngx_mail_proxy_close_session(s);
return;
}
if (c == s->connection) {
pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
ngx_add_timer(c->read, pcf->timeout);
}
}
static ngx_int_t
ngx_mail_proxy_read_response(ngx_mail_session_t *s, ngx_uint_t state)
{
u_char *p;
#if (NGX_MAIL_HANDLE_GMAIL)
u_char *ptemp;
#endif
ssize_t n;
ngx_buf_t *b;
ngx_mail_proxy_conf_t *pcf;
s->connection->log->action = "reading response from upstream";
b = s->proxy->buffer;
n = s->proxy->upstream.connection->recv(s->proxy->upstream.connection,
b->last, b->end - b->last);
if (n == NGX_ERROR || n == 0) {
return NGX_ERROR;
}
if (n == NGX_AGAIN) {
return NGX_AGAIN;
}
b->last += n;
if (b->last - b->pos < 4) {
return NGX_AGAIN;
}
if (*(b->last - 2) != CR || *(b->last - 1) != LF) {
if (b->last == b->end) {
*(b->last - 1) = '\0';
ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
"upstream sent too long response line: \"%s\"",
b->pos);
return NGX_ERROR;
}
return NGX_AGAIN;
}
p = b->pos;
switch (s->protocol) {
case NGX_MAIL_POP3_PROTOCOL:
if (p[0] == '+' && p[1] == 'O' && p[2] == 'K') {
return NGX_OK;
}
break;
case NGX_MAIL_IMAP_PROTOCOL:
switch (state) {
case ngx_imap_start:
if (p[0] == '*' && p[1] == ' ' && p[2] == 'O' && p[3] == 'K') {
return NGX_OK;
}
break;
case ngx_imap_login:
case ngx_imap_user:
if (p[0] == '+') {
return NGX_OK;
}
break;
case ngx_imap_passwd:
#if (NGX_MAIL_HANDLE_GMAIL)
/* pass & cut inappropriate unasked CAPABILITY answer */
if ((ptemp = ngx_strstrn(p, (char *) s->tag.data, s->tag.len - 1))) {
p = ptemp;
#else
if (ngx_strncmp(p, s->tag.data, s->tag.len) == 0) {
#endif
p += s->tag.len;
if (p[0] == 'O' && p[1] == 'K') {
return NGX_OK;
}
}
break;
}
break;
default: /* NGX_MAIL_SMTP_PROTOCOL */
switch (state) {
case ngx_smtp_start:
if (p[0] == '2' && p[1] == '2' && p[2] == '0') {
return NGX_OK;
}
break;
case ngx_smtp_helo:
case ngx_smtp_helo_xclient:
case ngx_smtp_helo_from:
case ngx_smtp_from:
if (p[0] == '2' && p[1] == '5' && p[2] == '0') {
return NGX_OK;
}
break;
case ngx_smtp_xclient:
case ngx_smtp_xclient_from:
case ngx_smtp_xclient_helo:
if (p[0] == '2' && (p[1] == '2' || p[1] == '5') && p[2] == '0') {
return NGX_OK;
}
break;
case ngx_smtp_to:
return NGX_OK;
}
break;
}
pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
if (pcf->pass_error_message == 0) {
*(b->last - 2) = '\0';
ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
"upstream sent invalid response: \"%s\"", p);
return NGX_ERROR;
}
s->out.len = b->last - p - 2;
s->out.data = p;
ngx_log_error(NGX_LOG_INFO, s->connection->log, 0,
"upstream sent invalid response: \"%V\"", &s->out);
s->out.len = b->last - b->pos;
s->out.data = b->pos;
return NGX_ERROR;
}
static void
ngx_mail_proxy_handler(ngx_event_t *ev)
{
char *action, *recv_action, *send_action;
size_t size;
ssize_t n;
ngx_buf_t *b;
ngx_uint_t do_write;
ngx_connection_t *c, *src, *dst;
ngx_mail_session_t *s;
ngx_mail_proxy_conf_t *pcf;
c = ev->data;
s = c->data;
if (ev->timedout) {
c->log->action = "proxying";
if (c == s->connection) {
ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
"client timed out");
c->timedout = 1;
} else {
ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
"upstream timed out");
}
ngx_mail_proxy_close_session(s);
return;
}
if (c == s->connection) {
if (ev->write) {
recv_action = "proxying and reading from upstream";
send_action = "proxying and sending to client";
src = s->proxy->upstream.connection;
dst = c;
b = s->proxy->buffer;
} else {
recv_action = "proxying and reading from client";
send_action = "proxying and sending to upstream";
src = c;
dst = s->proxy->upstream.connection;
b = s->buffer;
}
} else {
if (ev->write) {
recv_action = "proxying and reading from client";
send_action = "proxying and sending to upstream";
src = s->connection;
dst = c;
b = s->buffer;
} else {
recv_action = "proxying and reading from upstream";
send_action = "proxying and sending to client";
src = c;
dst = s->connection;
b = s->proxy->buffer;
}
}
do_write = ev->write ? 1 : 0;
ngx_log_debug3(NGX_LOG_DEBUG_MAIL, ev->log, 0,
"mail proxy handler: %d, #%d > #%d",
do_write, src->fd, dst->fd);
for ( ;; ) {
if (do_write) {
size = b->last - b->pos;
if (size && dst->write->ready) {
c->log->action = send_action;
n = dst->send(dst, b->pos, size);
if (n == NGX_ERROR) {
ngx_mail_proxy_close_session(s);
return;
}
if (n > 0) {
b->pos += n;
if (b->pos == b->last) {
b->pos = b->start;
b->last = b->start;
}
}
}
}
size = b->end - b->last;
if (size && src->read->ready) {
c->log->action = recv_action;
n = src->recv(src, b->last, size);
if (n == NGX_AGAIN || n == 0) {
break;
}
if (n > 0) {
do_write = 1;
b->last += n;
continue;
}
if (n == NGX_ERROR) {
src->read->eof = 1;
}
}
break;
}
c->log->action = "proxying";
if ((s->connection->read->eof && s->buffer->pos == s->buffer->last)
|| (s->proxy->upstream.connection->read->eof
&& s->proxy->buffer->pos == s->proxy->buffer->last)
|| (s->connection->read->eof
&& s->proxy->upstream.connection->read->eof))
{
action = c->log->action;
c->log->action = NULL;
ngx_log_error(NGX_LOG_INFO, c->log, 0, "proxied session done");
c->log->action = action;
ngx_mail_proxy_close_session(s);
return;
}
if (ngx_handle_write_event(dst->write, 0) != NGX_OK) {
ngx_mail_proxy_close_session(s);
return;
}
if (ngx_handle_read_event(dst->read, 0) != NGX_OK) {
ngx_mail_proxy_close_session(s);
return;
}
if (ngx_handle_write_event(src->write, 0) != NGX_OK) {
ngx_mail_proxy_close_session(s);
return;
}
if (ngx_handle_read_event(src->read, 0) != NGX_OK) {
ngx_mail_proxy_close_session(s);
return;
}
if (c == s->connection) {
pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
ngx_add_timer(c->read, pcf->timeout);
}
}
/* 透传上游邮件服务器与客户端间的流 */
static void ngx_mail_proxy_handler(ngx_event_t *ev)
{
char *action, *recv_action, *send_action;
size_t size;//读取消息时，size表示recv中空闲缓冲区的大小；发送消息时，表示将要发送的消息长度
ssize_t n;
ngx_buf_t *b;
ngx_uint_t do_write;//决定本次到底是发送还是接收TCP消息
/* 每次透传TCP，上、下游的客户端与邮件服务器之间必然有一个负责提供消息，另一个负责接收nginx转发的消息。
src表示nginx与提供消息一方的连接，dst表示nginx与接收消息一方之间的连接*/
ngx_connection_t *c, *src, *dst;
ngx_mail_session_t *s;
ngx_mail_proxy_conf_t *pcf;
/* 注意，事件ev既可能属于nginx与下游间的连接，也可能属于nginx与上游间的连接，此时无法判断c究竟是来自上游还是下游 */
c = ev->data;
s = c->data;//无论是在上游连接还是下游连接，ngx_connection_t结构体的data成员都指向ngx_mail_session_t结构体
/* 无论上下游，只要接收或者发送消息出现了超时，都需要终止透传 */
if (ev->timedout)
{
c->log->action = "proxying";
if (c == s->connection) {
ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
"client timed out");
c->timedout = 1;
} else {
ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
"upstream timed out");
}
ngx_mail_proxy_close_session(s);//同时关闭上下游的TCP连接
return;
}
/* ngx_mail_session_t结构体中的connection成员一定指向nginx与下游客户端间的TCP连接 */
/* 以下意味着收到了下游连接上的事件 */
if (c == s->connection)
{
/* 当下游可写事件被触发时，意味着本次nginx将负责把接收自上游的缓存消息发给下游 */
if (ev->write)
{
recv_action = "proxying and reading from upstream";
send_action = "proxying and sending to client";
src = s->proxy->upstream.connection;//设src来源连接为上游连接
dst = c;//设dst目标连接为下游连接
b = s->proxy->buffer;//设置用于向下游发送的消息缓冲区
}
/* 当下游可读事件被触发时，意味着本次nginx将负责先读取下游的响应到缓存中，为下一步转发给上游做准备 */
else
{
recv_action = "proxying and reading from client";
send_action = "proxying and sending to upstream";
src = c;//设置src来源链接为下游连接
dst = s->proxy->upstream.connection;//设置dst目标连接为上游连接
b = s->buffer;//设置用于接收下游消息的缓冲区
}
}
/* 以下意味着收到了上游连接上的事件 */
else
{
/* 当上游可写事件被触发时，意味着本次nginx将负责把接收自下游的缓存消息发送给上游 */
if (ev->write)
{
recv_action = "proxying and reading from client";
send_action = "proxying and sending to upstream";
src = s->connection;//设置src来源连接为下游连接
dst = c;//设置dst目标连接为上游连接
b = s->buffer;//设置用于向上游发送消息的缓冲区
}
/* 当上游可读事件被触发时，意味着本次nginx将负责接收上游的消息到缓存中，为下一步把这个消息发送给下游做准备 */
else
{
recv_action = "proxying and reading from upstream";
send_action = "proxying and sending to client";
src = c;//设src来源连接为上游连接
dst = s->connection;//设dst目标连接为下游连接
b = s->proxy->buffer;//设置用于接收上游消息的缓冲区
}
}
/* 当前触发事件的write标志位将决定do_write本次是发送还是接收消息 */
do_write = ev->write ? 1 : 0;
ngx_log_debug3(NGX_LOG_DEBUG_MAIL, ev->log, 0,
"mail proxy handler: %d, #%d > #%d",
do_write, src->fd, dst->fd);
/* 进入向dst连接发送消息或者由src连接接收消息的循环，直到套接字上暂无可读或可写事件时才退出 */
for ( ;; )
{
/* 如果本次将发送消息，那么首先计算出要发送的消息长度 */
if (do_write)
{
size = b->last - b->pos;
/* 目标连接是否可写 */
if (size && dst->write->ready)
{
c->log->action = send_action;
n = dst->send(dst, b->pos, size);//向目标连接发送TCP消息
if (n == NGX_ERROR) {
ngx_mail_proxy_close_session(s);
return;
}
/* 更新消息缓冲区 */
if (n > 0)
{
b->pos += n;
/* 如果缓冲区中的消息全部发送完，则清空缓冲区以复用 */
if (b->pos == b->last) {
b->pos = b->start;
b->last = b->start;
}
}
}
}
/* 下面为读取TCP准备，先计算接收缓冲区上的空闲空间大小 */
size = b->end - b->last;
/* 检查源连接上当前是否可读 */
if (size && src->read->ready)
{
c->log->action = recv_action;
n = src->recv(src, b->last, size);//由src源连接上接收TCP消息
/* 没有读取到内容或者对方主动关闭了TCP连接，则跳出循环 */
if (n == NGX_AGAIN || n == 0)
{
break;
}
/* 如果读取到消息，则应试图在本次ngx_mail_proxy_handler方法的执行中将它立即发送出去 */
if (n > 0)
{
do_write = 1;
b->last += n;//更新消息缓冲区
continue;//重新执行循环，检查是否可以立即转发出去
}
if (n == NGX_ERROR) {
src->read->eof = 1;
}
}
break;
}
c->log->action = "proxying";
/* 如果上下游间的连接中断，则结束透传流程 */
if ((s->connection->read->eof && s->buffer->pos == s->buffer->last)
|| (s->proxy->upstream.connection->read->eof
&& s->proxy->buffer->pos == s->proxy->buffer->last)
|| (s->connection->read->eof
&& s->proxy->upstream.connection->read->eof))
{
action = c->log->action;
c->log->action = NULL;
ngx_log_error(NGX_LOG_INFO, c->log, 0, "proxied session done");
c->log->action = action;
ngx_mail_proxy_close_session(s);
return;
}
/* 下面将会把nginx与上下游TCP连接上的4个读写事件再次添加到epoll中监控 */
if (ngx_handle_write_event(dst->write, 0) != NGX_OK) {
ngx_mail_proxy_close_session(s);
return;
}
if (ngx_handle_read_event(dst->read, 0) != NGX_OK) {
ngx_mail_proxy_close_session(s);
return;
}
if (ngx_handle_write_event(src->write, 0) != NGX_OK) {
ngx_mail_proxy_close_session(s);
return;
}
if (ngx_handle_read_event(src->read, 0) != NGX_OK) {
ngx_mail_proxy_close_session(s);
return;
}
/* 接收下游客户端的消息时还是需要检查超时的，防止僵死客户端占用nginx服务器资源 */
if (c == s->connection)
{
pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
ngx_add_timer(c->read, pcf->timeout);
}
}
