One Level Up Top Level

src/mail/ngx_mail_auth_http_module.c - nginx-1.7.10

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_addr_t                     *peer;

  18.     ngx_msec_t                      timeout;

  20.     ngx_str_t                       host_header;
  21.     ngx_str_t                       uri;
  22.     ngx_str_t                       header;

  24.     ngx_array_t                    *headers;

  26.     u_char                         *file;
  27.     ngx_uint_t                      line;
  28. ‌} ngx_mail_auth_http_conf_t;


  31. ‌typedef struct ngx_mail_auth_http_ctx_s  ngx_mail_auth_http_ctx_t;

  33. ‌typedef void (*ngx_mail_auth_http_handler_pt)(ngx_mail_session_t *s,
  34.     ngx_mail_auth_http_ctx_t *ctx);

  36. ‌struct ngx_mail_auth_http_ctx_s {
  37.     ngx_buf_t                      *request;
  38.     ngx_buf_t                      *response;
  39.     ngx_peer_connection_t           peer;

  41.     ngx_mail_auth_http_handler_pt   handler;

  43.     ngx_uint_t                      state;

  45.     u_char                         *header_name_start;
  46.     u_char                         *header_name_end;
  47.     u_char                         *header_start;
  48.     u_char                         *header_end;

  50.     ngx_str_t                       addr;
  51.     ngx_str_t                       port;
  52.     ngx_str_t                       err;
  53.     ngx_str_t                       errmsg;
  54.     ngx_str_t                       errcode;

  56.     time_t                          sleep;

  58.     ngx_pool_t                     *pool;
  59. };


  62. static void ngx_mail_auth_http_write_handler(ngx_event_t *wev);
  63. static void ngx_mail_auth_http_read_handler(ngx_event_t *rev);
  64. static void ngx_mail_auth_http_ignore_status_line(ngx_mail_session_t *s,
  65.     ngx_mail_auth_http_ctx_t *ctx);
  66. static void ngx_mail_auth_http_process_headers(ngx_mail_session_t *s,
  67.     ngx_mail_auth_http_ctx_t *ctx);
  68. static void ngx_mail_auth_sleep_handler(ngx_event_t *rev);
  69. static ngx_int_t ngx_mail_auth_http_parse_header_line(ngx_mail_session_t *s,
  70.     ngx_mail_auth_http_ctx_t *ctx);
  71. static void ngx_mail_auth_http_block_read(ngx_event_t *rev);
  72. static void ngx_mail_auth_http_dummy_handler(ngx_event_t *ev);
  73. static ngx_buf_t *ngx_mail_auth_http_create_request(ngx_mail_session_t *s,
  74.     ngx_pool_t *pool, ngx_mail_auth_http_conf_t *ahcf);
  75. static ngx_int_t ngx_mail_auth_http_escape(ngx_pool_t *pool, ngx_str_t *text,
  76.     ngx_str_t *escaped);

  78. static void *ngx_mail_auth_http_create_conf(ngx_conf_t *cf);
  79. static char *ngx_mail_auth_http_merge_conf(ngx_conf_t *cf, void *parent,
  80.     void *child);
  81. static char *ngx_mail_auth_http(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  82. static char *ngx_mail_auth_http_header(ngx_conf_t *cf, ngx_command_t *cmd,
  83.     void *conf);


  86. ‌static ngx_command_t  ngx_mail_auth_http_commands[] = {

  88.     { ngx_string("auth_http"),
  89.       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_TAKE1,
  90.       ngx_mail_auth_http,
  91.       NGX_MAIL_SRV_CONF_OFFSET,
  92.       0,
  93.       NULL },

  95.     { ngx_string("auth_http_timeout"),
  96.       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_TAKE1,
  97.       ngx_conf_set_msec_slot,
  98.       NGX_MAIL_SRV_CONF_OFFSET,
  99.       offsetof(ngx_mail_auth_http_conf_t, timeout),
  100.       NULL },

  102.     { ngx_string("auth_http_header"),
  103.       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_TAKE2,
  104.       ngx_mail_auth_http_header,
  105.       NGX_MAIL_SRV_CONF_OFFSET,
  106.       0,
  107.       NULL },

  109.       ngx_null_command
  110. };


  113. ‌static ngx_mail_module_t  ngx_mail_auth_http_module_ctx = {
  114.     NULL,                                  /* protocol */

  116.     NULL,                                  /* create main configuration */
  117.     NULL,                                  /* init main configuration */

  119.     ngx_mail_auth_http_create_conf,        /* create server configuration */
  120.     ngx_mail_auth_http_merge_conf          /* merge server configuration */
  121. };


  124. ‌ngx_module_t  ngx_mail_auth_http_module = {
  125.     NGX_MODULE_V1,
  126.     &ngx_mail_auth_http_module_ctx,        /* module context */
  127.     ngx_mail_auth_http_commands,           /* module directives */
  128.     NGX_MAIL_MODULE,                       /* module type */
  129.     NULL,                                  /* init master */
  130.     NULL,                                  /* init module */
  131.     NULL,                                  /* init process */
  132.     NULL,                                  /* init thread */
  133.     NULL,                                  /* exit thread */
  134.     NULL,                                  /* exit process */
  135.     NULL,                                  /* exit master */
  136.     NGX_MODULE_V1_PADDING
  137. };


  140. ‌static ngx_str_t   ngx_mail_auth_http_method[] = {
  141.     ngx_string("plain"),
  142.     ngx_string("plain"),
  143.     ngx_string("plain"),
  144.     ngx_string("apop"),
  145.     ngx_string("cram-md5"),
  146.     ngx_string("none")
  147. };

  149. ‌static ngx_str_t   ngx_mail_smtp_errcode = ngx_string("535 5.7.0");


  152. void
  153. ‌ngx_mail_auth_http_init(ngx_mail_session_t *s)
  154. {
  155.     ngx_int_t                   rc;
  156.     ngx_pool_t                 *pool;
  157.     ngx_mail_auth_http_ctx_t   *ctx;
  158.     ngx_mail_auth_http_conf_t  *ahcf;

  160.     s->connection->log->action = "in http auth state";

  162.     pool = ngx_create_pool(2048, s->connection->log);
  163.     if (pool == NULL) {
  164.         ngx_mail_session_internal_server_error(s);
  165.         return;
  166.     }

  168.     ctx = ngx_pcalloc(pool, sizeof(ngx_mail_auth_http_ctx_t));
  169.     if (ctx == NULL) {
  170.         ngx_destroy_pool(pool);
  171.         ngx_mail_session_internal_server_error(s);
  172.         return;
  173.     }

  175.     ctx->pool = pool;

  177.     ahcf = ngx_mail_get_module_srv_conf(s, ngx_mail_auth_http_module);

  179.     ctx->request = ngx_mail_auth_http_create_request(s, pool, ahcf);
  180.     if (ctx->request == NULL) {
  181.         ngx_destroy_pool(ctx->pool);
  182.         ngx_mail_session_internal_server_error(s);
  183.         return;
  184.     }

  186.     ngx_mail_set_ctx(s, ctx, ngx_mail_auth_http_module);

  188.     ctx->peer.sockaddr = ahcf->peer->sockaddr;
  189.     ctx->peer.socklen = ahcf->peer->socklen;
  190.     ctx->peer.name = &ahcf->peer->name;
  191.     ctx->peer.get = ngx_event_get_peer;
  192.     ctx->peer.log = s->connection->log;
  193.     ctx->peer.log_error = NGX_ERROR_ERR;

  195.     rc = ngx_event_connect_peer(&ctx->peer);

  197.     if (rc == NGX_ERROR || rc == NGX_BUSY || rc == NGX_DECLINED) {
  198.         if (ctx->peer.connection) {
  199.             ngx_close_connection(ctx->peer.connection);
  200.         }

  202.         ngx_destroy_pool(ctx->pool);
  203.         ngx_mail_session_internal_server_error(s);
  204.         return;
  205.     }

  207.     ctx->peer.connection->data = s;
  208.     ctx->peer.connection->pool = s->connection->pool;

  210.     s->connection->read->handler = ngx_mail_auth_http_block_read;
  211.     ctx->peer.connection->read->handler = ngx_mail_auth_http_read_handler;
  212.     ctx->peer.connection->write->handler = ngx_mail_auth_http_write_handler;

  214.     ctx->handler = ngx_mail_auth_http_ignore_status_line;

  216.     ngx_add_timer(ctx->peer.connection->read, ahcf->timeout);
  217.     ngx_add_timer(ctx->peer.connection->write, ahcf->timeout);

  219.     if (rc == NGX_OK) {
  220.         ngx_mail_auth_http_write_handler(ctx->peer.connection->write);
  221.         return;
  222.     }
  223. }


  226. static void
  227. ‌ngx_mail_auth_http_write_handler(ngx_event_t *wev)
  228. {
  229.     ssize_t                     n, size;
  230.     ngx_connection_t           *c;
  231.     ngx_mail_session_t         *s;
  232.     ngx_mail_auth_http_ctx_t   *ctx;
  233.     ngx_mail_auth_http_conf_t  *ahcf;

  235.     c = wev->data;
  236.     s = c->data;

  238.     ctx = ngx_mail_get_module_ctx(s, ngx_mail_auth_http_module);

  240.     ngx_log_debug0(NGX_LOG_DEBUG_MAIL, wev->log, 0,
  241.                    "mail auth http write handler");

  243.     if (wev->timedout) {
  244.         ngx_log_error(NGX_LOG_ERR, wev->log, NGX_ETIMEDOUT,
  245.                       "auth http server %V timed out", ctx->peer.name);
  246.         ngx_close_connection(c);
  247.         ngx_destroy_pool(ctx->pool);
  248.         ngx_mail_session_internal_server_error(s);
  249.         return;
  250.     }

  252.     size = ctx->request->last - ctx->request->pos;

  254.     n = ngx_send(c, ctx->request->pos, size);

  256.     if (n == NGX_ERROR) {
  257.         ngx_close_connection(c);
  258.         ngx_destroy_pool(ctx->pool);
  259.         ngx_mail_session_internal_server_error(s);
  260.         return;
  261.     }

  263.     if (n > 0) {
  264.         ctx->request->pos += n;

  266.         if (n == size) {
  267.             wev->handler = ngx_mail_auth_http_dummy_handler;

  269.             if (wev->timer_set) {
  270.                 ngx_del_timer(wev);
  271.             }

  273.             if (ngx_handle_write_event(wev, 0) != NGX_OK) {
  274.                 ngx_close_connection(c);
  275.                 ngx_destroy_pool(ctx->pool);
  276.                 ngx_mail_session_internal_server_error(s);
  277.             }

  279.             return;
  280.         }
  281.     }

  283.     if (!wev->timer_set) {
  284.         ahcf = ngx_mail_get_module_srv_conf(s, ngx_mail_auth_http_module);
  285.         ngx_add_timer(wev, ahcf->timeout);
  286.     }
  287. }


  290. static void
  291. ‌ngx_mail_auth_http_read_handler(ngx_event_t *rev)
  292. {
  293.     ssize_t                     n, size;
  294.     ngx_connection_t          *c;
  295.     ngx_mail_session_t        *s;
  296.     ngx_mail_auth_http_ctx_t  *ctx;

  298.     c = rev->data;
  299.     s = c->data;

  301.     ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  302.                    "mail auth http read handler");

  304.     ctx = ngx_mail_get_module_ctx(s, ngx_mail_auth_http_module);

  306.     if (rev->timedout) {
  307.         ngx_log_error(NGX_LOG_ERR, rev->log, NGX_ETIMEDOUT,
  308.                       "auth http server %V timed out", ctx->peer.name);
  309.         ngx_close_connection(c);
  310.         ngx_destroy_pool(ctx->pool);
  311.         ngx_mail_session_internal_server_error(s);
  312.         return;
  313.     }

  315.     if (ctx->response == NULL) {
  316.         ctx->response = ngx_create_temp_buf(ctx->pool, 1024);
  317.         if (ctx->response == NULL) {
  318.             ngx_close_connection(c);
  319.             ngx_destroy_pool(ctx->pool);
  320.             ngx_mail_session_internal_server_error(s);
  321.             return;
  322.         }
  323.     }

  325.     size = ctx->response->end - ctx->response->last;

  327.     n = ngx_recv(c, ctx->response->pos, size);

  329.     if (n > 0) {
  330.         ctx->response->last += n;

  332.         ctx->handler(s, ctx);
  333.         return;
  334.     }

  336.     if (n == NGX_AGAIN) {
  337.         return;
  338.     }

  340.     ngx_close_connection(c);
  341.     ngx_destroy_pool(ctx->pool);
  342.     ngx_mail_session_internal_server_error(s);
  343. }


  346. static void
  347. ‌ngx_mail_auth_http_ignore_status_line(ngx_mail_session_t *s,
  348.     ngx_mail_auth_http_ctx_t *ctx)
  349. {
  350.     u_char  *p, ch;
  351.     enum  {
  352.         sw_start = 0,
  353.         sw_H,
  354.         sw_HT,
  355.         sw_HTT,
  356.         sw_HTTP,
  357.         sw_skip,
  358.         sw_almost_done
  359.     } state;

  361.     ngx_log_debug0(NGX_LOG_DEBUG_MAIL, s->connection->log, 0,
  362.                    "mail auth http process status line");

  364.     state = ctx->state;

  366.     for (p = ctx->response->pos; p < ctx->response->last; p++) {
  367.         ch = *p;

  369.         switch (state) {

  371.         /* "HTTP/" */
  372.         case sw_start:
  373.             if (ch == 'H') {
  374.                 state = sw_H;
  375.                 break;
  376.             }
  377.             goto next;

  379.         case sw_H:
  380.             if (ch == 'T') {
  381.                 state = sw_HT;
  382.                 break;
  383.             }
  384.             goto next;

  386.         case sw_HT:
  387.             if (ch == 'T') {
  388.                 state = sw_HTT;
  389.                 break;
  390.             }
  391.             goto next;

  393.         case sw_HTT:
  394.             if (ch == 'P') {
  395.                 state = sw_HTTP;
  396.                 break;
  397.             }
  398.             goto next;

  400.         case sw_HTTP:
  401.             if (ch == '/') {
  402.                 state = sw_skip;
  403.                 break;
  404.             }
  405.             goto next;

  407.         /* any text until end of line */
  408.         case sw_skip:
  409.             switch (ch) {
  410.             case CR:
  411.                 state = sw_almost_done;

  413.                 break;
  414.             case LF:
  415.                 goto done;
  416.             }
  417.             break;

  419.         /* end of status line */
  420.         case sw_almost_done:
  421.             if (ch == LF) {
  422.                 goto done;
  423.             }

  425.             ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  426.                           "auth http server &V sent invalid response",
  427.                           ctx->peer.name);
  428.             ngx_close_connection(ctx->peer.connection);
  429.             ngx_destroy_pool(ctx->pool);
  430.             ngx_mail_session_internal_server_error(s);
  431.             return;
  432.         }
  433.     }

  435.     ctx->response->pos = p;
  436.     ctx->state = state;

  438.     return;

  440. next:

  442.     p = ctx->response->start - 1;

  444. done:

  446.     ctx->response->pos = p + 1;
  447.     ctx->state = 0;
  448.     ctx->handler = ngx_mail_auth_http_process_headers;
  449.     ctx->handler(s, ctx);
  450. }


  453. static void
  454. ‌ngx_mail_auth_http_process_headers(ngx_mail_session_t *s,
  455.     ngx_mail_auth_http_ctx_t *ctx)
  456. {
  457.     u_char               *p;
  458.     time_t                timer;
  459.     size_t                len, size;
  460.     ngx_int_t             rc, port, n;
  461.     ngx_addr_t           *peer;
  462.     struct sockaddr_in   *sin;
  463. #if (NGX_HAVE_INET6)
  464.     struct sockaddr_in6  *sin6;
  465. #endif

  467.     ngx_log_debug0(NGX_LOG_DEBUG_MAIL, s->connection->log, 0,
  468.                    "mail auth http process headers");

  470.     for ( ;; ) {
  471.         rc = ngx_mail_auth_http_parse_header_line(s, ctx);

  473.         if (rc == NGX_OK) {

  475. #if (NGX_DEBUG)
  476.             {
  477.             ngx_str_t  key, value;

  479.             key.len = ctx->header_name_end - ctx->header_name_start;
  480.             key.data = ctx->header_name_start;
  481.             value.len = ctx->header_end - ctx->header_start;
  482.             value.data = ctx->header_start;

  484.             ngx_log_debug2(NGX_LOG_DEBUG_MAIL, s->connection->log, 0,
  485.                            "mail auth http header: \"%V: %V\"",
  486.                            &key, &value);
  487.             }
  488. #endif

  490.             len = ctx->header_name_end - ctx->header_name_start;

  492.             if (len == sizeof("Auth-Status") - 1
  493.                 && ngx_strncasecmp(ctx->header_name_start,
  494.                                    (u_char *) "Auth-Status",
  495.                                    sizeof("Auth-Status") - 1)
  496.                    == 0)
  497.             {
  498.                 len = ctx->header_end - ctx->header_start;

  500.                 if (len == 2
  501.                     && ctx->header_start[0] == 'O'
  502.                     && ctx->header_start[1] == 'K')
  503.                 {
  504.                     continue;
  505.                 }

  507.                 if (len == 4
  508.                     && ctx->header_start[0] == 'W'
  509.                     && ctx->header_start[1] == 'A'
  510.                     && ctx->header_start[2] == 'I'
  511.                     && ctx->header_start[3] == 'T')
  512.                 {
  513.                     s->auth_wait = 1;
  514.                     continue;
  515.                 }

  517.                 ctx->errmsg.len = len;
  518.                 ctx->errmsg.data = ctx->header_start;

  520.                 switch (s->protocol) {

  522.                 case NGX_MAIL_POP3_PROTOCOL:
  523.                     size = sizeof("-ERR ") - 1 + len + sizeof(CRLF) - 1;
  524.                     break;

  526.                 case NGX_MAIL_IMAP_PROTOCOL:
  527.                     size = s->tag.len + sizeof("NO ") - 1 + len
  528.                            + sizeof(CRLF) - 1;
  529.                     break;

  531.                 default: /* NGX_MAIL_SMTP_PROTOCOL */
  532.                     ctx->err = ctx->errmsg;
  533.                     continue;
  534.                 }

  536.                 p = ngx_pnalloc(s->connection->pool, size);
  537.                 if (p == NULL) {
  538.                     ngx_close_connection(ctx->peer.connection);
  539.                     ngx_destroy_pool(ctx->pool);
  540.                     ngx_mail_session_internal_server_error(s);
  541.                     return;
  542.                 }

  544.                 ctx->err.data = p;

  546.                 switch (s->protocol) {

  548.                 case NGX_MAIL_POP3_PROTOCOL:
  549.                     *p++ = '-'; *p++ = 'E'; *p++ = 'R'; *p++ = 'R'; *p++ = ' ';
  550.                     break;

  552.                 case NGX_MAIL_IMAP_PROTOCOL:
  553.                     p = ngx_cpymem(p, s->tag.data, s->tag.len);
  554.                     *p++ = 'N'; *p++ = 'O'; *p++ = ' ';
  555.                     break;

  557.                 default: /* NGX_MAIL_SMTP_PROTOCOL */
  558.                     break;
  559.                 }

  561.                 p = ngx_cpymem(p, ctx->header_start, len);
  562.                 *p++ = CR; *p++ = LF;

  564.                 ctx->err.len = p - ctx->err.data;

  566.                 continue;
  567.             }

  569.             if (len == sizeof("Auth-Server") - 1
  570.                 && ngx_strncasecmp(ctx->header_name_start,
  571.                                    (u_char *) "Auth-Server",
  572.                                    sizeof("Auth-Server") - 1)
  573.                     == 0)
  574.             {
  575.                 ctx->addr.len = ctx->header_end - ctx->header_start;
  576.                 ctx->addr.data = ctx->header_start;

  578.                 continue;
  579.             }

  581.             if (len == sizeof("Auth-Port") - 1
  582.                 && ngx_strncasecmp(ctx->header_name_start,
  583.                                    (u_char *) "Auth-Port",
  584.                                    sizeof("Auth-Port") - 1)
  585.                    == 0)
  586.             {
  587.                 ctx->port.len = ctx->header_end - ctx->header_start;
  588.                 ctx->port.data = ctx->header_start;

  590.                 continue;
  591.             }

  593.             if (len == sizeof("Auth-User") - 1
  594.                 && ngx_strncasecmp(ctx->header_name_start,
  595.                                    (u_char *) "Auth-User",
  596.                                    sizeof("Auth-User") - 1)
  597.                    == 0)
  598.             {
  599.                 s->login.len = ctx->header_end - ctx->header_start;

  601.                 s->login.data = ngx_pnalloc(s->connection->pool, s->login.len);
  602.                 if (s->login.data == NULL) {
  603.                     ngx_close_connection(ctx->peer.connection);
  604.                     ngx_destroy_pool(ctx->pool);
  605.                     ngx_mail_session_internal_server_error(s);
  606.                     return;
  607.                 }

  609.                 ngx_memcpy(s->login.data, ctx->header_start, s->login.len);

  611.                 continue;
  612.             }

  614.             if (len == sizeof("Auth-Pass") - 1
  615.                 && ngx_strncasecmp(ctx->header_name_start,
  616.                                    (u_char *) "Auth-Pass",
  617.                                    sizeof("Auth-Pass") - 1)
  618.                    == 0)
  619.             {
  620.                 s->passwd.len = ctx->header_end - ctx->header_start;

  622.                 s->passwd.data = ngx_pnalloc(s->connection->pool,
  623.                                              s->passwd.len);
  624.                 if (s->passwd.data == NULL) {
  625.                     ngx_close_connection(ctx->peer.connection);
  626.                     ngx_destroy_pool(ctx->pool);
  627.                     ngx_mail_session_internal_server_error(s);
  628.                     return;
  629.                 }

  631.                 ngx_memcpy(s->passwd.data, ctx->header_start, s->passwd.len);

  633.                 continue;
  634.             }

  636.             if (len == sizeof("Auth-Wait") - 1
  637.                 && ngx_strncasecmp(ctx->header_name_start,
  638.                                    (u_char *) "Auth-Wait",
  639.                                    sizeof("Auth-Wait") - 1)
  640.                    == 0)
  641.             {
  642.                 n = ngx_atoi(ctx->header_start,
  643.                              ctx->header_end - ctx->header_start);

  645.                 if (n != NGX_ERROR) {
  646.                     ctx->sleep = n;
  647.                 }

  649.                 continue;
  650.             }

  652.             if (len == sizeof("Auth-Error-Code") - 1
  653.                 && ngx_strncasecmp(ctx->header_name_start,
  654.                                    (u_char *) "Auth-Error-Code",
  655.                                    sizeof("Auth-Error-Code") - 1)
  656.                    == 0)
  657.             {
  658.                 ctx->errcode.len = ctx->header_end - ctx->header_start;

  660.                 ctx->errcode.data = ngx_pnalloc(s->connection->pool,
  661.                                                 ctx->errcode.len);
  662.                 if (ctx->errcode.data == NULL) {
  663.                     ngx_close_connection(ctx->peer.connection);
  664.                     ngx_destroy_pool(ctx->pool);
  665.                     ngx_mail_session_internal_server_error(s);
  666.                     return;
  667.                 }

  669.                 ngx_memcpy(ctx->errcode.data, ctx->header_start,
  670.                            ctx->errcode.len);

  672.                 continue;
  673.             }

  675.             /* ignore other headers */

  677.             continue;
  678.         }

  680.         if (rc == NGX_DONE) {
  681.             ngx_log_debug0(NGX_LOG_DEBUG_MAIL, s->connection->log, 0,
  682.                            "mail auth http header done");

  684.             ngx_close_connection(ctx->peer.connection);

  686.             if (ctx->err.len) {

  688.                 ngx_log_error(NGX_LOG_INFO, s->connection->log, 0,
  689.                               "client login failed: \"%V\"", &ctx->errmsg);

  691.                 if (s->protocol == NGX_MAIL_SMTP_PROTOCOL) {

  693.                     if (ctx->errcode.len == 0) {
  694.                         ctx->errcode = ngx_mail_smtp_errcode;
  695.                     }

  697.                     ctx->err.len = ctx->errcode.len + ctx->errmsg.len
  698.                                    + sizeof(" " CRLF) - 1;

  700.                     p = ngx_pnalloc(s->connection->pool, ctx->err.len);
  701.                     if (p == NULL) {
  702.                         ngx_destroy_pool(ctx->pool);
  703.                         ngx_mail_session_internal_server_error(s);
  704.                         return;
  705.                     }

  707.                     ctx->err.data = p;

  709.                     p = ngx_cpymem(p, ctx->errcode.data, ctx->errcode.len);
  710.                     *p++ = ' ';
  711.                     p = ngx_cpymem(p, ctx->errmsg.data, ctx->errmsg.len);
  712.                     *p++ = CR; *p = LF;
  713.                 }

  715.                 s->out = ctx->err;
  716.                 timer = ctx->sleep;

  718.                 ngx_destroy_pool(ctx->pool);

  720.                 if (timer == 0) {
  721.                     s->quit = 1;
  722.                     ngx_mail_send(s->connection->write);
  723.                     return;
  724.                 }

  726.                 ngx_add_timer(s->connection->read, (ngx_msec_t) (timer * 1000));

  728.                 s->connection->read->handler = ngx_mail_auth_sleep_handler;

  730.                 return;
  731.             }

  733.             if (s->auth_wait) {
  734.                 timer = ctx->sleep;

  736.                 ngx_destroy_pool(ctx->pool);

  738.                 if (timer == 0) {
  739.                     ngx_mail_auth_http_init(s);
  740.                     return;
  741.                 }

  743.                 ngx_add_timer(s->connection->read, (ngx_msec_t) (timer * 1000));

  745.                 s->connection->read->handler = ngx_mail_auth_sleep_handler;

  747.                 return;
  748.             }

  750.             if (ctx->addr.len == 0 || ctx->port.len == 0) {
  751.                 ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  752.                               "auth http server %V did not send server or port",
  753.                               ctx->peer.name);
  754.                 ngx_destroy_pool(ctx->pool);
  755.                 ngx_mail_session_internal_server_error(s);
  756.                 return;
  757.             }

  759.             if (s->passwd.data == NULL
  760.                 && s->protocol != NGX_MAIL_SMTP_PROTOCOL)
  761.             {
  762.                 ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  763.                               "auth http server %V did not send password",
  764.                               ctx->peer.name);
  765.                 ngx_destroy_pool(ctx->pool);
  766.                 ngx_mail_session_internal_server_error(s);
  767.                 return;
  768.             }

  770.             peer = ngx_pcalloc(s->connection->pool, sizeof(ngx_addr_t));
  771.             if (peer == NULL) {
  772.                 ngx_destroy_pool(ctx->pool);
  773.                 ngx_mail_session_internal_server_error(s);
  774.                 return;
  775.             }

  777.             rc = ngx_parse_addr(s->connection->pool, peer,
  778.                                 ctx->addr.data, ctx->addr.len);

  780.             switch (rc) {
  781.             case NGX_OK:
  782.                 break;

  784.             case NGX_DECLINED:
  785.                 ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  786.                               "auth http server %V sent invalid server "
  787.                               "address:\"%V\"",
  788.                               ctx->peer.name, &ctx->addr);
  789.                 /* fall through */

  791.             default:
  792.                 ngx_destroy_pool(ctx->pool);
  793.                 ngx_mail_session_internal_server_error(s);
  794.                 return;
  795.             }

  797.             port = ngx_atoi(ctx->port.data, ctx->port.len);
  798.             if (port == NGX_ERROR || port < 1 || port > 65535) {
  799.                 ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  800.                               "auth http server %V sent invalid server "
  801.                               "port:\"%V\"",
  802.                               ctx->peer.name, &ctx->port);
  803.                 ngx_destroy_pool(ctx->pool);
  804.                 ngx_mail_session_internal_server_error(s);
  805.                 return;
  806.             }

  808.             switch (peer->sockaddr->sa_family) {

  810. #if (NGX_HAVE_INET6)
  811.             case AF_INET6:
  812.                 sin6 = (struct sockaddr_in6 *) peer->sockaddr;
  813.                 sin6->sin6_port = htons((in_port_t) port);
  814.                 break;
  815. #endif

  817.             default: /* AF_INET */
  818.                 sin = (struct sockaddr_in *) peer->sockaddr;
  819.                 sin->sin_port = htons((in_port_t) port);
  820.                 break;
  821.             }

  823.             len = ctx->addr.len + 1 + ctx->port.len;

  825.             peer->name.len = len;

  827.             peer->name.data = ngx_pnalloc(s->connection->pool, len);
  828.             if (peer->name.data == NULL) {
  829.                 ngx_destroy_pool(ctx->pool);
  830.                 ngx_mail_session_internal_server_error(s);
  831.                 return;
  832.             }

  834.             len = ctx->addr.len;

  836.             ngx_memcpy(peer->name.data, ctx->addr.data, len);

  838.             peer->name.data[len++] = ':';

  840.             ngx_memcpy(peer->name.data + len, ctx->port.data, ctx->port.len);

  842.             ngx_destroy_pool(ctx->pool);
  843.             ngx_mail_proxy_init(s, peer);

  845.             return;
  846.         }

  848.         if (rc == NGX_AGAIN ) {
  849.             return;
  850.         }

  852.         /* rc == NGX_ERROR */

  854.         ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  855.                       "auth http server %V sent invalid header in response",
  856.                       ctx->peer.name);
  857.         ngx_close_connection(ctx->peer.connection);
  858.         ngx_destroy_pool(ctx->pool);
  859.         ngx_mail_session_internal_server_error(s);

  861.         return;
  862.     }
  863. }


  866. static void
  867. ‌ngx_mail_auth_sleep_handler(ngx_event_t *rev)
  868. {
  869.     ngx_connection_t          *c;
  870.     ngx_mail_session_t        *s;
  871.     ngx_mail_core_srv_conf_t  *cscf;

  873.     ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0, "mail auth sleep handler");

  875.     c = rev->data;
  876.     s = c->data;

  878.     if (rev->timedout) {

  880.         rev->timedout = 0;

  882.         if (s->auth_wait) {
  883.             s->auth_wait = 0;
  884.             ngx_mail_auth_http_init(s);
  885.             return;
  886.         }

  888.         cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  890.         rev->handler = cscf->protocol->auth_state;

  892.         s->mail_state = 0;
  893.         s->auth_method = NGX_MAIL_AUTH_PLAIN;

  895.         c->log->action = "in auth state";

  897.         ngx_mail_send(c->write);

  899.         if (c->destroyed) {
  900.             return;
  901.         }

  903.         ngx_add_timer(rev, cscf->timeout);

  905.         if (rev->ready) {
  906.             rev->handler(rev);
  907.             return;
  908.         }

  910.         if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  911.             ngx_mail_close_connection(c);
  912.         }

  914.         return;
  915.     }

  917.     if (rev->active) {
  918.         if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  919.             ngx_mail_close_connection(c);
  920.         }
  921.     }
  922. }


  925. static ngx_int_t
  926. ‌ngx_mail_auth_http_parse_header_line(ngx_mail_session_t *s,
  927.     ngx_mail_auth_http_ctx_t *ctx)
  928. {
  929.     u_char      c, ch, *p;
  930.     enum {
  931.         sw_start = 0,
  932.         sw_name,
  933.         sw_space_before_value,
  934.         sw_value,
  935.         sw_space_after_value,
  936.         sw_almost_done,
  937.         sw_header_almost_done
  938.     } state;

  940.     state = ctx->state;

  942.     for (p = ctx->response->pos; p < ctx->response->last; p++) {
  943.         ch = *p;

  945.         switch (state) {

  947.         /* first char */
  948.         case sw_start:

  950.             switch (ch) {
  951.             case CR:
  952.                 ctx->header_end = p;
  953.                 state = sw_header_almost_done;
  954.                 break;
  955.             case LF:
  956.                 ctx->header_end = p;
  957.                 goto header_done;
  958.             default:
  959.                 state = sw_name;
  960.                 ctx->header_name_start = p;

  962.                 c = (u_char) (ch | 0x20);
  963.                 if (c >= 'a' && c <= 'z') {
  964.                     break;
  965.                 }

  967.                 if (ch >= '0' && ch <= '9') {
  968.                     break;
  969.                 }

  971.                 return NGX_ERROR;
  972.             }
  973.             break;

  975.         /* header name */
  976.         case sw_name:
  977.             c = (u_char) (ch | 0x20);
  978.             if (c >= 'a' && c <= 'z') {
  979.                 break;
  980.             }

  982.             if (ch == ':') {
  983.                 ctx->header_name_end = p;
  984.                 state = sw_space_before_value;
  985.                 break;
  986.             }

  988.             if (ch == '-') {
  989.                 break;
  990.             }

  992.             if (ch >= '0' && ch <= '9') {
  993.                 break;
  994.             }

  996.             if (ch == CR) {
  997.                 ctx->header_name_end = p;
  998.                 ctx->header_start = p;
  999.                 ctx->header_end = p;
  1000.                 state = sw_almost_done;
  1001.                 break;
  1002.             }

  1004.             if (ch == LF) {
  1005.                 ctx->header_name_end = p;
  1006.                 ctx->header_start = p;
  1007.                 ctx->header_end = p;
  1008.                 goto done;
  1009.             }

  1011.             return NGX_ERROR;

  1013.         /* space* before header value */
  1014.         case sw_space_before_value:
  1015.             switch (ch) {
  1016.             case ' ':
  1017.                 break;
  1018.             case CR:
  1019.                 ctx->header_start = p;
  1020.                 ctx->header_end = p;
  1021.                 state = sw_almost_done;
  1022.                 break;
  1023.             case LF:
  1024.                 ctx->header_start = p;
  1025.                 ctx->header_end = p;
  1026.                 goto done;
  1027.             default:
  1028.                 ctx->header_start = p;
  1029.                 state = sw_value;
  1030.                 break;
  1031.             }
  1032.             break;

  1034.         /* header value */
  1035.         case sw_value:
  1036.             switch (ch) {
  1037.             case ' ':
  1038.                 ctx->header_end = p;
  1039.                 state = sw_space_after_value;
  1040.                 break;
  1041.             case CR:
  1042.                 ctx->header_end = p;
  1043.                 state = sw_almost_done;
  1044.                 break;
  1045.             case LF:
  1046.                 ctx->header_end = p;
  1047.                 goto done;
  1048.             }
  1049.             break;

  1051.         /* space* before end of header line */
  1052.         case sw_space_after_value:
  1053.             switch (ch) {
  1054.             case ' ':
  1055.                 break;
  1056.             case CR:
  1057.                 state = sw_almost_done;
  1058.                 break;
  1059.             case LF:
  1060.                 goto done;
  1061.             default:
  1062.                 state = sw_value;
  1063.                 break;
  1064.             }
  1065.             break;

  1067.         /* end of header line */
  1068.         case sw_almost_done:
  1069.             switch (ch) {
  1070.             case LF:
  1071.                 goto done;
  1072.             default:
  1073.                 return NGX_ERROR;
  1074.             }

  1076.         /* end of header */
  1077.         case sw_header_almost_done:
  1078.             switch (ch) {
  1079.             case LF:
  1080.                 goto header_done;
  1081.             default:
  1082.                 return NGX_ERROR;
  1083.             }
  1084.         }
  1085.     }

  1087.     ctx->response->pos = p;
  1088.     ctx->state = state;

  1090.     return NGX_AGAIN;

  1092. done:

  1094.     ctx->response->pos = p + 1;
  1095.     ctx->state = sw_start;

  1097.     return NGX_OK;

  1099. header_done:

  1101.     ctx->response->pos = p + 1;
  1102.     ctx->state = sw_start;

  1104.     return NGX_DONE;
  1105. }


  1108. static void
  1109. ‌ngx_mail_auth_http_block_read(ngx_event_t *rev)
  1110. {
  1111.     ngx_connection_t          *c;
  1112.     ngx_mail_session_t        *s;
  1113.     ngx_mail_auth_http_ctx_t  *ctx;

  1115.     ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
  1116.                    "mail auth http block read");

  1118.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  1119.         c = rev->data;
  1120.         s = c->data;

  1122.         ctx = ngx_mail_get_module_ctx(s, ngx_mail_auth_http_module);

  1124.         ngx_close_connection(ctx->peer.connection);
  1125.         ngx_destroy_pool(ctx->pool);
  1126.         ngx_mail_session_internal_server_error(s);
  1127.     }
  1128. }


  1131. static void
  1132. ‌ngx_mail_auth_http_dummy_handler(ngx_event_t *ev)
  1133. {
  1134.     ngx_log_debug0(NGX_LOG_DEBUG_MAIL, ev->log, 0,
  1135.                    "mail auth http dummy handler");
  1136. }


  1139. static ngx_buf_t *
  1140. ‌ngx_mail_auth_http_create_request(ngx_mail_session_t *s, ngx_pool_t *pool,
  1141.     ngx_mail_auth_http_conf_t *ahcf)
  1142. {
  1143.     size_t                     len;
  1144.     ngx_buf_t                 *b;
  1145.     ngx_str_t                  login, passwd;
  1146.     ngx_mail_core_srv_conf_t  *cscf;

  1148.     if (ngx_mail_auth_http_escape(pool, &s->login, &login) != NGX_OK) {
  1149.         return NULL;
  1150.     }

  1152.     if (ngx_mail_auth_http_escape(pool, &s->passwd, &passwd) != NGX_OK) {
  1153.         return NULL;
  1154.     }

  1156.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  1158.     len = sizeof("GET ") - 1 + ahcf->uri.len + sizeof(" HTTP/1.0" CRLF) - 1
  1159.           + sizeof("Host: ") - 1 + ahcf->host_header.len + sizeof(CRLF) - 1
  1160.           + sizeof("Auth-Method: ") - 1
  1161.                 + ngx_mail_auth_http_method[s->auth_method].len
  1162.                 + sizeof(CRLF) - 1
  1163.           + sizeof("Auth-User: ") - 1 + login.len + sizeof(CRLF) - 1
  1164.           + sizeof("Auth-Pass: ") - 1 + passwd.len + sizeof(CRLF) - 1
  1165.           + sizeof("Auth-Salt: ") - 1 + s->salt.len
  1166.           + sizeof("Auth-Protocol: ") - 1 + cscf->protocol->name.len
  1167.                 + sizeof(CRLF) - 1
  1168.           + sizeof("Auth-Login-Attempt: ") - 1 + NGX_INT_T_LEN
  1169.                 + sizeof(CRLF) - 1
  1170.           + sizeof("Client-IP: ") - 1 + s->connection->addr_text.len
  1171.                 + sizeof(CRLF) - 1
  1172.           + sizeof("Client-Host: ") - 1 + s->host.len + sizeof(CRLF) - 1
  1173.           + sizeof("Auth-SMTP-Helo: ") - 1 + s->smtp_helo.len
  1174.           + sizeof("Auth-SMTP-From: ") - 1 + s->smtp_from.len
  1175.           + sizeof("Auth-SMTP-To: ") - 1 + s->smtp_to.len
  1176.           + ahcf->header.len
  1177.           + sizeof(CRLF) - 1;

  1179.     b = ngx_create_temp_buf(pool, len);
  1180.     if (b == NULL) {
  1181.         return NULL;
  1182.     }

  1184.     b->last = ngx_cpymem(b->last, "GET ", sizeof("GET ") - 1);
  1185.     b->last = ngx_copy(b->last, ahcf->uri.data, ahcf->uri.len);
  1186.     b->last = ngx_cpymem(b->last, " HTTP/1.0" CRLF,
  1187.                          sizeof(" HTTP/1.0" CRLF) - 1);

  1189.     b->last = ngx_cpymem(b->last, "Host: ", sizeof("Host: ") - 1);
  1190.     b->last = ngx_copy(b->last, ahcf->host_header.data,
  1191.                          ahcf->host_header.len);
  1192.     *b->last++ = CR; *b->last++ = LF;

  1194.     b->last = ngx_cpymem(b->last, "Auth-Method: ",
  1195.                          sizeof("Auth-Method: ") - 1);
  1196.     b->last = ngx_cpymem(b->last,
  1197.                          ngx_mail_auth_http_method[s->auth_method].data,
  1198.                          ngx_mail_auth_http_method[s->auth_method].len);
  1199.     *b->last++ = CR; *b->last++ = LF;

  1201.     b->last = ngx_cpymem(b->last, "Auth-User: ", sizeof("Auth-User: ") - 1);
  1202.     b->last = ngx_copy(b->last, login.data, login.len);
  1203.     *b->last++ = CR; *b->last++ = LF;

  1205.     b->last = ngx_cpymem(b->last, "Auth-Pass: ", sizeof("Auth-Pass: ") - 1);
  1206.     b->last = ngx_copy(b->last, passwd.data, passwd.len);
  1207.     *b->last++ = CR; *b->last++ = LF;

  1209.     if (s->auth_method != NGX_MAIL_AUTH_PLAIN && s->salt.len) {
  1210.         b->last = ngx_cpymem(b->last, "Auth-Salt: ", sizeof("Auth-Salt: ") - 1);
  1211.         b->last = ngx_copy(b->last, s->salt.data, s->salt.len);

  1213.         s->passwd.data = NULL;
  1214.     }

  1216.     b->last = ngx_cpymem(b->last, "Auth-Protocol: ",
  1217.                          sizeof("Auth-Protocol: ") - 1);
  1218.     b->last = ngx_cpymem(b->last, cscf->protocol->name.data,
  1219.                          cscf->protocol->name.len);
  1220.     *b->last++ = CR; *b->last++ = LF;

  1222.     b->last = ngx_sprintf(b->last, "Auth-Login-Attempt: %ui" CRLF,
  1223.                           s->login_attempt);

  1225.     b->last = ngx_cpymem(b->last, "Client-IP: ", sizeof("Client-IP: ") - 1);
  1226.     b->last = ngx_copy(b->last, s->connection->addr_text.data,
  1227.                        s->connection->addr_text.len);
  1228.     *b->last++ = CR; *b->last++ = LF;

  1230.     if (s->host.len) {
  1231.         b->last = ngx_cpymem(b->last, "Client-Host: ",
  1232.                              sizeof("Client-Host: ") - 1);
  1233.         b->last = ngx_copy(b->last, s->host.data, s->host.len);
  1234.         *b->last++ = CR; *b->last++ = LF;
  1235.     }

  1237.     if (s->auth_method == NGX_MAIL_AUTH_NONE) {

  1239.         /* HELO, MAIL FROM, and RCPT TO can't contain CRLF, no need to escape */

  1241.         b->last = ngx_cpymem(b->last, "Auth-SMTP-Helo: ",
  1242.                              sizeof("Auth-SMTP-Helo: ") - 1);
  1243.         b->last = ngx_copy(b->last, s->smtp_helo.data, s->smtp_helo.len);
  1244.         *b->last++ = CR; *b->last++ = LF;

  1246.         b->last = ngx_cpymem(b->last, "Auth-SMTP-From: ",
  1247.                              sizeof("Auth-SMTP-From: ") - 1);
  1248.         b->last = ngx_copy(b->last, s->smtp_from.data, s->smtp_from.len);
  1249.         *b->last++ = CR; *b->last++ = LF;

  1251.         b->last = ngx_cpymem(b->last, "Auth-SMTP-To: ",
  1252.                              sizeof("Auth-SMTP-To: ") - 1);
  1253.         b->last = ngx_copy(b->last, s->smtp_to.data, s->smtp_to.len);
  1254.         *b->last++ = CR; *b->last++ = LF;

  1256.     }

  1258.     if (ahcf->header.len) {
  1259.         b->last = ngx_copy(b->last, ahcf->header.data, ahcf->header.len);
  1260.     }

  1262.     /* add "\r\n" at the header end */
  1263.     *b->last++ = CR; *b->last++ = LF;

  1265. #if (NGX_DEBUG_MAIL_PASSWD)
  1266.     {
  1267.     ngx_str_t  l;

  1269.     l.len = b->last - b->pos;
  1270.     l.data = b->pos;
  1271.     ngx_log_debug1(NGX_LOG_DEBUG_MAIL, s->connection->log, 0,
  1272.                    "mail auth http header:%N\"%V\"", &l);
  1273.     }
  1274. #endif

  1276.     return b;
  1277. }


  1280. static ngx_int_t
  1281. ‌ngx_mail_auth_http_escape(ngx_pool_t *pool, ngx_str_t *text, ngx_str_t *escaped)
  1282. {
  1283.     u_char     *p;
  1284.     uintptr_t   n;

  1286.     n = ngx_escape_uri(NULL, text->data, text->len, NGX_ESCAPE_MAIL_AUTH);

  1288.     if (n == 0) {
  1289.         *escaped = *text;
  1290.         return NGX_OK;
  1291.     }

  1293.     escaped->len = text->len + n * 2;

  1295.     p = ngx_pnalloc(pool, escaped->len);
  1296.     if (p == NULL) {
  1297.         return NGX_ERROR;
  1298.     }

  1300.     (void) ngx_escape_uri(p, text->data, text->len, NGX_ESCAPE_MAIL_AUTH);

  1302.     escaped->data = p;

  1304.     return NGX_OK;
  1305. }


  1308. static void *
  1309. ‌ngx_mail_auth_http_create_conf(ngx_conf_t *cf)
  1310. {
  1311.     ngx_mail_auth_http_conf_t  *ahcf;

  1313.     ahcf = ngx_pcalloc(cf->pool, sizeof(ngx_mail_auth_http_conf_t));
  1314.     if (ahcf == NULL) {
  1315.         return NULL;
  1316.     }

  1318.     ahcf->timeout = NGX_CONF_UNSET_MSEC;

  1320.     ahcf->file = cf->conf_file->file.name.data;
  1321.     ahcf->line = cf->conf_file->line;

  1323.     return ahcf;
  1324. }


  1327. static char *
  1328. ‌ngx_mail_auth_http_merge_conf(ngx_conf_t *cf, void *parent, void *child)
  1329. {
  1330.     ngx_mail_auth_http_conf_t *prev = parent;
  1331.     ngx_mail_auth_http_conf_t *conf = child;

  1333.     u_char           *p;
  1334.     size_t            len;
  1335.     ngx_uint_t        i;
  1336.     ngx_table_elt_t  *header;

  1338.     if (conf->peer == NULL) {
  1339.         conf->peer = prev->peer;
  1340.         conf->host_header = prev->host_header;
  1341.         conf->uri = prev->uri;

  1343.         if (conf->peer == NULL) {
  1344.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  1345.                           "no \"auth_http\" is defined for server in %s:%ui",
  1346.                           conf->file, conf->line);

  1348.             return NGX_CONF_ERROR;
  1349.         }
  1350.     }

  1352.     ngx_conf_merge_msec_value(conf->timeout, prev->timeout, 60000);

  1354.     if (conf->headers == NULL) {
  1355.         conf->headers = prev->headers;
  1356.         conf->header = prev->header;
  1357.     }

  1359.     if (conf->headers && conf->header.len == 0) {
  1360.         len = 0;
  1361.         header = conf->headers->elts;
  1362.         for (i = 0; i < conf->headers->nelts; i++) {
  1363.             len += header[i].key.len + 2 + header[i].value.len + 2;
  1364.         }

  1366.         p = ngx_pnalloc(cf->pool, len);
  1367.         if (p == NULL) {
  1368.             return NGX_CONF_ERROR;
  1369.         }

  1371.         conf->header.len = len;
  1372.         conf->header.data = p;

  1374.         for (i = 0; i < conf->headers->nelts; i++) {
  1375.             p = ngx_cpymem(p, header[i].key.data, header[i].key.len);
  1376.             *p++ = ':'; *p++ = ' ';
  1377.             p = ngx_cpymem(p, header[i].value.data, header[i].value.len);
  1378.             *p++ = CR; *p++ = LF;
  1379.         }
  1380.     }

  1382.     return NGX_CONF_OK;
  1383. }


  1386. static char *
  1387. ‌ngx_mail_auth_http(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1388. {
  1389.     ngx_mail_auth_http_conf_t *ahcf = conf;

  1391.     ngx_str_t  *value;
  1392.     ngx_url_t   u;

  1394.     value = cf->args->elts;

  1396.     ngx_memzero(&u, sizeof(ngx_url_t));

  1398.     u.url = value[1];
  1399.     u.default_port = 80;
  1400.     u.uri_part = 1;

  1402.     if (ngx_strncmp(u.url.data, "http://", 7) == 0) {
  1403.         u.url.len -= 7;
  1404.         u.url.data += 7;
  1405.     }

  1407.     if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
  1408.         if (u.err) {
  1409.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1410.                                "%s in auth_http \"%V\"", u.err, &u.url);
  1411.         }

  1413.         return NGX_CONF_ERROR;
  1414.     }

  1416.     ahcf->peer = u.addrs;

  1418.     if (u.family != AF_UNIX) {
  1419.         ahcf->host_header = u.host;

  1421.     } else {
  1422.         ngx_str_set(&ahcf->host_header, "localhost");
  1423.     }

  1425.     ahcf->uri = u.uri;

  1427.     if (ahcf->uri.len == 0) {
  1428.         ngx_str_set(&ahcf->uri, "/");
  1429.     }

  1431.     return NGX_CONF_OK;
  1432. }


  1435. static char *
  1436. ‌ngx_mail_auth_http_header(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1437. {
  1438.     ngx_mail_auth_http_conf_t *ahcf = conf;

  1440.     ngx_str_t        *value;
  1441.     ngx_table_elt_t  *header;

  1443.     if (ahcf->headers == NULL) {
  1444.         ahcf->headers = ngx_array_create(cf->pool, 1, sizeof(ngx_table_elt_t));
  1445.         if (ahcf->headers == NULL) {
  1446.             return NGX_CONF_ERROR;
  1447.         }
  1448.     }

  1450.     header = ngx_array_push(ahcf->headers);
  1451.     if (header == NULL) {
  1452.         return NGX_CONF_ERROR;
  1453.     }

  1455.     value = cf->args->elts;

  1457.     header->key = value[1];
  1458.     header->value = value[2];

  1460.     return NGX_CONF_OK;
  1461. }

One Level Up Top Level