One Level Up Top Level

src/mail/ngx_mail_handler.c - nginx-1.7.10

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_mail.h>


  14. static void ngx_mail_init_session(ngx_connection_t *c);

  16. #if (NGX_MAIL_SSL)
  17. static void ngx_mail_ssl_init_connection(ngx_ssl_t *ssl, ngx_connection_t *c);
  18. static void ngx_mail_ssl_handshake_handler(ngx_connection_t *c);
  19. #endif


  22. void
  23. ‌ngx_mail_init_connection(ngx_connection_t *c)
  24. {
  25.     size_t                 len;
  26.     ngx_uint_t             i;
  27.     ngx_mail_port_t       *port;
  28.     struct sockaddr       *sa;
  29.     struct sockaddr_in    *sin;
  30.     ngx_mail_log_ctx_t    *ctx;
  31.     ngx_mail_in_addr_t    *addr;
  32.     ngx_mail_session_t    *s;
  33.     ngx_mail_addr_conf_t  *addr_conf;
  34.     u_char                 text[NGX_SOCKADDR_STRLEN];
  35. #if (NGX_HAVE_INET6)
  36.     struct sockaddr_in6   *sin6;
  37.     ngx_mail_in6_addr_t   *addr6;
  38. #endif


  41.     /* find the server configuration for the address:port */

  43.     port = c->listening->servers;

  45.     if (port->naddrs > 1) {

  47.         /*
  48.          * There are several addresses on this port and one of them
  49.          * is the "*:port" wildcard so getsockname() is needed to determine
  50.          * the server address.
  51.          *
  52.          * AcceptEx() already gave this address.
  53.          */

  55.         if (ngx_connection_local_sockaddr(c, NULL, 0) != NGX_OK) {
  56.             ngx_mail_close_connection(c);
  57.             return;
  58.         }

  60.         sa = c->local_sockaddr;

  62.         switch (sa->sa_family) {

  64. #if (NGX_HAVE_INET6)
  65.         case AF_INET6:
  66.             sin6 = (struct sockaddr_in6 *) sa;

  68.             addr6 = port->addrs;

  70.             /* the last address is "*" */

  72.             for (i = 0; i < port->naddrs - 1; i++) {
  73.                 if (ngx_memcmp(&addr6[i].addr6, &sin6->sin6_addr, 16) == 0) {
  74.                     break;
  75.                 }
  76.             }

  78.             addr_conf = &addr6[i].conf;

  80.             break;
  81. #endif

  83.         default: /* AF_INET */
  84.             sin = (struct sockaddr_in *) sa;

  86.             addr = port->addrs;

  88.             /* the last address is "*" */

  90.             for (i = 0; i < port->naddrs - 1; i++) {
  91.                 if (addr[i].addr == sin->sin_addr.s_addr) {
  92.                     break;
  93.                 }
  94.             }

  96.             addr_conf = &addr[i].conf;

  98.             break;
  99.         }

  101.     } else {
  102.         switch (c->local_sockaddr->sa_family) {

  104. #if (NGX_HAVE_INET6)
  105.         case AF_INET6:
  106.             addr6 = port->addrs;
  107.             addr_conf = &addr6[0].conf;
  108.             break;
  109. #endif

  111.         default: /* AF_INET */
  112.             addr = port->addrs;
  113.             addr_conf = &addr[0].conf;
  114.             break;
  115.         }
  116.     }

  118.     s = ngx_pcalloc(c->pool, sizeof(ngx_mail_session_t));
  119.     if (s == NULL) {
  120.         ngx_mail_close_connection(c);
  121.         return;
  122.     }

  124.     s->signature = NGX_MAIL_MODULE;

  126.     s->main_conf = addr_conf->ctx->main_conf;
  127.     s->srv_conf = addr_conf->ctx->srv_conf;

  129.     s->addr_text = &addr_conf->addr_text;

  131.     c->data = s;
  132.     s->connection = c;

  134.     len = ngx_sock_ntop(c->sockaddr, c->socklen, text, NGX_SOCKADDR_STRLEN, 1);

  136.     ngx_log_error(NGX_LOG_INFO, c->log, 0, "*%uA client %*s connected to %V",
  137.                   c->number, len, text, s->addr_text);

  139.     ctx = ngx_palloc(c->pool, sizeof(ngx_mail_log_ctx_t));
  140.     if (ctx == NULL) {
  141.         ngx_mail_close_connection(c);
  142.         return;
  143.     }

  145.     ctx->client = &c->addr_text;
  146.     ctx->session = s;

  148.     c->log->connection = c->number;
  149.     c->log->handler = ngx_mail_log_error;
  150.     c->log->data = ctx;
  151.     c->log->action = "sending client greeting line";

  153.     c->log_error = NGX_ERROR_INFO;

  155. #if (NGX_MAIL_SSL)
  156.     {
  157.     ngx_mail_ssl_conf_t  *sslcf;

  159.     sslcf = ngx_mail_get_module_srv_conf(s, ngx_mail_ssl_module);

  161.     if (sslcf->enable) {
  162.         c->log->action = "SSL handshaking";

  164.         ngx_mail_ssl_init_connection(&sslcf->ssl, c);
  165.         return;
  166.     }

  168.     if (addr_conf->ssl) {

  170.         c->log->action = "SSL handshaking";

  172.         if (sslcf->ssl.ctx == NULL) {
  173.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  174.                           "no \"ssl_certificate\" is defined "
  175.                           "in server listening on SSL port");
  176.             ngx_mail_close_connection(c);
  177.             return;
  178.         }

  180.         ngx_mail_ssl_init_connection(&sslcf->ssl, c);
  181.         return;
  182.     }

  184.     }
  185. #endif

  187.     ngx_mail_init_session(c);
  188. }


  191. #if (NGX_MAIL_SSL)

  193. void
  194. ‌ngx_mail_starttls_handler(ngx_event_t *rev)
  195. {
  196.     ngx_connection_t     *c;
  197.     ngx_mail_session_t   *s;
  198.     ngx_mail_ssl_conf_t  *sslcf;

  200.     c = rev->data;
  201.     s = c->data;
  202.     s->starttls = 1;

  204.     c->log->action = "in starttls state";

  206.     sslcf = ngx_mail_get_module_srv_conf(s, ngx_mail_ssl_module);

  208.     ngx_mail_ssl_init_connection(&sslcf->ssl, c);
  209. }


  212. static void
  213. ‌ngx_mail_ssl_init_connection(ngx_ssl_t *ssl, ngx_connection_t *c)
  214. {
  215.     ngx_mail_session_t        *s;
  216.     ngx_mail_core_srv_conf_t  *cscf;

  218.     if (ngx_ssl_create_connection(ssl, c, 0) == NGX_ERROR) {
  219.         ngx_mail_close_connection(c);
  220.         return;
  221.     }

  223.     if (ngx_ssl_handshake(c) == NGX_AGAIN) {

  225.         s = c->data;

  227.         cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  229.         ngx_add_timer(c->read, cscf->timeout);

  231.         c->ssl->handler = ngx_mail_ssl_handshake_handler;

  233.         return;
  234.     }

  236.     ngx_mail_ssl_handshake_handler(c);
  237. }


  240. static void
  241. ‌ngx_mail_ssl_handshake_handler(ngx_connection_t *c)
  242. {
  243.     ngx_mail_session_t        *s;
  244.     ngx_mail_core_srv_conf_t  *cscf;

  246.     if (c->ssl->handshaked) {

  248.         s = c->data;

  250.         if (s->starttls) {
  251.             cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  253.             c->read->handler = cscf->protocol->init_protocol;
  254.             c->write->handler = ngx_mail_send;

  256.             cscf->protocol->init_protocol(c->read);

  258.             return;
  259.         }

  261.         c->read->ready = 0;

  263.         ngx_mail_init_session(c);
  264.         return;
  265.     }

  267.     ngx_mail_close_connection(c);
  268. }

  270. #endif


  273. static void
  274. ‌ngx_mail_init_session(ngx_connection_t *c)
  275. {
  276.     ngx_mail_session_t        *s;
  277.     ngx_mail_core_srv_conf_t  *cscf;

  279.     s = c->data;

  281.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  283.     s->protocol = cscf->protocol->type;

  285.     s->ctx = ngx_pcalloc(c->pool, sizeof(void *) * ngx_mail_max_module);
  286.     if (s->ctx == NULL) {
  287.         ngx_mail_session_internal_server_error(s);
  288.         return;
  289.     }

  291.     c->write->handler = ngx_mail_send;

  293.     cscf->protocol->init_session(s, c);
  294. }


  297. ngx_int_t
  298. ‌ngx_mail_salt(ngx_mail_session_t *s, ngx_connection_t *c,
  299.     ngx_mail_core_srv_conf_t *cscf)
  300. {
  301.     s->salt.data = ngx_pnalloc(c->pool,
  302.                                sizeof(" <18446744073709551616.@>" CRLF) - 1
  303.                                + NGX_TIME_T_LEN
  304.                                + cscf->server_name.len);
  305.     if (s->salt.data == NULL) {
  306.         return NGX_ERROR;
  307.     }

  309.     s->salt.len = ngx_sprintf(s->salt.data, "<%ul.%T@%V>" CRLF,
  310.                               ngx_random(), ngx_time(), &cscf->server_name)
  311.                   - s->salt.data;

  313.     return NGX_OK;
  314. }


  317. #if (NGX_MAIL_SSL)

  319. ngx_int_t
  320. ‌ngx_mail_starttls_only(ngx_mail_session_t *s, ngx_connection_t *c)
  321. {
  322.     ngx_mail_ssl_conf_t  *sslcf;

  324.     if (c->ssl) {
  325.         return 0;
  326.     }

  328.     sslcf = ngx_mail_get_module_srv_conf(s, ngx_mail_ssl_module);

  330.     if (sslcf->starttls == NGX_MAIL_STARTTLS_ONLY) {
  331.         return 1;
  332.     }

  334.     return 0;
  335. }

  337. #endif


  340. ngx_int_t
  341. ‌ngx_mail_auth_plain(ngx_mail_session_t *s, ngx_connection_t *c, ngx_uint_t n)
  342. {
  343.     u_char     *p, *last;
  344.     ngx_str_t  *arg, plain;

  346.     arg = s->args.elts;

  348. #if (NGX_DEBUG_MAIL_PASSWD)
  349.     ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
  350.                    "mail auth plain: \"%V\"", &arg[n]);
  351. #endif

  353.     plain.data = ngx_pnalloc(c->pool, ngx_base64_decoded_length(arg[n].len));
  354.     if (plain.data == NULL) {
  355.         return NGX_ERROR;
  356.     }

  358.     if (ngx_decode_base64(&plain, &arg[n]) != NGX_OK) {
  359.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  360.             "client sent invalid base64 encoding in AUTH PLAIN command");
  361.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  362.     }

  364.     p = plain.data;
  365.     last = p + plain.len;

  367.     while (p < last && *p++) { /* void */ }

  369.     if (p == last) {
  370.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  371.                       "client sent invalid login in AUTH PLAIN command");
  372.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  373.     }

  375.     s->login.data = p;

  377.     while (p < last && *p) { p++; }

  379.     if (p == last) {
  380.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  381.                       "client sent invalid password in AUTH PLAIN command");
  382.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  383.     }

  385.     s->login.len = p++ - s->login.data;

  387.     s->passwd.len = last - p;
  388.     s->passwd.data = p;

  390. #if (NGX_DEBUG_MAIL_PASSWD)
  391.     ngx_log_debug2(NGX_LOG_DEBUG_MAIL, c->log, 0,
  392.                    "mail auth plain: \"%V\" \"%V\"", &s->login, &s->passwd);
  393. #endif

  395.     return NGX_DONE;
  396. }


  399. ngx_int_t
  400. ‌ngx_mail_auth_login_username(ngx_mail_session_t *s, ngx_connection_t *c,
  401.     ngx_uint_t n)
  402. {
  403.     ngx_str_t  *arg;

  405.     arg = s->args.elts;

  407.     ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
  408.                    "mail auth login username: \"%V\"", &arg[n]);

  410.     s->login.data = ngx_pnalloc(c->pool, ngx_base64_decoded_length(arg[n].len));
  411.     if (s->login.data == NULL) {
  412.         return NGX_ERROR;
  413.     }

  415.     if (ngx_decode_base64(&s->login, &arg[n]) != NGX_OK) {
  416.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  417.             "client sent invalid base64 encoding in AUTH LOGIN command");
  418.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  419.     }

  421.     ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
  422.                    "mail auth login username: \"%V\"", &s->login);

  424.     return NGX_OK;
  425. }


  428. ngx_int_t
  429. ‌ngx_mail_auth_login_password(ngx_mail_session_t *s, ngx_connection_t *c)
  430. {
  431.     ngx_str_t  *arg;

  433.     arg = s->args.elts;

  435. #if (NGX_DEBUG_MAIL_PASSWD)
  436.     ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
  437.                    "mail auth login password: \"%V\"", &arg[0]);
  438. #endif

  440.     s->passwd.data = ngx_pnalloc(c->pool,
  441.                                  ngx_base64_decoded_length(arg[0].len));
  442.     if (s->passwd.data == NULL) {
  443.         return NGX_ERROR;
  444.     }

  446.     if (ngx_decode_base64(&s->passwd, &arg[0]) != NGX_OK) {
  447.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  448.             "client sent invalid base64 encoding in AUTH LOGIN command");
  449.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  450.     }

  452. #if (NGX_DEBUG_MAIL_PASSWD)
  453.     ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
  454.                    "mail auth login password: \"%V\"", &s->passwd);
  455. #endif

  457.     return NGX_DONE;
  458. }


  461. ngx_int_t
  462. ‌ngx_mail_auth_cram_md5_salt(ngx_mail_session_t *s, ngx_connection_t *c,
  463.     char *prefix, size_t len)
  464. {
  465.     u_char      *p;
  466.     ngx_str_t    salt;
  467.     ngx_uint_t   n;

  469.     p = ngx_pnalloc(c->pool, len + ngx_base64_encoded_length(s->salt.len) + 2);
  470.     if (p == NULL) {
  471.         return NGX_ERROR;
  472.     }

  474.     salt.data = ngx_cpymem(p, prefix, len);
  475.     s->salt.len -= 2;

  477.     ngx_encode_base64(&salt, &s->salt);

  479.     s->salt.len += 2;
  480.     n = len + salt.len;
  481.     p[n++] = CR; p[n++] = LF;

  483.     s->out.len = n;
  484.     s->out.data = p;

  486.     return NGX_OK;
  487. }


  490. ngx_int_t
  491. ‌ngx_mail_auth_cram_md5(ngx_mail_session_t *s, ngx_connection_t *c)
  492. {
  493.     u_char     *p, *last;
  494.     ngx_str_t  *arg;

  496.     arg = s->args.elts;

  498.     ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
  499.                    "mail auth cram-md5: \"%V\"", &arg[0]);

  501.     s->login.data = ngx_pnalloc(c->pool, ngx_base64_decoded_length(arg[0].len));
  502.     if (s->login.data == NULL) {
  503.         return NGX_ERROR;
  504.     }

  506.     if (ngx_decode_base64(&s->login, &arg[0]) != NGX_OK) {
  507.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  508.             "client sent invalid base64 encoding in AUTH CRAM-MD5 command");
  509.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  510.     }

  512.     p = s->login.data;
  513.     last = p + s->login.len;

  515.     while (p < last) {
  516.         if (*p++ == ' ') {
  517.             s->login.len = p - s->login.data - 1;
  518.             s->passwd.len = last - p;
  519.             s->passwd.data = p;
  520.             break;
  521.         }
  522.     }

  524.     if (s->passwd.len != 32) {
  525.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  526.             "client sent invalid CRAM-MD5 hash in AUTH CRAM-MD5 command");
  527.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  528.     }

  530.     ngx_log_debug2(NGX_LOG_DEBUG_MAIL, c->log, 0,
  531.                    "mail auth cram-md5: \"%V\" \"%V\"", &s->login, &s->passwd);

  533.     s->auth_method = NGX_MAIL_AUTH_CRAM_MD5;

  535.     return NGX_DONE;
  536. }


  539. void
  540. ‌ngx_mail_send(ngx_event_t *wev)
  541. {
  542.     ngx_int_t                  n;
  543.     ngx_connection_t          *c;
  544.     ngx_mail_session_t        *s;
  545.     ngx_mail_core_srv_conf_t  *cscf;

  547.     c = wev->data;
  548.     s = c->data;

  550.     if (wev->timedout) {
  551.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  552.         c->timedout = 1;
  553.         ngx_mail_close_connection(c);
  554.         return;
  555.     }

  557.     if (s->out.len == 0) {
  558.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  559.             ngx_mail_close_connection(c);
  560.         }

  562.         return;
  563.     }

  565.     n = c->send(c, s->out.data, s->out.len);

  567.     if (n > 0) {
  568.         s->out.data += n;
  569.         s->out.len -= n;

  571.         if (s->out.len != 0) {
  572.             goto again;
  573.         }

  575.         if (wev->timer_set) {
  576.             ngx_del_timer(wev);
  577.         }

  579.         if (s->quit) {
  580.             ngx_mail_close_connection(c);
  581.             return;
  582.         }

  584.         if (s->blocked) {
  585.             c->read->handler(c->read);
  586.         }

  588.         return;
  589.     }

  591.     if (n == NGX_ERROR) {
  592.         ngx_mail_close_connection(c);
  593.         return;
  594.     }

  596.     /* n == NGX_AGAIN */

  598. again:

  600.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  602.     ngx_add_timer(c->write, cscf->timeout);

  604.     if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  605.         ngx_mail_close_connection(c);
  606.         return;
  607.     }
  608. }


  611. ngx_int_t
  612. ‌ngx_mail_read_command(ngx_mail_session_t *s, ngx_connection_t *c)
  613. {
  614.     ssize_t                    n;
  615.     ngx_int_t                  rc;
  616.     ngx_str_t                  l;
  617.     ngx_mail_core_srv_conf_t  *cscf;

  619.     n = c->recv(c, s->buffer->last, s->buffer->end - s->buffer->last);

  621.     if (n == NGX_ERROR || n == 0) {
  622.         ngx_mail_close_connection(c);
  623.         return NGX_ERROR;
  624.     }

  626.     if (n > 0) {
  627.         s->buffer->last += n;
  628.     }

  630.     if (n == NGX_AGAIN) {
  631.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  632.             ngx_mail_session_internal_server_error(s);
  633.             return NGX_ERROR;
  634.         }

  636.         if (s->buffer->pos == s->buffer->last) {
  637.             return NGX_AGAIN;
  638.         }
  639.     }

  641.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  643.     rc = cscf->protocol->parse_command(s);

  645.     if (rc == NGX_AGAIN) {

  647.         if (s->buffer->last < s->buffer->end) {
  648.             return rc;
  649.         }

  651.         l.len = s->buffer->last - s->buffer->start;
  652.         l.data = s->buffer->start;

  654.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  655.                       "client sent too long command \"%V\"", &l);

  657.         s->quit = 1;

  659.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  660.     }

  662.     if (rc == NGX_IMAP_NEXT || rc == NGX_MAIL_PARSE_INVALID_COMMAND) {
  663.         return rc;
  664.     }

  666.     if (rc == NGX_ERROR) {
  667.         ngx_mail_close_connection(c);
  668.         return NGX_ERROR;
  669.     }

  671.     return NGX_OK;
  672. }


  675. void
  676. ‌ngx_mail_auth(ngx_mail_session_t *s, ngx_connection_t *c)
  677. {
  678.     s->args.nelts = 0;

  680.     if (s->buffer->pos == s->buffer->last) {
  681.         s->buffer->pos = s->buffer->start;
  682.         s->buffer->last = s->buffer->start;
  683.     }

  685.     s->state = 0;

  687.     if (c->read->timer_set) {
  688.         ngx_del_timer(c->read);
  689.     }

  691.     s->login_attempt++;

  693.     ngx_mail_auth_http_init(s);
  694. }


  697. void
  698. ‌ngx_mail_session_internal_server_error(ngx_mail_session_t *s)
  699. {
  700.     ngx_mail_core_srv_conf_t  *cscf;

  702.     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);

  704.     s->out = cscf->protocol->internal_server_error;
  705.     s->quit = 1;

  707.     ngx_mail_send(s->connection->write);
  708. }


  711. void
  712. ‌ngx_mail_close_connection(ngx_connection_t *c)
  713. {
  714.     ngx_pool_t  *pool;

  716.     ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
  717.                    "close mail connection: %d", c->fd);

  719. #if (NGX_MAIL_SSL)

  721.     if (c->ssl) {
  722.         if (ngx_ssl_shutdown(c) == NGX_AGAIN) {
  723.             c->ssl->handler = ngx_mail_close_connection;
  724.             return;
  725.         }
  726.     }

  728. #endif

  730. #if (NGX_STAT_STUB)
  731.     (void) ngx_atomic_fetch_add(ngx_stat_active, -1);
  732. #endif

  734.     c->destroyed = 1;

  736.     pool = c->pool;

  738.     ngx_close_connection(c);

  740.     ngx_destroy_pool(pool);
  741. }


  744. u_char *
  745. ‌ngx_mail_log_error(ngx_log_t *log, u_char *buf, size_t len)
  746. {
  747.     u_char              *p;
  748.     ngx_mail_session_t  *s;
  749.     ngx_mail_log_ctx_t  *ctx;

  751.     if (log->action) {
  752.         p = ngx_snprintf(buf, len, " while %s", log->action);
  753.         len -= p - buf;
  754.         buf = p;
  755.     }

  757.     ctx = log->data;

  759.     p = ngx_snprintf(buf, len, ", client: %V", ctx->client);
  760.     len -= p - buf;
  761.     buf = p;

  763.     s = ctx->session;

  765.     if (s == NULL) {
  766.         return p;
  767.     }

  769.     p = ngx_snprintf(buf, len, "%s, server: %V",
  770.                      s->starttls ? " using starttls" : "",
  771.                      s->addr_text);
  772.     len -= p - buf;
  773.     buf = p;

  775.     if (s->login.len == 0) {
  776.         return p;
  777.     }

  779.     p = ngx_snprintf(buf, len, ", login: \"%V\"", &s->login);
  780.     len -= p - buf;
  781.     buf = p;

  783.     if (s->proxy == NULL) {
  784.         return p;
  785.     }

  787.     p = ngx_snprintf(buf, len, ", upstream: %V", s->proxy->upstream.name);

  789.     return p;
  790. }

One Level Up Top Level