One Level Up Top Level

src/mail/ngx_mail_proxy_module.c - nginx-1.31.4 nginx/ @ 8d9666701

Global variables defined

Data types defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_event.h>
  11. #include <ngx_event_connect.h>
  12. #include <ngx_mail.h>


  15. ‌typedef struct {
  16.     ngx_flag_t  enable;
  17.     ngx_flag_t  pass_error_message;
  18.     ngx_flag_t  xclient;
  19.     ngx_flag_t  smtp_auth;
  20.     ngx_uint_t  proxy_protocol;
  21.     size_t      buffer_size;
  22.     ngx_msec_t  timeout;
  23. ‌} ngx_mail_proxy_conf_t;


  26. static void ngx_mail_proxy_block_read(ngx_event_t *rev);
  27. static void ngx_mail_proxy_pop3_handler(ngx_event_t *rev);
  28. static void ngx_mail_proxy_imap_handler(ngx_event_t *rev);
  29. static void ngx_mail_proxy_smtp_handler(ngx_event_t *rev);
  30. static void ngx_mail_proxy_write_handler(ngx_event_t *wev);
  31. static ngx_int_t ngx_mail_proxy_send_proxy_protocol(ngx_mail_session_t *s);
  32. static ngx_int_t ngx_mail_proxy_read_response(ngx_mail_session_t *s,
  33.     ngx_uint_t state);
  34. static void ngx_mail_proxy_handler(ngx_event_t *ev);
  35. static void ngx_mail_proxy_upstream_error(ngx_mail_session_t *s);
  36. static void ngx_mail_proxy_internal_server_error(ngx_mail_session_t *s);
  37. static void ngx_mail_proxy_close_session(ngx_mail_session_t *s);
  38. static void *ngx_mail_proxy_create_conf(ngx_conf_t *cf);
  39. static char *ngx_mail_proxy_merge_conf(ngx_conf_t *cf, void *parent,
  40.     void *child);


  43. ‌static ngx_conf_enum_t  ngx_mail_proxy_protocol_versions[] = {
  44.     { ngx_string("off"), 0 },
  45.     { ngx_string("on"), 1 },
  46.     { ngx_string("v2"), 2 },
  47.     { ngx_null_string, 0 }
  48. };


  51. ‌static ngx_command_t  ngx_mail_proxy_commands[] = {

  53.     { ngx_string("proxy"),
  54.       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_FLAG,
  55.       ngx_conf_set_flag_slot,
  56.       NGX_MAIL_SRV_CONF_OFFSET,
  57.       offsetof(ngx_mail_proxy_conf_t, enable),
  58.       NULL },

  60.     { ngx_string("proxy_buffer"),
  61.       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_TAKE1,
  62.       ngx_conf_set_size_slot,
  63.       NGX_MAIL_SRV_CONF_OFFSET,
  64.       offsetof(ngx_mail_proxy_conf_t, buffer_size),
  65.       NULL },

  67.     { ngx_string("proxy_timeout"),
  68.       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_TAKE1,
  69.       ngx_conf_set_msec_slot,
  70.       NGX_MAIL_SRV_CONF_OFFSET,
  71.       offsetof(ngx_mail_proxy_conf_t, timeout),
  72.       NULL },

  74.     { ngx_string("proxy_pass_error_message"),
  75.       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_FLAG,
  76.       ngx_conf_set_flag_slot,
  77.       NGX_MAIL_SRV_CONF_OFFSET,
  78.       offsetof(ngx_mail_proxy_conf_t, pass_error_message),
  79.       NULL },

  81.     { ngx_string("xclient"),
  82.       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_FLAG,
  83.       ngx_conf_set_flag_slot,
  84.       NGX_MAIL_SRV_CONF_OFFSET,
  85.       offsetof(ngx_mail_proxy_conf_t, xclient),
  86.       NULL },

  88.     { ngx_string("proxy_smtp_auth"),
  89.       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_FLAG,
  90.       ngx_conf_set_flag_slot,
  91.       NGX_MAIL_SRV_CONF_OFFSET,
  92.       offsetof(ngx_mail_proxy_conf_t, smtp_auth),
  93.       NULL },

  95.     { ngx_string("proxy_protocol"),
  96.       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_TAKE1,
  97.       ngx_conf_set_enum_slot,
  98.       NGX_MAIL_SRV_CONF_OFFSET,
  99.       offsetof(ngx_mail_proxy_conf_t, proxy_protocol),
  100.       &ngx_mail_proxy_protocol_versions },

  102.       ngx_null_command
  103. };


  106. ‌static ngx_mail_module_t  ngx_mail_proxy_module_ctx = {
  107.     NULL,                                  /* protocol */

  109.     NULL,                                  /* create main configuration */
  110.     NULL,                                  /* init main configuration */

  112.     ngx_mail_proxy_create_conf,            /* create server configuration */
  113.     ngx_mail_proxy_merge_conf              /* merge server configuration */
  114. };


  117. ‌ngx_module_t  ngx_mail_proxy_module = {
  118.     NGX_MODULE_V1,
  119.     &ngx_mail_proxy_module_ctx,            /* module context */
  120.     ngx_mail_proxy_commands,               /* module directives */
  121.     NGX_MAIL_MODULE,                       /* module type */
  122.     NULL,                                  /* init master */
  123.     NULL,                                  /* init module */
  124.     NULL,                                  /* init process */
  125.     NULL,                                  /* init thread */
  126.     NULL,                                  /* exit thread */
  127.     NULL,                                  /* exit process */
  128.     NULL,                                  /* exit master */
  129.     NGX_MODULE_V1_PADDING
  130. };


  133. ‌static u_char  smtp_auth_ok[] = "235 2.0.0 OK" CRLF;


  136. void
  137. ‌ngx_mail_proxy_init(ngx_mail_session_t *s, ngx_addr_t *peer)
  138. {
  139.     ngx_int_t                  rc;
  140.     ngx_mail_proxy_ctx_t      *p;
  141.     ngx_mail_proxy_conf_t     *pcf;
  142.     ngx_mail_core_srv_conf_t  *cscf;

  144.     s->connection->log->action = "connecting to upstream";

  146.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  148.     p = ngx_pcalloc(s->connection->pool, sizeof(ngx_mail_proxy_ctx_t));
  149.     if (p == NULL) {
  150.         ngx_mail_session_internal_server_error(s);
  151.         return;
  152.     }

  154.     s->proxy = p;

  156.     p->upstream.sockaddr = peer->sockaddr;
  157.     p->upstream.socklen = peer->socklen;
  158.     p->upstream.name = &peer->name;
  159.     p->upstream.get = ngx_event_get_peer;
  160.     p->upstream.log = s->connection->log;
  161.     p->upstream.log_error = NGX_ERROR_ERR;

  163.     rc = ngx_event_connect_peer(&p->upstream);

  165.     if (rc == NGX_ERROR || rc == NGX_BUSY || rc == NGX_DECLINED) {
  166.         ngx_mail_proxy_internal_server_error(s);
  167.         return;
  168.     }

  170.     ngx_add_timer(p->upstream.connection->read, cscf->timeout);

  172.     p->upstream.connection->data = s;
  173.     p->upstream.connection->pool = s->connection->pool;

  175.     s->connection->read->handler = ngx_mail_proxy_block_read;
  176.     p->upstream.connection->write->handler = ngx_mail_proxy_write_handler;

  178.     pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);

  180.     s->proxy->buffer = ngx_create_temp_buf(s->connection->pool,
  181.                                            pcf->buffer_size);
  182.     if (s->proxy->buffer == NULL) {
  183.         ngx_mail_proxy_internal_server_error(s);
  184.         return;
  185.     }

  187.     s->proxy->proxy_protocol = pcf->proxy_protocol;

  189.     s->out.len = 0;

  191.     switch (s->protocol) {

  193.     case NGX_MAIL_POP3_PROTOCOL:
  194.         p->upstream.connection->read->handler = ngx_mail_proxy_pop3_handler;
  195.         s->mail_state = ngx_pop3_start;
  196.         break;

  198.     case NGX_MAIL_IMAP_PROTOCOL:
  199.         p->upstream.connection->read->handler = ngx_mail_proxy_imap_handler;
  200.         s->mail_state = ngx_imap_start;
  201.         break;

  203.     default: /* NGX_MAIL_SMTP_PROTOCOL */
  204.         p->upstream.connection->read->handler = ngx_mail_proxy_smtp_handler;
  205.         s->mail_state = ngx_smtp_start;
  206.         break;
  207.     }

  209.     if (rc == NGX_AGAIN) {
  210.         return;
  211.     }

  213.     ngx_mail_proxy_write_handler(p->upstream.connection->write);
  214. }


  217. static void
  218. ‌ngx_mail_proxy_block_read(ngx_event_t *rev)
  219. {
  220.     ngx_connection_t    *c;
  221.     ngx_mail_session_t  *s;

  223.     ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0, "mail proxy block read");

  225.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  226.         c = rev->data;
  227.         s = c->data;

  229.         ngx_mail_proxy_close_session(s);
  230.     }
  231. }


  234. static void
  235. ‌ngx_mail_proxy_pop3_handler(ngx_event_t *rev)
  236. {
  237.     u_char                 *p;
  238.     ngx_int_t               rc;
  239.     ngx_str_t               line;
  240.     ngx_connection_t       *c;
  241.     ngx_mail_session_t     *s;
  242.     ngx_mail_proxy_conf_t  *pcf;

  244.     ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  245.                    "mail proxy pop3 auth handler");

  247.     c = rev->data;
  248.     s = c->data;

  250.     if (rev->timedout) {
  251.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
  252.                       "upstream timed out");
  253.         c->timedout = 1;
  254.         ngx_mail_proxy_internal_server_error(s);
  255.         return;
  256.     }

  258.     if (s->proxy->proxy_protocol) {
  259.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, c->log, 0, "mail proxy pop3 busy");

  261.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  262.             ngx_mail_proxy_internal_server_error(s);
  263.             return;
  264.         }

  266.         return;
  267.     }

  269.     rc = ngx_mail_proxy_read_response(s, 0);

  271.     if (rc == NGX_AGAIN) {
  272.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  273.             ngx_mail_proxy_internal_server_error(s);
  274.             return;
  275.         }

  277.         return;
  278.     }

  280.     if (rc == NGX_ERROR) {
  281.         ngx_mail_proxy_upstream_error(s);
  282.         return;
  283.     }

  285.     switch (s->mail_state) {

  287.     case ngx_pop3_start:
  288.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0, "mail proxy send user");

  290.         s->connection->log->action = "sending user name to upstream";

  292.         line.len = sizeof("USER ")  - 1 + s->login.len + 2;
  293.         line.data = ngx_pnalloc(c->pool, line.len);
  294.         if (line.data == NULL) {
  295.             ngx_mail_proxy_internal_server_error(s);
  296.             return;
  297.         }

  299.         p = ngx_cpymem(line.data, "USER ", sizeof("USER ") - 1);
  300.         p = ngx_cpymem(p, s->login.data, s->login.len);
  301.         *p++ = CR; *p = LF;

  303.         s->mail_state = ngx_pop3_user;
  304.         break;

  306.     case ngx_pop3_user:
  307.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0, "mail proxy send pass");

  309.         s->connection->log->action = "sending password to upstream";

  311.         line.len = sizeof("PASS ")  - 1 + s->passwd.len + 2;
  312.         line.data = ngx_pnalloc(c->pool, line.len);
  313.         if (line.data == NULL) {
  314.             ngx_mail_proxy_internal_server_error(s);
  315.             return;
  316.         }

  318.         p = ngx_cpymem(line.data, "PASS ", sizeof("PASS ") - 1);
  319.         p = ngx_cpymem(p, s->passwd.data, s->passwd.len);
  320.         *p++ = CR; *p = LF;

  322.         s->mail_state = ngx_pop3_passwd;
  323.         break;

  325.     case ngx_pop3_passwd:
  326.         s->connection->read->handler = ngx_mail_proxy_handler;
  327.         s->connection->write->handler = ngx_mail_proxy_handler;
  328.         rev->handler = ngx_mail_proxy_handler;
  329.         c->write->handler = ngx_mail_proxy_handler;

  331.         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
  332.         ngx_add_timer(s->connection->read, pcf->timeout);
  333.         ngx_del_timer(c->read);

  335.         c->log->action = NULL;
  336.         ngx_log_error(NGX_LOG_INFO, c->log, 0, "client logged in");

  338.         if (s->buffer->pos < s->buffer->last
  339.             || s->connection->read->ready)
  340.         {
  341.             ngx_post_event(c->write, &ngx_posted_events);
  342.         }

  344.         ngx_mail_proxy_handler(s->connection->write);

  346.         return;

  348.     default:
  349. #if (NGX_SUPPRESS_WARN)
  350.         ngx_str_null(&line);
  351. #endif
  352.         break;
  353.     }

  355.     if (c->send(c, line.data, line.len) < (ssize_t) line.len) {
  356.         /*
  357.          * we treat the incomplete sending as NGX_ERROR
  358.          * because it is very strange here
  359.          */
  360.         ngx_mail_proxy_internal_server_error(s);
  361.         return;
  362.     }

  364.     if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  365.         ngx_mail_proxy_internal_server_error(s);
  366.         return;
  367.     }

  369.     s->proxy->buffer->pos = s->proxy->buffer->start;
  370.     s->proxy->buffer->last = s->proxy->buffer->start;
  371. }


  374. static void
  375. ‌ngx_mail_proxy_imap_handler(ngx_event_t *rev)
  376. {
  377.     u_char                 *p;
  378.     ngx_int_t               rc;
  379.     ngx_str_t               line;
  380.     ngx_connection_t       *c;
  381.     ngx_mail_session_t     *s;
  382.     ngx_mail_proxy_conf_t  *pcf;

  384.     ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  385.                    "mail proxy imap auth handler");

  387.     c = rev->data;
  388.     s = c->data;

  390.     if (rev->timedout) {
  391.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
  392.                       "upstream timed out");
  393.         c->timedout = 1;
  394.         ngx_mail_proxy_internal_server_error(s);
  395.         return;
  396.     }

  398.     if (s->proxy->proxy_protocol) {
  399.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, c->log, 0, "mail proxy imap busy");

  401.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  402.             ngx_mail_proxy_internal_server_error(s);
  403.             return;
  404.         }

  406.         return;
  407.     }

  409.     rc = ngx_mail_proxy_read_response(s, s->mail_state);

  411.     if (rc == NGX_AGAIN) {
  412.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  413.             ngx_mail_proxy_internal_server_error(s);
  414.             return;
  415.         }

  417.         return;
  418.     }

  420.     if (rc == NGX_ERROR) {
  421.         ngx_mail_proxy_upstream_error(s);
  422.         return;
  423.     }

  425.     switch (s->mail_state) {

  427.     case ngx_imap_start:
  428.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  429.                        "mail proxy send login");

  431.         s->connection->log->action = "sending LOGIN command to upstream";

  433.         line.len = s->tag.len + sizeof("LOGIN ") - 1
  434.                    + 1 + NGX_SIZE_T_LEN + 1 + 2;
  435.         line.data = ngx_pnalloc(c->pool, line.len);
  436.         if (line.data == NULL) {
  437.             ngx_mail_proxy_internal_server_error(s);
  438.             return;
  439.         }

  441.         line.len = ngx_sprintf(line.data, "%VLOGIN {%uz}" CRLF,
  442.                                &s->tag, s->login.len)
  443.                    - line.data;

  445.         s->mail_state = ngx_imap_login;
  446.         break;

  448.     case ngx_imap_login:
  449.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0, "mail proxy send user");

  451.         s->connection->log->action = "sending user name to upstream";

  453.         line.len = s->login.len + 1 + 1 + NGX_SIZE_T_LEN + 1 + 2;
  454.         line.data = ngx_pnalloc(c->pool, line.len);
  455.         if (line.data == NULL) {
  456.             ngx_mail_proxy_internal_server_error(s);
  457.             return;
  458.         }

  460.         line.len = ngx_sprintf(line.data, "%V {%uz}" CRLF,
  461.                                &s->login, s->passwd.len)
  462.                    - line.data;

  464.         s->mail_state = ngx_imap_user;
  465.         break;

  467.     case ngx_imap_user:
  468.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  469.                        "mail proxy send passwd");

  471.         s->connection->log->action = "sending password to upstream";

  473.         line.len = s->passwd.len + 2;
  474.         line.data = ngx_pnalloc(c->pool, line.len);
  475.         if (line.data == NULL) {
  476.             ngx_mail_proxy_internal_server_error(s);
  477.             return;
  478.         }

  480.         p = ngx_cpymem(line.data, s->passwd.data, s->passwd.len);
  481.         *p++ = CR; *p = LF;

  483.         s->mail_state = ngx_imap_passwd;
  484.         break;

  486.     case ngx_imap_passwd:
  487.         s->connection->read->handler = ngx_mail_proxy_handler;
  488.         s->connection->write->handler = ngx_mail_proxy_handler;
  489.         rev->handler = ngx_mail_proxy_handler;
  490.         c->write->handler = ngx_mail_proxy_handler;

  492.         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
  493.         ngx_add_timer(s->connection->read, pcf->timeout);
  494.         ngx_del_timer(c->read);

  496.         c->log->action = NULL;
  497.         ngx_log_error(NGX_LOG_INFO, c->log, 0, "client logged in");

  499.         if (s->buffer->pos < s->buffer->last
  500.             || s->connection->read->ready)
  501.         {
  502.             ngx_post_event(c->write, &ngx_posted_events);
  503.         }

  505.         ngx_mail_proxy_handler(s->connection->write);

  507.         return;

  509.     default:
  510. #if (NGX_SUPPRESS_WARN)
  511.         ngx_str_null(&line);
  512. #endif
  513.         break;
  514.     }

  516.     if (c->send(c, line.data, line.len) < (ssize_t) line.len) {
  517.         /*
  518.          * we treat the incomplete sending as NGX_ERROR
  519.          * because it is very strange here
  520.          */
  521.         ngx_mail_proxy_internal_server_error(s);
  522.         return;
  523.     }

  525.     if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  526.         ngx_mail_proxy_internal_server_error(s);
  527.         return;
  528.     }

  530.     s->proxy->buffer->pos = s->proxy->buffer->start;
  531.     s->proxy->buffer->last = s->proxy->buffer->start;
  532. }


  535. static void
  536. ‌ngx_mail_proxy_smtp_handler(ngx_event_t *rev)
  537. {
  538.     u_char                    *p;
  539.     ngx_int_t                  rc;
  540.     ngx_str_t                  line, auth, encoded;
  541.     ngx_buf_t                 *b;
  542.     uintptr_t                  n;
  543.     ngx_connection_t          *c;
  544.     ngx_mail_session_t        *s;
  545.     ngx_mail_proxy_conf_t     *pcf;
  546.     ngx_mail_core_srv_conf_t  *cscf;

  548.     ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  549.                    "mail proxy smtp auth handler");

  551.     c = rev->data;
  552.     s = c->data;

  554.     if (rev->timedout) {
  555.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
  556.                       "upstream timed out");
  557.         c->timedout = 1;
  558.         ngx_mail_proxy_internal_server_error(s);
  559.         return;
  560.     }

  562.     if (s->proxy->proxy_protocol) {
  563.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, c->log, 0, "mail proxy smtp busy");

  565.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  566.             ngx_mail_proxy_internal_server_error(s);
  567.             return;
  568.         }

  570.         return;
  571.     }

  573.     rc = ngx_mail_proxy_read_response(s, s->mail_state);

  575.     if (rc == NGX_AGAIN) {
  576.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  577.             ngx_mail_proxy_internal_server_error(s);
  578.             return;
  579.         }

  581.         return;
  582.     }

  584.     if (rc == NGX_ERROR) {
  585.         ngx_mail_proxy_upstream_error(s);
  586.         return;
  587.     }

  589.     switch (s->mail_state) {

  591.     case ngx_smtp_start:
  592.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0, "mail proxy send ehlo");

  594.         s->connection->log->action = "sending HELO/EHLO to upstream";

  596.         cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  598.         line.len = sizeof("HELO ")  - 1 + cscf->server_name.len + 2;
  599.         line.data = ngx_pnalloc(c->pool, line.len);
  600.         if (line.data == NULL) {
  601.             ngx_mail_proxy_internal_server_error(s);
  602.             return;
  603.         }

  605.         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);

  607.         p = ngx_cpymem(line.data,
  608.                        ((s->esmtp || pcf->xclient) ? "EHLO " : "HELO "),
  609.                        sizeof("HELO ") - 1);

  611.         p = ngx_cpymem(p, cscf->server_name.data, cscf->server_name.len);
  612.         *p++ = CR; *p = LF;

  614.         if (pcf->xclient) {
  615.             s->mail_state = ngx_smtp_helo_xclient;

  617.         } else if (s->auth_method == NGX_MAIL_AUTH_NONE) {
  618.             s->mail_state = ngx_smtp_helo_from;

  620.         } else if (pcf->smtp_auth) {
  621.             s->mail_state = ngx_smtp_helo_auth;

  623.         } else {
  624.             s->mail_state = ngx_smtp_helo;
  625.         }

  627.         break;

  629.     case ngx_smtp_helo_xclient:
  630.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  631.                        "mail proxy send xclient");

  633.         s->connection->log->action = "sending XCLIENT to upstream";

  635.         line.len = sizeof("XCLIENT ADDR= LOGIN= NAME="
  636.                           CRLF) - 1
  637.                    + s->connection->addr_text.len + s->login.len + s->host.len;

  639.         n = ngx_escape_uri(NULL, s->login.data, s->login.len,
  640.                            NGX_ESCAPE_MAIL_XTEXT);
  641.         line.len += n * 2;

  643. #if (NGX_HAVE_INET6)
  644.         if (s->connection->sockaddr->sa_family == AF_INET6) {
  645.             line.len += sizeof("IPV6:") - 1;
  646.         }
  647. #endif

  649.         line.data = ngx_pnalloc(c->pool, line.len);
  650.         if (line.data == NULL) {
  651.             ngx_mail_proxy_internal_server_error(s);
  652.             return;
  653.         }

  655.         p = ngx_cpymem(line.data, "XCLIENT ADDR=", sizeof("XCLIENT ADDR=") - 1);

  657. #if (NGX_HAVE_INET6)
  658.         if (s->connection->sockaddr->sa_family == AF_INET6) {
  659.             p = ngx_cpymem(p, "IPV6:", sizeof("IPV6:") - 1);
  660.         }
  661. #endif

  663.         p = ngx_copy(p, s->connection->addr_text.data,
  664.                      s->connection->addr_text.len);

  666.         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);

  668.         if (s->login.len && !pcf->smtp_auth) {
  669.             p = ngx_cpymem(p, " LOGIN=", sizeof(" LOGIN=") - 1);

  671.             if (n == 0) {
  672.                 p = ngx_copy(p, s->login.data, s->login.len);

  674.             } else {
  675.                 p = (u_char *) ngx_escape_uri(p, s->login.data, s->login.len,
  676.                                               NGX_ESCAPE_MAIL_XTEXT);
  677.             }
  678.         }

  680.         p = ngx_cpymem(p, " NAME=", sizeof(" NAME=") - 1);
  681.         p = ngx_copy(p, s->host.data, s->host.len);

  683.         *p++ = CR; *p++ = LF;

  685.         line.len = p - line.data;

  687.         if (s->smtp_helo.len) {
  688.             s->mail_state = ngx_smtp_xclient_helo;

  690.         } else if (s->auth_method == NGX_MAIL_AUTH_NONE) {
  691.             s->mail_state = ngx_smtp_xclient_from;

  693.         } else if (pcf->smtp_auth) {
  694.             s->mail_state = ngx_smtp_xclient_auth;

  696.         } else {
  697.             s->mail_state = ngx_smtp_xclient;
  698.         }

  700.         break;

  702.     case ngx_smtp_xclient_helo:
  703.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  704.                        "mail proxy send client ehlo");

  706.         s->connection->log->action = "sending client HELO/EHLO to upstream";

  708.         line.len = sizeof("HELO " CRLF) - 1 + s->smtp_helo.len;

  710.         line.data = ngx_pnalloc(c->pool, line.len);
  711.         if (line.data == NULL) {
  712.             ngx_mail_proxy_internal_server_error(s);
  713.             return;
  714.         }

  716.         line.len = ngx_sprintf(line.data,
  717.                        ((s->esmtp) ? "EHLO %V" CRLF : "HELO %V" CRLF),
  718.                        &s->smtp_helo)
  719.                    - line.data;

  721.         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);

  723.         if (s->auth_method == NGX_MAIL_AUTH_NONE) {
  724.             s->mail_state = ngx_smtp_helo_from;

  726.         } else if (pcf->smtp_auth) {
  727.             s->mail_state = ngx_smtp_helo_auth;

  729.         } else {
  730.             s->mail_state = ngx_smtp_helo;
  731.         }

  733.         break;

  735.     case ngx_smtp_helo_auth:
  736.     case ngx_smtp_xclient_auth:
  737.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  738.                        "mail proxy send auth");

  740.         s->connection->log->action = "sending AUTH to upstream";

  742.         if (s->passwd.data == NULL) {
  743.             ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  744.                           "no password available");
  745.             ngx_mail_proxy_internal_server_error(s);
  746.             return;
  747.         }

  749.         auth.len = 1 + s->login.len + 1 + s->passwd.len;
  750.         auth.data = ngx_pnalloc(c->pool, auth.len);
  751.         if (auth.data == NULL) {
  752.             ngx_mail_proxy_internal_server_error(s);
  753.             return;
  754.         }

  756.         auth.len = ngx_sprintf(auth.data, "%Z%V%Z%V", &s->login, &s->passwd)
  757.                    - auth.data;

  759.         line.len = sizeof("AUTH PLAIN " CRLF) - 1
  760.                    + ngx_base64_encoded_length(auth.len);

  762.         line.data = ngx_pnalloc(c->pool, line.len);
  763.         if (line.data == NULL) {
  764.             ngx_mail_proxy_internal_server_error(s);
  765.             return;
  766.         }

  768.         encoded.data = ngx_cpymem(line.data, "AUTH PLAIN ",
  769.                                   sizeof("AUTH PLAIN ") - 1);

  771.         ngx_encode_base64(&encoded, &auth);

  773.         p = encoded.data + encoded.len;
  774.         *p++ = CR; *p = LF;

  776.         s->mail_state = ngx_smtp_auth_plain;

  778.         break;

  780.     case ngx_smtp_helo_from:
  781.     case ngx_smtp_xclient_from:
  782.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  783.                        "mail proxy send mail from");

  785.         s->connection->log->action = "sending MAIL FROM to upstream";

  787.         line.len = s->smtp_from.len + sizeof(CRLF) - 1;
  788.         line.data = ngx_pnalloc(c->pool, line.len);
  789.         if (line.data == NULL) {
  790.             ngx_mail_proxy_internal_server_error(s);
  791.             return;
  792.         }

  794.         p = ngx_cpymem(line.data, s->smtp_from.data, s->smtp_from.len);
  795.         *p++ = CR; *p = LF;

  797.         s->mail_state = ngx_smtp_from;

  799.         break;

  801.     case ngx_smtp_from:
  802.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  803.                        "mail proxy send rcpt to");

  805.         s->connection->log->action = "sending RCPT TO to upstream";

  807.         line.len = s->smtp_to.len + sizeof(CRLF) - 1;
  808.         line.data = ngx_pnalloc(c->pool, line.len);
  809.         if (line.data == NULL) {
  810.             ngx_mail_proxy_internal_server_error(s);
  811.             return;
  812.         }

  814.         p = ngx_cpymem(line.data, s->smtp_to.data, s->smtp_to.len);
  815.         *p++ = CR; *p = LF;

  817.         s->mail_state = ngx_smtp_to;

  819.         break;

  821.     case ngx_smtp_helo:
  822.     case ngx_smtp_xclient:
  823.     case ngx_smtp_auth_plain:
  824.     case ngx_smtp_to:

  826.         b = s->proxy->buffer;

  828.         if (s->auth_method == NGX_MAIL_AUTH_NONE) {
  829.             b->pos = b->start;

  831.         } else {
  832.             ngx_memcpy(b->start, smtp_auth_ok, sizeof(smtp_auth_ok) - 1);
  833.             b->last = b->start + sizeof(smtp_auth_ok) - 1;
  834.         }

  836.         s->connection->read->handler = ngx_mail_proxy_handler;
  837.         s->connection->write->handler = ngx_mail_proxy_handler;
  838.         rev->handler = ngx_mail_proxy_handler;
  839.         c->write->handler = ngx_mail_proxy_handler;

  841.         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
  842.         ngx_add_timer(s->connection->read, pcf->timeout);
  843.         ngx_del_timer(c->read);

  845.         c->log->action = NULL;
  846.         ngx_log_error(NGX_LOG_INFO, c->log, 0, "client logged in");

  848.         if (s->buffer->pos < s->buffer->last
  849.             || s->connection->read->ready)
  850.         {
  851.             ngx_post_event(c->write, &ngx_posted_events);
  852.         }

  854.         ngx_mail_proxy_handler(s->connection->write);

  856.         return;

  858.     default:
  859. #if (NGX_SUPPRESS_WARN)
  860.         ngx_str_null(&line);
  861. #endif
  862.         break;
  863.     }

  865.     if (c->send(c, line.data, line.len) < (ssize_t) line.len) {
  866.         /*
  867.          * we treat the incomplete sending as NGX_ERROR
  868.          * because it is very strange here
  869.          */
  870.         ngx_mail_proxy_internal_server_error(s);
  871.         return;
  872.     }

  874.     if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  875.         ngx_mail_proxy_internal_server_error(s);
  876.         return;
  877.     }

  879.     s->proxy->buffer->pos = s->proxy->buffer->start;
  880.     s->proxy->buffer->last = s->proxy->buffer->start;
  881. }


  884. static void
  885. ‌ngx_mail_proxy_write_handler(ngx_event_t *wev)
  886. {
  887.     ngx_connection_t    *c;
  888.     ngx_mail_session_t  *s;

  890.     ngx_log_debug0(NGX_LOG_DEBUG_MAIL, wev->log, 0, "mail proxy write handler");

  892.     c = wev->data;
  893.     s = c->data;

  895.     if (s->proxy->proxy_protocol) {
  896.         if (ngx_mail_proxy_send_proxy_protocol(s) != NGX_OK) {
  897.             return;
  898.         }

  900.         s->proxy->proxy_protocol = 0;
  901.     }

  903.     if (ngx_handle_write_event(wev, 0) != NGX_OK) {
  904.         ngx_mail_proxy_internal_server_error(s);
  905.         return;
  906.     }

  908.     if (c->read->ready) {
  909.         ngx_post_event(c->read, &ngx_posted_events);
  910.     }
  911. }


  914. static ngx_int_t
  915. ‌ngx_mail_proxy_send_proxy_protocol(ngx_mail_session_t *s)
  916. {
  917.     u_char            *p;
  918.     size_t             size;
  919.     ssize_t            n;
  920.     ngx_connection_t  *c;
  921.     static u_char      buf[NGX_PROXY_PROTOCOL_MAX_HEADER];

  923.     s->connection->log->action = "sending PROXY protocol header to upstream";

  925.     ngx_log_debug0(NGX_LOG_DEBUG_MAIL, s->connection->log, 0,
  926.                    "mail proxy send PROXY protocol header");

  928.     if (s->proxy->proxy_protocol == 2) {
  929.         p = ngx_proxy_protocol_v2_write(s->connection, buf,
  930.                                         buf + sizeof(buf), NULL);

  932.     } else {
  933.         p = ngx_proxy_protocol_write(s->connection, buf,
  934.                                      buf + sizeof(buf));
  935.     }

  937.     if (p == NULL) {
  938.         ngx_mail_proxy_internal_server_error(s);
  939.         return NGX_ERROR;
  940.     }

  942.     c = s->proxy->upstream.connection;

  944.     size = p - buf;

  946.     n = c->send(c, buf, size);

  948.     if (n == NGX_AGAIN) {
  949.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  950.             ngx_mail_proxy_internal_server_error(s);
  951.             return NGX_ERROR;
  952.         }

  954.         return NGX_AGAIN;
  955.     }

  957.     if (n == NGX_ERROR) {
  958.         ngx_mail_proxy_internal_server_error(s);
  959.         return NGX_ERROR;
  960.     }

  962.     if (n != (ssize_t) size) {

  964.         /*
  965.          * PROXY protocol specification:
  966.          * The sender must always ensure that the header
  967.          * is sent at once, so that the transport layer
  968.          * maintains atomicity along the path to the receiver.
  969.          */

  971.         ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  972.                       "could not send PROXY protocol header at once");

  974.         ngx_mail_proxy_internal_server_error(s);

  976.         return NGX_ERROR;
  977.     }

  979.     return NGX_OK;
  980. }


  983. static ngx_int_t
  984. ‌ngx_mail_proxy_read_response(ngx_mail_session_t *s, ngx_uint_t state)
  985. {
  986.     u_char                 *p, *m;
  987.     ssize_t                 n;
  988.     ngx_buf_t              *b;
  989.     ngx_mail_proxy_conf_t  *pcf;

  991.     s->connection->log->action = "reading response from upstream";

  993.     b = s->proxy->buffer;

  995.     n = s->proxy->upstream.connection->recv(s->proxy->upstream.connection,
  996.                                             b->last, b->end - b->last);

  998.     if (n == NGX_ERROR || n == 0) {
  999.         return NGX_ERROR;
  1000.     }

  1002.     if (n == NGX_AGAIN) {
  1003.         return NGX_AGAIN;
  1004.     }

  1006.     b->last += n;

  1008.     if (b->last - b->pos < 4) {
  1009.         return NGX_AGAIN;
  1010.     }

  1012.     if (*(b->last - 2) != CR || *(b->last - 1) != LF) {
  1013.         if (b->last == b->end) {
  1014.             *(b->last - 1) = '\0';
  1015.             ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  1016.                           "upstream sent too long response line: \"%s\"",
  1017.                           b->pos);
  1018.             return NGX_ERROR;
  1019.         }

  1021.         return NGX_AGAIN;
  1022.     }

  1024.     p = b->pos;

  1026.     switch (s->protocol) {

  1028.     case NGX_MAIL_POP3_PROTOCOL:
  1029.         if (p[0] == '+' && p[1] == 'O' && p[2] == 'K') {
  1030.             return NGX_OK;
  1031.         }
  1032.         break;

  1034.     case NGX_MAIL_IMAP_PROTOCOL:
  1035.         switch (state) {

  1037.         case ngx_imap_start:
  1038.             if (p[0] == '*' && p[1] == ' ' && p[2] == 'O' && p[3] == 'K') {
  1039.                 return NGX_OK;
  1040.             }
  1041.             break;

  1043.         case ngx_imap_login:
  1044.         case ngx_imap_user:
  1045.             if (p[0] == '+') {
  1046.                 return NGX_OK;
  1047.             }
  1048.             break;

  1050.         case ngx_imap_passwd:

  1052.             /*
  1053.              * untagged CAPABILITY response (draft-crispin-imapv-16),
  1054.              * known to be sent by SmarterMail and Gmail
  1055.              */

  1057.             if (p[0] == '*' && p[1] == ' ') {
  1058.                 p += 2;

  1060.                 while (p < b->last - 1) {
  1061.                     if (p[0] == CR && p[1] == LF) {
  1062.                         p += 2;
  1063.                         break;
  1064.                     }

  1066.                     p++;
  1067.                 }

  1069.                 if (b->last - p < 4) {
  1070.                     return NGX_AGAIN;
  1071.                 }
  1072.             }

  1074.             if (ngx_strncmp(p, s->tag.data, s->tag.len) == 0) {
  1075.                 p += s->tag.len;
  1076.                 if (p[0] == 'O' && p[1] == 'K') {
  1077.                     return NGX_OK;
  1078.                 }
  1079.             }

  1081.             break;
  1082.         }

  1084.         break;

  1086.     default: /* NGX_MAIL_SMTP_PROTOCOL */

  1088.         if (p[3] == '-') {
  1089.             /* multiline reply, check if we got last line */

  1091.             m = b->last - (sizeof(CRLF "200" CRLF) - 1);

  1093.             while (m > p) {
  1094.                 if (m[0] == CR && m[1] == LF) {
  1095.                     break;
  1096.                 }

  1098.                 m--;
  1099.             }

  1101.             if (m <= p || m[5] == '-') {
  1102.                 return NGX_AGAIN;
  1103.             }
  1104.         }

  1106.         switch (state) {

  1108.         case ngx_smtp_start:
  1109.             if (p[0] == '2' && p[1] == '2' && p[2] == '0') {
  1110.                 return NGX_OK;
  1111.             }
  1112.             break;

  1114.         case ngx_smtp_helo:
  1115.         case ngx_smtp_helo_xclient:
  1116.         case ngx_smtp_helo_from:
  1117.         case ngx_smtp_helo_auth:
  1118.         case ngx_smtp_from:
  1119.             if (p[0] == '2' && p[1] == '5' && p[2] == '0') {
  1120.                 return NGX_OK;
  1121.             }
  1122.             break;

  1124.         case ngx_smtp_xclient:
  1125.         case ngx_smtp_xclient_from:
  1126.         case ngx_smtp_xclient_helo:
  1127.         case ngx_smtp_xclient_auth:
  1128.             if (p[0] == '2' && (p[1] == '2' || p[1] == '5') && p[2] == '0') {
  1129.                 return NGX_OK;
  1130.             }
  1131.             break;

  1133.         case ngx_smtp_auth_plain:
  1134.             if (p[0] == '2' && p[1] == '3' && p[2] == '5') {
  1135.                 return NGX_OK;
  1136.             }
  1137.             break;

  1139.         case ngx_smtp_to:
  1140.             return NGX_OK;
  1141.         }

  1143.         break;
  1144.     }

  1146.     pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);

  1148.     if (pcf->pass_error_message == 0) {
  1149.         *(b->last - 2) = '\0';
  1150.         ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  1151.                       "upstream sent invalid response: \"%s\"", p);
  1152.         return NGX_ERROR;
  1153.     }

  1155.     s->out.len = b->last - p - 2;
  1156.     s->out.data = p;

  1158.     ngx_log_error(NGX_LOG_INFO, s->connection->log, 0,
  1159.                   "upstream sent invalid response: \"%V\"", &s->out);

  1161.     s->out.len = b->last - b->pos;
  1162.     s->out.data = b->pos;

  1164.     return NGX_ERROR;
  1165. }


  1168. static void
  1169. ‌ngx_mail_proxy_handler(ngx_event_t *ev)
  1170. {
  1171.     char                   *action, *recv_action, *send_action;
  1172.     size_t                  size;
  1173.     ssize_t                 n;
  1174.     ngx_buf_t              *b;
  1175.     ngx_uint_t              do_write;
  1176.     ngx_connection_t       *c, *src, *dst;
  1177.     ngx_mail_session_t     *s;
  1178.     ngx_mail_proxy_conf_t  *pcf;

  1180.     c = ev->data;
  1181.     s = c->data;

  1183.     if (ev->timedout || c->close) {
  1184.         c->log->action = "proxying";

  1186.         if (c->close) {
  1187.             ngx_log_error(NGX_LOG_INFO, c->log, 0, "shutdown timeout");

  1189.         } else if (c == s->connection) {
  1190.             ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
  1191.                           "client timed out");
  1192.             c->timedout = 1;

  1194.         } else {
  1195.             ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
  1196.                           "upstream timed out");
  1197.         }

  1199.         ngx_mail_proxy_close_session(s);
  1200.         return;
  1201.     }

  1203.     if (c == s->connection) {
  1204.         if (ev->write) {
  1205.             recv_action = "proxying and reading from upstream";
  1206.             send_action = "proxying and sending to client";
  1207.             src = s->proxy->upstream.connection;
  1208.             dst = c;
  1209.             b = s->proxy->buffer;

  1211.         } else {
  1212.             recv_action = "proxying and reading from client";
  1213.             send_action = "proxying and sending to upstream";
  1214.             src = c;
  1215.             dst = s->proxy->upstream.connection;
  1216.             b = s->buffer;
  1217.         }

  1219.     } else {
  1220.         if (ev->write) {
  1221.             recv_action = "proxying and reading from client";
  1222.             send_action = "proxying and sending to upstream";
  1223.             src = s->connection;
  1224.             dst = c;
  1225.             b = s->buffer;

  1227.         } else {
  1228.             recv_action = "proxying and reading from upstream";
  1229.             send_action = "proxying and sending to client";
  1230.             src = c;
  1231.             dst = s->connection;
  1232.             b = s->proxy->buffer;
  1233.         }
  1234.     }

  1236.     do_write = ev->write ? 1 : 0;

  1238.     ngx_log_debug3(NGX_LOG_DEBUG_MAIL, ev->log, 0,
  1239.                    "mail proxy handler: %ui, #%d > #%d",
  1240.                    do_write, src->fd, dst->fd);

  1242.     for ( ;; ) {

  1244.         if (do_write) {

  1246.             size = b->last - b->pos;

  1248.             if (size && dst->write->ready) {
  1249.                 c->log->action = send_action;

  1251.                 n = dst->send(dst, b->pos, size);

  1253.                 if (n == NGX_ERROR) {
  1254.                     ngx_mail_proxy_close_session(s);
  1255.                     return;
  1256.                 }

  1258.                 if (n > 0) {
  1259.                     b->pos += n;

  1261.                     if (b->pos == b->last) {
  1262.                         b->pos = b->start;
  1263.                         b->last = b->start;
  1264.                     }
  1265.                 }
  1266.             }
  1267.         }

  1269.         size = b->end - b->last;

  1271.         if (size && src->read->ready) {
  1272.             c->log->action = recv_action;

  1274.             n = src->recv(src, b->last, size);

  1276.             if (n == NGX_AGAIN || n == 0) {
  1277.                 break;
  1278.             }

  1280.             if (n > 0) {
  1281.                 do_write = 1;
  1282.                 b->last += n;

  1284.                 continue;
  1285.             }

  1287.             if (n == NGX_ERROR) {
  1288.                 src->read->eof = 1;
  1289.             }
  1290.         }

  1292.         break;
  1293.     }

  1295.     c->log->action = "proxying";

  1297.     if ((s->connection->read->eof && s->buffer->pos == s->buffer->last)
  1298.         || (s->proxy->upstream.connection->read->eof
  1299.             && s->proxy->buffer->pos == s->proxy->buffer->last)
  1300.         || (s->connection->read->eof
  1301.             && s->proxy->upstream.connection->read->eof))
  1302.     {
  1303.         action = c->log->action;
  1304.         c->log->action = NULL;
  1305.         ngx_log_error(NGX_LOG_INFO, c->log, 0, "proxied session done");
  1306.         c->log->action = action;

  1308.         ngx_mail_proxy_close_session(s);
  1309.         return;
  1310.     }

  1312.     if (ngx_handle_write_event(dst->write, 0) != NGX_OK) {
  1313.         ngx_mail_proxy_close_session(s);
  1314.         return;
  1315.     }

  1317.     if (ngx_handle_read_event(dst->read, 0) != NGX_OK) {
  1318.         ngx_mail_proxy_close_session(s);
  1319.         return;
  1320.     }

  1322.     if (ngx_handle_write_event(src->write, 0) != NGX_OK) {
  1323.         ngx_mail_proxy_close_session(s);
  1324.         return;
  1325.     }

  1327.     if (ngx_handle_read_event(src->read, 0) != NGX_OK) {
  1328.         ngx_mail_proxy_close_session(s);
  1329.         return;
  1330.     }

  1332.     if (c == s->connection) {
  1333.         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
  1334.         ngx_add_timer(c->read, pcf->timeout);
  1335.     }
  1336. }


  1339. static void
  1340. ‌ngx_mail_proxy_upstream_error(ngx_mail_session_t *s)
  1341. {
  1342.     if (s->proxy->upstream.connection) {
  1343.         ngx_log_debug1(NGX_LOG_DEBUG_MAIL, s->connection->log, 0,
  1344.                        "close mail proxy connection: %d",
  1345.                        s->proxy->upstream.connection->fd);

  1347.         ngx_close_connection(s->proxy->upstream.connection);
  1348.     }

  1350.     if (s->out.len == 0) {
  1351.         ngx_mail_session_internal_server_error(s);
  1352.         return;
  1353.     }

  1355.     s->quit = 1;
  1356.     ngx_mail_send(s->connection->write);
  1357. }


  1360. static void
  1361. ‌ngx_mail_proxy_internal_server_error(ngx_mail_session_t *s)
  1362. {
  1363.     if (s->proxy->upstream.connection) {
  1364.         ngx_log_debug1(NGX_LOG_DEBUG_MAIL, s->connection->log, 0,
  1365.                        "close mail proxy connection: %d",
  1366.                        s->proxy->upstream.connection->fd);

  1368.         ngx_close_connection(s->proxy->upstream.connection);
  1369.     }

  1371.     ngx_mail_session_internal_server_error(s);
  1372. }


  1375. static void
  1376. ‌ngx_mail_proxy_close_session(ngx_mail_session_t *s)
  1377. {
  1378.     if (s->proxy->upstream.connection) {
  1379.         ngx_log_debug1(NGX_LOG_DEBUG_MAIL, s->connection->log, 0,
  1380.                        "close mail proxy connection: %d",
  1381.                        s->proxy->upstream.connection->fd);

  1383.         ngx_close_connection(s->proxy->upstream.connection);
  1384.     }

  1386.     ngx_mail_close_connection(s->connection);
  1387. }


  1390. static void *
  1391. ‌ngx_mail_proxy_create_conf(ngx_conf_t *cf)
  1392. {
  1393.     ngx_mail_proxy_conf_t  *pcf;

  1395.     pcf = ngx_pcalloc(cf->pool, sizeof(ngx_mail_proxy_conf_t));
  1396.     if (pcf == NULL) {
  1397.         return NULL;
  1398.     }

  1400.     pcf->enable = NGX_CONF_UNSET;
  1401.     pcf->pass_error_message = NGX_CONF_UNSET;
  1402.     pcf->xclient = NGX_CONF_UNSET;
  1403.     pcf->smtp_auth = NGX_CONF_UNSET;
  1404.     pcf->proxy_protocol = NGX_CONF_UNSET_UINT;
  1405.     pcf->buffer_size = NGX_CONF_UNSET_SIZE;
  1406.     pcf->timeout = NGX_CONF_UNSET_MSEC;

  1408.     return pcf;
  1409. }


  1412. static char *
  1413. ‌ngx_mail_proxy_merge_conf(ngx_conf_t *cf, void *parent, void *child)
  1414. {
  1415.     ngx_mail_proxy_conf_t *prev = parent;
  1416.     ngx_mail_proxy_conf_t *conf = child;

  1418.     ngx_conf_merge_value(conf->enable, prev->enable, 0);
  1419.     ngx_conf_merge_value(conf->pass_error_message, prev->pass_error_message, 0);
  1420.     ngx_conf_merge_value(conf->xclient, prev->xclient, 1);
  1421.     ngx_conf_merge_value(conf->smtp_auth, prev->smtp_auth, 0);
  1422.     ngx_conf_merge_uint_value(conf->proxy_protocol, prev->proxy_protocol, 0);
  1423.     ngx_conf_merge_size_value(conf->buffer_size, prev->buffer_size,
  1424.                               (size_t) ngx_pagesize);
  1425.     ngx_conf_merge_msec_value(conf->timeout, prev->timeout, 24 * 60 * 60000);

  1427.     return NGX_CONF_OK;
  1428. }

One Level Up Top Level