One Level Up Top Level

src/mail/ngx_mail_proxy_module.c - nginx

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.     uintptr_t                  n;
  535.     ngx_connection_t          *c;
  536.     ngx_mail_session_t        *s;
  537.     ngx_mail_proxy_conf_t     *pcf;
  538.     ngx_mail_core_srv_conf_t  *cscf;

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

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

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

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

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

  562.         return;
  563.     }

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

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

  573.         return;
  574.     }

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

  581.     switch (s->mail_state) {

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

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

  588.         cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

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

  597.         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);

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

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

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

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

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

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

  619.         break;

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

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

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

  631.         n = ngx_escape_uri(NULL, s->login.data, s->login.len,
  632.                            NGX_ESCAPE_MAIL_XTEXT);
  633.         line.len += n * 2;

  635. #if (NGX_HAVE_INET6)
  636.         if (s->connection->sockaddr->sa_family == AF_INET6) {
  637.             line.len += sizeof("IPV6:") - 1;
  638.         }
  639. #endif

  641.         line.data = ngx_pnalloc(c->pool, line.len);
  642.         if (line.data == NULL) {
  643.             ngx_mail_proxy_internal_server_error(s);
  644.             return;
  645.         }

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

  649. #if (NGX_HAVE_INET6)
  650.         if (s->connection->sockaddr->sa_family == AF_INET6) {
  651.             p = ngx_cpymem(p, "IPV6:", sizeof("IPV6:") - 1);
  652.         }
  653. #endif

  655.         p = ngx_copy(p, s->connection->addr_text.data,
  656.                      s->connection->addr_text.len);

  658.         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);

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

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

  666.             } else {
  667.                 p = (u_char *) ngx_escape_uri(p, s->login.data, s->login.len,
  668.                                               NGX_ESCAPE_MAIL_XTEXT);
  669.             }
  670.         }

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

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

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

  679.         if (s->smtp_helo.len) {
  680.             s->mail_state = ngx_smtp_xclient_helo;

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

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

  688.         } else {
  689.             s->mail_state = ngx_smtp_xclient;
  690.         }

  692.         break;

  694.     case ngx_smtp_xclient_helo:
  695.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  696.                        "mail proxy send client ehlo");

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

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

  702.         line.data = ngx_pnalloc(c->pool, line.len);
  703.         if (line.data == NULL) {
  704.             ngx_mail_proxy_internal_server_error(s);
  705.             return;
  706.         }

  708.         line.len = ngx_sprintf(line.data,
  709.                        ((s->esmtp) ? "EHLO %V" CRLF : "HELO %V" CRLF),
  710.                        &s->smtp_helo)
  711.                    - line.data;

  713.         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);

  715.         if (s->auth_method == NGX_MAIL_AUTH_NONE) {
  716.             s->mail_state = ngx_smtp_helo_from;

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

  721.         } else {
  722.             s->mail_state = ngx_smtp_helo;
  723.         }

  725.         break;

  727.     case ngx_smtp_helo_auth:
  728.     case ngx_smtp_xclient_auth:
  729.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  730.                        "mail proxy send auth");

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

  734.         if (s->passwd.data == NULL) {
  735.             ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  736.                           "no password available");
  737.             ngx_mail_proxy_internal_server_error(s);
  738.             return;
  739.         }

  741.         auth.len = 1 + s->login.len + 1 + s->passwd.len;
  742.         auth.data = ngx_pnalloc(c->pool, auth.len);
  743.         if (auth.data == NULL) {
  744.             ngx_mail_proxy_internal_server_error(s);
  745.             return;
  746.         }

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

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

  754.         line.data = ngx_pnalloc(c->pool, line.len);
  755.         if (line.data == NULL) {
  756.             ngx_mail_proxy_internal_server_error(s);
  757.             return;
  758.         }

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

  763.         ngx_encode_base64(&encoded, &auth);

  765.         p = encoded.data + encoded.len;
  766.         *p++ = CR; *p = LF;

  768.         s->mail_state = ngx_smtp_auth_plain;

  770.         break;

  772.     case ngx_smtp_helo_from:
  773.     case ngx_smtp_xclient_from:
  774.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  775.                        "mail proxy send mail from");

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

  779.         line.len = s->smtp_from.len + sizeof(CRLF) - 1;
  780.         line.data = ngx_pnalloc(c->pool, line.len);
  781.         if (line.data == NULL) {
  782.             ngx_mail_proxy_internal_server_error(s);
  783.             return;
  784.         }

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

  789.         s->mail_state = ngx_smtp_from;

  791.         break;

  793.     case ngx_smtp_from:
  794.         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  795.                        "mail proxy send rcpt to");

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

  799.         line.len = s->smtp_to.len + sizeof(CRLF) - 1;
  800.         line.data = ngx_pnalloc(c->pool, line.len);
  801.         if (line.data == NULL) {
  802.             ngx_mail_proxy_internal_server_error(s);
  803.             return;
  804.         }

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

  809.         s->mail_state = ngx_smtp_to;

  811.         break;

  813.     case ngx_smtp_helo:
  814.     case ngx_smtp_xclient:
  815.     case ngx_smtp_auth_plain:
  816.     case ngx_smtp_to:

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

  820.         if (s->auth_method == NGX_MAIL_AUTH_NONE) {
  821.             b->pos = b->start;

  823.         } else {
  824.             ngx_memcpy(b->start, smtp_auth_ok, sizeof(smtp_auth_ok) - 1);
  825.             b->last = b->start + sizeof(smtp_auth_ok) - 1;
  826.         }

  828.         s->connection->read->handler = ngx_mail_proxy_handler;
  829.         s->connection->write->handler = ngx_mail_proxy_handler;
  830.         rev->handler = ngx_mail_proxy_handler;
  831.         c->write->handler = ngx_mail_proxy_handler;

  833.         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
  834.         ngx_add_timer(s->connection->read, pcf->timeout);
  835.         ngx_del_timer(c->read);

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

  840.         if (s->buffer->pos < s->buffer->last
  841.             || s->connection->read->ready)
  842.         {
  843.             ngx_post_event(c->write, &ngx_posted_events);
  844.         }

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

  848.         return;

  850.     default:
  851. #if (NGX_SUPPRESS_WARN)
  852.         ngx_str_null(&line);
  853. #endif
  854.         break;
  855.     }

  857.     if (c->send(c, line.data, line.len) < (ssize_t) line.len) {
  858.         /*
  859.          * we treat the incomplete sending as NGX_ERROR
  860.          * because it is very strange here
  861.          */
  862.         ngx_mail_proxy_internal_server_error(s);
  863.         return;
  864.     }

  866.     if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  867.         ngx_mail_proxy_internal_server_error(s);
  868.         return;
  869.     }

  871.     s->proxy->buffer->pos = s->proxy->buffer->start;
  872.     s->proxy->buffer->last = s->proxy->buffer->start;
  873. }


  876. static void
  877. ‌ngx_mail_proxy_write_handler(ngx_event_t *wev)
  878. {
  879.     ngx_connection_t    *c;
  880.     ngx_mail_session_t  *s;

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

  884.     c = wev->data;
  885.     s = c->data;

  887.     if (s->proxy->proxy_protocol) {
  888.         if (ngx_mail_proxy_send_proxy_protocol(s) != NGX_OK) {
  889.             return;
  890.         }

  892.         s->proxy->proxy_protocol = 0;
  893.     }

  895.     if (ngx_handle_write_event(wev, 0) != NGX_OK) {
  896.         ngx_mail_proxy_internal_server_error(s);
  897.     }

  899.     if (c->read->ready) {
  900.         ngx_post_event(c->read, &ngx_posted_events);
  901.     }
  902. }


  905. static ngx_int_t
  906. ‌ngx_mail_proxy_send_proxy_protocol(ngx_mail_session_t *s)
  907. {
  908.     u_char            *p;
  909.     ssize_t            n, size;
  910.     ngx_connection_t  *c;
  911.     u_char             buf[NGX_PROXY_PROTOCOL_V1_MAX_HEADER];

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

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

  918.     p = ngx_proxy_protocol_write(s->connection, buf,
  919.                                  buf + NGX_PROXY_PROTOCOL_V1_MAX_HEADER);
  920.     if (p == NULL) {
  921.         ngx_mail_proxy_internal_server_error(s);
  922.         return NGX_ERROR;
  923.     }

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

  927.     size = p - buf;

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

  931.     if (n == NGX_AGAIN) {
  932.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  933.             ngx_mail_proxy_internal_server_error(s);
  934.             return NGX_ERROR;
  935.         }

  937.         return NGX_AGAIN;
  938.     }

  940.     if (n == NGX_ERROR) {
  941.         ngx_mail_proxy_internal_server_error(s);
  942.         return NGX_ERROR;
  943.     }

  945.     if (n != size) {

  947.         /*
  948.          * PROXY protocol specification:
  949.          * The sender must always ensure that the header
  950.          * is sent at once, so that the transport layer
  951.          * maintains atomicity along the path to the receiver.
  952.          */

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

  957.         ngx_mail_proxy_internal_server_error(s);

  959.         return NGX_ERROR;
  960.     }

  962.     return NGX_OK;
  963. }


  966. static ngx_int_t
  967. ‌ngx_mail_proxy_read_response(ngx_mail_session_t *s, ngx_uint_t state)
  968. {
  969.     u_char                 *p, *m;
  970.     ssize_t                 n;
  971.     ngx_buf_t              *b;
  972.     ngx_mail_proxy_conf_t  *pcf;

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

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

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

  981.     if (n == NGX_ERROR || n == 0) {
  982.         return NGX_ERROR;
  983.     }

  985.     if (n == NGX_AGAIN) {
  986.         return NGX_AGAIN;
  987.     }

  989.     b->last += n;

  991.     if (b->last - b->pos < 4) {
  992.         return NGX_AGAIN;
  993.     }

  995.     if (*(b->last - 2) != CR || *(b->last - 1) != LF) {
  996.         if (b->last == b->end) {
  997.             *(b->last - 1) = '\0';
  998.             ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  999.                           "upstream sent too long response line: \"%s\"",
  1000.                           b->pos);
  1001.             return NGX_ERROR;
  1002.         }

  1004.         return NGX_AGAIN;
  1005.     }

  1007.     p = b->pos;

  1009.     switch (s->protocol) {

  1011.     case NGX_MAIL_POP3_PROTOCOL:
  1012.         if (p[0] == '+' && p[1] == 'O' && p[2] == 'K') {
  1013.             return NGX_OK;
  1014.         }
  1015.         break;

  1017.     case NGX_MAIL_IMAP_PROTOCOL:
  1018.         switch (state) {

  1020.         case ngx_imap_start:
  1021.             if (p[0] == '*' && p[1] == ' ' && p[2] == 'O' && p[3] == 'K') {
  1022.                 return NGX_OK;
  1023.             }
  1024.             break;

  1026.         case ngx_imap_login:
  1027.         case ngx_imap_user:
  1028.             if (p[0] == '+') {
  1029.                 return NGX_OK;
  1030.             }
  1031.             break;

  1033.         case ngx_imap_passwd:

  1035.             /*
  1036.              * untagged CAPABILITY response (draft-crispin-imapv-16),
  1037.              * known to be sent by SmarterMail and Gmail
  1038.              */

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

  1043.                 while (p < b->last - 1) {
  1044.                     if (p[0] == CR && p[1] == LF) {
  1045.                         p += 2;
  1046.                         break;
  1047.                     }

  1049.                     p++;
  1050.                 }

  1052.                 if (b->last - p < 4) {
  1053.                     return NGX_AGAIN;
  1054.                 }
  1055.             }

  1057.             if (ngx_strncmp(p, s->tag.data, s->tag.len) == 0) {
  1058.                 p += s->tag.len;
  1059.                 if (p[0] == 'O' && p[1] == 'K') {
  1060.                     return NGX_OK;
  1061.                 }
  1062.             }

  1064.             break;
  1065.         }

  1067.         break;

  1069.     default: /* NGX_MAIL_SMTP_PROTOCOL */

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

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

  1076.             while (m > p) {
  1077.                 if (m[0] == CR && m[1] == LF) {
  1078.                     break;
  1079.                 }

  1081.                 m--;
  1082.             }

  1084.             if (m <= p || m[5] == '-') {
  1085.                 return NGX_AGAIN;
  1086.             }
  1087.         }

  1089.         switch (state) {

  1091.         case ngx_smtp_start:
  1092.             if (p[0] == '2' && p[1] == '2' && p[2] == '0') {
  1093.                 return NGX_OK;
  1094.             }
  1095.             break;

  1097.         case ngx_smtp_helo:
  1098.         case ngx_smtp_helo_xclient:
  1099.         case ngx_smtp_helo_from:
  1100.         case ngx_smtp_helo_auth:
  1101.         case ngx_smtp_from:
  1102.             if (p[0] == '2' && p[1] == '5' && p[2] == '0') {
  1103.                 return NGX_OK;
  1104.             }
  1105.             break;

  1107.         case ngx_smtp_xclient:
  1108.         case ngx_smtp_xclient_from:
  1109.         case ngx_smtp_xclient_helo:
  1110.         case ngx_smtp_xclient_auth:
  1111.             if (p[0] == '2' && (p[1] == '2' || p[1] == '5') && p[2] == '0') {
  1112.                 return NGX_OK;
  1113.             }
  1114.             break;

  1116.         case ngx_smtp_auth_plain:
  1117.             if (p[0] == '2' && p[1] == '3' && p[2] == '5') {
  1118.                 return NGX_OK;
  1119.             }
  1120.             break;

  1122.         case ngx_smtp_to:
  1123.             return NGX_OK;
  1124.         }

  1126.         break;
  1127.     }

  1129.     pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);

  1131.     if (pcf->pass_error_message == 0) {
  1132.         *(b->last - 2) = '\0';
  1133.         ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  1134.                       "upstream sent invalid response: \"%s\"", p);
  1135.         return NGX_ERROR;
  1136.     }

  1138.     s->out.len = b->last - p - 2;
  1139.     s->out.data = p;

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

  1144.     s->out.len = b->last - b->pos;
  1145.     s->out.data = b->pos;

  1147.     return NGX_ERROR;
  1148. }


  1151. static void
  1152. ‌ngx_mail_proxy_handler(ngx_event_t *ev)
  1153. {
  1154.     char                   *action, *recv_action, *send_action;
  1155.     size_t                  size;
  1156.     ssize_t                 n;
  1157.     ngx_buf_t              *b;
  1158.     ngx_uint_t              do_write;
  1159.     ngx_connection_t       *c, *src, *dst;
  1160.     ngx_mail_session_t     *s;
  1161.     ngx_mail_proxy_conf_t  *pcf;

  1163.     c = ev->data;
  1164.     s = c->data;

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

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

  1172.         } else if (c == s->connection) {
  1173.             ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
  1174.                           "client timed out");
  1175.             c->timedout = 1;

  1177.         } else {
  1178.             ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
  1179.                           "upstream timed out");
  1180.         }

  1182.         ngx_mail_proxy_close_session(s);
  1183.         return;
  1184.     }

  1186.     if (c == s->connection) {
  1187.         if (ev->write) {
  1188.             recv_action = "proxying and reading from upstream";
  1189.             send_action = "proxying and sending to client";
  1190.             src = s->proxy->upstream.connection;
  1191.             dst = c;
  1192.             b = s->proxy->buffer;

  1194.         } else {
  1195.             recv_action = "proxying and reading from client";
  1196.             send_action = "proxying and sending to upstream";
  1197.             src = c;
  1198.             dst = s->proxy->upstream.connection;
  1199.             b = s->buffer;
  1200.         }

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

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

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

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

  1225.     for ( ;; ) {

  1227.         if (do_write) {

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

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

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

  1236.                 if (n == NGX_ERROR) {
  1237.                     ngx_mail_proxy_close_session(s);
  1238.                     return;
  1239.                 }

  1241.                 if (n > 0) {
  1242.                     b->pos += n;

  1244.                     if (b->pos == b->last) {
  1245.                         b->pos = b->start;
  1246.                         b->last = b->start;
  1247.                     }
  1248.                 }
  1249.             }
  1250.         }

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

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

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

  1259.             if (n == NGX_AGAIN || n == 0) {
  1260.                 break;
  1261.             }

  1263.             if (n > 0) {
  1264.                 do_write = 1;
  1265.                 b->last += n;

  1267.                 continue;
  1268.             }

  1270.             if (n == NGX_ERROR) {
  1271.                 src->read->eof = 1;
  1272.             }
  1273.         }

  1275.         break;
  1276.     }

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

  1280.     if ((s->connection->read->eof && s->buffer->pos == s->buffer->last)
  1281.         || (s->proxy->upstream.connection->read->eof
  1282.             && s->proxy->buffer->pos == s->proxy->buffer->last)
  1283.         || (s->connection->read->eof
  1284.             && s->proxy->upstream.connection->read->eof))
  1285.     {
  1286.         action = c->log->action;
  1287.         c->log->action = NULL;
  1288.         ngx_log_error(NGX_LOG_INFO, c->log, 0, "proxied session done");
  1289.         c->log->action = action;

  1291.         ngx_mail_proxy_close_session(s);
  1292.         return;
  1293.     }

  1295.     if (ngx_handle_write_event(dst->write, 0) != NGX_OK) {
  1296.         ngx_mail_proxy_close_session(s);
  1297.         return;
  1298.     }

  1300.     if (ngx_handle_read_event(dst->read, 0) != NGX_OK) {
  1301.         ngx_mail_proxy_close_session(s);
  1302.         return;
  1303.     }

  1305.     if (ngx_handle_write_event(src->write, 0) != NGX_OK) {
  1306.         ngx_mail_proxy_close_session(s);
  1307.         return;
  1308.     }

  1310.     if (ngx_handle_read_event(src->read, 0) != NGX_OK) {
  1311.         ngx_mail_proxy_close_session(s);
  1312.         return;
  1313.     }

  1315.     if (c == s->connection) {
  1316.         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
  1317.         ngx_add_timer(c->read, pcf->timeout);
  1318.     }
  1319. }


  1322. static void
  1323. ‌ngx_mail_proxy_upstream_error(ngx_mail_session_t *s)
  1324. {
  1325.     if (s->proxy->upstream.connection) {
  1326.         ngx_log_debug1(NGX_LOG_DEBUG_MAIL, s->connection->log, 0,
  1327.                        "close mail proxy connection: %d",
  1328.                        s->proxy->upstream.connection->fd);

  1330.         ngx_close_connection(s->proxy->upstream.connection);
  1331.     }

  1333.     if (s->out.len == 0) {
  1334.         ngx_mail_session_internal_server_error(s);
  1335.         return;
  1336.     }

  1338.     s->quit = 1;
  1339.     ngx_mail_send(s->connection->write);
  1340. }


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

  1351.         ngx_close_connection(s->proxy->upstream.connection);
  1352.     }

  1354.     ngx_mail_session_internal_server_error(s);
  1355. }


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

  1366.         ngx_close_connection(s->proxy->upstream.connection);
  1367.     }

  1369.     ngx_mail_close_connection(s->connection);
  1370. }


  1373. static void *
  1374. ‌ngx_mail_proxy_create_conf(ngx_conf_t *cf)
  1375. {
  1376.     ngx_mail_proxy_conf_t  *pcf;

  1378.     pcf = ngx_pcalloc(cf->pool, sizeof(ngx_mail_proxy_conf_t));
  1379.     if (pcf == NULL) {
  1380.         return NULL;
  1381.     }

  1383.     pcf->enable = NGX_CONF_UNSET;
  1384.     pcf->pass_error_message = NGX_CONF_UNSET;
  1385.     pcf->xclient = NGX_CONF_UNSET;
  1386.     pcf->smtp_auth = NGX_CONF_UNSET;
  1387.     pcf->proxy_protocol = NGX_CONF_UNSET;
  1388.     pcf->buffer_size = NGX_CONF_UNSET_SIZE;
  1389.     pcf->timeout = NGX_CONF_UNSET_MSEC;

  1391.     return pcf;
  1392. }


  1395. static char *
  1396. ‌ngx_mail_proxy_merge_conf(ngx_conf_t *cf, void *parent, void *child)
  1397. {
  1398.     ngx_mail_proxy_conf_t *prev = parent;
  1399.     ngx_mail_proxy_conf_t *conf = child;

  1401.     ngx_conf_merge_value(conf->enable, prev->enable, 0);
  1402.     ngx_conf_merge_value(conf->pass_error_message, prev->pass_error_message, 0);
  1403.     ngx_conf_merge_value(conf->xclient, prev->xclient, 1);
  1404.     ngx_conf_merge_value(conf->smtp_auth, prev->smtp_auth, 0);
  1405.     ngx_conf_merge_value(conf->proxy_protocol, prev->proxy_protocol, 0);
  1406.     ngx_conf_merge_size_value(conf->buffer_size, prev->buffer_size,
  1407.                               (size_t) ngx_pagesize);
  1408.     ngx_conf_merge_msec_value(conf->timeout, prev->timeout, 24 * 60 * 60000);

  1410.     return NGX_CONF_OK;
  1411. }

One Level Up Top Level