One Level Up Top Level

src/mail/ngx_mail_proxy_module.c - nginx source code

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_flag_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_command_t  ngx_mail_proxy_commands[] = {

  45.     { ngx_string("proxy"),
  46.       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_FLAG,
  47.       ngx_conf_set_flag_slot,
  48.       NGX_MAIL_SRV_CONF_OFFSET,
  49.       offsetof(ngx_mail_proxy_conf_t, enable),
  50.       NULL },

  52.     { ngx_string("proxy_buffer"),
  53.       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_TAKE1,
  54.       ngx_conf_set_size_slot,
  55.       NGX_MAIL_SRV_CONF_OFFSET,
  56.       offsetof(ngx_mail_proxy_conf_t, buffer_size),
  57.       NULL },

  59.     { ngx_string("proxy_timeout"),
  60.       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_TAKE1,
  61.       ngx_conf_set_msec_slot,
  62.       NGX_MAIL_SRV_CONF_OFFSET,
  63.       offsetof(ngx_mail_proxy_conf_t, timeout),
  64.       NULL },

  66.     { ngx_string("proxy_pass_error_message"),
  67.       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_FLAG,
  68.       ngx_conf_set_flag_slot,
  69.       NGX_MAIL_SRV_CONF_OFFSET,
  70.       offsetof(ngx_mail_proxy_conf_t, pass_error_message),
  71.       NULL },

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

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

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

  94.       ngx_null_command
  95. };


  98. ‌static ngx_mail_module_t  ngx_mail_proxy_module_ctx = {
  99.     NULL,                                  /* protocol */

  101.     NULL,                                  /* create main configuration */
  102.     NULL,                                  /* init main configuration */

  104.     ngx_mail_proxy_create_conf,            /* create server configuration */
  105.     ngx_mail_proxy_merge_conf              /* merge server configuration */
  106. };


  109. ‌ngx_module_t  ngx_mail_proxy_module = {
  110.     NGX_MODULE_V1,
  111.     &ngx_mail_proxy_module_ctx,            /* module context */
  112.     ngx_mail_proxy_commands,               /* module directives */
  113.     NGX_MAIL_MODULE,                       /* module type */
  114.     NULL,                                  /* init master */
  115.     NULL,                                  /* init module */
  116.     NULL,                                  /* init process */
  117.     NULL,                                  /* init thread */
  118.     NULL,                                  /* exit thread */
  119.     NULL,                                  /* exit process */
  120.     NULL,                                  /* exit master */
  121.     NGX_MODULE_V1_PADDING
  122. };


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


  128. void
  129. ‌ngx_mail_proxy_init(ngx_mail_session_t *s, ngx_addr_t *peer)
  130. {
  131.     ngx_int_t                  rc;
  132.     ngx_mail_proxy_ctx_t      *p;
  133.     ngx_mail_proxy_conf_t     *pcf;
  134.     ngx_mail_core_srv_conf_t  *cscf;

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

  138.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  140.     p = ngx_pcalloc(s->connection->pool, sizeof(ngx_mail_proxy_ctx_t));
  141.     if (p == NULL) {
  142.         ngx_mail_session_internal_server_error(s);
  143.         return;
  144.     }

  146.     s->proxy = p;

  148.     p->upstream.sockaddr = peer->sockaddr;
  149.     p->upstream.socklen = peer->socklen;
  150.     p->upstream.name = &peer->name;
  151.     p->upstream.get = ngx_event_get_peer;
  152.     p->upstream.log = s->connection->log;
  153.     p->upstream.log_error = NGX_ERROR_ERR;

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

  157.     if (rc == NGX_ERROR || rc == NGX_BUSY || rc == NGX_DECLINED) {
  158.         ngx_mail_proxy_internal_server_error(s);
  159.         return;
  160.     }

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

  164.     p->upstream.connection->data = s;
  165.     p->upstream.connection->pool = s->connection->pool;

  167.     s->connection->read->handler = ngx_mail_proxy_block_read;
  168.     p->upstream.connection->write->handler = ngx_mail_proxy_write_handler;

  170.     pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);

  172.     s->proxy->buffer = ngx_create_temp_buf(s->connection->pool,
  173.                                            pcf->buffer_size);
  174.     if (s->proxy->buffer == NULL) {
  175.         ngx_mail_proxy_internal_server_error(s);
  176.         return;
  177.     }

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

  181.     s->out.len = 0;

  183.     switch (s->protocol) {

  185.     case NGX_MAIL_POP3_PROTOCOL:
  186.         p->upstream.connection->read->handler = ngx_mail_proxy_pop3_handler;
  187.         s->mail_state = ngx_pop3_start;
  188.         break;

  190.     case NGX_MAIL_IMAP_PROTOCOL:
  191.         p->upstream.connection->read->handler = ngx_mail_proxy_imap_handler;
  192.         s->mail_state = ngx_imap_start;
  193.         break;

  195.     default: /* NGX_MAIL_SMTP_PROTOCOL */
  196.         p->upstream.connection->read->handler = ngx_mail_proxy_smtp_handler;
  197.         s->mail_state = ngx_smtp_start;
  198.         break;
  199.     }

  201.     if (rc == NGX_AGAIN) {
  202.         return;
  203.     }

  205.     ngx_mail_proxy_write_handler(p->upstream.connection->write);
  206. }


  209. static void
  210. ‌ngx_mail_proxy_block_read(ngx_event_t *rev)
  211. {
  212.     ngx_connection_t    *c;
  213.     ngx_mail_session_t  *s;

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

  217.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  218.         c = rev->data;
  219.         s = c->data;

  221.         ngx_mail_proxy_close_session(s);
  222.     }
  223. }


  226. static void
  227. ‌ngx_mail_proxy_pop3_handler(ngx_event_t *rev)
  228. {
  229.     u_char                 *p;
  230.     ngx_int_t               rc;
  231.     ngx_str_t               line;
  232.     ngx_connection_t       *c;
  233.     ngx_mail_session_t     *s;
  234.     ngx_mail_proxy_conf_t  *pcf;

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

  239.     c = rev->data;
  240.     s = c->data;

  242.     if (rev->timedout) {
  243.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
  244.                       "upstream timed out");
  245.         c->timedout = 1;
  246.         ngx_mail_proxy_internal_server_error(s);
  247.         return;
  248.     }

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

  253.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  254.             ngx_mail_proxy_internal_server_error(s);
  255.             return;
  256.         }

  258.         return;
  259.     }

  261.     rc = ngx_mail_proxy_read_response(s, 0);

  263.     if (rc == NGX_AGAIN) {
  264.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  265.             ngx_mail_proxy_internal_server_error(s);
  266.             return;
  267.         }

  269.         return;
  270.     }

  272.     if (rc == NGX_ERROR) {
  273.         ngx_mail_proxy_upstream_error(s);
  274.         return;
  275.     }

  277.     switch (s->mail_state) {

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

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

  284.         line.len = sizeof("USER ")  - 1 + s->login.len + 2;
  285.         line.data = ngx_pnalloc(c->pool, line.len);
  286.         if (line.data == NULL) {
  287.             ngx_mail_proxy_internal_server_error(s);
  288.             return;
  289.         }

  291.         p = ngx_cpymem(line.data, "USER ", sizeof("USER ") - 1);
  292.         p = ngx_cpymem(p, s->login.data, s->login.len);
  293.         *p++ = CR; *p = LF;

  295.         s->mail_state = ngx_pop3_user;
  296.         break;

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

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

  303.         line.len = sizeof("PASS ")  - 1 + s->passwd.len + 2;
  304.         line.data = ngx_pnalloc(c->pool, line.len);
  305.         if (line.data == NULL) {
  306.             ngx_mail_proxy_internal_server_error(s);
  307.             return;
  308.         }

  310.         p = ngx_cpymem(line.data, "PASS ", sizeof("PASS ") - 1);
  311.         p = ngx_cpymem(p, s->passwd.data, s->passwd.len);
  312.         *p++ = CR; *p = LF;

  314.         s->mail_state = ngx_pop3_passwd;
  315.         break;

  317.     case ngx_pop3_passwd:
  318.         s->connection->read->handler = ngx_mail_proxy_handler;
  319.         s->connection->write->handler = ngx_mail_proxy_handler;
  320.         rev->handler = ngx_mail_proxy_handler;
  321.         c->write->handler = ngx_mail_proxy_handler;

  323.         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
  324.         ngx_add_timer(s->connection->read, pcf->timeout);
  325.         ngx_del_timer(c->read);

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

  330.         if (s->buffer->pos < s->buffer->last
  331.             || s->connection->read->ready)
  332.         {
  333.             ngx_post_event(c->write, &ngx_posted_events);
  334.         }

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

  338.         return;

  340.     default:
  341. #if (NGX_SUPPRESS_WARN)
  342.         ngx_str_null(&line);
  343. #endif
  344.         break;
  345.     }

  347.     if (c->send(c, line.data, line.len) < (ssize_t) line.len) {
  348.         /*
  349.          * we treat the incomplete sending as NGX_ERROR
  350.          * because it is very strange here
  351.          */
  352.         ngx_mail_proxy_internal_server_error(s);
  353.         return;
  354.     }

  356.     if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  357.         ngx_mail_proxy_internal_server_error(s);
  358.         return;
  359.     }

  361.     s->proxy->buffer->pos = s->proxy->buffer->start;
  362.     s->proxy->buffer->last = s->proxy->buffer->start;
  363. }


  366. static void
  367. ‌ngx_mail_proxy_imap_handler(ngx_event_t *rev)
  368. {
  369.     u_char                 *p;
  370.     ngx_int_t               rc;
  371.     ngx_str_t               line;
  372.     ngx_connection_t       *c;
  373.     ngx_mail_session_t     *s;
  374.     ngx_mail_proxy_conf_t  *pcf;

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

  379.     c = rev->data;
  380.     s = c->data;

  382.     if (rev->timedout) {
  383.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
  384.                       "upstream timed out");
  385.         c->timedout = 1;
  386.         ngx_mail_proxy_internal_server_error(s);
  387.         return;
  388.     }

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

  393.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  394.             ngx_mail_proxy_internal_server_error(s);
  395.             return;
  396.         }

  398.         return;
  399.     }

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

  403.     if (rc == NGX_AGAIN) {
  404.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  405.             ngx_mail_proxy_internal_server_error(s);
  406.             return;
  407.         }

  409.         return;
  410.     }

  412.     if (rc == NGX_ERROR) {
  413.         ngx_mail_proxy_upstream_error(s);
  414.         return;
  415.     }

  417.     switch (s->mail_state) {

  419.     case ngx_imap_start:
  420.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  421.                        "mail proxy send login");

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

  425.         line.len = s->tag.len + sizeof("LOGIN ") - 1
  426.                    + 1 + NGX_SIZE_T_LEN + 1 + 2;
  427.         line.data = ngx_pnalloc(c->pool, line.len);
  428.         if (line.data == NULL) {
  429.             ngx_mail_proxy_internal_server_error(s);
  430.             return;
  431.         }

  433.         line.len = ngx_sprintf(line.data, "%VLOGIN {%uz}" CRLF,
  434.                                &s->tag, s->login.len)
  435.                    - line.data;

  437.         s->mail_state = ngx_imap_login;
  438.         break;

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

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

  445.         line.len = s->login.len + 1 + 1 + NGX_SIZE_T_LEN + 1 + 2;
  446.         line.data = ngx_pnalloc(c->pool, line.len);
  447.         if (line.data == NULL) {
  448.             ngx_mail_proxy_internal_server_error(s);
  449.             return;
  450.         }

  452.         line.len = ngx_sprintf(line.data, "%V {%uz}" CRLF,
  453.                                &s->login, s->passwd.len)
  454.                    - line.data;

  456.         s->mail_state = ngx_imap_user;
  457.         break;

  459.     case ngx_imap_user:
  460.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  461.                        "mail proxy send passwd");

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

  465.         line.len = s->passwd.len + 2;
  466.         line.data = ngx_pnalloc(c->pool, line.len);
  467.         if (line.data == NULL) {
  468.             ngx_mail_proxy_internal_server_error(s);
  469.             return;
  470.         }

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

  475.         s->mail_state = ngx_imap_passwd;
  476.         break;

  478.     case ngx_imap_passwd:
  479.         s->connection->read->handler = ngx_mail_proxy_handler;
  480.         s->connection->write->handler = ngx_mail_proxy_handler;
  481.         rev->handler = ngx_mail_proxy_handler;
  482.         c->write->handler = ngx_mail_proxy_handler;

  484.         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
  485.         ngx_add_timer(s->connection->read, pcf->timeout);
  486.         ngx_del_timer(c->read);

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

  491.         if (s->buffer->pos < s->buffer->last
  492.             || s->connection->read->ready)
  493.         {
  494.             ngx_post_event(c->write, &ngx_posted_events);
  495.         }

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

  499.         return;

  501.     default:
  502. #if (NGX_SUPPRESS_WARN)
  503.         ngx_str_null(&line);
  504. #endif
  505.         break;
  506.     }

  508.     if (c->send(c, line.data, line.len) < (ssize_t) line.len) {
  509.         /*
  510.          * we treat the incomplete sending as NGX_ERROR
  511.          * because it is very strange here
  512.          */
  513.         ngx_mail_proxy_internal_server_error(s);
  514.         return;
  515.     }

  517.     if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  518.         ngx_mail_proxy_internal_server_error(s);
  519.         return;
  520.     }

  522.     s->proxy->buffer->pos = s->proxy->buffer->start;
  523.     s->proxy->buffer->last = s->proxy->buffer->start;
  524. }


  527. static void
  528. ‌ngx_mail_proxy_smtp_handler(ngx_event_t *rev)
  529. {
  530.     u_char                    *p;
  531.     ngx_int_t                  rc;
  532.     ngx_str_t                  line, auth, encoded;
  533.     ngx_buf_t                 *b;
  534.     ngx_connection_t          *c;
  535.     ngx_mail_session_t        *s;
  536.     ngx_mail_proxy_conf_t     *pcf;
  537.     ngx_mail_core_srv_conf_t  *cscf;

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

  542.     c = rev->data;
  543.     s = c->data;

  545.     if (rev->timedout) {
  546.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
  547.                       "upstream timed out");
  548.         c->timedout = 1;
  549.         ngx_mail_proxy_internal_server_error(s);
  550.         return;
  551.     }

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

  556.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  557.             ngx_mail_proxy_internal_server_error(s);
  558.             return;
  559.         }

  561.         return;
  562.     }

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

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

  572.         return;
  573.     }

  575.     if (rc == NGX_ERROR) {
  576.         ngx_mail_proxy_upstream_error(s);
  577.         return;
  578.     }

  580.     switch (s->mail_state) {

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

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

  587.         cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  589.         line.len = sizeof("HELO ")  - 1 + cscf->server_name.len + 2;
  590.         line.data = ngx_pnalloc(c->pool, line.len);
  591.         if (line.data == NULL) {
  592.             ngx_mail_proxy_internal_server_error(s);
  593.             return;
  594.         }

  596.         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);

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

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

  605.         if (pcf->xclient) {
  606.             s->mail_state = ngx_smtp_helo_xclient;

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

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

  614.         } else {
  615.             s->mail_state = ngx_smtp_helo;
  616.         }

  618.         break;

  620.     case ngx_smtp_helo_xclient:
  621.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  622.                        "mail proxy send xclient");

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

  626.         line.len = sizeof("XCLIENT ADDR= LOGIN= NAME="
  627.                           CRLF) - 1
  628.                    + s->connection->addr_text.len + s->login.len + s->host.len;

  630. #if (NGX_HAVE_INET6)
  631.         if (s->connection->sockaddr->sa_family == AF_INET6) {
  632.             line.len += sizeof("IPV6:") - 1;
  633.         }
  634. #endif

  636.         line.data = ngx_pnalloc(c->pool, line.len);
  637.         if (line.data == NULL) {
  638.             ngx_mail_proxy_internal_server_error(s);
  639.             return;
  640.         }

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

  644. #if (NGX_HAVE_INET6)
  645.         if (s->connection->sockaddr->sa_family == AF_INET6) {
  646.             p = ngx_cpymem(p, "IPV6:", sizeof("IPV6:") - 1);
  647.         }
  648. #endif

  650.         p = ngx_copy(p, s->connection->addr_text.data,
  651.                      s->connection->addr_text.len);

  653.         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);

  655.         if (s->login.len && !pcf->smtp_auth) {
  656.             p = ngx_cpymem(p, " LOGIN=", sizeof(" LOGIN=") - 1);
  657.             p = ngx_copy(p, s->login.data, s->login.len);
  658.         }

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

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

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

  667.         if (s->smtp_helo.len) {
  668.             s->mail_state = ngx_smtp_xclient_helo;

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

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

  676.         } else {
  677.             s->mail_state = ngx_smtp_xclient;
  678.         }

  680.         break;

  682.     case ngx_smtp_xclient_helo:
  683.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  684.                        "mail proxy send client ehlo");

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

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

  690.         line.data = ngx_pnalloc(c->pool, line.len);
  691.         if (line.data == NULL) {
  692.             ngx_mail_proxy_internal_server_error(s);
  693.             return;
  694.         }

  696.         line.len = ngx_sprintf(line.data,
  697.                        ((s->esmtp) ? "EHLO %V" CRLF : "HELO %V" CRLF),
  698.                        &s->smtp_helo)
  699.                    - line.data;

  701.         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);

  703.         if (s->auth_method == NGX_MAIL_AUTH_NONE) {
  704.             s->mail_state = ngx_smtp_helo_from;

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

  709.         } else {
  710.             s->mail_state = ngx_smtp_helo;
  711.         }

  713.         break;

  715.     case ngx_smtp_helo_auth:
  716.     case ngx_smtp_xclient_auth:
  717.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  718.                        "mail proxy send auth");

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

  722.         if (s->passwd.data == NULL) {
  723.             ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  724.                           "no password available");
  725.             ngx_mail_proxy_internal_server_error(s);
  726.             return;
  727.         }

  729.         auth.len = 1 + s->login.len + 1 + s->passwd.len;
  730.         auth.data = ngx_pnalloc(c->pool, auth.len);
  731.         if (auth.data == NULL) {
  732.             ngx_mail_proxy_internal_server_error(s);
  733.             return;
  734.         }

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

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

  742.         line.data = ngx_pnalloc(c->pool, line.len);
  743.         if (line.data == NULL) {
  744.             ngx_mail_proxy_internal_server_error(s);
  745.             return;
  746.         }

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

  751.         ngx_encode_base64(&encoded, &auth);

  753.         p = encoded.data + encoded.len;
  754.         *p++ = CR; *p = LF;

  756.         s->mail_state = ngx_smtp_auth_plain;

  758.         break;

  760.     case ngx_smtp_helo_from:
  761.     case ngx_smtp_xclient_from:
  762.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  763.                        "mail proxy send mail from");

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

  767.         line.len = s->smtp_from.len + sizeof(CRLF) - 1;
  768.         line.data = ngx_pnalloc(c->pool, line.len);
  769.         if (line.data == NULL) {
  770.             ngx_mail_proxy_internal_server_error(s);
  771.             return;
  772.         }

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

  777.         s->mail_state = ngx_smtp_from;

  779.         break;

  781.     case ngx_smtp_from:
  782.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  783.                        "mail proxy send rcpt to");

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

  787.         line.len = s->smtp_to.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_to.data, s->smtp_to.len);
  795.         *p++ = CR; *p = LF;

  797.         s->mail_state = ngx_smtp_to;

  799.         break;

  801.     case ngx_smtp_helo:
  802.     case ngx_smtp_xclient:
  803.     case ngx_smtp_auth_plain:
  804.     case ngx_smtp_to:

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

  808.         if (s->auth_method == NGX_MAIL_AUTH_NONE) {
  809.             b->pos = b->start;

  811.         } else {
  812.             ngx_memcpy(b->start, smtp_auth_ok, sizeof(smtp_auth_ok) - 1);
  813.             b->last = b->start + sizeof(smtp_auth_ok) - 1;
  814.         }

  816.         s->connection->read->handler = ngx_mail_proxy_handler;
  817.         s->connection->write->handler = ngx_mail_proxy_handler;
  818.         rev->handler = ngx_mail_proxy_handler;
  819.         c->write->handler = ngx_mail_proxy_handler;

  821.         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
  822.         ngx_add_timer(s->connection->read, pcf->timeout);
  823.         ngx_del_timer(c->read);

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

  828.         if (s->buffer->pos < s->buffer->last
  829.             || s->connection->read->ready)
  830.         {
  831.             ngx_post_event(c->write, &ngx_posted_events);
  832.         }

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

  836.         return;

  838.     default:
  839. #if (NGX_SUPPRESS_WARN)
  840.         ngx_str_null(&line);
  841. #endif
  842.         break;
  843.     }

  845.     if (c->send(c, line.data, line.len) < (ssize_t) line.len) {
  846.         /*
  847.          * we treat the incomplete sending as NGX_ERROR
  848.          * because it is very strange here
  849.          */
  850.         ngx_mail_proxy_internal_server_error(s);
  851.         return;
  852.     }

  854.     if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  855.         ngx_mail_proxy_internal_server_error(s);
  856.         return;
  857.     }

  859.     s->proxy->buffer->pos = s->proxy->buffer->start;
  860.     s->proxy->buffer->last = s->proxy->buffer->start;
  861. }


  864. static void
  865. ‌ngx_mail_proxy_write_handler(ngx_event_t *wev)
  866. {
  867.     ngx_connection_t    *c;
  868.     ngx_mail_session_t  *s;

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

  872.     c = wev->data;
  873.     s = c->data;

  875.     if (s->proxy->proxy_protocol) {
  876.         if (ngx_mail_proxy_send_proxy_protocol(s) != NGX_OK) {
  877.             return;
  878.         }

  880.         s->proxy->proxy_protocol = 0;
  881.     }

  883.     if (ngx_handle_write_event(wev, 0) != NGX_OK) {
  884.         ngx_mail_proxy_internal_server_error(s);
  885.     }

  887.     if (c->read->ready) {
  888.         ngx_post_event(c->read, &ngx_posted_events);
  889.     }
  890. }


  893. static ngx_int_t
  894. ‌ngx_mail_proxy_send_proxy_protocol(ngx_mail_session_t *s)
  895. {
  896.     u_char            *p;
  897.     ssize_t            n, size;
  898.     ngx_connection_t  *c;
  899.     u_char             buf[NGX_PROXY_PROTOCOL_V1_MAX_HEADER];

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

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

  906.     p = ngx_proxy_protocol_write(s->connection, buf,
  907.                                  buf + NGX_PROXY_PROTOCOL_V1_MAX_HEADER);
  908.     if (p == NULL) {
  909.         ngx_mail_proxy_internal_server_error(s);
  910.         return NGX_ERROR;
  911.     }

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

  915.     size = p - buf;

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

  919.     if (n == NGX_AGAIN) {
  920.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  921.             ngx_mail_proxy_internal_server_error(s);
  922.             return NGX_ERROR;
  923.         }

  925.         return NGX_AGAIN;
  926.     }

  928.     if (n == NGX_ERROR) {
  929.         ngx_mail_proxy_internal_server_error(s);
  930.         return NGX_ERROR;
  931.     }

  933.     if (n != size) {

  935.         /*
  936.          * PROXY protocol specification:
  937.          * The sender must always ensure that the header
  938.          * is sent at once, so that the transport layer
  939.          * maintains atomicity along the path to the receiver.
  940.          */

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

  945.         ngx_mail_proxy_internal_server_error(s);

  947.         return NGX_ERROR;
  948.     }

  950.     return NGX_OK;
  951. }


  954. static ngx_int_t
  955. ‌ngx_mail_proxy_read_response(ngx_mail_session_t *s, ngx_uint_t state)
  956. {
  957.     u_char                 *p, *m;
  958.     ssize_t                 n;
  959.     ngx_buf_t              *b;
  960.     ngx_mail_proxy_conf_t  *pcf;

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

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

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

  969.     if (n == NGX_ERROR || n == 0) {
  970.         return NGX_ERROR;
  971.     }

  973.     if (n == NGX_AGAIN) {
  974.         return NGX_AGAIN;
  975.     }

  977.     b->last += n;

  979.     if (b->last - b->pos < 4) {
  980.         return NGX_AGAIN;
  981.     }

  983.     if (*(b->last - 2) != CR || *(b->last - 1) != LF) {
  984.         if (b->last == b->end) {
  985.             *(b->last - 1) = '\0';
  986.             ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  987.                           "upstream sent too long response line: \"%s\"",
  988.                           b->pos);
  989.             return NGX_ERROR;
  990.         }

  992.         return NGX_AGAIN;
  993.     }

  995.     p = b->pos;

  997.     switch (s->protocol) {

  999.     case NGX_MAIL_POP3_PROTOCOL:
  1000.         if (p[0] == '+' && p[1] == 'O' && p[2] == 'K') {
  1001.             return NGX_OK;
  1002.         }
  1003.         break;

  1005.     case NGX_MAIL_IMAP_PROTOCOL:
  1006.         switch (state) {

  1008.         case ngx_imap_start:
  1009.             if (p[0] == '*' && p[1] == ' ' && p[2] == 'O' && p[3] == 'K') {
  1010.                 return NGX_OK;
  1011.             }
  1012.             break;

  1014.         case ngx_imap_login:
  1015.         case ngx_imap_user:
  1016.             if (p[0] == '+') {
  1017.                 return NGX_OK;
  1018.             }
  1019.             break;

  1021.         case ngx_imap_passwd:

  1023.             /*
  1024.              * untagged CAPABILITY response (draft-crispin-imapv-16),
  1025.              * known to be sent by SmarterMail and Gmail
  1026.              */

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

  1031.                 while (p < b->last - 1) {
  1032.                     if (p[0] == CR && p[1] == LF) {
  1033.                         p += 2;
  1034.                         break;
  1035.                     }

  1037.                     p++;
  1038.                 }

  1040.                 if (b->last - p < 4) {
  1041.                     return NGX_AGAIN;
  1042.                 }
  1043.             }

  1045.             if (ngx_strncmp(p, s->tag.data, s->tag.len) == 0) {
  1046.                 p += s->tag.len;
  1047.                 if (p[0] == 'O' && p[1] == 'K') {
  1048.                     return NGX_OK;
  1049.                 }
  1050.             }

  1052.             break;
  1053.         }

  1055.         break;

  1057.     default: /* NGX_MAIL_SMTP_PROTOCOL */

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

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

  1064.             while (m > p) {
  1065.                 if (m[0] == CR && m[1] == LF) {
  1066.                     break;
  1067.                 }

  1069.                 m--;
  1070.             }

  1072.             if (m <= p || m[5] == '-') {
  1073.                 return NGX_AGAIN;
  1074.             }
  1075.         }

  1077.         switch (state) {

  1079.         case ngx_smtp_start:
  1080.             if (p[0] == '2' && p[1] == '2' && p[2] == '0') {
  1081.                 return NGX_OK;
  1082.             }
  1083.             break;

  1085.         case ngx_smtp_helo:
  1086.         case ngx_smtp_helo_xclient:
  1087.         case ngx_smtp_helo_from:
  1088.         case ngx_smtp_helo_auth:
  1089.         case ngx_smtp_from:
  1090.             if (p[0] == '2' && p[1] == '5' && p[2] == '0') {
  1091.                 return NGX_OK;
  1092.             }
  1093.             break;

  1095.         case ngx_smtp_xclient:
  1096.         case ngx_smtp_xclient_from:
  1097.         case ngx_smtp_xclient_helo:
  1098.         case ngx_smtp_xclient_auth:
  1099.             if (p[0] == '2' && (p[1] == '2' || p[1] == '5') && p[2] == '0') {
  1100.                 return NGX_OK;
  1101.             }
  1102.             break;

  1104.         case ngx_smtp_auth_plain:
  1105.             if (p[0] == '2' && p[1] == '3' && p[2] == '5') {
  1106.                 return NGX_OK;
  1107.             }
  1108.             break;

  1110.         case ngx_smtp_to:
  1111.             return NGX_OK;
  1112.         }

  1114.         break;
  1115.     }

  1117.     pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);

  1119.     if (pcf->pass_error_message == 0) {
  1120.         *(b->last - 2) = '\0';
  1121.         ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  1122.                       "upstream sent invalid response: \"%s\"", p);
  1123.         return NGX_ERROR;
  1124.     }

  1126.     s->out.len = b->last - p - 2;
  1127.     s->out.data = p;

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

  1132.     s->out.len = b->last - b->pos;
  1133.     s->out.data = b->pos;

  1135.     return NGX_ERROR;
  1136. }


  1139. static void
  1140. ‌ngx_mail_proxy_handler(ngx_event_t *ev)
  1141. {
  1142.     char                   *action, *recv_action, *send_action;
  1143.     size_t                  size;
  1144.     ssize_t                 n;
  1145.     ngx_buf_t              *b;
  1146.     ngx_uint_t              do_write;
  1147.     ngx_connection_t       *c, *src, *dst;
  1148.     ngx_mail_session_t     *s;
  1149.     ngx_mail_proxy_conf_t  *pcf;

  1151.     c = ev->data;
  1152.     s = c->data;

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

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

  1160.         } else if (c == s->connection) {
  1161.             ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
  1162.                           "client timed out");
  1163.             c->timedout = 1;

  1165.         } else {
  1166.             ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
  1167.                           "upstream timed out");
  1168.         }

  1170.         ngx_mail_proxy_close_session(s);
  1171.         return;
  1172.     }

  1174.     if (c == s->connection) {
  1175.         if (ev->write) {
  1176.             recv_action = "proxying and reading from upstream";
  1177.             send_action = "proxying and sending to client";
  1178.             src = s->proxy->upstream.connection;
  1179.             dst = c;
  1180.             b = s->proxy->buffer;

  1182.         } else {
  1183.             recv_action = "proxying and reading from client";
  1184.             send_action = "proxying and sending to upstream";
  1185.             src = c;
  1186.             dst = s->proxy->upstream.connection;
  1187.             b = s->buffer;
  1188.         }

  1190.     } else {
  1191.         if (ev->write) {
  1192.             recv_action = "proxying and reading from client";
  1193.             send_action = "proxying and sending to upstream";
  1194.             src = s->connection;
  1195.             dst = c;
  1196.             b = s->buffer;

  1198.         } else {
  1199.             recv_action = "proxying and reading from upstream";
  1200.             send_action = "proxying and sending to client";
  1201.             src = c;
  1202.             dst = s->connection;
  1203.             b = s->proxy->buffer;
  1204.         }
  1205.     }

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

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

  1213.     for ( ;; ) {

  1215.         if (do_write) {

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

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

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

  1224.                 if (n == NGX_ERROR) {
  1225.                     ngx_mail_proxy_close_session(s);
  1226.                     return;
  1227.                 }

  1229.                 if (n > 0) {
  1230.                     b->pos += n;

  1232.                     if (b->pos == b->last) {
  1233.                         b->pos = b->start;
  1234.                         b->last = b->start;
  1235.                     }
  1236.                 }
  1237.             }
  1238.         }

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

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

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

  1247.             if (n == NGX_AGAIN || n == 0) {
  1248.                 break;
  1249.             }

  1251.             if (n > 0) {
  1252.                 do_write = 1;
  1253.                 b->last += n;

  1255.                 continue;
  1256.             }

  1258.             if (n == NGX_ERROR) {
  1259.                 src->read->eof = 1;
  1260.             }
  1261.         }

  1263.         break;
  1264.     }

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

  1268.     if ((s->connection->read->eof && s->buffer->pos == s->buffer->last)
  1269.         || (s->proxy->upstream.connection->read->eof
  1270.             && s->proxy->buffer->pos == s->proxy->buffer->last)
  1271.         || (s->connection->read->eof
  1272.             && s->proxy->upstream.connection->read->eof))
  1273.     {
  1274.         action = c->log->action;
  1275.         c->log->action = NULL;
  1276.         ngx_log_error(NGX_LOG_INFO, c->log, 0, "proxied session done");
  1277.         c->log->action = action;

  1279.         ngx_mail_proxy_close_session(s);
  1280.         return;
  1281.     }

  1283.     if (ngx_handle_write_event(dst->write, 0) != NGX_OK) {
  1284.         ngx_mail_proxy_close_session(s);
  1285.         return;
  1286.     }

  1288.     if (ngx_handle_read_event(dst->read, 0) != NGX_OK) {
  1289.         ngx_mail_proxy_close_session(s);
  1290.         return;
  1291.     }

  1293.     if (ngx_handle_write_event(src->write, 0) != NGX_OK) {
  1294.         ngx_mail_proxy_close_session(s);
  1295.         return;
  1296.     }

  1298.     if (ngx_handle_read_event(src->read, 0) != NGX_OK) {
  1299.         ngx_mail_proxy_close_session(s);
  1300.         return;
  1301.     }

  1303.     if (c == s->connection) {
  1304.         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
  1305.         ngx_add_timer(c->read, pcf->timeout);
  1306.     }
  1307. }


  1310. static void
  1311. ‌ngx_mail_proxy_upstream_error(ngx_mail_session_t *s)
  1312. {
  1313.     if (s->proxy->upstream.connection) {
  1314.         ngx_log_debug1(NGX_LOG_DEBUG_MAIL, s->connection->log, 0,
  1315.                        "close mail proxy connection: %d",
  1316.                        s->proxy->upstream.connection->fd);

  1318.         ngx_close_connection(s->proxy->upstream.connection);
  1319.     }

  1321.     if (s->out.len == 0) {
  1322.         ngx_mail_session_internal_server_error(s);
  1323.         return;
  1324.     }

  1326.     s->quit = 1;
  1327.     ngx_mail_send(s->connection->write);
  1328. }


  1331. static void
  1332. ‌ngx_mail_proxy_internal_server_error(ngx_mail_session_t *s)
  1333. {
  1334.     if (s->proxy->upstream.connection) {
  1335.         ngx_log_debug1(NGX_LOG_DEBUG_MAIL, s->connection->log, 0,
  1336.                        "close mail proxy connection: %d",
  1337.                        s->proxy->upstream.connection->fd);

  1339.         ngx_close_connection(s->proxy->upstream.connection);
  1340.     }

  1342.     ngx_mail_session_internal_server_error(s);
  1343. }


  1346. static void
  1347. ‌ngx_mail_proxy_close_session(ngx_mail_session_t *s)
  1348. {
  1349.     if (s->proxy->upstream.connection) {
  1350.         ngx_log_debug1(NGX_LOG_DEBUG_MAIL, s->connection->log, 0,
  1351.                        "close mail proxy connection: %d",
  1352.                        s->proxy->upstream.connection->fd);

  1354.         ngx_close_connection(s->proxy->upstream.connection);
  1355.     }

  1357.     ngx_mail_close_connection(s->connection);
  1358. }


  1361. static void *
  1362. ‌ngx_mail_proxy_create_conf(ngx_conf_t *cf)
  1363. {
  1364.     ngx_mail_proxy_conf_t  *pcf;

  1366.     pcf = ngx_pcalloc(cf->pool, sizeof(ngx_mail_proxy_conf_t));
  1367.     if (pcf == NULL) {
  1368.         return NULL;
  1369.     }

  1371.     pcf->enable = NGX_CONF_UNSET;
  1372.     pcf->pass_error_message = NGX_CONF_UNSET;
  1373.     pcf->xclient = NGX_CONF_UNSET;
  1374.     pcf->smtp_auth = NGX_CONF_UNSET;
  1375.     pcf->proxy_protocol = NGX_CONF_UNSET;
  1376.     pcf->buffer_size = NGX_CONF_UNSET_SIZE;
  1377.     pcf->timeout = NGX_CONF_UNSET_MSEC;

  1379.     return pcf;
  1380. }


  1383. static char *
  1384. ‌ngx_mail_proxy_merge_conf(ngx_conf_t *cf, void *parent, void *child)
  1385. {
  1386.     ngx_mail_proxy_conf_t *prev = parent;
  1387.     ngx_mail_proxy_conf_t *conf = child;

  1389.     ngx_conf_merge_value(conf->enable, prev->enable, 0);
  1390.     ngx_conf_merge_value(conf->pass_error_message, prev->pass_error_message, 0);
  1391.     ngx_conf_merge_value(conf->xclient, prev->xclient, 1);
  1392.     ngx_conf_merge_value(conf->smtp_auth, prev->smtp_auth, 0);
  1393.     ngx_conf_merge_value(conf->proxy_protocol, prev->proxy_protocol, 0);
  1394.     ngx_conf_merge_size_value(conf->buffer_size, prev->buffer_size,
  1395.                               (size_t) ngx_pagesize);
  1396.     ngx_conf_merge_msec_value(conf->timeout, prev->timeout, 24 * 60 * 60000);

  1398.     return NGX_CONF_OK;
  1399. }

One Level Up Top Level